React Native Integration

import androidx.annotation.NonNull;
import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.humansecurity.mobile_sdk.HumanSecurity;
import com.humansecurity.mobile_sdk.main.HSBotDefenderChallengeResult;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.Objects;

public class HumanModule extends ReactContextBaseJavaModule {

    static HumanModule shared = null;

    String strNewHeaders = "HumanNewHeaders";
    String strChallengeResult = "HumanChallengeResult";
    String strSolved = "solved";
    String strCancelled = "cancelled";
    String strFalse = "false";

    HumanModule(ReactApplicationContext context) {
        super(context);
    }

    @NonNull
    @Override
    public String getName() {
        return "HumanModule";
    }

    public void handleUpdatedHeaders(HashMap<String, String> headers) {
        if (!this.getReactApplicationContext().hasCatalystInstance()) {
            return;
        }
        JSONObject json = new JSONObject(headers);
        this.getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(strNewHeaders, json.toString());
    }

    public void handleChallengeSolvedEvent() {
        if (!this.getReactApplicationContext().hasCatalystInstance()) {
            return;
        }
        this.getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(strChallengeResult, strSolved);
    }

    public void handleChallengeCancelledEvent() {
        if (!this.getReactApplicationContext().hasCatalystInstance()) {
            return;
        }
        this.getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit(strChallengeResult, strCancelled);
    }

    @ReactMethod
    public void getHTTPHeaders(Promise promise) {
        JSONObject json = new JSONObject(Objects.requireNonNull(HumanSecurity.INSTANCE.getBD().headersForURLRequest(null)));
        promise.resolve(json.toString());
    }

    @ReactMethod
    public void handleResponse(String response, Integer code, String url, Promise promise) {
        boolean handled = HumanSecurity.INSTANCE.getBD().handleResponse(response, result -> {
            promise.resolve(result == HSBotDefenderChallengeResult.SOLVED ? strSolved : strCancelled);
            return null;
        });
        if (!handled) {
            promise.resolve(strFalse);
        }
    }
}

import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class HumanPackage implements ReactPackage {

    @Override
    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
        return Collections.emptyList();
    }

    @Override
    public List<NativeModule> createNativeModules(
            ReactApplicationContext reactContext) {
        List<NativeModule> modules = new ArrayList<>();

        HumanModule module = new HumanModule(reactContext);
        HumanModule.shared = module;
        modules.add(module);

        return modules;
    }
}

#import <Foundation/Foundation.h>
#import <React/RCTBridgeModule.h>
#import <React/RCTEventEmitter.h>

NS_ASSUME_NONNULL_BEGIN

@interface HumanModule : RCTEventEmitter <RCTBridgeModule>

+ (HumanModule *)shared;
- (void)handleUpdatedHeaders:(NSDictionary<NSString *,NSString *> *)headers;
- (void)handleChallengeSolvedEvent;
- (void)handleChallengeCancelledEvent;

@end

NS_ASSUME_NONNULL_END

#import "HumanModule.h"
@import HUMAN;

static NSString *strNewHeaders = @"HumanNewHeaders";
static NSString *strChallengeResult = @"HumanChallengeResult";
static NSString *strSolved = @"solved";
static NSString *strCancelled = @"cancelled";
static NSString *strFalse = @"false";

@implementation HumanModule

static HumanModule *shared = nil;

+ (HumanModule *)shared {
  return shared;
}

- (instancetype)init {
  self = [super init];
  shared = self;
  return self;
}

- (NSArray<NSString *> *)supportedEvents {
  return @[strNewHeaders, strChallengeResult];
}

- (void)handleUpdatedHeaders:(NSDictionary<NSString *,NSString *> *)headers {
  NSData *data = [NSJSONSerialization dataWithJSONObject:headers options:0 error:nil];
  NSString *json = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  [self sendEventWithName:strNewHeaders body:json];
}

- (void)handleChallengeSolvedEvent {
  [self sendEventWithName:strChallengeResult body:strSolved];
}

- (void)handleChallengeCancelledEvent {
  [self sendEventWithName:strChallengeResult body:strCancelled];
}

RCT_EXPORT_MODULE(HumanModule);

RCT_REMAP_METHOD(getHTTPHeaders,
                 resolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {
  NSDictionary<NSString *, NSString *> *humanHttpHeaders = [HumanSecurity.BD headersForURLRequestForAppId:nil];
  NSData *data = [NSJSONSerialization dataWithJSONObject:humanHttpHeaders options:0 error:nil];
  NSString *json = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  resolve(@[json]);
}

RCT_REMAP_METHOD(handleResponse,
                 response:(NSString *)response
                 code:(NSInteger)code
                 url:(NSString *)url
                 resolver:(RCTPromiseResolveBlock)resolve
                 rejecter:(RCTPromiseRejectBlock)reject) {
  NSData *data = [response dataUsingEncoding:NSUTF8StringEncoding];
  NSHTTPURLResponse *httpURLResponse = [[NSHTTPURLResponse alloc] initWithURL:[NSURL URLWithString:url] statusCode:code HTTPVersion:nil headerFields:nil];
  BOOL handled = [HumanSecurity.BD handleResponseWithResponse:httpURLResponse data:data callback:^(enum HSBotDefenderChallengeResult result) {
    resolve((result == HSBotDefenderChallengeResultSolved ? strSolved : strCancelled));
  }];
  if (!handled) {
    resolve(strFalse);
  }
}

@end

import android.app.Application;
import android.content.Context;
import android.util.Log;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.facebook.react.PackageList;
import com.facebook.react.ReactApplication;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.ReactNativeHost;
import com.facebook.react.config.ReactFeatureFlags;
import com.facebook.soloader.SoLoader;
import com.human_demo.newarchitecture.MainApplicationReactNativeHost;
import com.humansecurity.mobile_sdk.HumanSecurity;
import com.humansecurity.mobile_sdk.main.HSBotDefenderDelegate;
import com.humansecurity.mobile_sdk.main.policy.HSAutomaticInterceptorType;
import com.humansecurity.mobile_sdk.main.policy.HSPolicy;

public class MainApplication extends Application implements ReactApplication, HSBotDefenderDelegate {

    private final ReactNativeHost mReactNativeHost =
            new ReactNativeHost(this) {
                @Override
                public boolean getUseDeveloperSupport() {
                    return BuildConfig.DEBUG;
                }

                @Override
                protected List<ReactPackage> getPackages() {
                    List<ReactPackage> packages = new PackageList(this).getPackages();
                    packages.add(new HumanPackage());
                    return packages;
                }

                @Override
                protected String getJSMainModuleName() {
                    return "index";
                }
            };

    private final ReactNativeHost mNewArchitectureNativeHost =
            new MainApplicationReactNativeHost(this);

    @Override
    public ReactNativeHost getReactNativeHost() {
        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
            return mNewArchitectureNativeHost;
        } else {
            return mReactNativeHost;
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        ReactFeatureFlags.useTurboModules = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
        SoLoader.init(this, false);
        initializeFlipper(this, getReactNativeHost().getReactInstanceManager());

        startHumanSDK();
    }

    private static void initializeFlipper(
            Context context, ReactInstanceManager reactInstanceManager) {
        if (BuildConfig.DEBUG) {
            try {
                Class<?> aClass = Class.forName("<package_name>.ReactNativeFlipper");
                aClass
                        .getMethod("initializeFlipper", Context.class, ReactInstanceManager.class)
                        .invoke(null, context, reactInstanceManager);
            } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException |
                     InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    private void startHumanSDK() {
        HSPolicy policy = new HSPolicy();
        policy.getAutomaticInterceptorPolicy().setInterceptorType(HSAutomaticInterceptorType.NONE);
        try {
            HumanSecurity.INSTANCE.start(this, "<APP_ID>", policy);
            HumanSecurity.INSTANCE.getBD().setDelegate(this);
        }
        catch (Exception exception) {
            Log.e("MainApplication","Exception: " + exception.getMessage());
        }
    }

    @Override
    public void botDefenderDidUpdateHeaders(@NonNull HashMap<String, String> headers, @NonNull String appId) {
        if (HumanModule.shared != null) {
            HumanModule.shared.handleUpdatedHeaders(headers);
        }
    }

    @Override
    public void botDefenderRequestBlocked(@Nullable String url, @NonNull String appId) {

    }

    @Override
    public void botDefenderChallengeSolved(@NonNull String appId) {
        HumanModule.shared.handleChallengeSolvedEvent();
    }

    @Override
    public void botDefenderChallengeCancelled(@NonNull String appId) {
        HumanModule.shared.handleChallengeCancelledEvent();
    }

    @Override
    public void botDefenderChallengeRendered(@NonNull String appId) {

    }

    @Override
    public void botDefenderChallengeRenderFailed(@NonNull String appId) {

    }
}

#import <React/RCTBridgeDelegate.h>
#import <UIKit/UIKit.h>
@import HUMAN;

@interface AppDelegate : UIResponder <UIApplicationDelegate, RCTBridgeDelegate, HSBotDefenderDelegate>

@property (nonatomic, strong) UIWindow *window;

@end

#import "AppDelegate.h"
#import "HumanModule.h"
#import <React/RCTBridge.h>
#import <React/RCTBundleURLProvider.h>
#import <React/RCTRootView.h>
#import <React/RCTAppSetupUtils.h>

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    HSPolicy *policy = [[HSPolicy alloc] init];
    policy.automaticInterceptorPolicy.interceptorType = HSAutomaticInterceptorTypeNone;

    NSError *error = nil;
    [HumanSecurity startWithAppId:@"<APP_ID>" policy:policy error:&error];
    HumanSecurity.BD.delegate = self;
    if (error != nil) {
        NSLog(@"error: %@", error);
    }

    [[HumanModule shared] startObserving];

    // Configure React Native...

    return YES;
}

// MARK: - HSBotDefenderDelegate

- (void)botDefenderRequestBlockedWithUrl:(NSURL *)url appId:(NSString *)appId {

}

- (void)botDefenderChallengeSolvedForAppId:(NSString *)appId {
    [[HumanModule shared] handleChallengeSolvedEvent];
}

- (void)botDefenderChallengeCancelledForAppId:(NSString *)appId {
    [[HumanModule shared] handleChallengeCancelledEvent];
}

- (void)botDefenderDidUpdateHeadersWithHeaders:(NSDictionary<NSString *,NSString *> *)headers forAppId:(NSString *)appId {
    [[HumanModule shared] handleUpdatedHeaders:headers];
}

- (void)botDefenderChallengeRenderedForAppId:(NSString *)appId {

}

- (void)botDefenderChallengeRenderFailedForAppId:(NSString *)appId {

}

@end

/* Import HumanModule */
import { NativeModules, NativeEventEmitter } from 'react-native';
const { HumanModule } = NativeModules;

/* Create a new native event emitter */
const humanEventEmitter = new NativeEventEmitter(HumanModule);

/* Add listener to the "New Headers" event and store the SDK's HTTP headers in a variable */
let humanHttpHeaders = null;
const onNewHeaders = headers => {
  const obj = JSON.parse(headers);
  console.log(`Got new HTTP headers: ${JSON.stringify(obj)}`);
  humanHttpHeaders = obj;
};
const subscriptionHumanNewHeaders = humanEventEmitter.addListener('HumanNewHeaders', onNewHeaders);

/* Add listener to the "Challenge Result" event */
const onChallengeResult = result => {
  if (result === 'solved') {
    console.log('Challenge solved');
  } else if (result === 'cancelled') {
    console.log('Challenge cancelled');
  }
};
const subscriptionHumanChallengeResult = humanEventEmitter.addListener('HumanChallengeResult', onChallengeResult);

/* Get Human's HTTP headers */
const getHumanHeaders = async () => {
  if (humanHttpHeaders != null) {
    return humanHttpHeaders;
  }
  const headers = await HumanModule.getHTTPHeaders();
  const obj = JSON.parse(headers);
  console.log(`[HUMAN] Got HTTP headers: ${JSON.stringify(obj)}`);
  return obj;
};

/* Send URL request */
async function sendRequest(url) {
  /* Get Human's HTTP headers */
  const humanHeaders = await getHumanHeaders();

  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: humanHeaders,
    });

    const json = await response.json();

    /* Send the response to the SDK */
    const result = await HumanModule.handleResponse(JSON.stringify(json));
    if (result === 'solved') {
      console.log('Challenge solved');
      await sendRequest(url);
    } else if (result === 'cancelled') {
      console.log('Challenge cancelled');
    } else if (result === 'false') {
      console.log('Request was not blocked by Human');
    }
  } catch (error) {
    console.error(error);
  }
}