cordova-plugin-salus-call 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# cordova-plugin-salus-call
+
+Plugin proprietário do Salus para integrar a interface Cordova ao ciclo de vida nativo de chamadas VoIP no Android e no iOS.
+
+> Estado atual: a ponte Cordova e o contrato de eventos estão implementados. Android Telecom, WebRTC, PushKit e CallKit serão adicionados nas próximas versões.
+
+## Instalação
+
+```xml
+<plugin name="cordova-plugin-salus-call" spec="0.1.0" />
+```
+
+## API
+
+```javascript
+SalusCall.initialize(options);
+SalusCall.getCapabilities();
+SalusCall.startCall(call);
+SalusCall.answer(callId);
+SalusCall.reject(callId, reason);
+SalusCall.hangup(callId, reason);
+SalusCall.setMuted(muted);
+SalusCall.setVideoEnabled(enabled);
+SalusCall.switchCamera();
+SalusCall.onEvent(listener, onError);
+```
+
+Cada chamada utiliza um `callId` UUID fornecido pelo servidor. O ID do usuário nunca deve ser usado como ID de sala.
+
+## Publicação para o Volt Builder
+
+O plano Pro do Volt Builder instala plugins disponíveis no npm. Depois da publicação:
+
+1. adicionar a versão publicada ao `config.xml` do aplicativo;
+2. enviar o projeto ao Volt Builder sem depender da cópia local do plugin;
+3. confirmar no log do build a instalação de `cordova-plugin-salus-call@0.1.0`.
+
+## Licença
+
+Código proprietário. Todos os direitos reservados.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cordova-plugin-salus-call",
+  "version": "0.1.0",
+  "description": "Integração nativa de chamadas VoIP para o aplicativo Salus.",
+  "license": "UNLICENSED",
+  "private": false,
+  "main": "www/SalusCall.js",
+  "files": [
+    "plugin.xml",
+    "www/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "ecosystem:cordova",
+    "cordova-android",
+    "cordova-ios",
+    "voip",
+    "webrtc",
+    "callkit",
+    "telecom"
+  ],
+  "cordova": {
+    "id": "cordova-plugin-salus-call",
+    "platforms": [
+      "android",
+      "ios"
+    ]
+  },
+  "engines": {
+    "cordovaDependencies": {
+      "0.1.0": {
+        "cordova": ">=12.0.0",
+        "cordova-android": ">=14.0.0"
+      }
+    }
+  }
+}

package/plugin.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        id="cordova-plugin-salus-call"
+        version="0.1.0">
+    <name>Salus Call</name>
+    <description>Ponte nativa para chamadas de interfone do Salus.</description>
+    <license>UNLICENSED</license>
+
+    <js-module src="www/SalusCall.js" name="SalusCall">
+        <clobbers target="SalusCall" />
+    </js-module>
+
+    <platform name="android">
+        <config-file target="res/xml/config.xml" parent="/*">
+            <feature name="SalusCall">
+                <param name="android-package" value="br.com.salus.call.SalusCallPlugin" />
+            </feature>
+        </config-file>
+        <source-file src="src/android/SalusCallPlugin.java"
+                     target-dir="src/br/com/salus/call" />
+    </platform>
+
+    <platform name="ios">
+        <config-file target="config.xml" parent="/*">
+            <feature name="SalusCall">
+                <param name="ios-package" value="SalusCallPlugin" />
+            </feature>
+        </config-file>
+        <source-file src="src/ios/SalusCallPlugin.swift" />
+    </platform>
+</plugin>

package/src/android/SalusCallPlugin.java

@@ -0,0 +1,68 @@
+package br.com.salus.call;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class SalusCallPlugin extends CordovaPlugin {
+    private CallbackContext eventCallback;
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callback) throws JSONException {
+        switch (action) {
+            case "initialize":
+                JSONObject initialized = capabilities();
+                initialized.put("initialized", true);
+                callback.success(initialized);
+                return true;
+            case "getCapabilities":
+                callback.success(capabilities());
+                return true;
+            case "registerEventListener":
+                eventCallback = callback;
+                PluginResult listening = new PluginResult(PluginResult.Status.NO_RESULT);
+                listening.setKeepCallback(true);
+                callback.sendPluginResult(listening);
+                return true;
+            case "startCall":
+            case "answer":
+            case "reject":
+            case "hangup":
+            case "setMuted":
+            case "setVideoEnabled":
+            case "switchCamera":
+                callback.error(notImplemented(action));
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private JSONObject capabilities() throws JSONException {
+        JSONObject result = new JSONObject();
+        result.put("platform", "android");
+        result.put("nativeCalling", false);
+        result.put("audio", false);
+        result.put("video", false);
+        result.put("incomingCallUi", false);
+        return result;
+    }
+
+    private JSONObject notImplemented(String action) throws JSONException {
+        JSONObject error = new JSONObject();
+        error.put("code", "NATIVE_CALLING_NOT_IMPLEMENTED");
+        error.put("action", action);
+        error.put("message", "O núcleo Android Telecom/WebRTC ainda não foi ativado.");
+        return error;
+    }
+
+    protected void emitEvent(JSONObject event) {
+        if (eventCallback == null) return;
+        PluginResult result = new PluginResult(PluginResult.Status.OK, event);
+        result.setKeepCallback(true);
+        eventCallback.sendPluginResult(result);
+    }
+}

package/src/ios/SalusCallPlugin.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+@objc(SalusCallPlugin)
+final class SalusCallPlugin: CDVPlugin {
+    private var eventCallbackId: String?
+
+    @objc(initialize:)
+    func initialize(command: CDVInvokedUrlCommand) {
+        var result = capabilities()
+        result["initialized"] = true
+        send(result, command.callbackId)
+    }
+
+    @objc(getCapabilities:)
+    func getCapabilities(command: CDVInvokedUrlCommand) {
+        send(capabilities(), command.callbackId)
+    }
+
+    @objc(registerEventListener:)
+    func registerEventListener(command: CDVInvokedUrlCommand) {
+        eventCallbackId = command.callbackId
+        let result = CDVPluginResult(status: CDVCommandStatus_NO_RESULT)
+        result?.setKeepCallbackAs(true)
+        commandDelegate.send(result, callbackId: command.callbackId)
+    }
+
+    @objc(startCall:)
+    func startCall(command: CDVInvokedUrlCommand) { notImplemented("startCall", command) }
+
+    @objc(answer:)
+    func answer(command: CDVInvokedUrlCommand) { notImplemented("answer", command) }
+
+    @objc(reject:)
+    func reject(command: CDVInvokedUrlCommand) { notImplemented("reject", command) }
+
+    @objc(hangup:)
+    func hangup(command: CDVInvokedUrlCommand) { notImplemented("hangup", command) }
+
+    @objc(setMuted:)
+    func setMuted(command: CDVInvokedUrlCommand) { notImplemented("setMuted", command) }
+
+    @objc(setVideoEnabled:)
+    func setVideoEnabled(command: CDVInvokedUrlCommand) { notImplemented("setVideoEnabled", command) }
+
+    @objc(switchCamera:)
+    func switchCamera(command: CDVInvokedUrlCommand) { notImplemented("switchCamera", command) }
+
+    private func capabilities() -> [String: Any] {
+        return [
+            "platform": "ios",
+            "nativeCalling": false,
+            "audio": false,
+            "video": false,
+            "incomingCallUi": false
+        ]
+    }
+
+    private func notImplemented(_ action: String, _ command: CDVInvokedUrlCommand) {
+        let error: [String: Any] = [
+            "code": "NATIVE_CALLING_NOT_IMPLEMENTED",
+            "action": action,
+            "message": "O núcleo PushKit/CallKit/WebRTC ainda não foi ativado."
+        ]
+        let result = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error)
+        commandDelegate.send(result, callbackId: command.callbackId)
+    }
+
+    private func send(_ value: [String: Any], _ callbackId: String) {
+        let result = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: value)
+        commandDelegate.send(result, callbackId: callbackId)
+    }
+}

package/www/SalusCall.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var exec = require('cordova/exec');
+
+var STATES = Object.freeze({
+    IDLE: 'idle',
+    INVITING: 'inviting',
+    RINGING: 'ringing',
+    CONNECTING: 'connecting',
+    ACTIVE: 'active',
+    ENDING: 'ending',
+    ENDED: 'ended',
+    FAILED: 'failed'
+});
+
+function callNative(action, args) {
+    return new Promise(function(resolve, reject) {
+        exec(resolve, reject, 'SalusCall', action, args || []);
+    });
+}
+
+function validateCall(call) {
+    if (!call || typeof call !== 'object') {
+        throw new TypeError('Os dados da chamada são obrigatórios.');
+    }
+    if (!call.callId) {
+        throw new TypeError('callId é obrigatório.');
+    }
+    if (!call.remoteUserId) {
+        throw new TypeError('remoteUserId é obrigatório.');
+    }
+}
+
+module.exports = {
+    STATES: STATES,
+
+    initialize: function(options) {
+        return callNative('initialize', [options || {}]);
+    },
+
+    getCapabilities: function() {
+        return callNative('getCapabilities');
+    },
+
+    startCall: function(call) {
+        validateCall(call);
+        return callNative('startCall', [call]);
+    },
+
+    answer: function(callId) {
+        return callNative('answer', [callId]);
+    },
+
+    reject: function(callId, reason) {
+        return callNative('reject', [callId, reason || 'declined']);
+    },
+
+    hangup: function(callId, reason) {
+        return callNative('hangup', [callId, reason || 'local_hangup']);
+    },
+
+    setMuted: function(muted) {
+        return callNative('setMuted', [Boolean(muted)]);
+    },
+
+    setVideoEnabled: function(enabled) {
+        return callNative('setVideoEnabled', [Boolean(enabled)]);
+    },
+
+    switchCamera: function() {
+        return callNative('switchCamera');
+    },
+
+    onEvent: function(listener, onError) {
+        if (typeof listener !== 'function') {
+            throw new TypeError('O listener de eventos deve ser uma função.');
+        }
+        exec(listener, onError || function() {}, 'SalusCall', 'registerEventListener', []);
+    }
+};