@kaleem766/react-native-incoming-call 0.1.0

package/android/src/main/java/com/margelo/nitro/incomingcall/IncomingCallPackage.kt

@@ -0,0 +1,31 @@
+package com.margelo.nitro.incomingcall
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+import com.margelo.nitro.incomingcall.views.HybridIncomingCallManager
+
+class IncomingCallPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == IncomingCallModule.MODULE_NAME) {
+            IncomingCallModule(reactContext)
+        } else null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(HybridIncomingCallManager())
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("incomingcall")
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/incomingcall/IncomingCallService.kt

@@ -0,0 +1,109 @@
+package com.margelo.nitro.incomingcall
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+
+/**
+ * Foreground service that keeps the incoming call alive when the app is in the
+ * background or in the killed state. It immediately starts [IncomingCallActivity]
+ * so the full-screen UI appears above the lock screen.
+ */
+class IncomingCallService : Service() {
+
+    companion object {
+        private const val CHANNEL_ID = "incoming_call_channel"
+        private const val NOTIFICATION_ID = 1001
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val uuid = intent?.getStringExtra("uuid") ?: ""
+        val callerName = intent?.getStringExtra("callerName") ?: "Unknown"
+        val avatar = intent?.getStringExtra("avatar")
+        val backgroundColor = intent?.getStringExtra("backgroundColor")
+        val callType = intent?.getStringExtra("callType") ?: "audio"
+        val timeout = intent?.getLongExtra("timeout", 30000L) ?: 30000L
+
+        createNotificationChannel()
+        startForeground(NOTIFICATION_ID, buildNotification(callerName, uuid))
+
+        // Launch full-screen incoming call activity
+        val activityIntent = Intent(this, IncomingCallActivity::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            putExtra("uuid", uuid)
+            putExtra("callerName", callerName)
+            putExtra("avatar", avatar)
+            putExtra("backgroundColor", backgroundColor)
+            putExtra("callType", callType)
+            putExtra("timeout", timeout)
+        }
+        startActivity(activityIntent)
+
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            @Suppress("DEPRECATION")
+            stopForeground(true)
+        }
+    }
+
+    // ──────────────────────────────────────────────────────────────────────────
+    // Notification helpers
+    // ──────────────────────────────────────────────────────────────────────────
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Incoming Calls",
+                NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                description = "Displays incoming call alerts"
+                setSound(null, null)
+                setBypassDnd(true)
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+            }
+            val manager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun buildNotification(callerName: String, uuid: String): Notification {
+        // Full-screen intent so the activity shows on the lock screen
+        val fullScreenIntent = Intent(this, IncomingCallActivity::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            putExtra("uuid", uuid)
+            putExtra("callerName", callerName)
+        }
+        val fullScreenPendingIntent = PendingIntent.getActivity(
+            this,
+            0,
+            fullScreenIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("Incoming Call")
+            .setContentText(callerName)
+            .setSmallIcon(android.R.drawable.ic_menu_call)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setOngoing(true)
+            .setAutoCancel(false)
+            .setFullScreenIntent(fullScreenPendingIntent, true)
+            .build()
+    }
+}

package/ios/IncomingCall.swift

@@ -0,0 +1,28 @@
+class HybridIncomingCall : HybridIncomingCallSpec {
+
+  // UIView
+  var view: UIView = UIView()
+
+  // props
+  var color: String = "#000" {
+    didSet {
+      view.backgroundColor = hexStringToUIColor(hexColor: color)
+    }
+  }
+  
+  func hexStringToUIColor(hexColor: String) -> UIColor {
+    let stringScanner = Scanner(string: hexColor)
+
+    if(hexColor.hasPrefix("#")) {
+      stringScanner.scanLocation = 1
+    }
+    var color: UInt32 = 0
+    stringScanner.scanHexInt32(&color)
+
+    let r = CGFloat(Int(color >> 16) & 0x000000FF)
+    let g = CGFloat(Int(color >> 8) & 0x000000FF)
+    let b = CGFloat(Int(color) & 0x000000FF)
+
+    return UIColor(red: r / 255.0, green: g / 255.0, blue: b / 255.0, alpha: 1)
+  }  
+}

package/lib/module/IncomingCall.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=IncomingCall.nitro.js.map

package/lib/module/IncomingCall.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["IncomingCall.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,137 @@
+"use strict";
+
+import { getHostComponent } from 'react-native-nitro-modules';
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+const IncomingCallConfig = require('../nitrogen/generated/shared/json/IncomingCallConfig.json');
+export const IncomingCallView = getHostComponent('IncomingCall', () => IncomingCallConfig);
+
+// Types for the API
+
+// Event emitter for handling incoming call events
+class IncomingCallEventManager {
+  listeners = new Map();
+  constructor() {
+    if (Platform.OS === 'android' && NativeModules.IncomingCallModule) {
+      this.eventEmitter = new NativeEventEmitter(NativeModules.IncomingCallModule);
+      this.setupNativeListeners();
+    }
+  }
+  setupNativeListeners() {
+    if (!this.eventEmitter) return;
+    this.eventEmitter.addListener('onAnswer', data => {
+      this.emit('onAnswer', data);
+    });
+    this.eventEmitter.addListener('onReject', data => {
+      this.emit('onReject', data);
+    });
+    this.eventEmitter.addListener('onTimeout', data => {
+      this.emit('onTimeout', data);
+    });
+  }
+  emit(event, data) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      listeners.forEach(listener => listener(data));
+    }
+  }
+  addEventListener(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set());
+    }
+    this.listeners.get(event).add(listener);
+
+    // Return unsubscribe function
+    return () => {
+      this.listeners.get(event)?.delete(listener);
+    };
+  }
+  removeEventListener(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+}
+const eventManager = new IncomingCallEventManager();
+
+// Main API class
+export class IncomingCall {
+  /**
+   * Display an incoming call screen
+   */
+  static async display(options) {
+    try {
+      if (Platform.OS === 'android' && NativeModules.IncomingCallModule) {
+        return await NativeModules.IncomingCallModule.displayIncomingCall(options);
+      } else {
+        console.warn('IncomingCall: Native module not available');
+      }
+    } catch (error) {
+      console.error('IncomingCall: Failed to display call', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Answer the current incoming call
+   */
+  static async answer(uuid) {
+    try {
+      if (Platform.OS === 'android' && NativeModules.IncomingCallModule) {
+        return await NativeModules.IncomingCallModule.answerCall(uuid);
+      } else {
+        console.warn('IncomingCall: Native module not available');
+      }
+    } catch (error) {
+      console.error('IncomingCall: Failed to answer call', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Reject the current incoming call
+   */
+  static async reject(uuid) {
+    try {
+      if (Platform.OS === 'android' && NativeModules.IncomingCallModule) {
+        return await NativeModules.IncomingCallModule.rejectCall(uuid);
+      } else {
+        console.warn('IncomingCall: Native module not available');
+      }
+    } catch (error) {
+      console.error('IncomingCall: Failed to reject call', error);
+      throw error;
+    }
+  }
+
+  /**
+   * End an ongoing call
+   */
+  static async end(uuid) {
+    try {
+      if (Platform.OS === 'android' && NativeModules.IncomingCallModule) {
+        return await NativeModules.IncomingCallModule.endCall(uuid);
+      } else {
+        console.warn('IncomingCall: Native module not available');
+      }
+    } catch (error) {
+      console.error('IncomingCall: Failed to end call', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Add event listener for call events
+   */
+  static addEventListener(event, listener) {
+    return eventManager.addEventListener(event, listener);
+  }
+
+  /**
+   * Remove event listener for call events
+   */
+  static removeEventListener(event, listener) {
+    eventManager.removeEventListener(event, listener);
+  }
+}
+
+// Default export
+export default IncomingCall;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","NativeModules","NativeEventEmitter","Platform","IncomingCallConfig","require","IncomingCallView","IncomingCallEventManager","listeners","Map","constructor","OS","IncomingCallModule","eventEmitter","setupNativeListeners","addListener","data","emit","event","get","forEach","listener","addEventListener","has","set","Set","add","delete","removeEventListener","eventManager","IncomingCall","display","options","displayIncomingCall","console","warn","error","answer","uuid","answerCall","reject","rejectCall","end","endCall"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAC7D,SAASC,aAAa,EAAEC,kBAAkB,EAAEC,QAAQ,QAAQ,cAAc;AAC1E,MAAMC,kBAAkB,GAAGC,OAAO,CAAC,2DAA2D,CAAC;AAM/F,OAAO,MAAMC,gBAAgB,GAAGN,gBAAgB,CAG9C,cAAc,EAAE,MAAMI,kBAAkB,CAAC;;AAE3C;;AAiBA;AACA,MAAMG,wBAAwB,CAAC;EAErBC,SAAS,GAA2E,IAAIC,GAAG,CAAC,CAAC;EAErGC,WAAWA,CAAA,EAAG;IACZ,IAAIP,QAAQ,CAACQ,EAAE,KAAK,SAAS,IAAIV,aAAa,CAACW,kBAAkB,EAAE;MACjE,IAAI,CAACC,YAAY,GAAG,IAAIX,kBAAkB,CAACD,aAAa,CAACW,kBAAkB,CAAC;MAC5E,IAAI,CAACE,oBAAoB,CAAC,CAAC;IAC7B;EACF;EAEQA,oBAAoBA,CAAA,EAAG;IAC7B,IAAI,CAAC,IAAI,CAACD,YAAY,EAAE;IAExB,IAAI,CAACA,YAAY,CAACE,WAAW,CAAC,UAAU,EAAGC,IAAS,IAAK;MACvD,IAAI,CAACC,IAAI,CAAC,UAAU,EAAED,IAA6B,CAAC;IACtD,CAAC,CAAC;IAEF,IAAI,CAACH,YAAY,CAACE,WAAW,CAAC,UAAU,EAAGC,IAAS,IAAK;MACvD,IAAI,CAACC,IAAI,CAAC,UAAU,EAAED,IAA6B,CAAC;IACtD,CAAC,CAAC;IAEF,IAAI,CAACH,YAAY,CAACE,WAAW,CAAC,WAAW,EAAGC,IAAS,IAAK;MACxD,IAAI,CAACC,IAAI,CAAC,WAAW,EAAED,IAA6B,CAAC;IACvD,CAAC,CAAC;EACJ;EAEQC,IAAIA,CAACC,KAA4B,EAAEF,IAA2B,EAAE;IACtE,MAAMR,SAAS,GAAG,IAAI,CAACA,SAAS,CAACW,GAAG,CAACD,KAAK,CAAC;IAC3C,IAAIV,SAAS,EAAE;MACbA,SAAS,CAACY,OAAO,CAACC,QAAQ,IAAIA,QAAQ,CAACL,IAAI,CAAC,CAAC;IAC/C;EACF;EAEAM,gBAAgBA,CAACJ,KAA4B,EAAEG,QAA+C,EAAE;IAC9F,IAAI,CAAC,IAAI,CAACb,SAAS,CAACe,GAAG,CAACL,KAAK,CAAC,EAAE;MAC9B,IAAI,CAACV,SAAS,CAACgB,GAAG,CAACN,KAAK,EAAE,IAAIO,GAAG,CAAC,CAAC,CAAC;IACtC;IACA,IAAI,CAACjB,SAAS,CAACW,GAAG,CAACD,KAAK,CAAC,CAAEQ,GAAG,CAACL,QAAQ,CAAC;;IAExC;IACA,OAAO,MAAM;MACX,IAAI,CAACb,SAAS,CAACW,GAAG,CAACD,KAAK,CAAC,EAAES,MAAM,CAACN,QAAQ,CAAC;IAC7C,CAAC;EACH;EAEAO,mBAAmBA,CAACV,KAA4B,EAAEG,QAA+C,EAAE;IACjG,IAAI,CAACb,SAAS,CAACW,GAAG,CAACD,KAAK,CAAC,EAAES,MAAM,CAACN,QAAQ,CAAC;EAC7C;AACF;AAEA,MAAMQ,YAAY,GAAG,IAAItB,wBAAwB,CAAC,CAAC;;AAEnD;AACA,OAAO,MAAMuB,YAAY,CAAC;EACxB;AACF;AACA;EACE,aAAaC,OAAOA,CAACC,OAAmC,EAAiB;IACvE,IAAI;MACF,IAAI7B,QAAQ,CAACQ,EAAE,KAAK,SAAS,IAAIV,aAAa,CAACW,kBAAkB,EAAE;QACjE,OAAO,MAAMX,aAAa,CAACW,kBAAkB,CAACqB,mBAAmB,CAACD,OAAO,CAAC;MAC5E,CAAC,MAAM;QACLE,OAAO,CAACC,IAAI,CAAC,2CAA2C,CAAC;MAC3D;IACF,CAAC,CAAC,OAAOC,KAAK,EAAE;MACdF,OAAO,CAACE,KAAK,CAAC,sCAAsC,EAAEA,KAAK,CAAC;MAC5D,MAAMA,KAAK;IACb;EACF;;EAEA;AACF;AACA;EACE,aAAaC,MAAMA,CAACC,IAAY,EAAiB;IAC/C,IAAI;MACF,IAAInC,QAAQ,CAACQ,EAAE,KAAK,SAAS,IAAIV,aAAa,CAACW,kBAAkB,EAAE;QACjE,OAAO,MAAMX,aAAa,CAACW,kBAAkB,CAAC2B,UAAU,CAACD,IAAI,CAAC;MAChE,CAAC,MAAM;QACLJ,OAAO,CAACC,IAAI,CAAC,2CAA2C,CAAC;MAC3D;IACF,CAAC,CAAC,OAAOC,KAAK,EAAE;MACdF,OAAO,CAACE,KAAK,CAAC,qCAAqC,EAAEA,KAAK,CAAC;MAC3D,MAAMA,KAAK;IACb;EACF;;EAEA;AACF;AACA;EACE,aAAaI,MAAMA,CAACF,IAAY,EAAiB;IAC/C,IAAI;MACF,IAAInC,QAAQ,CAACQ,EAAE,KAAK,SAAS,IAAIV,aAAa,CAACW,kBAAkB,EAAE;QACjE,OAAO,MAAMX,aAAa,CAACW,kBAAkB,CAAC6B,UAAU,CAACH,IAAI,CAAC;MAChE,CAAC,MAAM;QACLJ,OAAO,CAACC,IAAI,CAAC,2CAA2C,CAAC;MAC3D;IACF,CAAC,CAAC,OAAOC,KAAK,EAAE;MACdF,OAAO,CAACE,KAAK,CAAC,qCAAqC,EAAEA,KAAK,CAAC;MAC3D,MAAMA,KAAK;IACb;EACF;;EAEA;AACF;AACA;EACE,aAAaM,GAAGA,CAACJ,IAAY,EAAiB;IAC5C,IAAI;MACF,IAAInC,QAAQ,CAACQ,EAAE,KAAK,SAAS,IAAIV,aAAa,CAACW,kBAAkB,EAAE;QACjE,OAAO,MAAMX,aAAa,CAACW,kBAAkB,CAAC+B,OAAO,CAACL,IAAI,CAAC;MAC7D,CAAC,MAAM;QACLJ,OAAO,CAACC,IAAI,CAAC,2CAA2C,CAAC;MAC3D;IACF,CAAC,CAAC,OAAOC,KAAK,EAAE;MACdF,OAAO,CAACE,KAAK,CAAC,kCAAkC,EAAEA,KAAK,CAAC;MACxD,MAAMA,KAAK;IACb;EACF;;EAEA;AACF;AACA;EACE,OAAOd,gBAAgBA,CACrBJ,KAA4B,EAC5BG,QAA+C,EACnC;IACZ,OAAOQ,YAAY,CAACP,gBAAgB,CAACJ,KAAK,EAAEG,QAAQ,CAAC;EACvD;;EAEA;AACF;AACA;EACE,OAAOO,mBAAmBA,CACxBV,KAA4B,EAC5BG,QAA+C,EACzC;IACNQ,YAAY,CAACD,mBAAmB,CAACV,KAAK,EAAEG,QAAQ,CAAC;EACnD;AACF;;AAEA;AACA,eAAeS,YAAY","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/IncomingCall.nitro.d.ts

@@ -0,0 +1,21 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+export interface IncomingCallProps extends HybridViewProps {
+    /** Background color of the call screen (CSS hex, e.g. "#1A1A2E") */
+    color: string;
+    /** Caller's display name */
+    callerName?: string;
+    /** Remote avatar URL */
+    avatar?: string;
+    /** "audio" | "video" – defaults to "audio" */
+    callType?: string;
+    /** Auto-reject timeout in milliseconds – defaults to 30000 */
+    timeout?: number;
+}
+export interface IncomingCallMethods extends HybridViewMethods {
+    /** Programmatically answer the call rendered in this view */
+    answerCall(): void;
+    /** Programmatically reject the call rendered in this view */
+    rejectCall(): void;
+}
+export type IncomingCall = HybridView<IncomingCallProps, IncomingCallMethods>;
+//# sourceMappingURL=IncomingCall.nitro.d.ts.map

package/lib/typescript/src/IncomingCall.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IncomingCall.nitro.d.ts","sourceRoot":"","sources":["../../../src/IncomingCall.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,6DAA6D;IAC7D,UAAU,IAAI,IAAI,CAAC;IACnB,6DAA6D;IAC7D,UAAU,IAAI,IAAI,CAAC;CACpB;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,43 @@
+import type { IncomingCallMethods, IncomingCallProps } from './IncomingCall.nitro';
+export declare const IncomingCallView: import("react-native-nitro-modules").ReactNativeView<IncomingCallProps, IncomingCallMethods>;
+export interface IncomingCallDisplayOptions {
+    uuid: string;
+    callerName: string;
+    avatar?: string;
+    callType?: 'audio' | 'video';
+    backgroundColor?: string;
+    timeout?: number;
+}
+export type IncomingCallEventType = 'onAnswer' | 'onReject' | 'onTimeout';
+export interface IncomingCallEventData {
+    uuid: string;
+    timestamp: number;
+}
+export declare class IncomingCall {
+    /**
+     * Display an incoming call screen
+     */
+    static display(options: IncomingCallDisplayOptions): Promise<void>;
+    /**
+     * Answer the current incoming call
+     */
+    static answer(uuid: string): Promise<void>;
+    /**
+     * Reject the current incoming call
+     */
+    static reject(uuid: string): Promise<void>;
+    /**
+     * End an ongoing call
+     */
+    static end(uuid: string): Promise<void>;
+    /**
+     * Add event listener for call events
+     */
+    static addEventListener(event: IncomingCallEventType, listener: (data: IncomingCallEventData) => void): () => void;
+    /**
+     * Remove event listener for call events
+     */
+    static removeEventListener(event: IncomingCallEventType, listener: (data: IncomingCallEventData) => void): void;
+}
+export default IncomingCall;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,gBAAgB,8FAGc,CAAC;AAG5C,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAyDD,qBAAa,YAAY;IACvB;;OAEG;WACU,OAAO,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxE;;OAEG;WACU,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAahD;;OAEG;WACU,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAahD;;OAEG;WACU,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa7C;;OAEG;IACH,MAAM,CAAC,gBAAgB,CACrB,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAC9C,MAAM,IAAI;IAIb;;OAEG;IACH,MAAM,CAAC,mBAAmB,CACxB,KAAK,EAAE,qBAAqB,EAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAC9C,IAAI;CAGR;AAGD,eAAe,YAAY,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["incomingcall"],
+  "ios": {
+    "iosModuleName": "IncomingCall"
+  },
+  "android": {
+    "androidNamespace": ["incomingcall"],
+    "androidCxxLibName": "incomingcall"
+  },
+  "autolinking": {
+    "IncomingCall": {
+      "swift": "HybridIncomingCall",
+      "kotlin": "HybridIncomingCall"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JHybridIncomingCallSpec.cpp

@@ -0,0 +1,101 @@
+///
+/// JHybridIncomingCallSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridIncomingCallSpec.hpp"
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::incomingcall {
+
+  std::shared_ptr<JHybridIncomingCallSpec> JHybridIncomingCallSpec::JavaPart::getJHybridIncomingCallSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridIncomingCallSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridIncomingCallSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridIncomingCallSpec::CxxPart::jhybriddata> JHybridIncomingCallSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridIncomingCallSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridIncomingCallSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridIncomingCallSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridIncomingCallSpec>(castJavaPart);
+  }
+
+  void JHybridIncomingCallSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridIncomingCallSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridIncomingCallSpec::getColor() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridIncomingCallSpec::setColor(const std::string& color) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* color */)>("setColor");
+    method(_javaPart, jni::make_jstring(color));
+  }
+  std::optional<std::string> JHybridIncomingCallSpec::getCallerName() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCallerName");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridIncomingCallSpec::setCallerName(const std::optional<std::string>& callerName) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* callerName */)>("setCallerName");
+    method(_javaPart, callerName.has_value() ? jni::make_jstring(callerName.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridIncomingCallSpec::getAvatar() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAvatar");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridIncomingCallSpec::setAvatar(const std::optional<std::string>& avatar) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* avatar */)>("setAvatar");
+    method(_javaPart, avatar.has_value() ? jni::make_jstring(avatar.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridIncomingCallSpec::getCallType() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCallType");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridIncomingCallSpec::setCallType(const std::optional<std::string>& callType) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* callType */)>("setCallType");
+    method(_javaPart, callType.has_value() ? jni::make_jstring(callType.value()) : nullptr);
+  }
+  std::optional<double> JHybridIncomingCallSpec::getTimeout() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getTimeout");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridIncomingCallSpec::setTimeout(std::optional<double> timeout) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* timeout */)>("setTimeout");
+    method(_javaPart, timeout.has_value() ? jni::JDouble::valueOf(timeout.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridIncomingCallSpec::answerCall() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("answerCall");
+    method(_javaPart);
+  }
+  void JHybridIncomingCallSpec::rejectCall() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("rejectCall");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::incomingcall

package/nitrogen/generated/android/c++/JHybridIncomingCallSpec.hpp

@@ -0,0 +1,73 @@
+///
+/// HybridIncomingCallSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridIncomingCallSpec.hpp"
+
+
+
+
+namespace margelo::nitro::incomingcall {
+
+  using namespace facebook;
+
+  class JHybridIncomingCallSpec: public virtual HybridIncomingCallSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/incomingcall/HybridIncomingCallSpec;";
+      std::shared_ptr<JHybridIncomingCallSpec> getJHybridIncomingCallSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/incomingcall/HybridIncomingCallSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridIncomingCallSpec(const jni::local_ref<JHybridIncomingCallSpec::JavaPart>& javaPart):
+      HybridObject(HybridIncomingCallSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridIncomingCallSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridIncomingCallSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getColor() override;
+    void setColor(const std::string& color) override;
+    std::optional<std::string> getCallerName() override;
+    void setCallerName(const std::optional<std::string>& callerName) override;
+    std::optional<std::string> getAvatar() override;
+    void setAvatar(const std::optional<std::string>& avatar) override;
+    std::optional<std::string> getCallType() override;
+    void setCallType(const std::optional<std::string>& callType) override;
+    std::optional<double> getTimeout() override;
+    void setTimeout(std::optional<double> timeout) override;
+
+  public:
+    // Methods
+    void answerCall() override;
+    void rejectCall() override;
+
+  private:
+    jni::global_ref<JHybridIncomingCallSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::incomingcall