@fishjam-cloud/react-native-client 0.18.1 → 0.19.1

package/ios/RNFishjamClient.swift

@@ -328,40 +328,51 @@ class RNFishjamClient: FishjamClientListener {
     }
 
     func toggleMicrophone() async throws -> Bool {
-        if let audioTrack = getLocalAudioTrack() {
-            setMicrophoneTrackState(audioTrack, enabled: !isMicrophoneOn)
+        if isMicrophoneOn {
+          try stopMicrophone()
         } else {
-            try await startMicrophone()
+          try await startMicrophone()
         }
 
-        try updateLocalAudioTrackMetadata(metadata: getMicrophoneTrackMetadata())
-
         return isMicrophoneOn
     }
 
     func startMicrophone() async throws {
-        guard await PermissionUtils.requestMicrophonePermission() else {
-            emit(event: .warning(message: "Microphone permission not granted."))
-            return
-        }
-        let microphoneTrack = RNFishjamClient.fishjamClient!.createAudioTrack(
-            metadata: getMicrophoneTrackMetadata().toMetadata())
-        setAudioSessionMode()
-        setMicrophoneTrackState(microphoneTrack, enabled: true)
-        emitEndpoints()
-    }
-
-    private func getMicrophoneTrackMetadata() -> [String: Any] {
+        // If microphone track already exist, just enable it
+        if let microphoneTrack = getLocalAudioTrack() {
+            try setMicrophoneTrackState(microphoneTrack, enabled: true)
+        } else {
+          guard await PermissionUtils.requestMicrophonePermission() else {
+              emit(event: .warning(message: "Microphone permission not granted."))
+              return
+          }
+          let microphoneTrack = RNFishjamClient.fishjamClient!.createAudioTrack(
+            metadata: getMicrophoneTrackMetadata(isEnabled: true).toMetadata())
+          setAudioSessionMode()
+          try setMicrophoneTrackState(microphoneTrack, enabled: true)
+          emitEndpoints()
+        }
+      }
+  
+    func stopMicrophone() throws {
+      guard let microphoneTrack = getLocalAudioTrack() else {
+          return
+      }
+      try setMicrophoneTrackState(microphoneTrack, enabled: false)
+    }
+
+    private func getMicrophoneTrackMetadata(isEnabled: Bool) -> [String: Any] {
         return [
-            "active": isMicrophoneOn,
-            "paused": !isMicrophoneOn,  //TODO: FCE-711
+            "active": isEnabled,
+            "paused": !isEnabled,  //TODO: FCE-711
             "type": "microphone",
         ]
     }
 
-    private func setMicrophoneTrackState(_ microphoneTrack: LocalAudioTrack, enabled: Bool) {
+    private func setMicrophoneTrackState(_ microphoneTrack: LocalAudioTrack, enabled: Bool) throws {
         microphoneTrack.enabled = enabled
         isMicrophoneOn = enabled
+        try updateLocalAudioTrackMetadata(metadata: getMicrophoneTrackMetadata(isEnabled: enabled))
         emit(event: .isMicrophoneOn(enabled: enabled))
     }
 

package/ios/RNFishjamClientModule.swift

@@ -63,159 +63,216 @@ struct ConnectConfig: Record {
 typealias RNTrackBandwidthLimit = Either<Int, [String: Int]>
 
 public class RNFishjamClientModule: Module {
-    public func definition() -> ModuleDefinition {
-        let rnFishjamClient: RNFishjamClient = {
-            let client = RNFishjamClient(sendEvent)
-            client.create()
-            return client
-        }()
+  public func definition() -> ModuleDefinition {
+    let rnFishjamClient: RNFishjamClient = {
+      let client = RNFishjamClient(sendEvent)
+      client.create()
+      return client
+    }()
+
+    Name("RNFishjamClient")
+
+    Events(EmitableEvent.allEvents)
+    
+    OnCreate {
+          let permissionsManager = self.appContext?.permissions
+          EXPermissionsMethodsDelegate.register(
+            [
+              CameraOnlyPermissionRequester(),
+              CameraMicrophonePermissionRequester()
+            ],
+            withPermissionsManager: permissionsManager
+          )
+        }
+
+    Property("peerStatus") {
+      return rnFishjamClient.peerStatus.rawValue
+    }
 
-        Name("RNFishjamClient")
+    Property("reconnectionStatus") {
+      return rnFishjamClient.reconnectionStatus.rawValue
+    }
 
-        Events(EmitableEvent.allEvents)
+    Property("isMicrophoneOn") {
+      return rnFishjamClient.isMicrophoneOn
+    }
 
-        Property("peerStatus") {
-            return rnFishjamClient.peerStatus.rawValue
-        }
+    Property("isCameraOn") {
+      return rnFishjamClient.isCameraOn
+    }
 
-        Property("reconnectionStatus") {
-            return rnFishjamClient.reconnectionStatus.rawValue
-        }
+    Property("cameras") {
+      return rnFishjamClient.getCaptureDevices()
+    }
 
-        Property("isMicrophoneOn") {
-            return rnFishjamClient.isMicrophoneOn
-        }
+    Property("currentCamera") {
+      return rnFishjamClient.currentCamera
+    }
 
-        Property("isCameraOn") {
-            return rnFishjamClient.isCameraOn
-        }
+    Property("isScreenShareOn") {
+      return rnFishjamClient.isScreenShareOn
+    }
 
-        Property("cameras") {
-            return rnFishjamClient.getCaptureDevices()
-        }
+    Property("isAppScreenShareOn") {
+      return rnFishjamClient.isAppScreenShareOn
+    }
 
-        Property("currentCamera") {
-            return rnFishjamClient.currentCamera
-        }
+    Property("isCameraInitialized") {
+      return rnFishjamClient.isCameraInitialized
+    }
 
-        Property("isScreenShareOn") {
-            return rnFishjamClient.isScreenShareOn
-        }
+    Function("getPeers") {
+      return rnFishjamClient.getPeers()
+    }
 
-        Property("isAppScreenShareOn") {
-            return rnFishjamClient.isAppScreenShareOn
-        }
+    AsyncFunction("joinRoom") {
+      (
+        url: String, peerToken: String, peerMetadata: [String: Any], config: ConnectConfig,
+        promise: Promise
+      ) in
+      rnFishjamClient.joinRoom(
+        url: url, peerToken: peerToken, peerMetadata: peerMetadata, config: config,
+        promise: promise)
+    }
 
-        Property("isCameraInitialized") {
-            return rnFishjamClient.isCameraInitialized
-        }
+    AsyncFunction("leaveRoom") {
+      rnFishjamClient.leaveRoom()
+    }
 
-        Function("getPeers") {
-            return rnFishjamClient.getPeers()
-        }
+    AsyncFunction("startCamera") { (config: CameraConfig) in
+      try await rnFishjamClient.startCamera(config: config)
+    }
 
-        AsyncFunction("joinRoom") {
-            (
-                url: String, peerToken: String, peerMetadata: [String: Any], config: ConnectConfig,
-                promise: Promise
-            ) in
-            rnFishjamClient.joinRoom(
-                url: url, peerToken: peerToken, peerMetadata: peerMetadata, config: config,
-                promise: promise)
-        }
+    AsyncFunction("toggleMicrophone") {
+      try await rnFishjamClient.toggleMicrophone()
+    }
+    
+    AsyncFunction("startMicrophone") {
+      try await rnFishjamClient.startMicrophone()
+    }
 
-        AsyncFunction("leaveRoom") {
-            rnFishjamClient.leaveRoom()
-        }
+    AsyncFunction("stopMicrophone") {
+      try rnFishjamClient.stopMicrophone()
+    }
 
-        AsyncFunction("startCamera") { (config: CameraConfig) in
-            try await rnFishjamClient.startCamera(config: config)
-        }
+    AsyncFunction("toggleCamera") {
+      try rnFishjamClient.toggleCamera()
+    }
 
-        AsyncFunction("toggleMicrophone") {
-            try await rnFishjamClient.toggleMicrophone()
-        }
+    AsyncFunction("flipCamera") {
+      try rnFishjamClient.flipCamera()
+    }
 
-        AsyncFunction("toggleCamera") {
-            try rnFishjamClient.toggleCamera()
-        }
+    AsyncFunction("switchCamera") { (cameraId: String) in
+      try rnFishjamClient.switchCamera(cameraId: cameraId)
+    }
 
-        AsyncFunction("flipCamera") {
-            try rnFishjamClient.flipCamera()
-        }
+    AsyncFunction("toggleScreenShare") { (screenShareOptions: ScreenShareOptions) in
+      try rnFishjamClient.toggleScreenShare(screenShareOptions: screenShareOptions)
+    }
 
-        AsyncFunction("switchCamera") { (cameraId: String) in
-            try rnFishjamClient.switchCamera(cameraId: cameraId)
-        }
+    AsyncFunction("toggleAppScreenShare") { (screenShareOptions: ScreenShareOptions) in
+      try rnFishjamClient.toggleAppScreenShare(screenShareOptions: screenShareOptions)
+    }
 
-        AsyncFunction("toggleScreenShare") { (screenShareOptions: ScreenShareOptions) in
-            try rnFishjamClient.toggleScreenShare(screenShareOptions: screenShareOptions)
-        }
+    AsyncFunction("updatePeerMetadata") { (metadata: [String: Any]) in
+      try rnFishjamClient.updatePeerMetadata(metadata: metadata)
+    }
 
-        AsyncFunction("toggleAppScreenShare") { (screenShareOptions: ScreenShareOptions) in
-            try rnFishjamClient.toggleAppScreenShare(screenShareOptions: screenShareOptions)
-        }
+    AsyncFunction("updateVideoTrackMetadata") { (metadata: [String: Any]) in
+      try rnFishjamClient.updateLocalVideoTrackMetadata(metadata: metadata)
+    }
 
-        AsyncFunction("updatePeerMetadata") { (metadata: [String: Any]) in
-            try rnFishjamClient.updatePeerMetadata(metadata: metadata)
-        }
+    AsyncFunction("updateScreenShareTrackMetadata") { (metadata: [String: Any]) in
+      try rnFishjamClient.updateLocalScreenShareTrackMetadata(metadata: metadata)
+    }
 
-        AsyncFunction("updateVideoTrackMetadata") { (metadata: [String: Any]) in
-            try rnFishjamClient.updateLocalVideoTrackMetadata(metadata: metadata)
-        }
+    AsyncFunction("toggleScreenShareTrackEncoding") { (encoding: String) in
+      try rnFishjamClient.toggleScreenShareTrackEncoding(encoding: encoding)
+    }
 
-        AsyncFunction("updateScreenShareTrackMetadata") { (metadata: [String: Any]) in
-            try rnFishjamClient.updateLocalScreenShareTrackMetadata(metadata: metadata)
-        }
+    AsyncFunction("setScreenShareTrackBandwidth") { (bandwidth: Int) in
+      try rnFishjamClient.setScreenShareTrackBandwidth(bandwidth: bandwidth)
+    }
 
-        AsyncFunction("toggleScreenShareTrackEncoding") { (encoding: String) in
-            try rnFishjamClient.toggleScreenShareTrackEncoding(encoding: encoding)
-        }
+    AsyncFunction("setScreenShareTrackEncodingBandwidth") { (encoding: String, bandwidth: Int) in
+      try rnFishjamClient.setScreenShareTrackEncodingBandwidth(
+        encoding: encoding, bandwidth: bandwidth)
+    }
 
-        AsyncFunction("setScreenShareTrackBandwidth") { (bandwidth: Int) in
-            try rnFishjamClient.setScreenShareTrackBandwidth(bandwidth: bandwidth)
-        }
+    AsyncFunction("setTargetTrackEncoding") { (trackId: String, encoding: String) in
+      try rnFishjamClient.setTargetTrackEncoding(trackId: trackId, encoding: encoding)
+    }
 
-        AsyncFunction("setScreenShareTrackEncodingBandwidth") { (encoding: String, bandwidth: Int) in
-            try rnFishjamClient.setScreenShareTrackEncodingBandwidth(
-                encoding: encoding, bandwidth: bandwidth)
-        }
+    AsyncFunction("toggleVideoTrackEncoding") { (encoding: String) in
+      try rnFishjamClient.toggleVideoTrackEncoding(encoding: encoding)
+    }
 
-        AsyncFunction("setTargetTrackEncoding") { (trackId: String, encoding: String) in
-            try rnFishjamClient.setTargetTrackEncoding(trackId: trackId, encoding: encoding)
-        }
+    AsyncFunction("setVideoTrackEncodingBandwidth") { (encoding: String, bandwidth: Int) in
+      try rnFishjamClient.setVideoTrackEncodingBandwidth(
+        encoding: encoding, bandwidth: bandwidth)
+    }
 
-        AsyncFunction("toggleVideoTrackEncoding") { (encoding: String) in
-            try rnFishjamClient.toggleVideoTrackEncoding(encoding: encoding)
-        }
+    AsyncFunction("setVideoTrackBandwidth") { (bandwidth: Int) in
+      try rnFishjamClient.setVideoTrackBandwidth(bandwidth: bandwidth)
+    }
 
-        AsyncFunction("setVideoTrackEncodingBandwidth") { (encoding: String, bandwidth: Int) in
-            try rnFishjamClient.setVideoTrackEncodingBandwidth(
-                encoding: encoding, bandwidth: bandwidth)
-        }
+    AsyncFunction("changeWebRTCLoggingSeverity") { (severity: String) in
+      try rnFishjamClient.changeWebRTCLoggingSeverity(severity: severity)
+    }
 
-        AsyncFunction("setVideoTrackBandwidth") { (bandwidth: Int) in
-            try rnFishjamClient.setVideoTrackBandwidth(bandwidth: bandwidth)
-        }
+    AsyncFunction("getStatistics") {
+      try await rnFishjamClient.getStatistics()
+    }
 
-        AsyncFunction("changeWebRTCLoggingSeverity") { (severity: String) in
-            try rnFishjamClient.changeWebRTCLoggingSeverity(severity: severity)
-        }
+    AsyncFunction("selectAudioSessionMode") { (sessionMode: String) in
+      try rnFishjamClient.selectAudioSessionMode(sessionMode: sessionMode)
+    }
 
-        AsyncFunction("getStatistics") {
-            try await rnFishjamClient.getStatistics()
-        }
+    AsyncFunction("showAudioRoutePicker") {
+      rnFishjamClient.showAudioRoutePicker()
+    }
 
-        AsyncFunction("selectAudioSessionMode") { (sessionMode: String) in
-            try rnFishjamClient.selectAudioSessionMode(sessionMode: sessionMode)
-        }
+    AsyncFunction("startAudioSwitcher") {
+      rnFishjamClient.startAudioSwitcher()
+    }
 
-        AsyncFunction("showAudioRoutePicker") {
-            rnFishjamClient.showAudioRoutePicker()
-        }
+    AsyncFunction("getCameraPermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.getPermissionWithPermissionsManager(
+        self.appContext?.permissions,
+        withRequester: CameraOnlyPermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
+    }
 
-        AsyncFunction("startAudioSwitcher") {
-            rnFishjamClient.startAudioSwitcher()
-        }
+    AsyncFunction("requestCameraPermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.askForPermission(
+        withPermissionsManager: self.appContext?.permissions,
+        withRequester: CameraOnlyPermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
     }
-}
+
+    AsyncFunction("getMicrophonePermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.getPermissionWithPermissionsManager(
+        self.appContext?.permissions,
+        withRequester: CameraMicrophonePermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
+    }
+
+    AsyncFunction("requestMicrophonePermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.askForPermission(
+        withPermissionsManager: self.appContext?.permissions,
+        withRequester: CameraMicrophonePermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
+    }
+
+    }
+  }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fishjam-cloud/react-native-client",
-  "version": "0.18.1",
+  "version": "0.19.1",
   "description": "A React Native client for Fishjam",
   "author": "Fishjam Team",
   "license": "Apache-2.0",
@@ -9,8 +9,8 @@
   "scripts": {
     "build": "EXPO_NONINTERACTIVE=1 sh -c 'expo-module build && expo-module build plugin'",
     "clean": "expo-module clean",
-    "lint": "sh ./scripts/lint.sh",
-    "lint:check": "sh ./scripts/lint_check.sh",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "yarn lint --fix",
     "test": "expo-module test",
     "prepare": "expo-module prepare",
     "prepublishOnly": "expo-module prepublishOnly",
@@ -42,26 +42,31 @@
   "dependencies": {
     "promise-fs": "^2.1.1",
     "protobufjs": "^7.4.0",
-    "react-native-whip-whep": "0.2.1",
-    "zod": "^3.24.2"
+    "react-native-whip-whep": "0.2.3",
+    "zod": "^3.25.71"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.3.0",
-    "@types/lodash": "^4.17.16",
+    "@types/lodash": "^4.17.20",
     "@types/promise-fs": "^2.1.2",
     "@types/react": "~19.0.10",
     "@types/react-dom": "^19",
-    "expo-module-scripts": "^4.1.7",
+    "eslint": "^9.29.0",
+    "eslint-config-expo": "~9.2.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "expo-module-scripts": "^4.1.9",
     "husky": "^9.1.7",
     "jest": "^29.6.1",
     "jest-environment-jsdom": "^29.6.1",
-    "jest-expo": "~53.0.5",
+    "jest-expo": "~53.0.9",
     "jest-websocket-mock": "^2.4.0",
-    "pod-install": "^0.3.4",
+    "pod-install": "^0.3.9",
+    "prettier": "^3.6.2",
     "react-dom": "19.0.0",
-    "ts-proto": "^2.7.0",
-    "typedoc": "^0.28.1",
+    "ts-proto": "^2.7.5",
+    "typedoc": "^0.28.7",
     "typedoc-plugin-mark-react-functional-components": "^0.2.2",
     "typescript": "~5.8.3"
   },

package/plugin/build/types.d.ts

@@ -1,9 +1,14 @@
 export type FishjamPluginOptions = {
     android?: {
         enableForegroundService?: boolean;
+        supportsPictureInPicture?: boolean;
     };
     ios?: {
         iphoneDeploymentTarget?: string;
         enableScreensharing?: boolean;
+        supportsPictureInPicture?: boolean;
+        appGroupContainerId?: string;
+        mainTargetName?: string;
+        broadcastExtensionTargetName?: string;
     };
 } | undefined;

package/plugin/build/withFishjamAndroid.js

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withFishjamAndroid = void 0;
 const config_plugins_1 = require("@expo/config-plugins");
 const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
-const withFishjamForegroundService = (config) => (0, config_plugins_1.withAndroidManifest)(config, async (configuration) => {
+const withFishjamForegroundService = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, async (configuration) => {
+    if (!props?.android?.enableForegroundService) {
+        return configuration;
+    }
     const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(configuration.modResults);
     mainApplication.service = mainApplication.service || [];
     const newService = {
@@ -22,10 +25,19 @@ const withFishjamForegroundService = (config) => (0, config_plugins_1.withAndroi
     }
     return configuration;
 });
-const withFishjamAndroid = (config, props) => {
-    if (props?.android?.enableForegroundService) {
-        config = withFishjamForegroundService(config);
+const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
+    const activity = config_plugins_1.AndroidConfig.Manifest.getMainActivityOrThrow(configuration.modResults);
+    if (props?.android?.supportsPictureInPicture) {
+        activity.$['android:supportsPictureInPicture'] = 'true';
+    }
+    else {
+        delete activity.$['android:supportsPictureInPicture'];
     }
+    return configuration;
+});
+const withFishjamAndroid = (config, props) => {
+    config = withFishjamForegroundService(config, props);
+    config = withFishjamPictureInPicture(config, props);
     return config;
 };
 exports.withFishjamAndroid = withFishjamAndroid;

package/plugin/build/withFishjamIos.d.ts

@@ -1,6 +1,6 @@
 import { ConfigPlugin } from '@expo/config-plugins';
 import { FishjamPluginOptions } from './types';
-export declare const SBE_PODFILE_SNIPPET = "\ntarget 'FishjamScreenBroadcastExtension' do\n  pod 'FishjamCloudClient/Broadcast'\nend";
+export declare function getSbePodfileSnippet(props: FishjamPluginOptions): string;
 /**
  * Applies screen sharing plugin if enabled. In order for screensharing to work, we need to copy extension files to your iOS project.
  * Allows for dynamically changing deploymentTarget.