shakebug-react-native 1.0.14

package/ios/NetInfo/RNCNetInfo.m

@@ -0,0 +1,269 @@
+//
+//  RNCNetInfo.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 06/03/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import "RNCNetInfo.h"
+#import "RNCConnectionStateWatcher.h"
+
+#include <ifaddrs.h>
+#include <arpa/inet.h>
+
+#if !TARGET_OS_TV && !TARGET_OS_MACCATALYST && !TARGET_OS_VISION
+#import <CoreTelephony/CTCarrier.h>
+#import <CoreTelephony/CTTelephonyNetworkInfo.h>
+#endif
+@import SystemConfiguration.CaptiveNetwork;
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+
+@interface ShakebugSDKRNCNetInfo () <RNCConnectionStateWatcherDelegate>
+
+@property (nonatomic, strong) ShakebugSDKRNCConnectionStateWatcher *connectionStateWatcher;
+@property (nonatomic) BOOL isObserving;
+@property (nonatomic) NSDictionary *config;
+
+@end
+
+@implementation ShakebugSDKRNCNetInfo
+
+#pragma mark - Module setup
+
+RCT_EXPORT_MODULE()
+
+// We need RNCReachabilityCallback's and module methods to be called on the same thread so that we can have
+// guarantees about when we mess with the reachability callbacks.
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+#pragma mark - Lifecycle
+
+- (NSArray *)supportedEvents
+{
+  return @[@"netInfo.networkStatusDidChange"];
+}
+
+- (void)startObserving
+{
+  self.isObserving = YES;
+}
+
+- (void)stopObserving
+{
+  self.isObserving = NO;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _connectionStateWatcher = [[ShakebugSDKRNCConnectionStateWatcher alloc] initWithDelegate:self];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  self.connectionStateWatcher = nil;
+}
+
+#pragma mark - RNCConnectionStateWatcherDelegate
+
+- (void)connectionStateWatcher:(ShakebugSDKRNCConnectionStateWatcher *)connectionStateWatcher didUpdateState:(ShakebugSDKRNCConnectionState *)state
+{
+  if (self.isObserving) {
+    NSDictionary *dictionary = [self currentDictionaryFromUpdateState:state withInterface:NULL];
+    [self sendEventWithName:@"netInfo.networkStatusDidChange" body:dictionary];
+  }
+}
+
+#pragma mark - Public API
+
+RCT_EXPORT_METHOD(getCurrentState:(nullable NSString *)requestedInterface resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(__unused RCTPromiseRejectBlock)reject)
+{
+  ShakebugSDKRNCConnectionState *state = [self.connectionStateWatcher currentState];
+  resolve([self currentDictionaryFromUpdateState:state withInterface:requestedInterface]);
+}
+
+RCT_EXPORT_METHOD(configure:(NSDictionary *)config)
+{
+    self.config = config;
+}
+
+#pragma mark - Utilities
+
+// Converts the state into a dictionary to send over the bridge
+- (NSDictionary *)currentDictionaryFromUpdateState:(ShakebugSDKRNCConnectionState *)state withInterface:(nullable NSString *)requestedInterface
+{
+  NSString *selectedInterface = requestedInterface ?: state.type;
+  NSMutableDictionary *details = [self detailsFromInterface:selectedInterface withState:state];
+  bool connected = [state.type isEqualToString:selectedInterface] && state.connected;
+  if (connected) {
+    details[@"isConnectionExpensive"] = @(state.expensive);
+  }
+
+  return @{
+    @"type": selectedInterface,
+    @"isConnected": @(connected),
+    @"details": details ?: NSNull.null
+  };
+}
+
+- (NSMutableDictionary *)detailsFromInterface:(nonnull NSString *)requestedInterface withState:(ShakebugSDKRNCConnectionState *)state
+{
+  NSMutableDictionary *details = [NSMutableDictionary new];
+  if ([requestedInterface isEqualToString: RNCConnectionTypeCellular]) {
+    details[@"cellularGeneration"] = state.cellularGeneration ?: NSNull.null;
+    details[@"carrier"] = [self carrier] ?: NSNull.null;
+  } else if ([requestedInterface isEqualToString: RNCConnectionTypeWifi] || [requestedInterface isEqualToString: RNCConnectionTypeEthernet]) {
+    details[@"ipAddress"] = [self ipAddress] ?: NSNull.null;
+    details[@"subnet"] = [self subnet] ?: NSNull.null;
+    #if !TARGET_OS_TV && !TARGET_OS_OSX && !TARGET_OS_MACCATALYST && !TARGET_OS_VISION
+      /*
+        Without one of the conditions needed to use CNCopyCurrentNetworkInfo, it will leak memory.
+        Clients should only set the shouldFetchWiFiSSID to true after ensuring requirements are met to get (B)SSID.
+      */
+      if (self.config && self.config[@"shouldFetchWiFiSSID"]) {
+        details[@"ssid"] = [self ssid] ?: NSNull.null;
+        details[@"bssid"] = [self bssid] ?: NSNull.null;
+      }
+    #endif
+  }
+  return details;
+}
+
+- (NSString *)carrier
+{
+#if (TARGET_OS_TV || TARGET_OS_OSX || TARGET_OS_MACCATALYST || TARGET_OS_VISION)
+  return nil;
+#else
+  CTTelephonyNetworkInfo *netinfo = [[CTTelephonyNetworkInfo alloc] init];
+  CTCarrier *carrier = [netinfo subscriberCellularProvider];
+  return carrier.carrierName;
+#endif
+}
+
+- (NSString *)ipAddress
+{
+  NSString *address = @"0.0.0.0";
+  struct ifaddrs *interfaces = NULL;
+  struct ifaddrs *temp_addr = NULL;
+  int success = 0;
+  // retrieve the current interfaces - returns 0 on success
+  success = getifaddrs(&interfaces);
+  if (success == 0) {
+    // Loop through linked list of interfaces
+    temp_addr = interfaces;
+    while (temp_addr != NULL) {
+      if (temp_addr->ifa_addr->sa_family == AF_INET) {
+        NSString* ifname = [NSString stringWithUTF8String:temp_addr->ifa_name];
+        if (
+          // Check if interface is en0 which is the wifi connection on the iPhone
+          // and the ethernet connection on the Apple TV
+          [ifname isEqualToString:@"en0"] ||
+          // Check if interface is en1 which is the wifi connection on the Apple TV
+          [ifname isEqualToString:@"en1"]
+        ) {
+          // Get NSString from C String
+          char str[INET_ADDRSTRLEN];
+          inet_ntop(AF_INET, &((struct sockaddr_in *)temp_addr->ifa_addr)->sin_addr, str, INET_ADDRSTRLEN);
+          address = [NSString stringWithUTF8String:str];
+        }
+      }
+
+      temp_addr = temp_addr->ifa_next;
+    }
+  }
+  // Free memory
+  freeifaddrs(interfaces);
+  return address;
+}
+
+- (NSString *)subnet
+{
+  NSString *subnet = @"0.0.0.0";
+  struct ifaddrs *interfaces = NULL;
+  struct ifaddrs *temp_addr = NULL;
+  int success = 0;
+  // retrieve the current interfaces - returns 0 on success
+  success = getifaddrs(&interfaces);
+  if (success == 0) {
+    // Loop through linked list of interfaces
+    temp_addr = interfaces;
+    while (temp_addr != NULL) {
+      if (temp_addr->ifa_addr->sa_family == AF_INET) {
+        NSString* ifname = [NSString stringWithUTF8String:temp_addr->ifa_name];
+        if (
+          // Check if interface is en0 which is the wifi connection on the iPhone
+          // and the ethernet connection on the Apple TV
+          [ifname isEqualToString:@"en0"] ||
+          // Check if interface is en1 which is the wifi connection on the Apple TV
+          [ifname isEqualToString:@"en1"]
+        ) {
+          // Get NSString from C String
+          char str[INET_ADDRSTRLEN];
+          inet_ntop(AF_INET, &((struct sockaddr_in *)temp_addr->ifa_netmask)->sin_addr, str, INET_ADDRSTRLEN);
+          subnet = [NSString stringWithUTF8String:str];
+        }
+      }
+
+      temp_addr = temp_addr->ifa_next;
+    }
+  }
+  // Free memory
+  freeifaddrs(interfaces);
+  return subnet;
+}
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX && !TARGET_OS_MACCATALYST
+- (NSString *)ssid
+{
+  NSArray *interfaceNames = CFBridgingRelease(CNCopySupportedInterfaces());
+  NSDictionary *SSIDInfo;
+  NSString *SSID = NULL;
+  for (NSString *interfaceName in interfaceNames) {
+    // CNCopyCurrentNetworkInfo is deprecated for iOS 13+, need to override & use fetchCurrentWithCompletionHandler
+    SSIDInfo = CFBridgingRelease(CNCopyCurrentNetworkInfo((__bridge CFStringRef)interfaceName));
+    if (SSIDInfo.count > 0) {
+        SSID = SSIDInfo[@"SSID"];
+        if ([SSID isEqualToString:@"Wi-Fi"] || [SSID isEqualToString:@"WLAN"]){
+          SSID = NULL;
+        }
+        break;
+    }
+  }
+  return SSID;
+}
+
+- (NSString *)bssid
+{
+  NSArray *interfaceNames = CFBridgingRelease(CNCopySupportedInterfaces());
+  NSDictionary *networkDetails;
+  NSString *BSSID = NULL;
+  for (NSString *interfaceName in interfaceNames) {
+        // CNCopyCurrentNetworkInfo is deprecated for iOS 13+, need to override & use fetchCurrentWithCompletionHandler
+      networkDetails = CFBridgingRelease(CNCopyCurrentNetworkInfo((__bridge CFStringRef)interfaceName));
+      if (networkDetails.count > 0)
+      {
+          BSSID = networkDetails[(NSString *) kCNNetworkInfoKeyBSSID];
+          break;
+      }
+  }
+  return BSSID;
+}
+#endif
+
+@end

package/ios/RecordScreen/ShakebugSDKRecordScreen.h

@@ -0,0 +1,31 @@
+//
+//  RecordScreen.h
+//  Shakebug
+//
+//  Created by ideveloper2 on 28/02/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <ReplayKit/ReplayKit.h>
+#import <AVFoundation/AVFoundation.h>
+
+@interface ShakebugSDKRecordScreen : NSObject <RCTBridgeModule>
+
+    @property (strong, nonatomic) RPScreenRecorder *screenRecorder;
+    @property (strong, nonatomic) AVAssetWriterInput *videoInput;
+    @property (strong, nonatomic) AVAssetWriterInput *audioInput;
+    @property (strong, nonatomic) AVAssetWriterInput *micInput;
+    @property (assign, nonatomic) int screenWidth;
+    @property (assign, nonatomic) int screenHeight;
+    @property (assign, nonatomic) BOOL enableMic;
+    @property (assign, nonatomic) int fps;
+    @property (assign, nonatomic) int bitrate;
+
+    @property (nonatomic) AVAssetWriter *writer;
+    @property BOOL encounteredFirstBuffer;
+    @property CMSampleBufferRef afterAppBackgroundAudioSampleBuffer;
+    @property CMSampleBufferRef afterAppBackgroundMicSampleBuffer;
+    @property CMSampleBufferRef afterAppBackgroundVideoSampleBuffer;
+
+@end

package/ios/RecordScreen/ShakebugSDKRecordScreen.m

@@ -0,0 +1,309 @@
+//
+//  RecordScreen.m
+//  Shakebug
+//
+//  Created by ideveloper2 on 28/02/24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import "ShakebugSDKRecordScreen.h"
+#import <React/RCTConvert.h>
+
+@implementation ShakebugSDKRecordScreen
+
+UIBackgroundTaskIdentifier _ShakebugSDKbackgroundRenderingID;
+
+- (NSDictionary *)errorResponse:(NSDictionary *)result;
+{
+    NSDictionary *json = [NSDictionary dictionaryWithObjectsAndKeys:
+        @"error", @"status",
+        result, @"result",nil];
+    return json;
+
+}
+
+- (NSDictionary *) successResponse:(NSDictionary *)result;
+{
+    NSDictionary *json = [NSDictionary dictionaryWithObjectsAndKeys:
+        @"success", @"status",
+        result, @"result",nil];
+    return json;
+
+}
+
+- (void) muteAudioInBuffer:(CMSampleBufferRef)sampleBuffer
+{
+
+    CMItemCount numSamples = CMSampleBufferGetNumSamples(sampleBuffer);
+    NSUInteger channelIndex = 0;
+
+    CMBlockBufferRef audioBlockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
+    size_t audioBlockBufferOffset = (channelIndex * numSamples * sizeof(SInt16));
+    size_t lengthAtOffset = 0;
+    size_t totalLength = 0;
+    SInt16 *samples = NULL;
+    CMBlockBufferGetDataPointer(audioBlockBuffer, audioBlockBufferOffset, &lengthAtOffset, &totalLength, (char **)(&samples));
+
+    for (NSInteger i=0; i<numSamples; i++) {
+        samples[i] = (SInt16)0;
+    }
+}
+
+// For H264, unless the value is a multiple of 2 or 4, a green border will appear, so a function to adjust it
+- (int) adjustMultipleOf2:(int)value;
+{
+    if (value % 2 == 1) {
+        return value + 1;
+    }
+    return value;
+}
+
+
+RCT_EXPORT_MODULE()
+
+RCT_EXPORT_METHOD(setup: (NSDictionary *)config)
+{
+    self.screenWidth = [RCTConvert int: config[@"width"]];
+    self.screenHeight = [RCTConvert int: config[@"height"]];
+    self.enableMic = [RCTConvert BOOL: config[@"mic"]];
+    self.bitrate = [RCTConvert int: config[@"bitrate"]];
+    self.fps = [RCTConvert int: config[@"fps"]];
+}
+
+RCT_REMAP_METHOD(startRecording, resolve:(RCTPromiseResolveBlock)resolve rejecte:(RCTPromiseRejectBlock)reject)
+{
+    UIApplication *app = [UIApplication sharedApplication];
+    _ShakebugSDKbackgroundRenderingID = [app beginBackgroundTaskWithExpirationHandler:^{
+        [app endBackgroundTask:_ShakebugSDKbackgroundRenderingID];
+        _ShakebugSDKbackgroundRenderingID = UIBackgroundTaskInvalid;
+    }];
+
+    self.screenRecorder = [RPScreenRecorder sharedRecorder];
+    if (self.screenRecorder.isRecording) {
+        return;
+    }
+
+    self.encounteredFirstBuffer = NO;
+
+    NSArray *pathDocuments = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *outputURL = pathDocuments[0];
+
+    NSString *videoOutPath = [[outputURL stringByAppendingPathComponent:[NSString stringWithFormat:@"%u", arc4random() % 1000]] stringByAppendingPathExtension:@"mp4"];
+
+    NSError *error;
+    self.writer = [AVAssetWriter assetWriterWithURL:[NSURL fileURLWithPath:videoOutPath] fileType:AVFileTypeMPEG4 error:&error];
+    if (!self.writer) {
+        NSLog(@"writer: %@", error);
+        abort();
+    }
+
+    AudioChannelLayout acl = { 0 };
+    acl.mChannelLayoutTag = kAudioChannelLayoutTag_Mono;
+    self.audioInput = [[AVAssetWriterInput alloc] initWithMediaType:AVMediaTypeAudio outputSettings:@{ AVFormatIDKey: @(kAudioFormatMPEG4AAC), AVSampleRateKey: @(44100),  AVChannelLayoutKey: [NSData dataWithBytes: &acl length: sizeof( acl ) ], AVEncoderBitRateKey: @(64000)}];
+    self.micInput = [[AVAssetWriterInput alloc] initWithMediaType:AVMediaTypeAudio outputSettings:@{ AVFormatIDKey: @(kAudioFormatMPEG4AAC), AVSampleRateKey: @(44100),  AVChannelLayoutKey: [NSData dataWithBytes: &acl length: sizeof( acl ) ], AVEncoderBitRateKey: @(64000)}];
+
+    self.audioInput.preferredVolume = 0.0;
+    self.micInput.preferredVolume = 0.0;
+
+    NSDictionary *compressionProperties = @{AVVideoProfileLevelKey         : AVVideoProfileLevelH264HighAutoLevel,
+                                            AVVideoH264EntropyModeKey      : AVVideoH264EntropyModeCABAC,
+                                            AVVideoAverageBitRateKey       : @(self.bitrate),
+                                            AVVideoMaxKeyFrameIntervalKey  : @(self.fps),
+                                            AVVideoAllowFrameReorderingKey : @NO};
+
+    NSLog(@"width: %d", [self adjustMultipleOf2:self.screenWidth]);
+    NSLog(@"height: %d", [self adjustMultipleOf2:self.screenHeight]);
+    if (@available(iOS 11.0, *)) {
+        NSDictionary *videoSettings = @{AVVideoCompressionPropertiesKey : compressionProperties,
+                                        AVVideoCodecKey                 : AVVideoCodecTypeH264,
+                                        AVVideoWidthKey                 : @([self adjustMultipleOf2:self.screenWidth]),
+                                        AVVideoHeightKey                : @([self adjustMultipleOf2:self.screenHeight])};
+
+        self.videoInput = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:videoSettings];
+    } else {
+        // Fallback on earlier versions
+    }
+
+    [self.writer addInput:self.audioInput];
+    [self.writer addInput:self.micInput];
+    [self.writer addInput:self.videoInput];
+    [self.videoInput setMediaTimeScale:60];
+    [self.writer setMovieTimeScale:60];
+    [self.videoInput setExpectsMediaDataInRealTime:YES];
+
+    if (self.enableMic) {
+        self.screenRecorder.microphoneEnabled = YES;
+    }
+
+    [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
+        if (granted) {
+            if (@available(iOS 11.0, *)) {
+                [self.screenRecorder startCaptureWithHandler:^(CMSampleBufferRef sampleBuffer, RPSampleBufferType bufferType, NSError* error) {
+                    // Failure to do so will result in a memory error when accessing the sampleBuffer in the main thread.
+                    CFRetain(sampleBuffer);
+                    dispatch_async(dispatch_get_main_queue(), ^{
+                        if (CMSampleBufferDataIsReady(sampleBuffer)) {
+                            if (self.writer.status == AVAssetWriterStatusUnknown && !self.encounteredFirstBuffer && bufferType == RPSampleBufferTypeVideo) {
+                                self.encounteredFirstBuffer = YES;
+                                NSLog(@"First buffer video");
+                                [self.writer startWriting];
+                                [self.writer startSessionAtSourceTime:CMSampleBufferGetPresentationTimeStamp(sampleBuffer)];
+                            } else if (self.writer.status == AVAssetWriterStatusFailed) {
+
+                            }
+
+                            if ([[UIApplication sharedApplication] applicationState] == UIApplicationStateBackground) {
+                                CMSampleBufferRef copiedBuffer;
+                                CMSampleBufferCreateCopy(kCFAllocatorDefault, sampleBuffer, &copiedBuffer);
+                                switch (bufferType) {
+                                    case RPSampleBufferTypeVideo:
+                                        self.afterAppBackgroundVideoSampleBuffer = copiedBuffer;
+                                        break;
+                                    case RPSampleBufferTypeAudioApp:
+                                        self.afterAppBackgroundAudioSampleBuffer = copiedBuffer;
+                                        break;
+                                    case RPSampleBufferTypeAudioMic:
+                                        self.afterAppBackgroundMicSampleBuffer = copiedBuffer;
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            } else if ([[UIApplication sharedApplication] applicationState] == UIApplicationStateActive) {
+                                if (bufferType == RPSampleBufferTypeVideo && self.afterAppBackgroundVideoSampleBuffer != nil && self.afterAppBackgroundAudioSampleBuffer != nil && self.afterAppBackgroundMicSampleBuffer != nil) {
+                                    CMTime timeWhenAppBackground = CMTimeSubtract(CMSampleBufferGetPresentationTimeStamp(sampleBuffer), CMSampleBufferGetPresentationTimeStamp(self.afterAppBackgroundVideoSampleBuffer));
+                                    // Calc loop count for appendSampleBuffer.
+                                    long bufferCount = floor(CMTimeGetSeconds(timeWhenAppBackground) * (1 / CMTimeGetSeconds(CMSampleBufferGetDuration(self.afterAppBackgroundAudioSampleBuffer))));
+
+                                    // Make mute audio.
+                                    [self muteAudioInBuffer:self.afterAppBackgroundAudioSampleBuffer];
+                                    [self muteAudioInBuffer:self.afterAppBackgroundMicSampleBuffer];
+
+                                    for (int i = 0; i < bufferCount; i ++) {
+                                        if (self.audioInput.isReadyForMoreMediaData) {
+                                            [self.audioInput appendSampleBuffer:self.afterAppBackgroundAudioSampleBuffer];
+                                        }
+                                    }
+                                    for (int i = 0; i < bufferCount; i ++) {
+                                        if (self.enableMic && self.micInput.isReadyForMoreMediaData) {
+                                            [self.micInput appendSampleBuffer:self.afterAppBackgroundMicSampleBuffer];
+                                        }
+                                    }
+
+                                    // Clean
+                                    CFRelease(self.afterAppBackgroundAudioSampleBuffer);
+                                    CFRelease(self.afterAppBackgroundMicSampleBuffer);
+                                    CFRelease(self.afterAppBackgroundVideoSampleBuffer);
+                                    self.afterAppBackgroundAudioSampleBuffer = nil;
+                                    self.afterAppBackgroundMicSampleBuffer = nil;
+                                    self.afterAppBackgroundVideoSampleBuffer = nil;
+                                }
+                            }
+
+                            if (self.writer.status == AVAssetWriterStatusWriting) {
+                                switch (bufferType) {
+                                    case RPSampleBufferTypeVideo:
+                                        if (self.videoInput.isReadyForMoreMediaData) {
+                                            [self.videoInput appendSampleBuffer:sampleBuffer];
+                                        }
+                                        break;
+                                    case RPSampleBufferTypeAudioApp:
+                                        if (self.audioInput.isReadyForMoreMediaData) {
+                                            if(self.enableMic){
+                                                [self.audioInput appendSampleBuffer:sampleBuffer];
+                                            } else {
+                                                [self muteAudioInBuffer:sampleBuffer];
+                                            }
+                                        }
+                                        break;
+                                    case RPSampleBufferTypeAudioMic:
+                                        if (self.micInput.isReadyForMoreMediaData) {
+                                            if(self.enableMic){
+                                                [self.micInput appendSampleBuffer:sampleBuffer];
+                                            } else {
+                                                [self muteAudioInBuffer:sampleBuffer];
+                                            }
+                                        }
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+
+                        CFRelease(sampleBuffer);
+                    });
+                } completionHandler:^(NSError* error) {
+                    NSLog(@"startCapture: %@", error);
+                    if (error) {
+                        resolve(@"permission_error");
+                    } else {
+                        resolve(@"started");
+                    }
+                }];
+            } else {
+                // Fallback on earlier versions
+            }
+        } else {
+            NSError* err = nil;
+            reject(0, @"Permission denied", err);
+        }
+    }];
+
+    if (self.enableMic) {
+        self.screenRecorder.microphoneEnabled = YES;
+    }
+}
+
+RCT_REMAP_METHOD(stopRecording, resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [[UIApplication sharedApplication] endBackgroundTask:_ShakebugSDKbackgroundRenderingID];
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (@available(iOS 11.0, *)) {
+            [[RPScreenRecorder sharedRecorder] stopCaptureWithHandler:^(NSError * _Nullable error) {
+                if (!error) {
+                    [self.audioInput markAsFinished];
+                    [self.micInput markAsFinished];
+                    [self.videoInput markAsFinished];
+                    [self.writer finishWritingWithCompletionHandler:^{
+
+                        NSDictionary *result = [NSDictionary dictionaryWithObject:self.writer.outputURL.absoluteString forKey:@"outputURL"];
+                        resolve([self successResponse:result]);
+
+                        NSLog(@"finishWritingWithCompletionHandler: Recording stopped successfully. Cleaning up... %@", result);
+                        self.audioInput = nil;
+                        self.micInput = nil;
+                        self.videoInput = nil;
+                        self.writer = nil;
+                        self.screenRecorder = nil;
+                    }];
+                }
+            }];
+        } else {
+            // Fallback on earlier versions
+        }
+    });
+}
+
+RCT_REMAP_METHOD(clean,
+                 cleanResolve:(RCTPromiseResolveBlock)resolve
+                 cleanRejecte:(RCTPromiseRejectBlock)reject)
+{
+
+    NSArray *pathDocuments = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSString *path = pathDocuments[0];
+    NSLog(@"startCapture: %@", path);
+    [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
+    resolve(@"cleaned");
+}
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeRecordScreenSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/ScreenShot/ShakebugSDKRNViewShot.h

@@ -0,0 +1,6 @@
+
+#import <React/RCTBridgeModule.h>
+
+@interface ShakebugSDKRNViewShot : NSObject <RCTBridgeModule>
+
+@end