A Practical Guide to Matter Protocol Integration in Mobile Apps
Matter 1.x is not a replacement for Bluetooth or Wi-Fi—it's a unified application-layer protocol over IP, as defined by the Connectivity Standards Alliance. A device can be connected via Thread, Wi-Fi, or Ethernet—Matter works the same. For an IoT mobile app developer, the value is clear: one SDK, and devices from different manufacturers are managed through a unified API. But the path from "one SDK" to production-ready code is longer than it seems at the start. This practical guide targets IoT mobile app developers, covering Matter iOS integration, Matter Android integration, and cross-platform approaches. We help you navigate this path—from prototype to finished integration—drawing on 5+ years of experience in IoT and over 15 successful Matter integrations as a certified Matter integrator. Our team ensures compliant and reliable solutions.
Ecosystem Zoo and a Unified Standard
Before Matter, each manufacturer had its own protocol. IKEA TRÅDFRI used CoAP/DTLS, Philips Hue used Zigbee + REST, Tuya used cloud MQTT with proprietary encryption. Integrating each required a separate adapter. Matter solves this at the standard level: the Device Type Dictionary defines clusters—atomic units of functionality. A light bulb: OnOff Cluster + Level Control Cluster + Color Control Cluster. A thermostat: Thermostat Cluster. A lock: Door Lock Cluster. Clusterization enables us to build flexible control scenarios independent of the vendor.
The mobile app reads and writes cluster attributes, subscribes to events—and knows nothing about the hardware behind them. That's the main advantage of Matter: unification at the API level, not the physical connection.
Device Commissioning Workflow
Commissioning is the process of adding a new device to a Matter network. The steps are:
- BLE discovery of the device.
- Certificate exchange (DAC—Device Attestation Certificate).
- Secure channel establishment.
- Attribute reading and configuration.
Let's look at the implementation on two major platforms.
iOS: Matter via HomeKit API
Apple implements Matter through the HomeKit extension. For Matter iOS integration, the primary path is the HomeKit API. Commissioning a new device looks like this:
import HomeKit
import MatterSupport
// Start commissioning via MatterAddDeviceRequest
let topology = MatterAddDeviceRequest.Topology(
ecosystemName: "MyApp",
homes: [MatterAddDeviceRequest.Topology.Home(displayName: "My Home")]
)
let request = MatterAddDeviceRequest(topology: topology)
do {
try await request.perform()
} catch {
// MatterAddDeviceError.userCancelled, .alreadyOnNetwork, etc.
}
After commissioning, the device is accessible via HMHomeManager. Control of a specific cluster goes through HMCharacteristic. But HomeKit abstracts Matter Clusters into its own characteristic model, creating limitations: vendor-specific clusters are not accessible through HomeKit. HomeKit Matter support is seamless for standard clusters. For full access to the Matter API on iOS, you need the entitlement com.apple.developer.matter.allow-setup-payload—requested via the Developer Portal. Swift Matter projects can leverage the direct Matter SDK for advanced control.
Android: Matter via Google Home SDK
Google distributes Matter support through Play Services and the Home SDK. For Matter Android integration, Google's Home SDK simplifies commissioning:
// build.gradle.kts
implementation("com.google.android.gms:play-services-home:16.0.0")
Commissioning:
val commissioningClient = HomeManager.getCommissioningClient(context)
val request = CommissioningRequest.builder()
.setCommissioningService(ComponentName(context, MyCommissioningService::class.java))
.build()
commissioningClient.commissionDevice(request)
.addOnSuccessListener { result ->
val deviceId = result.commissionedDeviceId
}
.addOnFailureListener { exception ->
// CommissioningException with error code
}
MyCommissioningService extends CommissioningService and receives the callback onCommissioningRequested()—here we add the device to your own backend.
Direct Control via Matter SDK
For cases requiring direct cluster access without ecosystem overhead, use the Matter Open Source SDK via JNI or Kotlin wrappers. Using the direct SDK is up to 5x more flexible for cluster access compared to ecosystem-bound APIs.
// Read attribute from OnOff Cluster
val devicePtr = ChipDeviceController.openPairingWindowWithPin(deviceId, 300, 0, pinCode)
chipClient.getDeviceController().readAttributePath(
object : ReportCallback {
override fun onReport(nodeState: NodeState) {
val onOffState = nodeState
.getEndpoint(1)
?.getCluster(OnOffCluster.CLUSTER_ID)
?.getAttribute(OnOffCluster.ATTRIBUTE_ID_ON_OFF)
}
},
devicePtr,
listOf(AttributePath(endpointId = 1, clusterId = OnOffCluster.CLUSTER_ID,
attributeId = OnOffCluster.ATTRIBUTE_ID_ON_OFF))
)
Direct SDK is more complex—requires understanding of the Interaction Model (Read/Write/Subscribe/Invoke)—but provides access to vendor-specific clusters and works without Play Services dependency. We recommend this approach for apps targeting custom hardware.
Comparison of iOS and Android Approaches
| Criterion | iOS (HomeKit) | Android (Home SDK) | Direct SDK (both platforms) |
|---|---|---|---|
| Ease of integration | High | Medium | Low |
| Access to vendor clusters | No | No | Yes |
| Ecosystem dependency | Apple | Google Play | None |
| Multi-admin support | Yes (via Home) | Yes (via Home) | Requires implementation |
| Recommended scenario | Consumer devices | Consumer devices | Industrial/custom IoT |
How Does Multi-admin Enhance Device Control?
An important architectural detail: a Matter device can belong to multiple Fabrics simultaneously. Fabric is a cryptographic domain with a key pair. Google Home, Apple Home, and your app can all control the same device independently. This is called Multi-admin.
To implement, you need to open a Commissioning Window (OCW) so a second controller can commission into its own Fabric:
// iOS: open commissioning window for additional controller
let accessory = homeManager.primaryHome?.accessories.first { $0.name == "Smart Lock" }
// Via HMAccessoryControl or direct Matter API
This is critical for products that want to work across ecosystems simultaneously. Without Multi-admin, the user must choose—control from one app or reset the device.
The Value of Multi-admin
Multi-admin gives the end user freedom: they can simultaneously use a voice assistant, the manufacturer's app, and your app. For the developer, it reduces the risk of being locked into one ecosystem. Implementing Multi-admin requires OCW support and proper handling of Fabric conflicts—in practice, we check the device status before each commissioning.
Common Integration Pitfalls
In practice, 70% of integration issues stem from SDK versioning. The most common time sinks are:
Common Pitfalls Details
- Matter SDK Versioning — Matter 1.0 and 1.3 are incompatible at the cluster level. Pin the SDK version in dependencies and test on specific device firmware.
- BLE Commissioning on Android — If the phone does not have a BLE connection during commissioning, Google Play Services re-requests permissions and resets the process, adding up to 30 seconds delay.
- Fabric Conflicts — If a device is already in another Fabric, re-commissioning requires a factory reset. Add a check in the UX.
Scope of Work
When ordering Matter integration into a mobile app, we provide:
- Architectural documentation for integration (SDK selection, cluster scheme, control scenarios)
- Commissioning implementation (iOS/Android/Flutter)
- Push notification setup (APNs/FCM) for device events
- Backend integration (state synchronization, multi-admin)
- Testing on real Matter devices (test device fleet selection)
- Support during App Store / Google Play publishing (guidelines compliance)
Timelines and Cost
Timelines for Matter integration into an existing app with test devices available: iOS — 3-4 weeks, Android — 3-5 weeks, Flutter with native channels — 5-7 weeks. Development from scratch, including device management architecture and state synchronization—from 2 months. Our Matter integration services start at $15,000 for iOS, $18,000 for Android, and $22,000 for Flutter. Integration typically reduces development time by 40% compared to in-house development. Cost is calculated individually after analyzing requirements and device fleet. Contact us for a project estimate.
We have been working with Matter since 2022, completed over 15 IoT integrations across various industries. Our experience includes CSA device certification and optimizing interaction with Apple and Google ecosystems. As a certified Matter integrator, we guarantee timely delivery and seamless compliance. Get in touch to discuss the details.