Manual installation

Add the SDK to your app by hand. To have your coding agent do it instead, see AI Native installation.

The examples below use version 0.0.15, the latest release.

Your publishable key

Scanning needs a publishable key, which you pass to configure in the quickstart. Create one under Developers → API keys in the Roomio dashboard. It starts with roomio_pub_live_ and is safe to ship in your app. Keep the key in your build configuration rather than in source, so you can change it without a code change.

iOS

Requires Xcode 26 or later and an iPhone running iOS 17 or later. The Simulator can build your app but cannot scan.

In Xcode, choose File → Add Package Dependencies… and enter https://github.com/CAPTUR3D-tech/roomio-sdk-ios. For Dependency Rule, pick Exact Version and choose version 0.0.15.
Add the RoomioSDK library to your app target. Xcode downloads the framework from cdn.roomio.io, then embeds and signs it with your app; there are no other build settings to change. In your code, import RoomioSDK.
Add the camera permission text, which the user sees in the camera permission prompt. Select your app target, open its Info tab, and add the key Privacy - Camera Usage Description (NSCameraUsageDescription), with text such as:
```
The camera is used to scan the space.
```
New Xcode projects have no Info.plist file; the Info tab is where its keys go. If your project has an Info.plist file, you can add it there instead:
```
<key>NSCameraUsageDescription</key>
<string>The camera is used to scan the space.</string>
```
If you keep settings in an .xcconfig file, set INFOPLIST_KEY_NSCameraUsageDescription to the text.

To build on a phone, choose your team under Signing & Capabilities, as for any app. With a free personal team, the phone refuses to open the app until you trust your developer profile under Settings → General → VPN & Device Management.

Note: Set your app's Minimum Deployments to the lowest iOS version you support, 17.0 or later. New Xcode projects default to the newest iOS, which works but limits which iPhones can install your app. A target below 17.0 fails, because the package requires iOS 17.

Android (Beta)

Android is in beta. You can build and test your Android integration, but Roomio doesn't process Android scans yet: sending one returns scan.failed. Processing is coming in the next few weeks.

Requires minSdk 24 (Android 7.0) or higher and an ARCore-supported phone with a 64-bit processor. The emulator cannot scan.

Add Roomio's Maven repository, which needs no account or token, and the dependency:

// settings.gradle.kts
dependencyResolutionManagement {
    repositories {
        maven("https://cdn.roomio.io/sdk/android/maven") {
            content { includeGroup("io.captur3d") }
        }
        google()
        mavenCentral()
    }
}

// app/build.gradle.kts
android {
    defaultConfig {
        ndk { abiFilters += "arm64-v8a" }
    }
}

dependencies {
    implementation("io.captur3d:roomio-sdk:0.0.15")
}

The SDK's native code is 64-bit ARM only. abiFilters keeps your app to that architecture; without it, your app also builds for others where scanning can't run.

The SDK adds about 22 MB to your app's download from Google Play and about 70 MB once installed. Gradle's "Unable to strip the following libraries" warning about it is expected.

The SDK brings its dependencies with it, so there's nothing else to add. They include ARCore, Kotlin coroutines and the Compose runtime, but not Compose UI: your app doesn't need to use Compose. Gradle resolves each to the newest version your app asks for, and ./gradlew :app:dependencies lists them.

The SDK adds the camera, internet and high-sampling-rate sensor permissions to your app's manifest (only the camera shows the user a prompt), requires OpenGL ES 3.0, and declares ARCore as optional. Your app can therefore install on phones that can't scan, so call Roomio.isSupported(context) and only offer scanning where it returns a supported result. The first time the scan view appears, Android may ask the user to install or update Google Play Services for AR.

If your app can't work without scanning, add this to your app's manifest so Google Play offers it only to ARCore-supported devices and installs Google Play Services for AR with it:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <uses-feature android:name="android.hardware.camera.ar" android:required="true" />

    <application>
        <meta-data
            android:name="com.google.ar.core"
            android:value="required"
            tools:replace="android:value" />
    </application>
</manifest>

Release builds that shrink code with R8 need no extra rules: the SDK includes its own.

The SDK is published without its source, so jumping to one of its classes in Android Studio shows decompiled code. The Android reference documents every public class.

Note: In projects made from Android Studio's newest template, turning on shrinking with optimization { enable = true } fails until you add android.r8.gradual.support=true to gradle.properties. This comes from the Android Gradle plugin, not the SDK. isMinifyEnabled = true works without it.

React Native

Requires React Native 0.80 or later with the new architecture, and the iOS and Android requirements above.

Install the package from cdn.roomio.io:

npm install https://cdn.roomio.io/sdk/react-native/0.0.15/roomio-react-native-sdk-0.0.15.tgz

It includes the iOS framework, and takes the Android SDK of the same version from the Maven repository on cdn.roomio.io.

iOS

In ios/Podfile, set platform :ios, '17.0'.
Install the pods:
```
cd ios && pod install
```
Open ios/<YourApp>.xcworkspace, not the .xcodeproj. Set your app target's Minimum Deployments to 17.0 or later.

Add the camera permission text to ios/<YourApp>/Info.plist:

<key>NSCameraUsageDescription</key>
<string>The camera is used to scan the space.</string>

Android

In android/gradle.properties, build for 64-bit ARM only:

reactNativeArchitectures=arm64-v8a

In android/build.gradle, add the repository that hosts the Android SDK:

allprojects {
    repositories {
        maven {
            url "https://cdn.roomio.io/sdk/android/maven"
            content { includeGroup "io.captur3d" }
        }
    }
}

Note: A new React Native app builds for four Android architectures by default. Without reactNativeArchitectures=arm64-v8a, it also builds for architectures where scanning can't run.

Expo

Requires Expo SDK 56 or later. Expo Go can't run the SDK, so use a development build.

npm install https://cdn.roomio.io/sdk/react-native/0.0.15/roomio-react-native-sdk-0.0.15.tgz
npx expo install expo-build-properties

Add both plugins and the iOS deployment target to your app config:

{
  "expo": {
    "ios": { "deploymentTarget": "17.0" },
    "plugins": [
      [
        "@roomio/react-native-sdk",
        { "cameraPermission": "The camera is used to scan the space." }
      ],
      [
        "expo-build-properties",
        {
          "android": {
            "buildArchs": ["arm64-v8a"]
          }
        }
      ]
    ]
  }
}

The Roomio plugin adds the camera permission text and the repository that hosts the Android SDK, and stops prebuild if the iOS deployment target is below 17.0, even for Android-only builds. expo-build-properties builds Android for 64-bit ARM only. npx expo install expo-build-properties adds a bare plugin entry; replace it with the configured one above.

Build with npx expo run:ios, npx expo run:android or EAS Build.

Command-line and CI builds

Android, React Native and Expo builds need nothing beyond the steps above: the Maven repository on cdn.roomio.io needs no account or token.

For iOS, commit your project's Package.resolved so every machine resolves the same SDK version, and resolve packages before you build:

xcodebuild -resolvePackageDependencies -project MyApp.xcodeproj

Signing works as for any app: the SDK's framework is signed with your app's identity when it is embedded. Use the same team, certificate and provisioning profile as your app's other builds. To only check that the app compiles, build without signing:

xcodebuild build -scheme MyApp -destination 'generic/platform=iOS' CODE_SIGNING_ALLOWED=NO

AI Native installation

Quickstart