@luciq/react-native 18.0.0

package/ios/RNLuciq/LuciqAPMBridge.m

@@ -0,0 +1,99 @@
+
+
+#import "LuciqAPMBridge.h"
+#import <LuciqSDK/LCQAPM.h>
+#import <asl.h>
+#import <React/RCTLog.h>
+#import <os/log.h>
+#import <LuciqSDK/LCQTypes.h>
+#import <React/RCTUIManager.h>
+#import "Util/LCQAPM+PrivateAPIs.h"
+
+@implementation LuciqAPMBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[];
+}
+
+RCT_EXPORT_MODULE(LCQAPM)
+
+- (id) init
+{
+    self = [super init];
+    return self;
+}
+
+// Pauses the current thread for 3 seconds.
+RCT_EXPORT_METHOD(LCQSleep) {
+    [NSThread sleepForTimeInterval:3.0f];
+}
+
+// Enables or disables APM.
+RCT_EXPORT_METHOD(setEnabled:(BOOL)isEnabled) {
+    LCQAPM.enabled = isEnabled;
+}
+
+// Determines either coldAppLaunch is enabled or not.
+RCT_EXPORT_METHOD(setAppLaunchEnabled:(BOOL)isEnabled) {
+    LCQAPM.coldAppLaunchEnabled = isEnabled;
+}
+
+// This method is used to signal the end of the app launch process.
+RCT_EXPORT_METHOD(endAppLaunch) {
+    [LCQAPM endAppLaunch];
+}
+
+// Controls whether automatic tracing of UI interactions is enabled or disabled within the SDK.
+RCT_EXPORT_METHOD(setAutoUITraceEnabled:(BOOL)isEnabled) {
+    LCQAPM.autoUITraceEnabled = isEnabled;
+}
+
+// Starts a flow trace with the specified `name`,
+// allowing the SDK to capture and analyze the flow of execution within the application.
+RCT_EXPORT_METHOD(startFlow: (NSString *)name) {
+    [LCQAPM startFlowWithName:name];
+}
+
+// Ends a flow with the specified `name`.
+RCT_EXPORT_METHOD(endFlow: (NSString *)name) {
+    [LCQAPM endFlowWithName:name];
+}
+
+
+// Sets a user defined attribute for the currently active flow.
+RCT_EXPORT_METHOD(setFlowAttribute:(NSString *)name :(NSString *)key :(NSString *_Nullable)value) {
+    [LCQAPM setAttributeForFlowWithName:name key:key value:value];
+}
+
+// Starts a new `UITrace` with the provided `name` parameter,
+// allowing the SDK to capture and analyze the UI components within the application.
+RCT_EXPORT_METHOD(startUITrace:(NSString *)name) {
+    [LCQAPM startUITraceWithName:name];
+}
+
+// Terminates the currently active UI trace.
+RCT_EXPORT_METHOD(endUITrace) {
+    [LCQAPM endUITrace];
+}
+
+
+
+
+
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end
+

package/ios/RNLuciq/LuciqBugReportingBridge.h

@@ -0,0 +1,60 @@
+//
+//  LuciqBugReportingBridge.h
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <LuciqSDK/LCQTypes.h>
+#import <LuciqSDK/LCQBugReporting.h>
+
+@interface LuciqBugReportingBridge : RCTEventEmitter <RCTBridgeModule>
+/*
+ +------------------------------------------------------------------------+
+ |                            BugReporting Module                         |
+ +------------------------------------------------------------------------+
+ */
+
+- (void)setEnabled:(BOOL)isEnabled;
+
+- (void)setInvocationEvents:(NSArray *)invocationEventsArray;
+
+- (void)setOptions:(NSArray *)optionsArray;
+
+- (void)setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop;
+
+- (void)setOnInvokeHandler:(RCTResponseSenderBlock)callBack;
+
+- (void)setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack;
+
+- (void)setShakingThresholdForiPhone:(double)iPhoneShakingThreshold;
+
+- (void)setShakingThresholdForiPad:(double)iPadShakingThreshold;
+
+- (void)setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode;
+
+- (void)setReportTypes:(NSArray *)types;
+
+- (void)show:(LCQBugReportingReportType)type options:(NSArray *)options;
+
+- (void)setAutoScreenRecordingEnabled:(BOOL)enabled;
+
+- (void)setAutoScreenRecordingDuration:(CGFloat)duration;
+
+- (void)setViewHierarchyEnabled:(BOOL)viewHirearchyEnabled;
+
+- (void)setDisclaimerText:(NSString *)text;
+
+- (void)setCommentMinimumCharacterCount:(NSNumber *)limit reportTypes:(NSArray *)reportTypes;
+
+- (void)addUserConsent:(NSString *)key
+                  description:(NSString *)description
+                    mandatory:(BOOL)mandatory
+                      checked:(BOOL)checked
+                   actionType:(id)actionType;
+
+@end

package/ios/RNLuciq/LuciqBugReportingBridge.m

@@ -0,0 +1,241 @@
+//
+//  LuciqBugReportingBridge.m
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
+#import "LuciqBugReportingBridge.h"
+#import <LuciqSDK/LCQBugReporting.h>
+#import <asl.h>
+#import <React/RCTLog.h>
+#import <os/log.h>
+#import <React/RCTUIManager.h>
+
+@implementation LuciqBugReportingBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+             @"LCQpreInvocationHandler",
+             @"LCQpostInvocationHandler",
+             @"LCQDidSelectPromptOptionHandler",
+             ];
+}
+
+RCT_EXPORT_MODULE(LCQBugReporting)
+
+RCT_EXPORT_METHOD(setEnabled:(BOOL) isEnabled) {
+    LCQBugReporting.enabled = isEnabled;
+}
+
+RCT_EXPORT_METHOD(setAutoScreenRecordingEnabled:(BOOL)enabled) {
+    LCQBugReporting.autoScreenRecordingEnabled = enabled;
+}
+
+RCT_EXPORT_METHOD(setAutoScreenRecordingDuration:(CGFloat)duration) {
+    LCQBugReporting.autoScreenRecordingDuration = duration;
+}
+
+RCT_EXPORT_METHOD(setOnInvokeHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+        LCQBugReporting.willInvokeHandler = ^{
+            [self sendEventWithName:@"LCQpreInvocationHandler" body:nil];
+        };
+    } else {
+        LCQBugReporting.willInvokeHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+        LCQBugReporting.didDismissHandler = ^(LCQDismissType dismissType, LCQReportCategory reportType) {
+
+            //parse dismiss type enum
+            NSString* dismissTypeString;
+            if (dismissType == LCQDismissTypeCancel) {
+                dismissTypeString = @"CANCEL";
+            } else if (dismissType == LCQDismissTypeSubmit) {
+                dismissTypeString = @"SUBMIT";
+            } else if (dismissType == LCQDismissTypeAddAttachment) {
+                dismissTypeString = @"ADD_ATTACHMENT";
+            }
+
+            //parse report type enum
+            NSString* reportTypeString;
+            if (reportType == LCQReportCategoryBug) {
+                reportTypeString = @"bug";
+            } else if (reportType == LCQReportCategoryFeedback) {
+                reportTypeString = @"feedback";
+            } else {
+                reportTypeString = @"other";
+            }
+            NSDictionary *result = @{ @"dismissType": dismissTypeString,
+                                      @"reportType": reportTypeString};
+            [self sendEventWithName:@"LCQpostInvocationHandler" body: result];
+        };
+    } else {
+        LCQBugReporting.didDismissHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setDidSelectPromptOptionHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+
+        LCQBugReporting.didSelectPromptOptionHandler = ^(LCQPromptOption promptOption) {
+
+            NSString *promptOptionString;
+            if (promptOption == LCQPromptOptionBug) {
+                promptOptionString = @"bug";
+            } else if (promptOption == LCQBugReportingTypeFeedback) {
+                promptOptionString = @"feedback";
+            } else if (promptOption == LCQPromptOptionChat) {
+                promptOptionString = @"chat";
+            } else {
+                promptOptionString = @"none";
+            }
+
+            [self sendEventWithName:@"LCQDidSelectPromptOptionHandler" body:@{
+                                                                              @"promptOption": promptOptionString
+                                                                              }];
+        };
+    } else {
+        LCQBugReporting.didSelectPromptOptionHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setInvocationEvents:(NSArray*)invocationEventsArray) {
+    LCQInvocationEvent invocationEvents = 0;
+    for (NSNumber *boxedValue in invocationEventsArray) {
+        invocationEvents |= [boxedValue intValue];
+    }
+    LCQBugReporting.invocationEvents = invocationEvents;
+}
+
+RCT_EXPORT_METHOD(setOptions:(NSArray*)invocationOptionsArray) {
+    LCQBugReportingOption invocationOptions = 0;
+
+    for (NSNumber *boxedValue in invocationOptionsArray) {
+        invocationOptions |= [boxedValue intValue];
+    }
+
+    LCQBugReporting.bugReportingOptions = invocationOptions;
+}
+
+RCT_EXPORT_METHOD(setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop) {
+    LCQBugReporting.floatingButtonEdge = floatingButtonEdge;
+    LCQBugReporting.floatingButtonTopOffset = floatingButtonOffsetFromTop;
+}
+
+RCT_EXPORT_METHOD(setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode) {
+    LCQBugReporting.extendedBugReportMode = extendedBugReportMode;
+}
+
+RCT_EXPORT_METHOD(setEnabledAttachmentTypes:(BOOL)screenShot
+                  extraScreenShot:(BOOL)extraScreenShot
+                  galleryImage:(BOOL)galleryImage
+                  screenRecording:(BOOL)screenRecording) {
+    LCQAttachmentType attachmentTypes = 0;
+    if(screenShot) {
+        attachmentTypes = LCQAttachmentTypeScreenShot;
+    }
+    if(extraScreenShot) {
+        attachmentTypes |= LCQAttachmentTypeExtraScreenShot;
+    }
+    if(galleryImage) {
+        attachmentTypes |= LCQAttachmentTypeGalleryImage;
+    }
+    if(screenRecording) {
+        attachmentTypes |= LCQAttachmentTypeScreenRecording;
+    }
+
+    LCQBugReporting.enabledAttachmentTypes = attachmentTypes;
+}
+
+RCT_EXPORT_METHOD(setViewHierarchyEnabled:(BOOL)viewHirearchyEnabled) {
+    LCQBugReporting.shouldCaptureViewHierarchy = viewHirearchyEnabled;
+}
+
+RCT_EXPORT_METHOD(setVideoRecordingFloatingButtonPosition:(LCQPosition)position) {
+    LCQBugReporting.videoRecordingFloatingButtonPosition = position;
+}
+
+RCT_EXPORT_METHOD(setReportTypes:(NSArray*) types ) {
+    LCQBugReportingReportType reportTypes = 0;
+    for (NSNumber *boxedValue in types) {
+        reportTypes |= [boxedValue intValue];
+    }
+    [LCQBugReporting setPromptOptionsEnabledReportTypes: reportTypes];
+}
+
+RCT_EXPORT_METHOD(show:(LCQBugReportingReportType)type options:(NSArray*) options) {
+    LCQBugReportingOption parsedOptions = 0;
+    for (NSNumber *boxedValue in options) {
+        parsedOptions |= [boxedValue intValue];
+    }
+    NSArray* args = @[@(type), @(parsedOptions)];
+    [[NSRunLoop mainRunLoop] performSelector:@selector(showBugReportingWithReportTypeAndOptionsHelper:) target:self argument:args order:0 modes:@[NSDefaultRunLoopMode]];
+}
+
+- (void) showBugReportingWithReportTypeAndOptionsHelper:(NSArray*)args {
+    LCQBugReportingReportType parsedreportType = [args[0] intValue];
+    LCQBugReportingOption parsedOptions = [args[1] intValue];
+    [LCQBugReporting showWithReportType:parsedreportType options:parsedOptions];
+}
+
+RCT_EXPORT_METHOD(setShakingThresholdForiPhone:(double)iPhoneShakingThreshold) {
+    LCQBugReporting.shakingThresholdForiPhone = iPhoneShakingThreshold;
+}
+
+RCT_EXPORT_METHOD(setShakingThresholdForiPad:(double)iPadShakingThreshold) {
+    LCQBugReporting.shakingThresholdForiPad = iPadShakingThreshold;
+}
+
+RCT_EXPORT_METHOD(setDisclaimerText:(NSString*)text) {
+   [LCQBugReporting setDisclaimerText:text];
+}
+
+RCT_EXPORT_METHOD(setCommentMinimumCharacterCount:(nonnull NSNumber *)limit reportTypes:(NSArray *)reportTypes) {
+    LCQBugReportingType parsedReportTypes = 0;
+    if (![reportTypes count]) {
+        parsedReportTypes = @(LCQBugReportingTypeBug).integerValue | @(LCQBugReportingTypeFeedback).integerValue | @(LCQBugReportingTypeQuestion).integerValue;
+    }
+    else {
+        for (NSNumber *reportType in reportTypes) {
+            parsedReportTypes |= [reportType intValue];
+        }
+    }
+   [LCQBugReporting setCommentMinimumCharacterCount:[limit integerValue] forBugReportType:parsedReportTypes];
+}
+
+RCT_EXPORT_METHOD(addUserConsent:(NSString *)key
+                  description:(NSString *)description
+                  mandatory:(BOOL)mandatory
+                  checked:(BOOL)checked
+                  actionType:(id)actionType) {
+    LCQConsentAction mappedActionType = (LCQConsentAction)[actionType integerValue];
+
+    [LCQBugReporting addUserConsentWithKey:key
+                               description:description
+                                 mandatory:mandatory
+                                   checked:checked
+                                actionType:mappedActionType];
+}
+
+
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end

package/ios/RNLuciq/LuciqCrashReportingBridge.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <LuciqSDK/LCQBugReporting.h>
+#import <LuciqSDK/LCQTypes.h>
+#import <LuciqSDK/LCQCrashReporting.h>
+#import <LuciqSDK/LuciqSDK.h>
+#import "ArgsRegistry.h"
+
+@interface LuciqCrashReportingBridge : RCTEventEmitter <RCTBridgeModule>
+
+- (void)setEnabled:(BOOL) isEnabled;
+- (void)sendJSCrash:(NSDictionary *_Nonnull )stackTrace resolver:(RCTPromiseResolveBlock _Nullable )resolve
+           rejecter:(RCTPromiseRejectBlock _Nullable )reject;
+- (void)sendHandledJSCrash:(NSDictionary *_Nonnull)stackTrace userAttributes:(nullable NSDictionary *)userAttributes fingerprint:(nullable NSString *)fingerprint nonFatalExceptionLevel:(LCQNonFatalLevel) nonFatalExceptionLevel resolver:(RCTPromiseResolveBlock _Nullable )resolve
+                  rejecter:(RCTPromiseRejectBlock _Nullable )reject;
+
+@end

package/ios/RNLuciq/LuciqCrashReportingBridge.m

@@ -0,0 +1,68 @@
+#import "LuciqCrashReportingBridge.h"
+#import "Util/LCQCrashReporting+CP.h"
+
+
+@implementation LuciqCrashReportingBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"LCQSendHandledJSCrash",
+        @"LCQSendUnhandledJSCrash",
+    ];
+}
+
+RCT_EXPORT_MODULE(LCQCrashReporting)
+
+RCT_EXPORT_METHOD(setEnabled: (BOOL) isEnabled) {
+    LCQCrashReporting.enabled = isEnabled;
+}
+
+RCT_EXPORT_METHOD(sendJSCrash:(NSDictionary *)stackTrace
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportFatalCrashWithStackTrace:stackTrace];
+        resolve([NSNull null]);
+    });
+}
+
+RCT_EXPORT_METHOD(sendHandledJSCrash: (NSDictionary *)stackTrace
+                  userAttributes:(nullable NSDictionary *)userAttributes fingerprint:(nullable NSString *)fingerprint nonFatalExceptionLevel:(LCQNonFatalLevel)nonFatalExceptionLevel
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+
+    if([fingerprint isKindOfClass:NSNull.class]){
+        fingerprint = nil;
+    }
+
+    if([userAttributes isKindOfClass:NSNull.class]){
+        userAttributes = nil;
+    }
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportNonFatalCrashWithStackTrace:stackTrace level:nonFatalExceptionLevel groupingString:fingerprint userAttributes:userAttributes];
+
+        resolve([NSNull null]);
+    });
+
+}
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end
+
+

package/ios/RNLuciq/LuciqFeatureRequestsBridge.h

@@ -0,0 +1,30 @@
+//
+//  LuciqFeatureRequestsBridge.h
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <LuciqSDK/LCQTypes.h>
+
+@interface LuciqFeatureRequestsBridge : RCTEventEmitter <RCTBridgeModule>
+/*
+ +------------------------------------------------------------------------+
+ |                            Feature Requests Module                     |
+ +------------------------------------------------------------------------+
+ */
+
+- (void)setEmailFieldRequiredForFeatureRequests:(BOOL)isEmailFieldRequired forAction:(NSArray *)actionTypesArray;
+
+- (void)show;
+
+- (void)setEnabled:(BOOL) isEnabled;
+
+
+@end
+
+

package/ios/RNLuciq/LuciqFeatureRequestsBridge.m

@@ -0,0 +1,61 @@
+//
+//  LuciqFeatureRequestsBridge.m
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
+#import "LuciqFeatureRequestsBridge.h"
+#import <LuciqSDK/LCQFeatureRequests.h>
+#import <asl.h>
+#import <React/RCTLog.h>
+#import <os/log.h>
+#import <LuciqSDK/LCQTypes.h>
+#import <React/RCTUIManager.h>
+
+@implementation LuciqFeatureRequestsBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[];
+}
+
+RCT_EXPORT_MODULE(LCQFeatureRequests)
+
+RCT_EXPORT_METHOD(show) {
+    [[NSRunLoop mainRunLoop] performSelector:@selector(show) target:[LCQFeatureRequests class] argument:nil order:0 modes:@[NSDefaultRunLoopMode]];
+}
+
+RCT_EXPORT_METHOD(setEmailFieldRequiredForFeatureRequests:(BOOL)isEmailFieldRequired
+                  forAction:(NSArray *)actionTypesArray) {
+    LCQAction actionTypes = 0;
+
+    for (NSNumber *boxedValue in actionTypesArray) {
+        actionTypes |= [boxedValue intValue];
+    }
+
+    [LCQFeatureRequests setEmailFieldRequired:isEmailFieldRequired forAction:actionTypes];
+}
+
+RCT_EXPORT_METHOD(setEnabled: (BOOL) isEnabled) {
+    LCQFeatureRequests.enabled = isEnabled;
+}
+
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end
+
+

package/ios/RNLuciq/LuciqNetworkLoggerBridge.h

@@ -0,0 +1,44 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <LuciqSDK/LCQTypes.h>
+
+typedef void (^ LCQURLRequestAsyncObfuscationCompletedHandler)(NSURLRequest * _Nonnull request);
+typedef void (^LCQURLRequestResponseAsyncFilteringCompletedHandler)(BOOL keep);
+
+typedef NS_ENUM(NSInteger, NetworkListenerType) {
+    NetworkListenerTypeFiltering,
+    NetworkListenerTypeObfuscation,
+    NetworkListenerTypeBoth
+};
+
+@interface LuciqNetworkLoggerBridge : RCTEventEmitter <RCTBridgeModule>
+
+@property NSMutableDictionary<NSString *, LCQURLRequestAsyncObfuscationCompletedHandler> * _Nonnull requestObfuscationCompletionDictionary;
+@property NSMutableDictionary<NSString *, NetworkObfuscationCompletionBlock> * _Nonnull responseObfuscationCompletionDictionary;
+@property NSMutableDictionary<NSString *, LCQURLRequestResponseAsyncFilteringCompletedHandler> * _Nonnull requestFilteringCompletionDictionary;
+@property NSMutableDictionary<NSString *, LCQURLRequestResponseAsyncFilteringCompletedHandler> * _Nonnull responseFilteringCompletionDictionary;
+
+/*
+ +------------------------------------------------------------------------+
+ |                            NetworkLogger Module                        |
+ +------------------------------------------------------------------------+
+ */
+
+- (BOOL)isNativeInterceptionEnabled;
+
+- (void) registerNetworkLogsListener:(NetworkListenerType)listenerType;
+
+- (void)updateNetworkLogSnapshot:(NSString * _Nonnull)url
+                        callbackID:(NSString * _Nonnull)callbackID
+                        requestBody:(NSString * _Nullable)requestBody
+                        responseBody:(NSString * _Nullable)responseBody
+                        responseCode:(double)responseCode
+                        requestHeaders:(NSDictionary * _Nullable)requestHeaders
+                        responseHeaders:(NSDictionary * _Nullable)responseHeaders;
+
+- (void) setNetworkLoggingRequestFilterPredicateIOS:(NSString * _Nonnull) callbackID : (BOOL)value;
+
+- (void)forceStartNetworkLoggingIOS;
+
+- (void)forceStopNetworkLoggingIOS;
+@end