@cometchat/calls-sdk-react-native 4.4.1 → 5.0.0-beta.1

package/dist/polyfills/ipv6utils.js

@@ -0,0 +1,197 @@
+import { NativeModules } from 'react-native';
+import { RTCSessionDescription } from 'react-native-webrtc';
+
+/**
+ * Synthesizes IPv6 addresses on iOS in order to support IPv6 NAT64 networks.
+ *
+ * @param {RTCSessionDescription} sdp - The RTCSessionDescription which
+ * specifies the configuration of the remote end of the connection.
+ * @private
+ * @returns {Promise}
+ */
+export function synthesizeIPv6Addresses(sdp) {
+    return (
+        new Promise(resolve => resolve(_synthesizeIPv6Addresses0(sdp)))
+            .then(({ ips, lines }) =>
+                Promise.all(Array.from(ips.values()))
+                    .then(() => _synthesizeIPv6Addresses1(sdp, ips, lines))
+            ));
+}
+
+/* eslint-disable max-depth */
+
+/**
+ * Synthesizes an IPv6 address from a specific IPv4 address.
+ *
+ * @param {string} ipv4 - The IPv4 address from which an IPv6 address is to be
+ * synthesized.
+ * @returns {Promise<?string>} A {@code Promise} which gets resolved with the
+ * IPv6 address synthesized from the specified {@code ipv4} or a falsy value to
+ * be treated as inability to synthesize an IPv6 address from the specified
+ * {@code ipv4}.
+ */
+const _synthesizeIPv6FromIPv4Address = (function() {
+    // POSIX.getaddrinfo
+    const { POSIX } = NativeModules;
+
+    if (POSIX) {
+        const { getaddrinfo } = POSIX;
+
+        if (typeof getaddrinfo === 'function') {
+            return ipv4 =>
+                getaddrinfo(/* hostname */ ipv4, /* servname */ undefined)
+                    .then(([ { ai_addr: ipv6 } ]) => ipv6);
+        }
+    }
+
+    // NAT64AddrInfo.getIPv6Address
+    const { NAT64AddrInfo } = NativeModules;
+
+    if (NAT64AddrInfo) {
+        const { getIPv6Address } = NAT64AddrInfo;
+
+        if (typeof getIPv6Address === 'function') {
+            return getIPv6Address;
+        }
+    }
+
+    // There's no POSIX.getaddrinfo or NAT64AddrInfo.getIPv6Address.
+    return ip => Promise.resolve(ip);
+})();
+
+/**
+ * Begins the asynchronous synthesis of IPv6 addresses.
+ *
+ * @param {RTCSessionDescription} sessionDescription - The RTCSessionDescription
+ * for which IPv6 addresses will be synthesized.
+ * @private
+ * @returns {{
+ *     ips: Map,
+ *     lines: Array
+ * }}
+ */
+function _synthesizeIPv6Addresses0(sessionDescription) {
+    const sdp = sessionDescription.sdp;
+    let start = 0;
+    const lines = [];
+    const ips = new Map();
+
+    do {
+        const end = sdp.indexOf('\r\n', start);
+        let line;
+
+        if (end === -1) {
+            line = sdp.substring(start);
+
+            // Break out of the loop at the end of the iteration.
+            start = undefined;
+        } else {
+            line = sdp.substring(start, end);
+            start = end + 2;
+        }
+
+        if (line.startsWith('a=candidate:')) {
+            const candidate = line.split(' ');
+
+            if (candidate.length >= 10 && candidate[6] === 'typ') {
+                const ip4s = [ candidate[4] ];
+                let abort = false;
+
+                for (let i = 8; i < candidate.length; ++i) {
+                    if (candidate[i] === 'raddr') {
+                        ip4s.push(candidate[++i]);
+                        break;
+                    }
+                }
+
+                for (const ip of ip4s) {
+                    if (ip.indexOf(':') === -1) {
+                        ips.has(ip)
+                            || ips.set(ip, new Promise((resolve, reject) => {
+                                const v = ips.get(ip);
+
+                                if (v && typeof v === 'string') {
+                                    resolve(v);
+                                } else {
+                                    _synthesizeIPv6FromIPv4Address(ip).then(
+                                        value => {
+                                            if (!value
+                                                    || value.indexOf(':') === -1
+                                                    || value === ips.get(ip)) {
+                                                ips.delete(ip);
+                                            } else {
+                                                ips.set(ip, value);
+                                            }
+                                            resolve(value);
+                                        },
+                                        reject);
+                                }
+                            }));
+                    } else {
+                        abort = true;
+                        break;
+                    }
+                }
+                if (abort) {
+                    ips.clear();
+                    break;
+                }
+
+                line = candidate;
+            }
+        }
+
+        lines.push(line);
+    } while (start);
+
+    return {
+        ips,
+        lines
+    };
+}
+
+/* eslint-enable max-depth */
+
+/**
+ * Completes the asynchronous synthesis of IPv6 addresses.
+ *
+ * @param {RTCSessionDescription} sessionDescription - The RTCSessionDescription
+ * for which IPv6 addresses are being synthesized.
+ * @param {Map} ips - A Map of IPv4 addresses found in the specified
+ * sessionDescription to synthesized IPv6 addresses.
+ * @param {Array} lines - The lines of the specified sessionDescription.
+ * @private
+ * @returns {RTCSessionDescription} A RTCSessionDescription that represents the
+ * result of the synthesis of IPv6 addresses.
+ */
+function _synthesizeIPv6Addresses1(sessionDescription, ips, lines) {
+    if (ips.size === 0) {
+        return sessionDescription;
+    }
+
+    for (let l = 0; l < lines.length; ++l) {
+        const candidate = lines[l];
+
+        if (typeof candidate !== 'string') {
+            let ip4 = candidate[4];
+            let ip6 = ips.get(ip4);
+
+            ip6 && (candidate[4] = ip6);
+
+            for (let i = 8; i < candidate.length; ++i) {
+                if (candidate[i] === 'raddr') {
+                    ip4 = candidate[++i];
+                    (ip6 = ips.get(ip4)) && (candidate[i] = ip6);
+                    break;
+                }
+            }
+
+            lines[l] = candidate.join(' ');
+        }
+    }
+
+    return new RTCSessionDescription({
+        sdp: lines.join('\r\n'),
+        type: sessionDescription.type
+    });
+}

package/dist/polyfills/webrtc.js

@@ -0,0 +1,11 @@
+import { registerGlobals } from 'react-native-webrtc';
+
+import RTCPeerConnection from './RTCPeerConnection';
+
+registerGlobals();
+
+(global => {
+    // Override with ours.
+    // TODO: consider dropping our override.
+    global.RTCPeerConnection = RTCPeerConnection;
+})(global || window || this); // eslint-disable-line no-invalid-this

package/package.json

@@ -1,119 +1,27 @@
 {
   "name": "@cometchat/calls-sdk-react-native",
-  "version": "4.4.1",
-  "description": "Cometchat React Native Calling component for iOS and Android",
+  "version": "5.0.0-beta.1",
+  "private": false,
   "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "start": "webpack --mode development",
-    "build": "webpack --mode production",
-    "test": "jest",
-    "typescript": "tsc --noEmit",
-    "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "release": "release-it",
-    "example": "yarn --cwd example",
-    "pods": "cd example && pod-install --quiet",
-    "bootstrap": "yarn example && yarn && yarn pods",
-    "buildold": "rm -rf package && tsc && cp src/calling.js package/calling.js"
-  },
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
   "files": [
-    "android/src/main/",
-    "android/build.gradle",
-    "dist/",
-    "ios/",
-    "cometchat-calls-sdk-react-native.podspec"
-  ],
-  "keywords": [
-    "react-native",
-    "ios",
+    "dist",
     "android"
   ],
-  "repository": "https://github.com/cometchat/calls-sdk-react-native",
-  "author": "Cometchat Team (https://cometchat.com)",
-  "license": "https://www.cometchat.com/legal-terms-of-service",
-  "homepage": "https://www.cometchat.com/docs/sdk/react-native/calling-overview",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
-  },
-  "devDependencies": {
-    "@types/react": "^17.0.53",
-    "babel-loader": "^8.0.4",
-    "esbuild-loader": "^2.19.0",
-    "react": "^17.0.2",
-    "react-native": "^0.66.5",
-    "ts-loader": "^9.4.2",
-    "typescript": "^4.9.5",
-    "typescript-declaration-webpack-plugin": "^0.2.2",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.1"
-  },
+  "scripts": {},
+  "dependencies": {},
+  "devDependencies": {},
   "peerDependencies": {
-    "react": "*",
-    "react-native": "*",
-    "@react-native-async-storage/async-storage": "*",
-    "@react-native-community/netinfo": "*",
-    "react-native-background-timer": "*",
-    "react-native-callstats": "*",
-    "react-native-webrtc": "*"
-  },
-  "jest": {
-    "preset": "react-native",
-    "modulePathIgnorePatterns": [
-      "<rootDir>/example/node_modules",
-      "<rootDir>/lib/"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "release-it": {
-    "git": {
-      "commitMessage": "chore: release ${version}",
-      "tagName": "v${version}"
-    },
-    "npm": {
-      "publish": true
-    },
-    "github": {
-      "release": true
-    },
-    "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": "angular"
-      }
-    }
-  },
-  "eslintConfig": {
-    "root": true,
-    "extends": [
-      "@react-native-community",
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": [
-        "error",
-        {
-          "quoteProps": "consistent",
-          "singleQuote": true,
-          "tabWidth": 2,
-          "trailingComma": "es5",
-          "useTabs": false
-        }
-      ]
-    }
-  },
-  "eslintIgnore": [
-    "node_modules/",
-    "lib/"
-  ],
-  "prettier": {
-    "quoteProps": "consistent",
-    "singleQuote": true,
-    "tabWidth": 2,
-    "trailingComma": "es5",
-    "useTabs": false
+    "@xmldom/xmldom": "^0.8.11",
+    "abab": "^2.0.6",
+    "clsx": "^2.1.1",
+    "promise.allsettled": "^1.0.7",
+    "text-encoding": "^0.7.0",
+    "valibot": "^1.2.0",
+    "lib-jitsi-meet": "https://github.com/jitsi/lib-jitsi-meet/releases/download/v1790.0.0+311766e3/lib-jitsi-meet.tgz"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }

package/LICENSE.md

@@ -1,3 +0,0 @@
-Copyright (c) 2023 CometChat Inc.
-
-License agreement: https://www.cometchat.com/legal-terms-of-service

package/android/src/main/java/com/CometChatCalls/AudioDeviceHandlerGeneric.java

@@ -1,213 +0,0 @@
-package com.CometChatCalls;
-import android.annotation.TargetApi;
-import android.media.AudioDeviceInfo;
-import android.media.AudioManager;
-import android.os.Build;
-import android.util.Log;
-
-import java.util.HashSet;
-import java.util.Set;
-
-
-
-/**
- * {@link AudioModeModule.AudioDeviceHandlerInterface} module implementing device handling for
- * all post-M Android versions. This handler can be used on any Android versions >= M, but by
- * default it's only used on versions < O, since versions >= O use ConnectionService, but it
- * can be disabled.
- */
-@TargetApi(Build.VERSION_CODES.M)
-class AudioDeviceHandlerGeneric implements
-        AudioModeModule.AudioDeviceHandlerInterface,
-        AudioManager.OnAudioFocusChangeListener {
-
-    private final static String TAG = AudioDeviceHandlerGeneric.class.getSimpleName();
-
-    /**
-     * Reference to the main {@code AudioModeModule}.
-     */
-    private AudioModeModule module;
-
-    /**
-     * Constant defining a USB headset. Only available on API level >= 26.
-     * The value of: AudioDeviceInfo.TYPE_USB_HEADSET
-     */
-    private static final int TYPE_USB_HEADSET = 22;
-
-    /**
-     * Indicator that we have lost audio focus.
-     */
-    private boolean audioFocusLost = false;
-
-    /**
-     * {@link AudioManager} instance used to interact with the Android audio
-     * subsystem.
-     */
-    private AudioManager audioManager;
-
-    /**
-     * {@link Runnable} for running audio device detection the main thread.
-     * This is only used on Android >= M.
-     */
-    private final Runnable onAudioDeviceChangeRunner = new Runnable() {
-        @Override
-        public void run() {
-            Set<String> devices = new HashSet<>();
-            AudioDeviceInfo[] deviceInfos = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS);
-
-            for (AudioDeviceInfo info: deviceInfos) {
-                switch (info.getType()) {
-                    case AudioDeviceInfo.TYPE_BLUETOOTH_SCO:
-                        devices.add(AudioModeModule.DEVICE_BLUETOOTH);
-                        break;
-                    case AudioDeviceInfo.TYPE_BUILTIN_EARPIECE:
-                        devices.add(AudioModeModule.DEVICE_EARPIECE);
-                        break;
-                    case AudioDeviceInfo.TYPE_BUILTIN_SPEAKER:
-                        devices.add(AudioModeModule.DEVICE_SPEAKER);
-                        break;
-                    case AudioDeviceInfo.TYPE_WIRED_HEADPHONES:
-                    case AudioDeviceInfo.TYPE_WIRED_HEADSET:
-                    case TYPE_USB_HEADSET:
-                        devices.add(AudioModeModule.DEVICE_HEADPHONES);
-                        break;
-                }
-            }
-
-            module.replaceDevices(devices);
-
-            Log.i(TAG , " Available audio devices: " + devices.toString());
-
-            module.updateAudioRoute();
-        }
-    };
-
-    private final android.media.AudioDeviceCallback audioDeviceCallback =
-            new android.media.AudioDeviceCallback() {
-                @Override
-                public void onAudioDevicesAdded(
-                        AudioDeviceInfo[] addedDevices) {
-                    Log.d(TAG , " Audio devices added");
-                    onAudioDeviceChange();
-                }
-
-                @Override
-                public void onAudioDevicesRemoved(
-                        AudioDeviceInfo[] removedDevices) {
-                    Log.d(TAG , " Audio devices removed");
-                    onAudioDeviceChange();
-                }
-            };
-
-    public AudioDeviceHandlerGeneric(AudioManager audioManager) {
-        this.audioManager = audioManager;
-    }
-
-    /**
-     * Helper method to trigger an audio route update when devices change. It
-     * makes sure the operation is performed on the audio thread.
-     */
-    private void onAudioDeviceChange() {
-        module.runInAudioThread(onAudioDeviceChangeRunner);
-    }
-
-    /**
-     * {@link AudioManager.OnAudioFocusChangeListener} interface method. Called
-     * when the audio focus of the system is updated.
-     *
-     * @param focusChange - The type of focus change.
-     */
-    @Override
-    public void onAudioFocusChange(final int focusChange) {
-        module.runInAudioThread(new Runnable() {
-            @Override
-            public void run() {
-                switch (focusChange) {
-                    case AudioManager.AUDIOFOCUS_GAIN: {
-                        Log.d(TAG , " Audio focus gained");
-                        // Some other application potentially stole our audio focus
-                        // temporarily. Restore our mode.
-                        if (audioFocusLost) {
-                            module.updateAudioRoute();
-                        }
-                        audioFocusLost = false;
-                        break;
-                    }
-                    case AudioManager.AUDIOFOCUS_LOSS:
-                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT:
-                    case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: {
-                        Log.d(TAG , " Audio focus lost");
-                        audioFocusLost = true;
-                        break;
-                    }
-                }
-            }
-        });
-    }
-
-    /**
-     * Helper method to set the output route to a Bluetooth device.
-     *
-     * @param enabled true if Bluetooth should use used, false otherwise.
-     */
-    private void setBluetoothAudioRoute(boolean enabled) {
-        if (enabled) {
-            audioManager.startBluetoothSco();
-            audioManager.setBluetoothScoOn(true);
-        } else {
-            audioManager.setBluetoothScoOn(false);
-            audioManager.stopBluetoothSco();
-        }
-    }
-
-    @Override
-    public void start(AudioModeModule audioModeModule) {
-        Log.i("Using " , TAG + " as the audio device handler");
-
-        module = audioModeModule;
-
-        // Setup runtime device change detection.
-        audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
-
-        // Do an initial detection.
-        onAudioDeviceChange();
-    }
-
-    @Override
-    public void stop() {
-        audioManager.unregisterAudioDeviceCallback(audioDeviceCallback);
-    }
-
-    @Override
-    public void setAudioRoute(String device) {
-        // Turn speaker on / off
-        audioManager.setSpeakerphoneOn(device.equals(AudioModeModule.DEVICE_SPEAKER));
-
-        // Turn bluetooth on / off
-        setBluetoothAudioRoute(device.equals(AudioModeModule.DEVICE_BLUETOOTH));
-    }
-
-    @Override
-    public boolean setMode(int mode) {
-        if (mode == AudioModeModule.DEFAULT) {
-            audioFocusLost = false;
-            audioManager.setMode(AudioManager.MODE_NORMAL);
-            audioManager.abandonAudioFocus(this);
-            audioManager.setSpeakerphoneOn(false);
-            setBluetoothAudioRoute(false);
-
-            return true;
-        }
-
-        audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-        audioManager.setMicrophoneMute(false);
-
-        if (audioManager.requestAudioFocus(this, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN)
-                == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
-            Log.w(TAG , " Audio focus request failed");
-            return false;
-        }
-
-        return true;
-    }
-}