@apirtc/expo-apirtc-options-plugin 0.0.1 → 0.0.2

package/README.md

@@ -13,13 +13,16 @@ npm install @apizee/expo-apirtc-options-plugin-test
 
 ## Usage in app.json
 
-You need to declare the plugin in app.json file :
+You need to declare the plugin in app.json file of your application :
 
 ```js
 module.exports = {
   ...
   plugins: [
-    ['@apizee/expo-apirtc-options-plugin-test', { }]
+    ['@apizee/expo-apirtc-options-plugin-test', {
+      enableMediaProjectionService: false,
+      appleTeamId: "YOUR_TEAM_ID"
+    }]
   ],
 };
 ```
@@ -29,14 +32,31 @@ module.exports = {
 | Parameter | Description | Default value |
 | --- | --- | --- |
 | enableMediaProjectionService | Can be used to deactivate screenSharing activation on Android | true |
+| appleTeamId | used to define appleTeamId in your application project and screensharing extension | "APPLE_TEAM_ID_NOT_SET" |
 
+Example :
 
 ```js
 module.exports = {
   ...
   plugins: [
-    ['@apizee/expo-apirtc-options-plugin-test', { enableMediaProjectionService: false }]
+    ['@apizee/expo-apirtc-options-plugin-test', {
+      enableMediaProjectionService: false,
+      appleTeamId: "YOUR_TEAM_ID"
+    }]
   ],
 };
 ```
 
+### What does this plugin do ? :
+
+On Android :
+
+- Add needed permission in your app AndroidManifest file for screenSharing
+- Manage the case where the application is killed by user when a screenShare is enabled :
+A native module AppLifecycleModule is added in your application to manage the case where the user kill the application using swipe.
+This module detect the onHostDestroy event to stop the screenSharing extension and unpublish stream.
+
+On iOS :
+- Add broadcast extension for screenSharing feature
+- Configure project with needed modification for screenSharing feature

package/build/static/Atomic.swift

@@ -0,0 +1,37 @@
+//
+//  Atomic.swift
+//  Broadcast Extension
+//
+//  Created by Maksym Shcheglov.
+//  https://www.onswiftwings.com/posts/atomic-property-wrapper/
+//
+
+import Foundation
+
+@propertyWrapper
+struct Atomic<Value> {
+
+    private var value: Value
+    private let lock = NSLock()
+
+    init(wrappedValue value: Value) {
+        self.value = value
+    }
+
+    var wrappedValue: Value {
+        get { load() }
+        set { store(newValue: newValue) }
+    }
+
+    func load() -> Value {
+        lock.lock()
+        defer { lock.unlock() }
+        return value
+    }
+
+    mutating func store(newValue: Value) {
+        lock.lock()
+        defer { lock.unlock() }
+        value = newValue
+    }
+}

package/build/static/DarwinNotificationCenter.swift

@@ -0,0 +1,29 @@
+//
+//  DarwinNotificationCenter.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 23/03/2021.
+//  Copyright © 2021 8x8, Inc. All rights reserved.
+//
+
+import Foundation
+
+enum DarwinNotification: String {
+    case broadcastStarted = "iOS_BroadcastStarted"
+    case broadcastStopped = "iOS_BroadcastStopped"
+}
+
+class DarwinNotificationCenter {
+    
+    static let shared = DarwinNotificationCenter()
+    
+    private let notificationCenter: CFNotificationCenter
+    
+    init() {
+        notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+    }
+    
+    func postNotification(_ name: DarwinNotification) {
+        CFNotificationCenterPostNotification(notificationCenter, CFNotificationName(rawValue: name.rawValue as CFString), nil, nil, true)
+    }
+}

package/build/static/ReactNativeApiRTC_RPK.m

@@ -0,0 +1,14 @@
+//
+//  ReactNativeApiRTC_RPK.m
+//  reactNativeApiRTC
+//
+//  Created by Fred on 22/04/2024.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import "React/RCTEventEmitter.h"
+
+@interface RCT_EXTERN_MODULE(ReactNativeApiRTC_RPK, RCTEventEmitter)
+RCT_EXTERN_METHOD(sendBroadcastNeedToBeStopped)
+@end

package/build/static/ReactNativeApiRTC_RPK.swift

@@ -0,0 +1,83 @@
+//
+//  ReactNativeApiRTC_RPK.swift
+//  reactNativeApiRTC
+//
+//  Created by Fred on 22/04/2024.
+//
+
+import Foundation
+import ReplayKit
+import Photos
+import UIKit
+
+@objc(ReactNativeApiRTC_RPK)
+class ReactNativeApiRTC_RPK: RCTEventEmitter {
+  
+  private var status = "Empty"
+  
+  var start_notification_callback: CFNotificationCallback = { center, observer, name, object, info in
+    NotificationCenter.default.post(name: Notification.Name("START_BROADCAST"), object: nil)
+  }
+  
+  var stop_notification_callback: CFNotificationCallback = { center, observer, name, object, info in
+    NotificationCenter.default.post(name: Notification.Name("STOP_BROADCAST"), object: nil)
+  }
+  
+  override init() {
+    super.init()
+    NotificationCenter.default.addObserver(self, selector: #selector(self.startBroadcastCallback(notification:)), name: Notification.Name("START_BROADCAST"), object: nil)
+    
+    NotificationCenter.default.addObserver(self, selector: #selector(self.stopBroadcastCallback(notification:)), name: Notification.Name("STOP_BROADCAST"), object: nil)
+    
+    let notificationStartIdentifier = "com.reactnativeapirtc.notification.broadcaststart" as CFString
+    let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+    
+    CFNotificationCenterAddObserver(notificationCenter,
+                                    nil,
+                                    start_notification_callback,
+                                    notificationStartIdentifier,
+                                    nil,
+                                    CFNotificationSuspensionBehavior.deliverImmediately)
+    
+    
+    let notificationStopIdentifier = "com.reactnativeapirtc.notification.broadcaststop" as CFString
+    
+    CFNotificationCenterAddObserver(notificationCenter,
+                                    nil,
+                                    stop_notification_callback,
+                                    notificationStopIdentifier,
+                                    nil,
+                                    CFNotificationSuspensionBehavior.deliverImmediately)
+  }
+  
+  @objc func startBroadcastCallback(notification: NSNotification){
+    status = "START_BROADCAST"
+    sendEvent(withName: "onScreenShare", body: status)
+    status="STARTED_BROADCASTING"
+  }
+  
+  @objc func stopBroadcastCallback(notification: NSNotification){
+    status = "STOP_BROADCAST"
+    sendEvent(withName: "onScreenShare", body: status)
+    status = "Empty"
+  }
+
+  //This function is used to send a notification to the extension to stop the broadcast
+  @objc
+  func sendBroadcastNeedToBeStopped() {
+    //Sending event to screen sharing extension
+    let notificationName = CFNotificationName("com.reactnativeapirtc.notification.broadcastneedtobestopped" as CFString)
+    let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+    CFNotificationCenterPostNotification(notificationCenter, notificationName, nil, nil, true)
+  }
+  
+  override func supportedEvents() -> [String]! {
+    return ["onScreenShare"]
+  }
+  override func constantsToExport() -> [AnyHashable : Any]! {
+    return ["initialCount": status]
+  }
+  override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+}

package/build/static/SampleHandler.swift

@@ -0,0 +1,157 @@
+//
+//  SampleHandler.swift
+//  screenSharing_Extension
+//
+//  Created by Fred on 17/04/2024.
+//
+
+import ReplayKit
+//import OSLog
+
+private enum Constants {
+    // the App Group ID value that the app and the broadcast extension targets are setup with. It differs for each app.
+    static let appGroupIdentifier = "group.apirtc.reactNativeApiRTC.broadcast"
+}
+
+class SampleHandler: RPBroadcastSampleHandler {
+
+    //var logger = Logger()
+  
+    private var clientConnection: SocketConnection?
+    private var uploader: SampleUploader?
+    
+    private var frameCount: Int = 0
+    
+    var socketFilePath: String {
+        let sharedContainer = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: Constants.appGroupIdentifier)
+        return sharedContainer?.appendingPathComponent("rtc_SSFD").path ?? ""
+    }
+
+    var needtobestopped_notification_callback: CFNotificationCallback = { center, observer, name, object, info in
+        NotificationCenter.default.post(name: Notification.Name("NEED_TO_BE_STOPPED_BROADCAST"), object: nil)
+    }
+
+    override init() {
+      super.init()
+        if let connection = SocketConnection(filePath: socketFilePath) {
+            clientConnection = connection
+            setupConnection()
+            uploader = SampleUploader(connection: connection)
+        }
+
+        //Setting observer for broadcastneedtobestopped notification from application
+        NotificationCenter.default.addObserver(self, selector: #selector(self.needToBeStoppedBroadcastCallback(notification:)), name: Notification.Name("NEED_TO_BE_STOPPED_BROADCAST"), object: nil)
+
+        let notificationStartIdentifier = "com.reactnativeapirtc.notification.broadcastneedtobestopped" as CFString
+        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+    
+        CFNotificationCenterAddObserver(notificationCenter,
+                                        nil,
+                                        needtobestopped_notification_callback,
+                                        notificationStartIdentifier,
+                                        nil,
+                                        CFNotificationSuspensionBehavior.deliverImmediately)
+    }
+  
+    override func broadcastStarted(withSetupInfo setupInfo: [String : NSObject]?) {
+        // User has requested to start the broadcast. Setup info from the UI extension can be supplied but optional. 
+        //logger.error("QQQ: broadcastStarted")
+        frameCount = 0
+        
+        DarwinNotificationCenter.shared.postNotification(.broadcastStarted)
+        openConnection()
+
+        //Sending event to application
+        let notificationName = CFNotificationName("com.reactnativeapirtc.notification.broadcaststart" as CFString)
+        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+        CFNotificationCenterPostNotification(notificationCenter, notificationName, nil, nil, true)
+    }
+    
+    override func broadcastPaused() {
+        // User has requested to pause the broadcast. Samples will stop being delivered.
+        //logger.error("QQQ: broadcastPaused")
+    }
+    
+    override func broadcastResumed() {
+        // User has requested to resume the broadcast. Samples delivery will resume.
+        //logger.error("QQQ: broadcastResumed")
+    }
+    
+    override func broadcastFinished() {
+        // User has requested to finish the broadcast.
+        //logger.error("QQQ: broadcastFinished")
+      
+        DarwinNotificationCenter.shared.postNotification(.broadcastStopped)
+        clientConnection?.close()
+
+        let notificationName = CFNotificationName("com.reactnativeapirtc.notification.broadcaststop" as CFString)
+        let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+        CFNotificationCenterPostNotification(notificationCenter, notificationName, nil, nil, true)
+    }
+    
+    override func processSampleBuffer(_ sampleBuffer: CMSampleBuffer, with sampleBufferType: RPSampleBufferType) {
+        switch sampleBufferType {
+        case RPSampleBufferType.video:
+            // Handle video sample buffer
+
+            // very simple mechanism for adjusting frame rate by using every third frame
+            frameCount += 1
+            if frameCount % 3 == 0 {
+                uploader?.send(sample: sampleBuffer)
+            }
+            break
+        case RPSampleBufferType.audioApp:
+            // Handle audio sample buffer for app audio
+            break
+        case RPSampleBufferType.audioMic:
+            // Handle audio sample buffer for mic audio
+            break
+        @unknown default:
+            // Handle other sample buffer types
+            fatalError("Unknown type of sample buffer")
+        }
+    }
+}
+
+private extension SampleHandler {
+
+    func setupConnection() {
+        clientConnection?.didClose = { [weak self] error in
+            print("client connection did close \(String(describing: error))")
+          
+            if let error = error {
+                self?.finishBroadcastWithError(error)
+            } else {
+                // the displayed failure message is more user friendly when using NSError instead of Error
+                let JMScreenSharingStopped = 10001
+                let customError = NSError(domain: RPRecordingErrorDomain, code: JMScreenSharingStopped, userInfo: [NSLocalizedDescriptionKey: "Screen sharing stopped"])
+                self?.finishBroadcastWithError(customError)
+            }
+        }
+    }
+    
+    func openConnection() {
+        let queue = DispatchQueue(label: "broadcast.connectTimer")
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now(), repeating: .milliseconds(100), leeway: .milliseconds(500))
+        timer.setEventHandler { [weak self] in
+            guard self?.clientConnection?.open() == true else {
+                return
+            }
+            timer.cancel()
+        }
+        timer.resume()
+    }
+
+    @objc func needToBeStoppedBroadcastCallback(notification: NSNotification){
+        //logger.error("QQQ: needToBeStoppedBroadcastCallback")
+        
+        //needToBeStoppedBroadcast notification received from the application
+        //stopping the broadcast extension with finishBroadcastWithError()
+      
+        // the displayed failure message is more user friendly when using NSError instead of Error
+        let JMScreenSharingStopped = 10001
+        let customError = NSError(domain: RPRecordingErrorDomain, code: JMScreenSharingStopped, userInfo: [NSLocalizedDescriptionKey: "User has requested screen sharing to be stopped"])
+        self.finishBroadcastWithError(customError)
+    }
+}

package/build/static/SampleUploader.swift

@@ -0,0 +1,146 @@
+//
+//  SampleUploader.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 22/03/2021.
+//  Copyright © 2021 8x8, Inc. All rights reserved.
+//
+
+import Foundation
+import ReplayKit
+
+private enum Constants {
+    static let bufferMaxLength = 10240
+}
+
+class SampleUploader {
+    
+    private static var imageContext = CIContext(options: nil)
+    
+    @Atomic private var isReady = false
+    private var connection: SocketConnection
+  
+    private var dataToSend: Data?
+    private var byteIndex = 0
+  
+    private let serialQueue: DispatchQueue
+    
+    init(connection: SocketConnection) {
+        self.connection = connection
+        self.serialQueue = DispatchQueue(label: "org.jitsi.meet.broadcast.sampleUploader")
+      
+        setupConnection()
+    }
+  
+    @discardableResult func send(sample buffer: CMSampleBuffer) -> Bool {
+        guard isReady else {
+            return false
+        }
+        
+        isReady = false
+
+        dataToSend = prepare(sample: buffer)
+        byteIndex = 0
+
+        serialQueue.async { [weak self] in
+            self?.sendDataChunk()
+        }
+        
+        return true
+    }
+}
+
+private extension SampleUploader {
+    
+    func setupConnection() {
+        connection.didOpen = { [weak self] in
+            self?.isReady = true
+        }
+        connection.streamHasSpaceAvailable = { [weak self] in
+            self?.serialQueue.async {
+                if let success = self?.sendDataChunk() {
+                    self?.isReady = !success
+                }
+            }
+        }
+    }
+    
+    @discardableResult func sendDataChunk() -> Bool {
+        guard let dataToSend = dataToSend else {
+            return false
+        }
+      
+        var bytesLeft = dataToSend.count - byteIndex
+        var length = bytesLeft > Constants.bufferMaxLength ? Constants.bufferMaxLength : bytesLeft
+
+        length = dataToSend[byteIndex..<(byteIndex + length)].withUnsafeBytes {
+            guard let ptr = $0.bindMemory(to: UInt8.self).baseAddress else {
+                return 0
+            }
+
+            return connection.writeToStream(buffer: ptr, maxLength: length)
+        }
+
+        if length > 0 {
+            byteIndex += length
+            bytesLeft -= length
+
+            if bytesLeft == 0 {
+                self.dataToSend = nil
+                byteIndex = 0
+            }
+        } else {
+            print("writeBufferToStream failure")
+        }
+      
+        return true
+    }
+    
+    func prepare(sample buffer: CMSampleBuffer) -> Data? {
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(buffer) else {
+            print("image buffer not available")
+            return nil
+        }
+        
+        CVPixelBufferLockBaseAddress(imageBuffer, .readOnly)
+        
+        let scaleFactor = 2.0
+        let width = CVPixelBufferGetWidth(imageBuffer)/Int(scaleFactor)
+        let height = CVPixelBufferGetHeight(imageBuffer)/Int(scaleFactor)
+        let orientation = CMGetAttachment(buffer, key: RPVideoSampleOrientationKey as CFString, attachmentModeOut: nil)?.uintValue ?? 0
+                                    
+        let scaleTransform = CGAffineTransform(scaleX: CGFloat(1.0/scaleFactor), y: CGFloat(1.0/scaleFactor))
+        let bufferData = self.jpegData(from: imageBuffer, scale: scaleTransform)
+        
+        CVPixelBufferUnlockBaseAddress(imageBuffer, .readOnly)
+        
+        guard let messageData = bufferData else {
+            print("corrupted image buffer")
+            return nil
+        }
+              
+        let httpResponse = CFHTTPMessageCreateResponse(nil, 200, nil, kCFHTTPVersion1_1).takeRetainedValue()
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Content-Length" as CFString, String(messageData.count) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Width" as CFString, String(width) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Height" as CFString, String(height) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Orientation" as CFString, String(orientation) as CFString)
+        
+        CFHTTPMessageSetBody(httpResponse, messageData as CFData)
+        
+        let serializedMessage = CFHTTPMessageCopySerializedMessage(httpResponse)?.takeRetainedValue() as Data?
+      
+        return serializedMessage
+    }
+    
+    func jpegData(from buffer: CVPixelBuffer, scale scaleTransform: CGAffineTransform) -> Data? {
+        let image = CIImage(cvPixelBuffer: buffer).transformed(by: scaleTransform)
+        
+        guard let colorSpace = image.colorSpace else {
+            return nil
+        }
+      
+        let options: [CIImageRepresentationOption: Float] = [kCGImageDestinationLossyCompressionQuality as CIImageRepresentationOption: 1.0]
+
+        return SampleUploader.imageContext.jpegRepresentation(of: image, colorSpace: colorSpace, options: options)
+    }
+}

package/build/static/SocketConnection.swift

@@ -0,0 +1,198 @@
+//
+//  SocketConnection.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 22/03/2021.
+//  Copyright © 2021 Atlassian Inc. All rights reserved.
+//
+
+import Foundation
+
+class SocketConnection: NSObject {
+    var didOpen: (() -> Void)?
+    var didClose: ((Error?) -> Void)?
+    var streamHasSpaceAvailable: (() -> Void)?
+
+    private let filePath: String
+    private var socketHandle: Int32 = -1
+    private var address: sockaddr_un?
+
+    private var inputStream: InputStream?
+    private var outputStream: OutputStream?
+    
+    private var networkQueue: DispatchQueue?
+    private var shouldKeepRunning = false
+
+    init?(filePath path: String) {
+        filePath = path
+        socketHandle = Darwin.socket(AF_UNIX, SOCK_STREAM, 0)
+
+        guard socketHandle != -1 else {
+            print("failure: create socket")
+            return nil
+        }
+    }
+
+    func open() -> Bool {
+        print("open socket connection")
+
+        guard FileManager.default.fileExists(atPath: filePath) else {
+            print("failure: socket file missing")
+            return false
+        }
+      
+        guard setupAddress() == true else {
+            return false
+        }
+        
+        guard connectSocket() == true else {
+            return false
+        }
+
+        setupStreams()
+        
+        inputStream?.open()
+        outputStream?.open()
+
+        return true
+    }
+
+    func close() {
+        unscheduleStreams()
+
+        inputStream?.delegate = nil
+        outputStream?.delegate = nil
+
+        inputStream?.close()
+        outputStream?.close()
+        
+        inputStream = nil
+        outputStream = nil
+    }
+
+    func writeToStream(buffer: UnsafePointer<UInt8>, maxLength length: Int) -> Int {
+        outputStream?.write(buffer, maxLength: length) ?? 0
+    }
+}
+
+extension SocketConnection: StreamDelegate {
+
+    func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
+        switch eventCode {
+        case .openCompleted:
+            print("client stream open completed")
+            if aStream == outputStream {
+                didOpen?()
+            }
+        case .hasBytesAvailable:
+            if aStream == inputStream {
+                var buffer: UInt8 = 0
+                let numberOfBytesRead = inputStream?.read(&buffer, maxLength: 1)
+                if numberOfBytesRead == 0 && aStream.streamStatus == .atEnd {
+                    print("server socket closed")
+                    close()
+                    notifyDidClose(error: nil)
+                }
+            }
+        case .hasSpaceAvailable:
+            if aStream == outputStream {
+                streamHasSpaceAvailable?()
+            }
+        case .errorOccurred:
+            print("client stream error occured: \(String(describing: aStream.streamError))")
+            close()
+            notifyDidClose(error: aStream.streamError)
+
+        default:
+            break
+        }
+    }
+}
+
+private extension SocketConnection {
+  
+    func setupAddress() -> Bool {
+        var addr = sockaddr_un()
+        guard filePath.count < MemoryLayout.size(ofValue: addr.sun_path) else {
+            print("failure: fd path is too long")
+            return false
+        }
+
+        _ = withUnsafeMutablePointer(to: &addr.sun_path.0) { ptr in
+            filePath.withCString {
+                strncpy(ptr, $0, filePath.count)
+            }
+        }
+        
+        address = addr
+        return true
+    }
+
+    func connectSocket() -> Bool {
+        guard var addr = address else {
+            return false
+        }
+        
+        let status = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+                Darwin.connect(socketHandle, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
+            }
+        }
+
+        guard status == noErr else {
+            print("failure: \(status)")
+            return false
+        }
+        
+        return true
+    }
+
+    func setupStreams() {
+        var readStream: Unmanaged<CFReadStream>?
+        var writeStream: Unmanaged<CFWriteStream>?
+
+        CFStreamCreatePairWithSocket(kCFAllocatorDefault, socketHandle, &readStream, &writeStream)
+
+        inputStream = readStream?.takeRetainedValue()
+        inputStream?.delegate = self
+        inputStream?.setProperty(kCFBooleanTrue, forKey: Stream.PropertyKey(kCFStreamPropertyShouldCloseNativeSocket as String))
+
+        outputStream = writeStream?.takeRetainedValue()
+        outputStream?.delegate = self
+        outputStream?.setProperty(kCFBooleanTrue, forKey: Stream.PropertyKey(kCFStreamPropertyShouldCloseNativeSocket as String))
+
+        scheduleStreams()
+    }
+  
+    func scheduleStreams() {
+        shouldKeepRunning = true
+        
+        networkQueue = DispatchQueue.global(qos: .userInitiated)
+        networkQueue?.async { [weak self] in
+            self?.inputStream?.schedule(in: .current, forMode: .common)
+            self?.outputStream?.schedule(in: .current, forMode: .common)
+            RunLoop.current.run()
+            
+            var isRunning = false
+                        
+            repeat {
+                isRunning = self?.shouldKeepRunning ?? false && RunLoop.current.run(mode: .default, before: .distantFuture)
+            } while (isRunning)
+        }
+    }
+    
+    func unscheduleStreams() {
+        networkQueue?.sync { [weak self] in
+            self?.inputStream?.remove(from: .current, forMode: .common)
+            self?.outputStream?.remove(from: .current, forMode: .common)
+        }
+        
+        shouldKeepRunning = false
+    }
+    
+    func notifyDidClose(error: Error?) {
+        if didClose != nil {
+            didClose?(error)
+        }
+    }
+}

package/build/static/reactNativeApiRTCExpo-Bridging-Header.h

@@ -0,0 +1,6 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
+
+#import "React/RCTEventEmitter.h"

package/build/static/reactNativeApiRTCExpo.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>com.apple.security.application-groups</key>
+    <array>
+      <string>group.reactnativeexpo.apirtc.com.screenSharing-Extension</string>
+    </array>
+  </dict>
+</plist>

package/build/withIosBroadcastExtension.d.ts

@@ -0,0 +1,7 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+type PluginProps = {
+    enableMediaProjectionService?: boolean;
+    appleTeamId?: string;
+};
+declare const withIosBroadcastExtension: ConfigPlugin<PluginProps>;
+export default withIosBroadcastExtension;

package/build/withIosBroadcastExtension.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const plist_1 = __importDefault(require("@expo/plist"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util = __importStar(require("util"));
+const quoted = (str) => {
+    return util.format(`"%s"`, str);
+};
+const withIosBroadcastExtension = (config, props) => {
+    console.log('withIosBroadcastExtension called with props:', props);
+    config = withAppEntitlements(config);
+    config = withInfoPlistRTC(config);
+    config = withBroadcastExtensionXcodeTarget(config, props);
+    config = withBroadcastExtensionPlist(config);
+    //TODO Suite à relire
+    return config;
+};
+const withAppEntitlements = (config) => {
+    config = (0, config_plugins_1.withEntitlementsPlist)(config, (config) => {
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.screenSharing-Extension`;
+        config.modResults['com.apple.security.application-groups'] = [
+            appGroupIdentifier,
+        ];
+        return config;
+    });
+    return config;
+};
+const withInfoPlistRTC = (config) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.screenSharing-Extension`;
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.screenSharing-Extension`;
+        config.modResults['RTCAppGroupIdentifier'] = appGroupIdentifier;
+        config.modResults['RTCScreenSharingExtension'] = extensionBundleIdentifier;
+        if (!config.modResults['UIBackgroundModes']) {
+            config.modResults['UIBackgroundModes'] = [];
+        }
+        config.modResults['UIBackgroundModes'].push('voip');
+        config.modResults['UIBackgroundModes'].push('audio');
+        config.modResults['UIBackgroundModes'].push('fetch');
+        config.modResults['UIBackgroundModes'].push('processing');
+        config.modResults['UIBackgroundModes'].push('remote-notification');
+        config.modResults['NSCameraUsageDescription'] = 'Camera permission description F';
+        config.modResults['NSMicrophoneUsageDescription'] = 'Microphone permission description F';
+        return config;
+    });
+};
+const withBroadcastExtensionPlist = (config) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        'ios',
+        async (config) => {
+            const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'screenSharing_Extension');
+            const extensionPlistPath = path.join(extensionRootPath, 'Info.plist');
+            const extensionPlist = {
+                NSExtension: {
+                    NSExtensionPointIdentifier: 'com.apple.broadcast-services-upload',
+                    NSExtensionPrincipalClass: '$(PRODUCT_MODULE_NAME).SampleHandler',
+                    RPBroadcastProcessMode: 'RPBroadcastProcessModeSampleBuffer',
+                },
+            };
+            await fs.promises.mkdir(path.dirname(extensionPlistPath), {
+                recursive: true,
+            });
+            await fs.promises.writeFile(extensionPlistPath, plist_1.default.build(extensionPlist));
+            return config;
+        },
+    ]);
+};
+const withBroadcastExtensionXcodeTarget = (config, props) => {
+    return (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const appName = config.modRequest.projectName;
+        const extensionName = 'screenSharing_Extension';
+        const extensionBundleIdentifier = `${config.ios.bundleIdentifier}.screenSharing-Extension`;
+        const currentProjectVersion = config.ios.buildNumber || '1';
+        const marketingVersion = config.version;
+        let updatedProj = addBroadcastExtensionXcodeTarget(config.modResults, {
+            appName,
+            extensionName,
+            extensionBundleIdentifier,
+            currentProjectVersion,
+            marketingVersion,
+            appleTeamId: props.appleTeamId,
+        });
+        addBroadcastEntitlements(updatedProj, config, props.appleTeamId);
+        addExtensionSources(updatedProj, config);
+        return config;
+    });
+};
+const addBroadcastExtensionXcodeTarget = (proj, { appName, extensionName, extensionBundleIdentifier, currentProjectVersion, marketingVersion, appleTeamId, }) => {
+    var _a;
+    if (((_a = proj.getFirstProject().firstProject.targets) === null || _a === void 0 ? void 0 : _a.length) > 1) {
+        console.error("addBroadcastExtensionXcodeTarget targets?.length > 1");
+        return;
+    }
+    const targetUuid = proj.generateUuid();
+    const groupName = 'Embed App Extensions';
+    const xCConfigurationList = addXCConfigurationList(proj, {
+        extensionBundleIdentifier,
+        currentProjectVersion,
+        marketingVersion,
+        extensionName,
+        appName,
+        appleTeamId,
+    });
+    const productFile = addProductFile(proj, extensionName, groupName);
+    const target = addToPbxNativeTargetSection(proj, {
+        extensionName,
+        targetUuid,
+        productFile,
+        xCConfigurationList,
+    });
+    addToPbxProjectSection(proj, target);
+    addTargetDependency(proj, target);
+    const frameworkFile = proj.addFramework('ReplayKit.framework', {
+        target: target.uuid,
+        link: false,
+    });
+    const frameworkPath = frameworkFile.path;
+    //console.log(`Added ReplayKit.framework to target ${target.uuid}`);
+    addBuildPhases(proj, {
+        groupName,
+        productFile,
+        targetUuid,
+        frameworkPath,
+    });
+    addPbxGroup(proj, productFile);
+    return proj;
+};
+const addXCConfigurationList = (proj, { extensionBundleIdentifier, currentProjectVersion, marketingVersion, extensionName, appName, appleTeamId, }) => {
+    const commonBuildSettings = {
+        CLANG_ANALYZER_NONNULL: 'YES',
+        CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION: 'YES_AGGRESSIVE',
+        CLANG_CXX_LANGUAGE_STANDARD: quoted('gnu++17'),
+        CLANG_ENABLE_OBJC_WEAK: 'YES',
+        CLANG_WARN_DOCUMENTATION_COMMENTS: 'YES',
+        CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER: 'YES',
+        CLANG_WARN_UNGUARDED_AVAILABILITY: 'YES_AGGRESSIVE',
+        DEVELOPMENT_TEAM: appleTeamId ? quoted(appleTeamId) : undefined, // <-- Ajoute ici
+        CODE_SIGN_ENTITLEMENTS: `${appName}/${appName}.entitlements`,
+        CODE_SIGN_STYLE: 'Automatic',
+        CURRENT_PROJECT_VERSION: currentProjectVersion,
+        GCC_C_LANGUAGE_STANDARD: 'gnu11',
+        GENERATE_INFOPLIST_FILE: 'YES',
+        INFOPLIST_FILE: `${extensionName}/Info.plist`,
+        INFOPLIST_KEY_CFBundleDisplayName: `${extensionName}`,
+        INFOPLIST_KEY_NSHumanReadableCopyright: quoted(''),
+        IPHONEOS_DEPLOYMENT_TARGET: '15.1',
+        LD_RUNPATH_SEARCH_PATHS: quoted('$(inherited) @executable_path/Frameworks @executable_path/../../Frameworks'),
+        MARKETING_VERSION: marketingVersion,
+        MTL_FAST_MATH: 'YES',
+        PRODUCT_BUNDLE_IDENTIFIER: quoted(extensionBundleIdentifier),
+        PRODUCT_NAME: quoted('$(TARGET_NAME)'),
+        SKIP_INSTALL: 'YES',
+        SWIFT_EMIT_LOC_STRINGS: 'YES',
+        SWIFT_VERSION: '5.0',
+        TARGETED_DEVICE_FAMILY: quoted('1,2'),
+        //SWIFT_OBJC_BRIDGING_HEADER: `reactNativeApiRTC-Bridging-Header.h`,
+    };
+    const buildConfigurationsList = [
+        {
+            name: 'Debug',
+            isa: 'XCBuildConfiguration',
+            buildSettings: Object.assign(Object.assign({}, commonBuildSettings), { DEBUG_INFORMATION_FORMAT: 'dwarf', MTL_ENABLE_DEBUG_INFO: 'INCLUDE_SOURCE', SWIFT_ACTIVE_COMPILATION_CONDITIONS: 'DEBUG', SWIFT_OPTIMIZATION_LEVEL: quoted('-Onone') }),
+        },
+        {
+            name: 'Release',
+            isa: 'XCBuildConfiguration',
+            buildSettings: Object.assign(Object.assign({}, commonBuildSettings), { COPY_PHASE_STRIP: 'NO', DEBUG_INFORMATION_FORMAT: quoted('dwarf-with-dsym'), SWIFT_OPTIMIZATION_LEVEL: quoted('-Owholemodule') }),
+        },
+    ];
+    const xCConfigurationList = proj.addXCConfigurationList(buildConfigurationsList, 'Release', `Build configuration list for PBXNativeTarget ${quoted(extensionName)}`);
+    //console.log(`Added XCConfigurationList ${xCConfigurationList.uuid}`);
+    // update other build properties
+    proj.updateBuildProperty('ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES', 'YES', null, proj.getFirstTarget().firstTarget.name);
+    proj.updateBuildProperty('IPHONEOS_DEPLOYMENT_TARGET', '15.1');
+    return xCConfigurationList;
+};
+const addProductFile = (proj, extensionName, groupName) => {
+    const productFile = {
+        basename: `${extensionName}.appex`,
+        fileRef: proj.generateUuid(),
+        uuid: proj.generateUuid(),
+        group: groupName,
+        explicitFileType: 'wrapper.app-extension',
+        settings: {
+            ATTRIBUTES: ['RemoveHeadersOnCopy'],
+        },
+        includeInIndex: 0,
+        path: `${extensionName}.appex`,
+        sourceTree: 'BUILT_PRODUCTS_DIR',
+    };
+    proj.addToPbxFileReferenceSection(productFile);
+    //console.log(`Added PBXFileReference: ${productFile.fileRef}`);
+    proj.addToPbxBuildFileSection(productFile);
+    //console.log(`Added PBXBuildFile: ${productFile.fileRef}`);
+    return productFile;
+};
+const addToPbxNativeTargetSection = (proj, { extensionName, targetUuid, productFile, xCConfigurationList, }) => {
+    const target = {
+        uuid: targetUuid,
+        pbxNativeTarget: {
+            isa: 'PBXNativeTarget',
+            buildConfigurationList: xCConfigurationList.uuid,
+            buildPhases: [],
+            buildRules: [],
+            dependencies: [],
+            name: extensionName,
+            productName: extensionName,
+            productReference: productFile.fileRef,
+            productType: quoted('com.apple.product-type.app-extension'),
+        },
+    };
+    proj.addToPbxNativeTargetSection(target);
+    //console.log(`Added PBXNativeTarget ${target.uuid}`);
+    return target;
+};
+const addToPbxProjectSection = (proj, target) => {
+    proj.addToPbxProjectSection(target);
+    //console.log(`Added target to pbx project section ${target.uuid}`);
+    // Add target attributes to project section
+    if (!proj.pbxProjectSection()[proj.getFirstProject().uuid].attributes
+        .TargetAttributes) {
+        proj.pbxProjectSection()[proj.getFirstProject().uuid].attributes.TargetAttributes = {};
+    }
+    proj.pbxProjectSection()[proj.getFirstProject().uuid].attributes.LastSwiftUpdateCheck = 1340;
+    proj.pbxProjectSection()[proj.getFirstProject().uuid].attributes.TargetAttributes[target.uuid] = {
+        CreatedOnToolsVersion: '13.4.1',
+        ProvisioningStyle: 'Automatic',
+    };
+};
+const addTargetDependency = (proj, target) => {
+    if (!proj.hash.project.objects['PBXTargetDependency']) {
+        proj.hash.project.objects['PBXTargetDependency'] = {};
+    }
+    if (!proj.hash.project.objects['PBXContainerItemProxy']) {
+        proj.hash.project.objects['PBXContainerItemProxy'] = {};
+    }
+    proj.addTargetDependency(proj.getFirstTarget().uuid, [target.uuid]);
+    //console.log(`Added target dependency for target ${target.uuid}`);
+};
+const addBuildPhases = (proj, { groupName, productFile, targetUuid, frameworkPath }) => {
+    const buildPath = quoted('');
+    // Sources build phase
+    const { uuid: sourcesBuildPhaseUuid } = proj.addBuildPhase([`SampleHandler.swift`, 'Atomic.swift', 'DarwinNotificationCenter.swift', 'SampleUploader.swift', 'SocketConnection.swift', 'screenSharing_Extension.entitlements'], 'PBXSourcesBuildPhase', 'Sources', targetUuid, 'app_extension', buildPath);
+    //console.log(`Added PBXSourcesBuildPhase ${sourcesBuildPhaseUuid}`);
+    // Copy files build phase
+    const { uuid: copyFilesBuildPhaseUuid } = proj.addBuildPhase([productFile.path], 'PBXCopyFilesBuildPhase', groupName, proj.getFirstTarget().uuid, 'app_extension', buildPath);
+    //console.log(`Added PBXCopyFilesBuildPhase ${copyFilesBuildPhaseUuid}`);
+    // Frameworks build phase
+    const { uuid: frameworksBuildPhaseUuid } = proj.addBuildPhase([frameworkPath], 'PBXFrameworksBuildPhase', 'Frameworks', targetUuid, 'app_extension', buildPath);
+    //console.log(`Added PBXFrameworksBuildPhase ${frameworksBuildPhaseUuid}`);
+    // Resources build phase
+    const { uuid: resourcesBuildPhaseUuid } = proj.addBuildPhase([], 'PBXResourcesBuildPhase', 'Resources', targetUuid, 'app_extension', buildPath);
+    //console.log(`Added PBXResourcesBuildPhase ${resourcesBuildPhaseUuid}`);
+};
+const addPbxGroup = (proj, productFile) => {
+    // Add PBX group
+    const { uuid: pbxGroupUuid } = proj.addPbxGroup(['SampleHandler.swift', 'Atomic.swift', 'DarwinNotificationCenter.swift', 'SampleUploader.swift', 'SocketConnection.swift', 'screenSharing_Extension.entitlements'], 'screenSharing_Extension', 'screenSharing_Extension');
+    //console.log(`Added PBXGroup ${pbxGroupUuid}`);
+    // Add PBXGroup to top level group
+    const groups = proj.hash.project.objects['PBXGroup'];
+    if (pbxGroupUuid) {
+        Object.keys(groups).forEach(function (key) {
+            if (groups[key].name === undefined && groups[key].path === undefined) {
+                proj.addToPbxGroup(pbxGroupUuid, key);
+                //console.log(`Added PBXGroup ${pbxGroupUuid} root PBXGroup group ${key}`);
+            }
+            else if (groups[key].name === 'Products') {
+                proj.addToPbxGroup(productFile, key);
+                //console.log(`Added broadcast.apex to Products PBXGroup`);
+            }
+        });
+    }
+};
+const addBroadcastEntitlements = async (proj, config, appleTeamId) => {
+    const appGroupIdentifier = `group.${config.ios.bundleIdentifier}.screenSharing-Extension`;
+    const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'screenSharing_Extension');
+    const entitlementsPath = path.join(extensionRootPath, 'screenSharing_Extension.entitlements');
+    const extensionEntitlements = {
+        'com.apple.security.application-groups': [appGroupIdentifier],
+        'com.apple.developer.team-identifier': appleTeamId,
+    };
+    // create file
+    await fs.promises.mkdir(path.dirname(entitlementsPath), { recursive: true, });
+    await fs.promises.writeFile(entitlementsPath, plist_1.default.build(extensionEntitlements));
+    const targetUuid = proj.findTargetKey('screenSharing_Extension');
+    const groupUuid = proj.findPBXGroupKey({ name: 'screenSharing_Extension' });
+    proj.addFile('screenSharing_Extension.entitlements', groupUuid, {
+        target: targetUuid,
+        lastKnownFileType: 'text.plist.entitlements',
+    });
+    // update build properties
+    proj.updateBuildProperty('CODE_SIGN_ENTITLEMENTS', 'screenSharing_Extension/screenSharing_Extension.entitlements', null, 'screenSharing_Extension');
+};
+const addExtensionSources = async (proj, config) => {
+    const appGroupIdentifier = `group.${config.ios
+        .bundleIdentifier}.screenSharing-Extension`;
+    const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'screenSharing_Extension');
+    const platformProjectRootPath = path.join(config.modRequest.platformProjectRoot);
+    await fs.promises.mkdir(extensionRootPath, { recursive: true });
+    await fs.promises.copyFile(path.join(__dirname, 'static', 'Atomic.swift'), path.join(extensionRootPath, 'Atomic.swift'));
+    await fs.promises.copyFile(path.join(__dirname, 'static', 'DarwinNotificationCenter.swift'), path.join(extensionRootPath, 'DarwinNotificationCenter.swift'));
+    // Override SampleHandler.swift initial template
+    await fs.promises.copyFile(path.join(__dirname, 'static', 'SampleHandler.swift'), path.join(extensionRootPath, 'SampleHandler.swift'));
+    await fs.promises.copyFile(path.join(__dirname, 'static', 'SampleUploader.swift'), path.join(extensionRootPath, 'SampleUploader.swift'));
+    await fs.promises.copyFile(path.join(__dirname, 'static', 'SocketConnection.swift'), path.join(extensionRootPath, 'SocketConnection.swift'));
+    // Update app group bundle id in SampleHandler code
+    const code = await fs.promises.readFile(path.join(extensionRootPath, 'SampleHandler.swift'), { encoding: 'utf-8' });
+    await fs.promises.writeFile(path.join(extensionRootPath, 'SampleHandler.swift'), code.replace('group.apirtc.reactNativeApiRTC.broadcast', appGroupIdentifier));
+    addSourceFiles(proj, extensionRootPath);
+};
+const addSourceFiles = (proj, extensionRootPath) => {
+    const targetUuid = proj.findTargetKey('screenSharing_Extension');
+    const groupUuid = proj.findPBXGroupKey({ name: 'screenSharing_Extension' });
+    if (!targetUuid) {
+        console.error(`Failed to find "screenSharing_Extension" target!`);
+        return;
+    }
+    if (!groupUuid) {
+        console.error(`Failed to find "screenSharing_Extension" group!`);
+        return;
+    }
+    proj.addSourceFile('Atomic.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('DarwinNotificationCenter.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('SampleHandler.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('SampleUploader.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('SocketConnection.swift', {
+        target: targetUuid,
+    }, groupUuid);
+};
+exports.default = withIosBroadcastExtension;

package/build/withIosRPKFiles.d.ts

@@ -0,0 +1,6 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+type PluginProps = {
+    enableMediaProjectionService?: boolean;
+};
+declare const withNativeFilesPlugin: ConfigPlugin<PluginProps>;
+export default withNativeFilesPlugin;

package/build/withIosRPKFiles.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const NATIVE_FILES = [
+    'ReactNativeApiRTC_RPK.swift',
+    'ReactNativeApiRTC_RPK.m',
+    'reactNativeApiRTCExpo.entitlements'
+];
+const BRIDGING_FILES = [
+    'reactNativeApiRTCExpo-Bridging-Header.h',
+];
+const BRIDGING_HEADER = 'reactNativeApiRTCExpo-Bridging-Header.h';
+function copyNativeFiles(projectRoot, iosProjectName) {
+    const nativeSrcPath = path.join(projectRoot, 'node_modules/@apizee/expo-apirtc-options-plugin-test/build/static');
+    //const nativeSrcPath = path.join('static');
+    const iosPath = path.join(projectRoot, 'ios', iosProjectName);
+    for (const file of NATIVE_FILES) {
+        const src = path.join(nativeSrcPath, file);
+        const dest = path.join(iosPath, file);
+        if (!fs.existsSync(src)) {
+            console.warn(`⚠️ Fichier manquant : ${src}`);
+            continue;
+        }
+        fs.copyFileSync(src, dest);
+        console.log(`📄 Copié : ${file}`);
+    }
+}
+function copyBridgingFiles(projectRoot, iosProjectName) {
+    const nativeSrcPath = path.join(projectRoot, 'node_modules/@apizee/expo-apirtc-options-plugin-test/build/static');
+    const iosPath = path.join(projectRoot, 'ios', iosProjectName);
+    for (const file of BRIDGING_FILES) {
+        const src = path.join(nativeSrcPath, file);
+        const dest = path.join(iosPath, file);
+        if (!fs.existsSync(src)) {
+            console.warn(`⚠️ Fichier manquant : ${src}`);
+            continue;
+        }
+        fs.copyFileSync(src, dest);
+        console.log(`📄 Copié : ${file}`);
+    }
+}
+const withNativeFilesPlugin = (config) => {
+    return (0, config_plugins_1.withXcodeProject)(config, (config) => {
+        const project = config.modResults;
+        const projectRoot = config.modRequest.projectRoot;
+        const iosProjectName = config.modRequest.projectName;
+        const iosDir = path.join(projectRoot, 'ios');
+        const nativeGroup = project.getFirstProject().firstProject.mainGroup;
+        copyNativeFiles(projectRoot, iosProjectName);
+        copyBridgingFiles(projectRoot, iosProjectName);
+        // Trouve la section Sources (PBXSourcesBuildPhase)
+        const buildPhases = project.hash.project.objects['PBXSourcesBuildPhase'];
+        const buildPhaseEntry = Object.entries(buildPhases).find(([key, val]) => key !== 'isa' && (val === null || val === void 0 ? void 0 : val.isa) === 'PBXSourcesBuildPhase');
+        if (!buildPhaseEntry) {
+            throw new Error('❌ PBXSourcesBuildPhase non trouvé dans le projet Xcode.');
+        }
+        const [sourcesBuildPhaseUuid, sourcesBuildPhase] = buildPhaseEntry;
+        sourcesBuildPhase.files = sourcesBuildPhase.files || [];
+        for (const fileName of NATIVE_FILES) {
+            const filePath = path.join(iosDir, iosProjectName, fileName);
+            if (!fs.existsSync(filePath)) {
+                console.warn(`⚠️  Fichier natif introuvable : ${filePath}`);
+                continue;
+            }
+            const file = project.addFile(path.join(iosProjectName, fileName), nativeGroup);
+            if (!(file === null || file === void 0 ? void 0 : file.fileRef)) {
+                console.warn(`❌ Échec de l'ajout de : ${fileName}`);
+                continue;
+            }
+            // Vérifie s’il est déjà présent
+            const alreadyExists = sourcesBuildPhase.files.some((f) => (f === null || f === void 0 ? void 0 : f.comment) === `${fileName} in Sources`);
+            if (alreadyExists)
+                continue;
+            // Crée un buildFile
+            const buildFileUuid = project.generateUuid();
+            project.hash.project.objects['PBXBuildFile'][buildFileUuid] = {
+                isa: 'PBXBuildFile',
+                fileRef: file.fileRef,
+                //comment: `${fileName} in Sources`,
+            };
+            sourcesBuildPhase.files.push({
+                value: buildFileUuid,
+                comment: `${fileName} in Sources`,
+            });
+            console.log(`✅ Fichier ajouté : ${fileName}`);
+        }
+        // Swift config
+        const targetUuid = project.getFirstTarget().uuid;
+        project.addBuildProperty('SWIFT_OBJC_BRIDGING_HEADER', `${iosProjectName}/${BRIDGING_HEADER}`, `${BRIDGING_HEADER}`, targetUuid);
+        project.addBuildProperty('SWIFT_VERSION', '5.0', targetUuid);
+        return config;
+    });
+};
+exports.default = withNativeFilesPlugin;

package/build/withPlugin.d.ts

@@ -1,6 +1,7 @@
 import { ConfigPlugin } from '@expo/config-plugins';
 type PluginProps = {
     enableMediaProjectionService?: boolean;
+    appleTeamId?: string;
 };
 export declare const withPlugin: ConfigPlugin<PluginProps>;
 export default withPlugin;

package/build/withPlugin.js

@@ -5,8 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withPlugin = void 0;
 const withAndroidPlugin_1 = __importDefault(require("./withAndroidPlugin"));
-const withPlugin = (config, props = { enableMediaProjectionService: true }) => {
-    return (0, withAndroidPlugin_1.default)(config, props);
+const withIosBroadcastExtension_1 = __importDefault(require("./withIosBroadcastExtension"));
+const withIosRPKFiles_1 = __importDefault(require("./withIosRPKFiles"));
+const withPlugin = (config, props = {
+    enableMediaProjectionService: true,
+    appleTeamId: process.env.EXPO_APPLE_TEAM_ID || 'APPLE_TEAM_ID_NOT_SET',
+}) => {
+    config = (0, withAndroidPlugin_1.default)(config, props);
+    config = (0, withIosBroadcastExtension_1.default)(config, props);
+    config = (0, withIosRPKFiles_1.default)(config, props);
+    return config;
 };
 exports.withPlugin = withPlugin;
 exports.default = exports.withPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apirtc/expo-apirtc-options-plugin",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Plugin Expo pour ajouter les features apiRTC dans une application React Native",
   "main": "index.js",
   "keywords": [