voip-callkit 0.0.1

package/README.md

@@ -0,0 +1,154 @@
+# voip-callkit
+
+capacitor plugin for callkit and voip
+
+## Install
+
+```bash
+npm install voip-callkit
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`register(...)`](#register)
+* [`incomingCall(...)`](#incomingcall)
+* [`addListener('registration', ...)`](#addlistenerregistration)
+* [`addListener('callAnswered', ...)`](#addlistenercallanswered)
+* [`addListener('callStarted', ...)`](#addlistenercallstarted)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### register(...)
+
+```typescript
+register(options: { topic: string; }) => Promise<void>
+```
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ topic: string; }</code> |
+
+--------------------
+
+
+### incomingCall(...)
+
+```typescript
+incomingCall(options: { from: string; }) => Promise<void>
+```
+
+| Param         | Type                           |
+| ------------- | ------------------------------ |
+| **`options`** | <code>{ from: string; }</code> |
+
+--------------------
+
+
+### addListener('registration', ...)
+
+```typescript
+addListener(eventName: 'registration', listenerFunc: (token: Token) => void) => Promise<PluginListenerHandle> & PluginListenerHandle
+```
+
+| Param              | Type                                                        |
+| ------------------ | ----------------------------------------------------------- |
+| **`eventName`**    | <code>'registration'</code>                                 |
+| **`listenerFunc`** | <code>(token: <a href="#token">Token</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt; & <a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener('callAnswered', ...)
+
+```typescript
+addListener(eventName: 'callAnswered', listenerFunc: (callDate: CallData) => void) => Promise<PluginListenerHandle> & PluginListenerHandle
+```
+
+| Param              | Type                                                                 |
+| ------------------ | -------------------------------------------------------------------- |
+| **`eventName`**    | <code>'callAnswered'</code>                                          |
+| **`listenerFunc`** | <code>(callDate: <a href="#calldata">CallData</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt; & <a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### addListener('callStarted', ...)
+
+```typescript
+addListener(eventName: 'callStarted', listenerFunc: (callDate: CallData) => void) => Promise<PluginListenerHandle> & PluginListenerHandle
+```
+
+| Param              | Type                                                                 |
+| ------------------ | -------------------------------------------------------------------- |
+| **`eventName`**    | <code>'callStarted'</code>                                           |
+| **`listenerFunc`** | <code>(callDate: <a href="#calldata">CallData</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt; & <a href="#pluginlistenerhandle">PluginListenerHandle</a></code>
+
+--------------------
+
+
+### Interfaces
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
+#### Token
+
+| Prop        | Type                |
+| ----------- | ------------------- |
+| **`token`** | <code>string</code> |
+
+
+#### CallData
+
+| Prop               | Type                |
+| ------------------ | ------------------- |
+| **`connectionId`** | <code>string</code> |
+| **`username`**     | <code>string</code> |
+
+
+#### MessageCallData
+
+| Prop             | Type                   |
+| ---------------- | ---------------------- |
+| **`type`**       | <code>'message'</code> |
+| **`callbackId`** | <code>string</code>    |
+| **`pluginId`**   | <code>string</code>    |
+| **`methodName`** | <code>string</code>    |
+| **`options`**    | <code>any</code>       |
+
+
+#### ErrorCallData
+
+| Prop        | Type                                                                                           |
+| ----------- | ---------------------------------------------------------------------------------------------- |
+| **`type`**  | <code>'js.error'</code>                                                                        |
+| **`error`** | <code>{ message: string; url: string; line: number; col: number; errorObject: string; }</code> |
+
+
+### Type Aliases
+
+
+#### CallData
+
+<code><a href="#messagecalldata">MessageCallData</a> | <a href="#errorcalldata">ErrorCallData</a></code>
+
+</docgen-api>

package/VoipCallkit.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'VoipCallkit'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '12.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,58 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.1'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.2.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.2'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 30
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 21
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 30
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    jcenter()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,55 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.test.callkit">
+    
+    <uses-permission android:name="android.permission.CALL_PHONE"/>
+    <uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
+    <uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <uses-permission android:name="android.permission.VIBRATE" />
+
+    <application
+        android:usesCleartextTraffic="true"
+        >
+        <activity
+            android:name=".androidcall.CallActivity"
+            android:label="@string/app_name"
+            android:launchMode="singleTop"
+            android:configChanges="locale"
+
+            android:turnScreenOn="true"
+            android:autoRemoveFromRecents="true"
+            android:showWhenLocked="true"
+            android:windowSoftInputMode="adjustResize|stateHidden"
+            android:screenOrientation="portrait"
+            android:theme="@style/Theme.AppCompat.Light.NoActionBar"/>
+        <service android:name="com.test.callkit.MyConnectionService"
+            android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.telecom.ConnectionService" />
+            </intent-filter>
+        </service>
+        <service
+            android:name="com.test.callkit.androidcall.VoipForegroundService"
+            android:enabled="true"
+            android:stopWithTask="true"
+            android:exported="true"></service>
+        <receiver
+            android:name="com.test.callkit.androidcall.VoipForegroundServiceActionReceiver">
+        </receiver>
+        <service
+            android:name="com.test.callkit.androidcall.VoipBackgroundService"
+            android:enabled="true"
+            android:exported="false"
+            android:stopWithTask="true">
+
+        </service>
+        <service
+            android:name="com.test.callkit.MyFirebaseMessagingService">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT" />
+            </intent-filter>
+        </service>
+    </application>
+</manifest>

package/android/src/main/java/com/test/callkit/CallKitVoip.java

@@ -0,0 +1,12 @@
+package com.test.callkit;
+
+import android.util.Log;
+
+public class CallKitVoip {
+
+    public String echo(String value) {
+
+        Log.d("CallKitVoip","called");
+        return value;
+    }
+}

package/android/src/main/java/com/test/callkit/CallKitVoipPlugin.java

@@ -0,0 +1,81 @@
+package com.test.callkit;
+
+import com.getcapacitor.Bridge;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginHandle;
+import com.getcapacitor.PluginMethod;
+import com.google.firebase.messaging.FirebaseMessaging;
+
+
+import android.content.Context;
+import android.util.Log;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+public class CallKitVoipPlugin extends Plugin {
+    public  static  Bridge                      staticBridge = null;
+    public          MyFirebaseMessagingService  messagingService;
+
+
+    @Override
+    public void load(){
+        staticBridge   = this.bridge;
+
+
+        this.getActivity().getApplicationContext();
+
+    }
+
+    @PluginMethod
+    public void register(PluginCall call) {
+        final String topicName = call.getString("userToken");
+        Log.d("CallKitVoip","register");
+
+        if(topicName == null){
+            call.reject("Topic name hasn't been specified correctly");
+            return;
+        }
+        FirebaseMessaging
+                .getInstance()
+                .subscribeToTopic(topicName)
+                .addOnSuccessListener(unused -> {
+                    JSObject ret = new JSObject();
+                    Logger.debug("CallKit: Subscribed");
+                    ret.put("message", "Subscribed to topic " + topicName);
+                    call.resolve(ret);
+
+                })
+                .addOnFailureListener(e -> {
+                    Logger.debug("CallKit: Cannot subscribe");
+                    call.reject("Cant subscribe to topic" + topicName);
+                });
+        call.resolve();
+    }
+    public void notifyEvent(String eventName, String username, String connectionId){
+        Log.d("notifyEvent",eventName + "  " + username + "   " + connectionId);
+
+//        JSObject data = new JSObject();
+//        data.put("username",        username);
+//        data.put("connectionId",    connectionId);
+//        notifyListeners("callAnswered", data);
+    }
+
+
+
+    public static CallKitVoipPlugin getInstance() {
+        if (staticBridge == null || staticBridge.getWebView() == null)
+            return  null;
+
+        PluginHandle handler = staticBridge.getPlugin("CallKitVoip");
+
+        return handler == null
+                ? null
+                : (CallKitVoipPlugin) handler.getInstance();
+    }
+
+}

package/android/src/main/java/com/test/callkit/MyConnectionService.java

@@ -0,0 +1,200 @@
+package com.test.callkit;
+
+import android.content.Intent;
+import android.graphics.drawable.Icon;
+import android.os.Build;
+import android.os.Bundle;
+import android.telecom.Connection;
+import android.telecom.ConnectionRequest;
+import android.telecom.ConnectionService;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.StatusHints;
+import android.telecom.TelecomManager;
+import android.os.Handler;
+import android.net.Uri;
+import java.util.ArrayList;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+
+import com.getcapacitor.Logger;
+
+@RequiresApi(api = Build.VERSION_CODES.M)
+public class MyConnectionService extends ConnectionService {
+
+    private static String TAG = "MyConnectionService";
+    private static Connection conn;
+
+    public static Connection getConnection() {
+        return conn;
+    }
+
+    public static void deinitConnection() {
+        conn = null;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.M)
+    @Override
+    public Connection onCreateIncomingConnection(final PhoneAccountHandle connectionManagerPhoneAccount, final ConnectionRequest request) {
+        final Connection connection = new Connection() {
+            @RequiresApi(api = Build.VERSION_CODES.O)
+            @Override
+            public void onAnswer() {
+                this.setActive();
+                CallKitVoipPlugin plugin = CallKitVoipPlugin.getInstance();
+
+
+
+                if(plugin != null)
+                    plugin.notifyEvent("callAnswered",
+                            request.getExtras().getString("username"),
+                            request.getExtras().getString("connectionId")
+                    );
+
+
+                Intent launchIntent = getPackageManager().getLaunchIntentForPackage("app.appname");
+                if (launchIntent != null) {
+                    startActivity(launchIntent);//null pointer check in case package name was not found
+                }
+
+                this.setDisconnected(new DisconnectCause(DisconnectCause.LOCAL));
+
+            }
+
+            @Override
+            public void onReject() {
+                DisconnectCause cause = new DisconnectCause(DisconnectCause.REJECTED);
+                this.setDisconnected(cause);
+                this.destroy();
+                conn = null;
+//                ArrayList<CallbackContext> callbackContexts = AndroidCall.getCallbackContexts().get("reject");
+//                for (final CallbackContext callbackContext : callbackContexts) {
+//                    AndroidCall.getCordova().getThreadPool().execute(new Runnable() {
+//                        public void run() {
+//                            PluginResult result = new PluginResult(PluginResult.Status.OK, "reject event called successfully");
+//                            result.setKeepCallback(true);
+//                            callbackContext.sendPluginResult(result);
+//                        }
+//                    });
+//                }
+            }
+
+            @Override
+            public void onAbort() {
+                super.onAbort();
+            }
+
+            @Override
+            public void onDisconnect() {
+                DisconnectCause cause = new DisconnectCause(DisconnectCause.LOCAL);
+                this.setDisconnected(cause);
+                this.destroy();
+                conn = null;
+//                ArrayList<CallbackContext> callbackContexts = AndroidCall.getCallbackContexts().get("hangup");
+//                for (final CallbackContext callbackContext : callbackContexts) {
+//                    AndroidCall.getCordova().getThreadPool().execute(new Runnable() {
+//                        public void run() {
+//                            PluginResult result = new PluginResult(PluginResult.Status.OK, "hangup event called successfully");
+//                            result.setKeepCallback(true);
+//                            callbackContext.sendPluginResult(result);
+//                        }
+//                    });
+//                }
+            }
+        };
+        connection.setAddress(Uri.parse(request.getExtras().getString("from")), TelecomManager.PRESENTATION_ALLOWED);
+//        Icon icon = AndroidCall.getIcon();
+//        if(icon != null) {
+//            StatusHints statusHints = new StatusHints((CharSequence)"", icon, new Bundle());
+//            connection.setStatusHints(statusHints);
+//        }
+        conn = connection;
+//        ArrayList<CallbackContext> callbackContexts = AndroidCall.getCallbackContexts().get("receiveCall");
+//        for (final CallbackContext callbackContext : callbackContexts) {
+//            AndroidCall.getCordova().getThreadPool().execute(new Runnable() {
+//                public void run() {
+//                    PluginResult result = new PluginResult(PluginResult.Status.OK, "receiveCall event called successfully");
+//                    result.setKeepCallback(true);
+//                    callbackContext.sendPluginResult(result);
+//                }
+//            });
+//        }
+        return connection;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.M)
+    @Override
+    public Connection onCreateOutgoingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) {
+        final Connection connection = new Connection() {
+            @Override
+            public void onAnswer() {
+                super.onAnswer();
+            }
+
+            @Override
+            public void onReject() {
+                super.onReject();
+            }
+
+            @Override
+            public void onAbort() {
+                super.onAbort();
+            }
+
+            @Override
+            public void onDisconnect() {
+                DisconnectCause cause = new DisconnectCause(DisconnectCause.LOCAL);
+                this.setDisconnected(cause);
+                this.destroy();
+                conn = null;
+//                ArrayList<CallbackContext> callbackContexts = AndroidCall.getCallbackContexts().get("hangup");
+//                for (final CallbackContext callbackContext : callbackContexts) {
+//                    AndroidCall.getCordova().getThreadPool().execute(new Runnable() {
+//                        public void run() {
+//                            PluginResult result = new PluginResult(PluginResult.Status.OK, "hangup event called successfully");
+//                            result.setKeepCallback(true);
+//                            callbackContext.sendPluginResult(result);
+//                        }
+//                    });
+//                }
+            }
+
+            @Override
+            public void onStateChanged(int state) {
+                if(state == Connection.STATE_DIALING) {
+                    final Handler handler = new Handler();
+                    handler.postDelayed(new Runnable() {
+                        @Override
+                        public void run() {
+//                            Intent intent = new Intent(AndroidCall.getCapacitor().getActivity().getApplicationContext(), AndroidCall.getCordova().getActivity().getClass());
+//                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_SINGLE_TOP);
+//                            AndroidCall.getCapacitor().getActivity().getApplicationContext().startActivity(intent);
+                        }
+                    }, 500);
+                }
+            }
+        };
+        connection.setAddress(Uri.parse(request.getExtras().getString("to")), TelecomManager.PRESENTATION_ALLOWED);
+//        Icon icon = AndroidCall.getIcon();
+//        if(icon != null) {
+//            StatusHints statusHints = new StatusHints((CharSequence)"", icon, new Bundle());
+//            connection.setStatusHints(statusHints);
+//        }
+        connection.setDialing();
+        conn = connection;
+//        ArrayList<CallbackContext> callbackContexts = AndroidCall.getCallbackContexts().get("sendCall");
+//        if(callbackContexts != null) {
+//            for (final CallbackContext callbackContext : callbackContexts) {
+//                AndroidCall.getCordova().getThreadPool().execute(new Runnable() {
+//                    public void run() {
+//                        PluginResult result = new PluginResult(PluginResult.Status.OK, "sendCall event called successfully");
+//                        result.setKeepCallback(true);
+//                        callbackContext.sendPluginResult(result);
+//                    }
+//                });
+//            }
+//        }
+        return connection;
+    }
+}

package/android/src/main/java/com/test/callkit/MyFirebaseMessagingService.java

@@ -0,0 +1,90 @@
+package com.test.callkit;
+
+
+import android.annotation.SuppressLint;
+import android.app.ActivityManager;
+import android.content.Intent;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+
+import com.test.callkit.androidcall.VoipBackgroundService;
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+
+
+/**
+ * NOTE: There can only be one service in each app that receives FCM messages. If multiple
+ * are declared in the Manifest then the first one will be chosen.
+ * <p>
+ * In order to make this Java sample functional, you must remove the following from the Kotlin messaging
+ * service in the AndroidManifest.xml:
+ * <p>
+ * <intent-filter>
+ * <action android:name="com.google.firebase.MESSAGING_EVENT" />
+ * </intent-filter>
+ */
+@SuppressLint("MissingFirebaseInstanceTokenRefresh")
+public class MyFirebaseMessagingService extends FirebaseMessagingService {
+
+    private static final String TAG = "MyFirebaseMsgService";
+
+    public MyFirebaseMessagingService() {
+        super();
+        Log.d(TAG, "class instantiated");
+    }
+
+    /**
+     * Called when message is received.
+     *
+     * @param remoteMessage Object representing the message received from Firebase Cloud Messaging.
+     */
+
+    @Override
+    public void onMessageReceived(RemoteMessage remoteMessage) {
+        Log.d(TAG, "received " + remoteMessage.getData());
+
+        if (remoteMessage.getData().containsKey("type") && remoteMessage.getData().get("type").equals("call")) {
+            show_call_notification(remoteMessage.getData().get("connectionId"), remoteMessage.getData().get("username"));
+        }
+
+        if (remoteMessage.getData().containsKey("type") && remoteMessage.getData().get("type").equals("stopCall")) {
+
+        }
+
+    private boolean isServiceRunning(String service_name) {
+        ActivityManager manager = (ActivityManager) getApplicationContext().getSystemService(getApplicationContext().ACTIVITY_SERVICE);
+        for (ActivityManager.RunningServiceInfo service_running : manager.getRunningServices(Integer.MAX_VALUE)) {
+            if (service_name.equals(service_running.service.getClassName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void show_call_notification(String connectionId, String username) {
+        Intent voip_service = new Intent(getApplicationContext(), VoipBackgroundService.class);
+        voip_service.putExtra("connectionId", connectionId);
+        voip_service.putExtra("username", username);
+        Log.d("show_call_notification", "called");
+
+        if (!isServiceRunning("com.test.callkit.androidcall.VoipBackgroundService")) {
+            try {
+                getApplicationContext().startService(voip_service);
+            } catch (Exception e) {
+            }
+        } else {
+            try {
+                getApplicationContext().stopService(voip_service);
+            } catch (Exception e) {
+            }
+            try {
+                getApplicationContext().startService(voip_service);
+            } catch (Exception e) {
+                Log.d("sip_call_init", e.toString());
+            }
+        }
+
+    }
+}