@q9labsai/chalk-react-native 4.0.0

package/Q9ChalkReactNative.podspec

@@ -0,0 +1,27 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |spec|
+  spec.name = "Q9ChalkReactNative"
+  spec.version = package["version"]
+  spec.summary = "Native iOS support for Chalk React Native CallKit and PiP."
+  spec.homepage = "https://github.com/Q9Labs/chalk"
+  spec.license = package["license"] || "UNLICENSED"
+  spec.authors = { "Q9Labs" => "opensource@q9labs.ai" }
+  spec.platforms = { :ios => "15.1" }
+  spec.source = { :git => "https://github.com/Q9Labs/chalk.git", :tag => spec.version.to_s }
+  spec.source_files = "ios/**/*.{h,m,mm,swift}"
+  spec.resource_bundles = {
+    "ChalkWhiteboard" => ["embedded/chalk-whiteboard"]
+  }
+  spec.requires_arc = true
+  spec.swift_version = "5.0"
+  spec.frameworks = ["AVFoundation", "AVKit", "CallKit"]
+  spec.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_COMPILATION_MODE" => "wholemodule"
+  }
+
+  spec.dependency "React-Core"
+end

package/README.md

@@ -0,0 +1,41 @@
+# @q9labsai/chalk-react-native
+
+React Native bindings and native platform adapters for Chalk.
+
+The root package exports exactly:
+
+- Components: `Chalk`, `Entrance`.
+- Context: `ChalkProvider`, `useSpaceClient`.
+- Snapshot hooks: `useCan`, `useChat`, `useConnection`, `useMedia`,
+  `useParticipants`, `useReactions`, `useSelf`, and `useWhiteboard`.
+- Types: `ChalkFeatures`, `ChalkProps`, `ChalkTheme`, `ChalkThemeTokens`,
+  `SpaceLayout`, `EntranceProps`, `EntranceSettings`, and `ChalkProviderProps`.
+
+```tsx
+import { Chalk } from "@q9labsai/chalk-react-native";
+
+export function SpaceScreen() {
+  return <Chalk displayName="Taylor" getAccess={getAccess} logoUrl="https://example.com/logo.png" space="design-review" theme={{ colorScheme: "dark", accent: "#14b8a6" }} />;
+}
+```
+
+`Chalk` can instead receive an existing `SpaceClient` through `client`. Set
+`entrance={false}` to join immediately; an absent display name is omitted from
+the join request. The native experience has focus, grid, and presentation
+layouts, and `features.settings` is enabled unless explicitly set to `false`.
+
+The platform subpaths (`android`, `ios`, `ios-phone`, `ios-pad`, and `macos`)
+export the same public surface as the root package.
+
+## Native client adapter
+
+For advanced lifecycle ownership, import the React Native implementation seam
+from `@q9labsai/chalk-react-native/client`. It exposes only
+`createNativeSpaceClient` and `NativeSpaceClientOptions`; it does not add a
+second root binding shape.
+
+```tsx
+import { createNativeSpaceClient } from "@q9labsai/chalk-react-native/client";
+
+const client = createNativeSpaceClient({ space: "design-review", getAccess });
+```

package/android/build.gradle

@@ -0,0 +1,43 @@
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+android {
+  namespace "ai.q9labs.chalk.reactnative"
+  compileSdkVersion safeExtGet("compileSdkVersion", 36)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    consumerProguardFiles "consumer-rules.pro"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_17.toString()
+  }
+
+  sourceSets {
+    main.java.srcDirs += "src/main/kotlin"
+    main.assets.srcDirs += "${projectDir}/../embedded"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation("com.facebook.react:react-android")
+  implementation("androidx.core:core:1.16.0")
+}

package/android/consumer-rules.pro

@@ -0,0 +1 @@
+# Intentionally empty.

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,24 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <service
+      android:name=".ChalkSelfManagedConnectionService"
+      android:exported="true"
+      android:label="Chalk"
+      android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE">
+      <intent-filter>
+        <action android:name="android.telecom.ConnectionService" />
+      </intent-filter>
+    </service>
+    <service
+      android:name=".ChalkSpaceForegroundService"
+      android:enabled="true"
+      android:exported="false"
+      android:foregroundServiceType="camera|microphone" />
+  </application>
+</manifest>

package/android/src/main/java/ai/q9labs/chalk/reactnative/ChalkSpaceForegroundService.java

@@ -0,0 +1,94 @@
+package ai.q9labs.chalk.reactnative;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.IBinder;
+
+import androidx.core.app.NotificationCompat;
+
+public class ChalkSpaceForegroundService extends Service {
+    static final String ACTION_START = "ai.q9labs.chalk.reactnative.action.START_BACKGROUND_SPACE";
+    static final String ACTION_STOP = "ai.q9labs.chalk.reactnative.action.STOP_BACKGROUND_SPACE";
+    static final String EXTRA_SPACE_NAME = "spaceName";
+    static final String EXTRA_PARTICIPANT_NAME = "participantName";
+    static final String EXTRA_CAMERA_OFF = "cameraOff";
+    private static final String CHANNEL_ID = "chalk_space_background";
+    private static final int NOTIFICATION_ID = 19487;
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        String action = intent != null ? intent.getAction() : null;
+        if (ACTION_STOP.equals(action)) {
+            stopForeground(STOP_FOREGROUND_REMOVE);
+            stopSelf();
+            return START_NOT_STICKY;
+        }
+
+        ensureNotificationChannel();
+
+        String spaceName = intent != null ? intent.getStringExtra(EXTRA_SPACE_NAME) : null;
+        String participantName = intent != null ? intent.getStringExtra(EXTRA_PARTICIPANT_NAME) : null;
+        boolean cameraOff = intent != null && intent.getBooleanExtra(EXTRA_CAMERA_OFF, false);
+        Notification notification = buildNotification(spaceName, participantName, cameraOff);
+
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                int foregroundType = ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE;
+                if (!cameraOff) {
+                    foregroundType |= ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA;
+                }
+                startForeground(NOTIFICATION_ID, notification, foregroundType);
+            } else {
+                startForeground(NOTIFICATION_ID, notification);
+            }
+        } catch (RuntimeException error) {
+            stopSelf();
+        }
+
+        return START_STICKY;
+    }
+
+    private Notification buildNotification(String spaceName, String participantName, boolean cameraOff) {
+        String title = spaceName != null && !spaceName.trim().isEmpty() ? spaceName.trim() : "Chalk Space in progress";
+        String subtitle = participantName != null && !participantName.trim().isEmpty() ? participantName.trim() : "Your Space stays live in the background";
+        String detail = cameraOff ? "Audio stays live while you multitask." : "Video and audio stay live while you multitask.";
+
+        return new NotificationCompat.Builder(this, CHANNEL_ID)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setContentTitle(title)
+                .setContentText(subtitle)
+                .setStyle(new NotificationCompat.BigTextStyle().bigText(detail))
+                .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+                .setOngoing(true)
+                .setOnlyAlertOnce(true)
+                .setPriority(NotificationCompat.PRIORITY_LOW)
+                .setSmallIcon(android.R.drawable.presence_video_online)
+                .build();
+    }
+
+    private void ensureNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+        if (manager == null || manager.getNotificationChannel(CHANNEL_ID) != null) {
+            return;
+        }
+
+        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Chalk background Space", NotificationManager.IMPORTANCE_LOW);
+        channel.setDescription("Keeps Chalk Spaces active while the app is in the background");
+        manager.createNotificationChannel(channel);
+    }
+}

package/android/src/main/kotlin/ai/q9labs/chalk/reactnative/ChalkAndroidConnectionServiceModule.kt

@@ -0,0 +1,161 @@
+package ai.q9labs.chalk.reactnative
+
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.telecom.PhoneAccount
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.telecom.VideoProfile
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+
+class ChalkAndroidConnectionServiceModule(
+  private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  override fun getName(): String = "ChalkAndroidConnectionService"
+
+  override fun initialize() {
+    super.initialize()
+    ChalkConnectionRegistry.attachBridge(reactContext)
+  }
+
+  override fun invalidate() {
+    ChalkConnectionRegistry.detachBridge(reactContext)
+    super.invalidate()
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // Required by React Native's NativeEventEmitter contract.
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Required by React Native's NativeEventEmitter contract.
+  }
+
+  @ReactMethod
+  fun isSupported(promise: Promise) {
+    promise.resolve(ChalkConnectionRegistry.isSupported(reactContext))
+  }
+
+  @ReactMethod
+  fun registerPhoneAccount(promise: Promise) {
+    promise.resolve(registerPhoneAccount())
+  }
+
+  @ReactMethod
+  fun startCall(options: ReadableMap, promise: Promise) {
+    if (!registerPhoneAccount()) {
+      promise.resolve(false)
+      return
+    }
+
+    val callId = options.getNullableString("callId")
+    val spaceId = options.getNullableString("spaceId")
+    val spaceName = options.getNullableString("spaceName")
+    val displayName = options.getNullableString("displayName")
+    val hasVideo = options.getNullableBoolean("hasVideo") ?: true
+
+    if (callId.isNullOrBlank() || spaceId.isNullOrBlank() || spaceName.isNullOrBlank() || displayName.isNullOrBlank()) {
+      promise.reject("E_CONNECTION_SERVICE_INVALID_CALL", "Android ConnectionService requires callId, spaceId, spaceName, and displayName.")
+      return
+    }
+
+    val telecomManager = reactContext.getSystemService(TelecomManager::class.java)
+    val phoneAccountHandle = ChalkConnectionRegistry.phoneAccountHandle(reactContext)
+
+    if (telecomManager == null) {
+      promise.resolve(false)
+      return
+    }
+
+    ChalkConnectionRegistry.rememberPendingCall(
+      ChalkConnectionRegistry.ChalkCallSpec(
+        callId = callId,
+        spaceId = spaceId,
+        spaceName = spaceName,
+        displayName = displayName,
+        hasVideo = hasVideo,
+      ),
+    )
+
+    val extras =
+      Bundle().apply {
+        putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+        putInt(
+          TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE,
+          if (hasVideo) VideoProfile.STATE_BIDIRECTIONAL else VideoProfile.STATE_AUDIO_ONLY,
+        )
+        putString(ChalkConnectionRegistry.extraCallId, callId)
+        putString(ChalkConnectionRegistry.extraSpaceId, spaceId)
+        putString(ChalkConnectionRegistry.extraSpaceName, spaceName)
+        putString(ChalkConnectionRegistry.extraDisplayName, displayName)
+        putBoolean(ChalkConnectionRegistry.extraHasVideo, hasVideo)
+      }
+
+    val uriToken = spaceId.lowercase().replace("[^a-z0-9._-]".toRegex(), "-")
+
+    try {
+      telecomManager.placeCall(Uri.fromParts(PhoneAccount.SCHEME_SIP, "$uriToken@chalkmeet.local", null), extras)
+      promise.resolve(true)
+    } catch (error: Throwable) {
+      ChalkConnectionRegistry.unregisterConnection(callId)
+      promise.reject("E_CONNECTION_SERVICE_START_CALL_FAILED", error.message, error)
+    }
+  }
+
+  @ReactMethod
+  fun setActive(callId: String, promise: Promise) {
+    promise.resolve(ChalkConnectionRegistry.setActive(callId))
+  }
+
+  @ReactMethod
+  fun endCall(callId: String, reason: String?, label: String?, promise: Promise) {
+    promise.resolve(ChalkConnectionRegistry.disconnect(callId, reason, label))
+  }
+
+  private fun registerPhoneAccount(): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return false
+    }
+
+    val telecomManager = reactContext.getSystemService(TelecomManager::class.java) ?: return false
+    val phoneAccountHandle: PhoneAccountHandle = ChalkConnectionRegistry.phoneAccountHandle(reactContext)
+    val label = reactContext.applicationInfo.loadLabel(reactContext.packageManager)?.toString() ?: "Chalk"
+
+    return try {
+      telecomManager.registerPhoneAccount(
+        PhoneAccount
+          .builder(phoneAccountHandle, label)
+          .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
+          .setSupportedUriSchemes(listOf(PhoneAccount.SCHEME_SIP))
+          .build(),
+      )
+
+      true
+    } catch (error: Throwable) {
+      false
+    }
+  }
+
+  private fun ReadableMap.getNullableBoolean(key: String): Boolean? {
+    if (!hasKey(key) || isNull(key)) {
+      return null
+    }
+
+    return getBoolean(key)
+  }
+
+  private fun ReadableMap.getNullableString(key: String): String? {
+    if (!hasKey(key) || isNull(key)) {
+      return null
+    }
+
+    return getString(key)
+  }
+}

package/android/src/main/kotlin/ai/q9labs/chalk/reactnative/ChalkAndroidConnectionServicePackage.kt

@@ -0,0 +1,18 @@
+package ai.q9labs.chalk.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ChalkAndroidConnectionServicePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(
+      ChalkAndroidConnectionServiceModule(reactContext),
+    )
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/kotlin/ai/q9labs/chalk/reactnative/ChalkConnectionRegistry.kt

@@ -0,0 +1,120 @@
+package ai.q9labs.chalk.reactnative
+
+import android.content.ComponentName
+import android.content.Context
+import android.os.Build
+import android.telecom.DisconnectCause
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ConcurrentHashMap
+
+internal object ChalkConnectionRegistry {
+  const val phoneAccountId = "chalk-self-managed-calls"
+  const val eventName = "ChalkAndroidConnectionServiceEvent"
+  const val extraCallId = "chalk.call_id"
+  const val extraSpaceId = "chalk.space_id"
+  const val extraSpaceName = "chalk.space_name"
+  const val extraDisplayName = "chalk.display_name"
+  const val extraHasVideo = "chalk.has_video"
+
+  private val pendingCalls = ConcurrentHashMap<String, ChalkCallSpec>()
+  private val activeConnections = ConcurrentHashMap<String, ChalkSelfManagedConnection>()
+
+  @Volatile
+  private var bridgeContext: ReactApplicationContext? = null
+
+  data class ChalkCallSpec(
+    val callId: String,
+    val spaceId: String,
+    val spaceName: String,
+    val displayName: String,
+    val hasVideo: Boolean,
+  )
+
+  fun isSupported(context: Context): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return false
+    }
+
+    return context.getSystemService(TelecomManager::class.java) != null
+  }
+
+  fun phoneAccountHandle(context: Context): PhoneAccountHandle {
+    return PhoneAccountHandle(ComponentName(context, ChalkSelfManagedConnectionService::class.java), phoneAccountId)
+  }
+
+  fun rememberPendingCall(spec: ChalkCallSpec) {
+    pendingCalls[spec.callId] = spec
+  }
+
+  fun findPendingCall(callId: String): ChalkCallSpec? {
+    return pendingCalls[callId]
+  }
+
+  fun registerConnection(callId: String, connection: ChalkSelfManagedConnection) {
+    activeConnections[callId] = connection
+    pendingCalls.remove(callId)
+  }
+
+  fun unregisterConnection(callId: String) {
+    activeConnections.remove(callId)
+    pendingCalls.remove(callId)
+  }
+
+  fun setActive(callId: String): Boolean {
+    val connection = activeConnections[callId] ?: return false
+    connection.markActive()
+    return true
+  }
+
+  fun disconnect(callId: String, reason: String?, label: String?): Boolean {
+    val removedPendingCall = pendingCalls.remove(callId) != null
+    val connection = activeConnections.remove(callId) ?: return removedPendingCall
+    connection.markDisconnected(buildDisconnectCause(reason, label))
+    return true
+  }
+
+  fun attachBridge(context: ReactApplicationContext) {
+    bridgeContext = context
+  }
+
+  fun detachBridge(context: ReactApplicationContext) {
+    if (bridgeContext == context) {
+      bridgeContext = null
+    }
+  }
+
+  fun emitDisconnectRequested(callId: String, reason: String) {
+    val context = bridgeContext ?: return
+    if (!context.hasActiveCatalystInstance()) {
+      return
+    }
+
+    val payload = Arguments.createMap().apply {
+      putString("type", "disconnect")
+      putString("callId", callId)
+      putString("reason", reason)
+    }
+
+    context
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, payload)
+  }
+
+  private fun buildDisconnectCause(reason: String?, label: String?): DisconnectCause {
+    val code =
+      when (reason) {
+        "canceled" -> DisconnectCause.CANCELED
+        "rejected" -> DisconnectCause.REJECTED
+        "missed" -> DisconnectCause.MISSED
+        "remote" -> DisconnectCause.REMOTE
+        "error" -> DisconnectCause.ERROR
+        else -> DisconnectCause.LOCAL
+      }
+
+    return DisconnectCause(code, label)
+  }
+}

package/android/src/main/kotlin/ai/q9labs/chalk/reactnative/ChalkSelfManagedConnection.kt

@@ -0,0 +1,64 @@
+package ai.q9labs.chalk.reactnative
+
+import android.net.Uri
+import android.telecom.Connection
+import android.telecom.DisconnectCause
+import android.telecom.PhoneAccount
+import android.telecom.TelecomManager
+import android.telecom.VideoProfile
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal class ChalkSelfManagedConnection(
+  private val callSpec: ChalkConnectionRegistry.ChalkCallSpec,
+) : Connection() {
+  private val isClosed = AtomicBoolean(false)
+
+  init {
+    val uriToken = callSpec.spaceId.lowercase().replace("[^a-z0-9._-]".toRegex(), "-")
+    setAddress(Uri.fromParts(PhoneAccount.SCHEME_SIP, "$uriToken@chalkmeet.local", null), TelecomManager.PRESENTATION_ALLOWED)
+    setCallerDisplayName(callSpec.spaceName, TelecomManager.PRESENTATION_ALLOWED)
+    setConnectionProperties(PROPERTY_SELF_MANAGED)
+    setAudioModeIsVoip(true)
+    setInitializing()
+    setVideoState(if (callSpec.hasVideo) VideoProfile.STATE_BIDIRECTIONAL else VideoProfile.STATE_AUDIO_ONLY)
+  }
+
+  fun markActive() {
+    if (isClosed.get()) {
+      return
+    }
+
+    setInitialized()
+    setActive()
+  }
+
+  fun markDisconnected(cause: DisconnectCause) {
+    finish(cause, null)
+  }
+
+  override fun onAbort() {
+    finish(DisconnectCause(DisconnectCause.CANCELED), "canceled")
+  }
+
+  override fun onDisconnect() {
+    finish(DisconnectCause(DisconnectCause.LOCAL), "local")
+  }
+
+  override fun onReject() {
+    finish(DisconnectCause(DisconnectCause.REJECTED), "rejected")
+  }
+
+  private fun finish(cause: DisconnectCause, reason: String?) {
+    if (!isClosed.compareAndSet(false, true)) {
+      return
+    }
+
+    if (reason != null) {
+      ChalkConnectionRegistry.emitDisconnectRequested(callSpec.callId, reason)
+    }
+
+    ChalkConnectionRegistry.unregisterConnection(callSpec.callId)
+    setDisconnected(cause)
+    destroy()
+  }
+}

package/android/src/main/kotlin/ai/q9labs/chalk/reactnative/ChalkSelfManagedConnectionService.kt

@@ -0,0 +1,35 @@
+package ai.q9labs.chalk.reactnative
+
+import android.telecom.Connection
+import android.telecom.ConnectionRequest
+import android.telecom.ConnectionService
+import android.telecom.DisconnectCause
+import android.telecom.PhoneAccountHandle
+
+class ChalkSelfManagedConnectionService : ConnectionService() {
+  override fun onCreateIncomingConnection(connectionManagerPhoneAccount: PhoneAccountHandle, request: ConnectionRequest): Connection {
+    return Connection.createFailedConnection(DisconnectCause(DisconnectCause.ERROR))
+  }
+
+  override fun onCreateIncomingConnectionFailed(connectionManagerPhoneAccount: PhoneAccountHandle, request: ConnectionRequest) {
+    // Chalk currently starts telecom calls from app-driven Space joins only.
+  }
+
+  override fun onCreateOutgoingConnection(connectionManagerPhoneAccount: PhoneAccountHandle, request: ConnectionRequest): Connection {
+    val extras = request.extras
+    val callId = extras?.getString(ChalkConnectionRegistry.extraCallId)
+
+    val callSpec =
+      callId?.let(ChalkConnectionRegistry::findPendingCall)
+        ?: return Connection.createFailedConnection(DisconnectCause(DisconnectCause.ERROR))
+
+    val connection = ChalkSelfManagedConnection(callSpec)
+    ChalkConnectionRegistry.registerConnection(callSpec.callId, connection)
+    return connection
+  }
+
+  override fun onCreateOutgoingConnectionFailed(connectionManagerPhoneAccount: PhoneAccountHandle, request: ConnectionRequest) {
+    val callId = request.extras?.getString(ChalkConnectionRegistry.extraCallId) ?: return
+    ChalkConnectionRegistry.disconnect(callId, "error", "Android could not start the telecom call.")
+  }
+}

package/dist/android/connection-service.d.ts

@@ -0,0 +1,26 @@
+export type AndroidConnectionServiceDisconnectReason = "canceled" | "error" | "local" | "missed" | "rejected" | "remote";
+export interface AndroidConnectionServiceCall {
+    callId: string;
+    spaceId: string;
+    spaceName: string;
+    displayName: string;
+    hasVideo?: boolean;
+}
+export interface AndroidConnectionServiceDisconnectEvent {
+    type: "disconnect";
+    callId: string;
+    reason: AndroidConnectionServiceDisconnectReason;
+}
+export interface AndroidConnectionServiceEndCallOptions {
+    reason?: AndroidConnectionServiceDisconnectReason;
+    label?: string;
+}
+type AndroidConnectionServiceEvent = AndroidConnectionServiceDisconnectEvent;
+export declare function isAndroidConnectionServiceSupported(): Promise<boolean>;
+export declare function ensureAndroidConnectionServiceRegistered(): Promise<boolean>;
+export declare function startAndroidConnectionServiceCall(call: AndroidConnectionServiceCall): Promise<boolean>;
+export declare function setAndroidConnectionServiceActive(callId: string): Promise<boolean>;
+export declare function endAndroidConnectionServiceCall(callId: string, options?: AndroidConnectionServiceEndCallOptions): Promise<boolean>;
+export declare function addAndroidConnectionServiceListener(listener: (event: AndroidConnectionServiceEvent) => void): () => void;
+export {};
+//# sourceMappingURL=connection-service.d.ts.map

package/dist/android/connection-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-service.d.ts","sourceRoot":"","sources":["../../src/android/connection-service.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,wCAAwC,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEzH,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,uCAAuC;IACtD,IAAI,EAAE,YAAY,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,wCAAwC,CAAC;CAClD;AAED,MAAM,WAAW,sCAAsC;IACrD,MAAM,CAAC,EAAE,wCAAwC,CAAC;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,6BAA6B,GAAG,uCAAuC,CAAC;AAqB7E,wBAAsB,mCAAmC,IAAI,OAAO,CAAC,OAAO,CAAC,CAO5E;AAED,wBAAsB,wCAAwC,IAAI,OAAO,CAAC,OAAO,CAAC,CAOjF;AAED,wBAAsB,iCAAiC,CAAC,IAAI,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC,CAO5G;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOxF;AAED,wBAAsB,+BAA+B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,sCAA2C,GAAG,OAAO,CAAC,OAAO,CAAC,CAO5I;AAED,wBAAgB,mCAAmC,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,6BAA6B,KAAK,IAAI,GAAG,MAAM,IAAI,CAcxH"}

package/dist/android.d.ts

@@ -0,0 +1,2 @@
+export * from "./index";
+//# sourceMappingURL=android.d.ts.map

package/dist/android.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"android.d.ts","sourceRoot":"","sources":["../src/android.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}