uqudosdk-react-native 2.2.1

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+## 2.2.1
+
+* Minor bug fixes
+
+## 2.2.0
+
+* Added new document type Senegal National ID and Uganda Voter ID
+* Added support to read the chip of Senegal ID through NFC
+* Added new configuration option enableAgeVerification for the document scanning that allows to reject the scan if the age is not above or equals the one defined in the configuration
+* We replaced the 5 images in the facial recognition popup when the face doesn't match. The images can now be replaced with your own images
+* Improved glare detection during document scanning
+* Removed additional dependency for the Android SDK
+* Minor bug fixes and minor improvements

package/COPYRIGHT.md

@@ -0,0 +1 @@
+Copyright (c) uqudo 2022

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2022] [uqudo]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# uqudo SDK ReactNative plugin
+
+The Official uqudo SDK wrapper for the Android and iOS SDKs.\
+Onboard new users faster, easier, and cheaper with an experience that seamlessly fits into your onboarding journey. Fully supported across the Middle East & Africa.
+
+### Platform specifics
+
+Plugin implementation is in folder `uqudoBuilder`, while platform specific implementations are in `android` and `ios` folders.
+
+#### Android
+
+https://docs.uqudo.com
+
+#### iOS
+
+https://docs.uqudo.com
+
+## Licensing
+
+- In order to use the SDK you require a valid license. Contact us at https://uqudo.com/contact-us/

package/android/build.gradle

@@ -0,0 +1,37 @@
+def DEFAULT_COMPILE_SDK_VERSION = 30
+def DEFAULT_BUILD_TOOLS_VERSION = '30.0.2'
+def DEFAULT_MIN_SDK_VERSION = 21
+def DEFAULT_TARGET_SDK_VERSION = 30
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+apply plugin: 'com.android.library'
+
+
+rootProject.allprojects {
+    repositories {
+        google()
+        maven { url "https://rm.dev.uqudo.io/repository/uqudo-public/" }
+    }
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
+    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
+        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
+        versionCode 1
+        versionName "1.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'io.uqudo.sdk:Uqudo:2.2.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="io.sdk.uqudoid">
+
+</manifest>

package/android/src/main/java/io/sdk/uqudoid/UqudoIdModule.java

@@ -0,0 +1,399 @@
+package io.sdk.uqudoid;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+import android.util.SparseArray;
+import android.content.Context;
+import androidx.appcompat.app.AppCompatDelegate;
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Arguments;
+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.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import java.util.UUID;
+import org.json.JSONException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+
+import io.uqudo.sdk.core.DocumentBuilder;
+import io.uqudo.sdk.core.SessionStatus;
+import io.uqudo.sdk.core.SessionStatusCode;
+import io.uqudo.sdk.core.UqudoBuilder;
+import io.uqudo.sdk.core.UqudoSDK;
+import io.uqudo.sdk.core.analytics.Trace;
+import io.uqudo.sdk.core.analytics.Tracer;
+import io.uqudo.sdk.core.builder.BackgroundCheckConfigurationBuilder;
+import io.uqudo.sdk.core.builder.FacialRecognitionConfigurationBuilder;
+import io.uqudo.sdk.core.builder.ReadingConfigurationBuilder;
+import io.uqudo.sdk.core.domain.model.BackgroundCheckType;
+import io.uqudo.sdk.core.domain.model.Document;
+import io.uqudo.sdk.core.domain.model.DocumentType;
+
+public class UqudoIdModule extends ReactContextBaseJavaModule implements ActivityEventListener {
+
+    private final ReactApplicationContext context;
+    private final SparseArray<Promise> mPromises;
+    public static final int REQUEST_CODE_ENROLLMENT = 1001;
+    public static final int REQUEST_CODE_ACCOUNT_RECOVERY = 1002;
+    public static final int REQUEST_CODE_FACE_SESSION = 1003;
+
+    public UqudoIdModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.context = reactContext;
+        mPromises = new SparseArray<>();
+    }
+
+    @Override
+    public String getName() {
+        return "UqudoId";
+    }
+
+    @Override
+    public void initialize() {
+        super.initialize();
+        getReactApplicationContext().addActivityEventListener(this);
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        getReactApplicationContext().removeActivityEventListener(this);
+    }
+
+    @ReactMethod
+    public void init() {
+        UqudoSDK.init(context, new TraceObject());
+    }
+
+    private class TraceObject implements Tracer {
+        @Override
+        public void trace(@NotNull Trace trace) {
+            try {
+                JSONObject json = new JSONObject();
+                json.put("category", trace.getCategory());
+                json.put("sessionId", trace.getSessionId());
+                json.put("event", trace.getEvent());
+                json.put("page", trace.getPage());
+                json.put("statusCode", trace.getStatusCode());
+                json.put("status", trace.getStatus());
+                json.put("message", trace.getStatusMessage());
+                json.put("timestamp", trace.getTimestamp());
+                json.put("documentType", trace.getDocumentType());
+                String data = json.toString();
+                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                        .emit("TraceEvent", data);
+            } catch (Exception e) {
+                Log.e("UqudoIdModule", e.getMessage(), e);
+            }
+        }
+    }
+
+    @ReactMethod
+    public void setLocale(String locale) {
+        UqudoSDK.setLocale(context, locale);
+    }
+
+    @ReactMethod
+    public void enroll(String message, Promise promise) {
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.Enrollment enrollment = new UqudoBuilder.Enrollment();
+                if (json.has("isSecuredWindowsDisabled") && json.getBoolean("isSecuredWindowsDisabled")) {
+                    enrollment.disableSecureWindow();
+                }
+                if (json.has("isRootedDeviceAllowed") && json.getBoolean("isRootedDeviceAllowed")) {
+                    enrollment.enableRootedDeviceUsage();
+                }
+                if (json.has("nonce")) {
+                    enrollment.setNonce(json.getString("nonce"));
+                }
+                if (json.has("sessionId")) {
+                    enrollment.setSessionId(json.getString("sessionId"));
+                }
+                if (json.has("userIdentifier")) {
+                    enrollment.setUserIdentifier(UUID.fromString(json.getString("userIdentifier")));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    enrollment.returnDataForIncompleteSession();
+                }
+                if (json.has("facialRecognitionSpecification")) {
+                    FacialRecognitionConfigurationBuilder faceBuilder = new FacialRecognitionConfigurationBuilder();
+                    JSONObject faceObject = json.getJSONObject("facialRecognitionSpecification");
+                    if (faceObject.has("enrollFace") && faceObject.getBoolean("enrollFace")) {
+                        faceBuilder.enrollFace();
+                    }
+                    if (faceObject.has("scanMinimumMatchLevel") && faceObject.getInt("scanMinimumMatchLevel") > 0) {
+                        faceBuilder.setScanMinimumMatchLevel(faceObject.getInt("scanMinimumMatchLevel"));
+                    }
+                    if (faceObject.has("readMinimumMatchLevel") && faceObject.getInt("readMinimumMatchLevel") > 0) {
+                        faceBuilder.setReadMinimumMatchLevel(faceObject.getInt("readMinimumMatchLevel"));
+                    }
+                    if (faceObject.has("maxAttempts") && faceObject.getInt("maxAttempts") > 0) {
+                        faceBuilder.setMaxAttempts(faceObject.getInt("maxAttempts"));
+                    }
+
+                    enrollment.enableFacialRecognition(faceBuilder.build());
+                }
+                  if (json.has("lookupConfiguration")) {
+                     JSONObject lookupObject = json.getJSONObject("lookupConfiguration");
+                     if (lookupObject.has("documentList")) {
+                         JSONArray lookupDocuments = lookupObject.getJSONArray("documentList");
+                         if (lookupDocuments.length() > 0) {
+                             DocumentType[] documents = new DocumentType[lookupDocuments.length()];
+                             for (int i = 0; i < lookupDocuments.length(); i++) {
+                                 String parsedDocument = lookupDocuments.getString(i);
+                                 documents[i] = DocumentType.valueOf(parsedDocument);
+                             }
+                             enrollment.enableLookup(documents);
+                         } else {
+                             enrollment.enableLookup();
+                         }
+                     } else {
+                         enrollment.enableLookup();
+                     }
+                 }
+                if (json.has("backgroundCheckConfiguration")) {
+                    BackgroundCheckConfigurationBuilder backgroundCheckConfigurationBuilder = new BackgroundCheckConfigurationBuilder();
+                    JSONObject backgroundObject = json.getJSONObject("backgroundCheckConfiguration");
+                    if (backgroundObject.has("disableConsent") && backgroundObject.getBoolean("disableConsent")) {
+                        backgroundCheckConfigurationBuilder.disableConsent();
+                    }
+                    if (backgroundObject.has("backgroundCheckType")) {
+                        backgroundCheckConfigurationBuilder.setBackgroundCheckType(BackgroundCheckType.valueOf(backgroundObject.getString("backgroundCheckType")));
+                    }
+                    if (backgroundObject.has("monitoringEnabled") && backgroundObject.getBoolean("monitoringEnabled")) {
+                        backgroundCheckConfigurationBuilder.enableMonitoring();
+                    }
+                    if (backgroundObject.has("skipView") && backgroundObject.getBoolean("skipView")) {
+                        backgroundCheckConfigurationBuilder.skipView();
+                    }
+                    enrollment.enableBackgroundCheck(backgroundCheckConfigurationBuilder.build());
+                }
+                enrollment.setToken(json.getString("authorizationToken"));
+                JSONArray documentList = json.getJSONArray("documentList");
+                for (int i = 0; i < documentList.length(); i++) {
+                    JSONObject documentJson = documentList.getJSONObject(i);
+                    DocumentBuilder documentBuilder = new DocumentBuilder(context);
+                    documentBuilder.setDocumentType(DocumentType.valueOf(documentJson.getString("documentType")));
+                    if (documentJson.has("isHelpPageDisabled") && documentJson.getBoolean("isHelpPageDisabled")) {
+                        documentBuilder.disableHelpPage();
+                    }
+                    if (documentJson.has("isExpiredDocumentValidateDisabled") && documentJson.getBoolean("isExpiredDocumentValidateDisabled")) {
+                        documentBuilder.disableExpiryValidation();
+                    }
+                    if (documentJson.has("isUserDataReviewDisabled") && documentJson.getBoolean("isUserDataReviewDisabled")) {
+                        documentBuilder.disableUserDataReview();
+                    }
+                    if (documentJson.has("isFrontSideReviewEnabled") || documentJson.has("isBackSideReviewEnabled")) {
+                        documentBuilder.enableScanReview(documentJson.optBoolean("isFrontSideReviewEnabled", false), documentJson.optBoolean("isBackSideReviewEnabled", false));
+                    }
+                    if (documentJson.has("isUploadEnabled") && documentJson.getBoolean("isUploadEnabled")) {
+                        documentBuilder.enableUpload();
+                    }
+                    if (documentJson.has("readingConfiguration")) {
+                        JSONObject readConfiguration = documentJson.getJSONObject("readingConfiguration");
+                        if (readConfiguration.has("forceReading")) {
+                            ReadingConfigurationBuilder readingConfigurationBuilder = new ReadingConfigurationBuilder();
+                            if (readConfiguration.has("forceReading")) {
+                                readingConfigurationBuilder.forceReading(readConfiguration.getBoolean("forceReading"));
+                            }
+                            if (readConfiguration.has("forceReadingIfSupported")) {
+                                readingConfigurationBuilder.forceReadingIfSupported(readConfiguration.getBoolean("forceReadingIfSupported"));
+                            }
+                            if (readConfiguration.has("timeoutInSeconds")) {
+                                readingConfigurationBuilder.forceReadingTimeout(readConfiguration.getInt("timeoutInSeconds"));
+                            }
+                            documentBuilder.enableReading(readingConfigurationBuilder.build());
+                        } else {
+                            documentBuilder.enableReading();
+                        }
+                    }
+                    if (documentJson.has("faceScanMinimumMatchLevel") && documentJson.getInt("faceScanMinimumMatchLevel") > 0) {
+                        documentBuilder.setFaceScanMinimumMatchLevel(documentJson.getInt("faceScanMinimumMatchLevel"));
+                    }
+                    if (documentJson.has("faceReadMinimumMatchLevel") && documentJson.getInt("faceReadMinimumMatchLevel") > 0) {
+                        documentBuilder.setFaceReadMinimumMatchLevel(documentJson.getInt("faceReadMinimumMatchLevel"));
+                    }
+                    if (documentJson.has("minimumAge") && documentJson.getInt("minimumAge") > 0) {
+                        documentBuilder.enableAgeVerification(documentJson.getInt("minimumAge"));
+                    }
+
+                    Document document = documentBuilder.build();
+                    enrollment.add(document);
+                }
+                Intent intent = enrollment.build(context);
+                if (json.has("appearanceMode")) {
+                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                    }
+                }else{
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                getReactApplicationContext().startActivityForResult(intent, REQUEST_CODE_ENROLLMENT, null);
+                mPromises.put(REQUEST_CODE_ENROLLMENT, promise);
+            } catch (Exception e) {
+                Log.e("UqudoIdModule", e.getMessage(), e);
+                sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected enrollment object as argument.", null);
+        }
+    }
+
+    @ReactMethod
+    public void recover(String message, Promise promise) {
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.AccountRecovery recovery = new UqudoBuilder.AccountRecovery();
+                recovery.setToken(json.getString("token"));
+                recovery.setEnrollmentIdentifier(json.getString("enrollmentIdentifier"));
+                if (json.has("nonce")) {
+                    recovery.setNonce(json.getString("nonce"));
+                }
+                if (json.has("isRootedDeviceAllowed")) {
+                    recovery.enableRootedDeviceUsage();
+                }
+                if (json.has("isSecuredWindowsDisabled")) {
+                    recovery.disableSecureWindow();
+                }
+                if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
+                    recovery.setMinimumMatchLevel(json.getInt("minimumMatchLevel"));
+                }
+                if (json.has("maxAttempts") && json.getInt("maxAttempts") > 0) {
+                    recovery.setMaxAttempts(json.getInt("maxAttempts"));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    recovery.returnDataForIncompleteSession();
+                }
+               Intent intent = recovery.build(context);
+
+                if (json.has("appearanceMode")) {
+                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                    }
+                }else{
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                getReactApplicationContext().startActivityForResult(intent, REQUEST_CODE_ACCOUNT_RECOVERY, null);
+                mPromises.put(REQUEST_CODE_ACCOUNT_RECOVERY, promise);
+            } catch (Exception e) {
+                Log.e("UqudoIdModule", e.getMessage(), e);
+                sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected account recovery object as argument.", null);
+        }
+    }
+
+    @ReactMethod
+    public void faceSession(String configuration, Promise promise) {
+        if (configuration != null && configuration.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(configuration);
+                UqudoBuilder.FaceSession faceSession = new UqudoBuilder.FaceSession();
+                faceSession.setToken(json.getString("token"));
+                faceSession.setSessionId(json.getString("sessionId"));
+                if (json.has("nonce")) {
+                    faceSession.setNonce(json.getString("nonce"));
+                }
+                if (json.has("isRootedDeviceAllowed")) {
+                    faceSession.enableRootedDeviceUsage();
+                }
+                if (json.has("isSecuredWindowsDisabled")) {
+                    faceSession.disableSecureWindow();
+                }
+                if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
+                    faceSession.setMinimumMatchLevel(json.getInt("minimumMatchLevel"));
+                }
+                if (json.has("maxAttempts") && json.getInt("maxAttempts") > 0) {
+                    faceSession.setMaxAttempts(json.getInt("maxAttempts"));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    faceSession.returnDataForIncompleteSession();
+                }
+                Intent intent = faceSession.build(context);
+                if (json.has("appearanceMode")) {
+                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                    }
+                }else{
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                getReactApplicationContext().startActivityForResult(intent, REQUEST_CODE_FACE_SESSION, null);
+                mPromises.put(REQUEST_CODE_FACE_SESSION, promise);
+            } catch (Exception e) {
+                Log.e("UqudoIdModule", e.getMessage(), e);
+                sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(promise, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected face session configuration as argument.", null);
+        }
+    }
+
+    private void sendError(Promise promise, String code, String message, String task) {
+        sendError(promise, code, message, task, null);
+    }
+
+    private void sendError(Promise promise, String code, String message, String task, String data) {
+        JSONObject error = new JSONObject();
+        try {
+            error.put("code", code);
+            error.put("message", message);
+            error.put("task", task);
+            error.put("data", data);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        promise.reject(error.toString(),"");
+    }
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+        Promise promise = mPromises.get(requestCode);
+        if (promise == null) {
+            return;
+        }
+        if (requestCode == REQUEST_CODE_ENROLLMENT || requestCode == REQUEST_CODE_ACCOUNT_RECOVERY || requestCode == REQUEST_CODE_FACE_SESSION) {
+            if (resultCode == Activity.RESULT_OK) {
+                WritableMap map = Arguments.createMap();
+                map.putString("result", data.getStringExtra("data"));
+                promise.resolve(map);
+            } else if (resultCode == Activity.RESULT_CANCELED) {
+                if (data != null) {
+                    SessionStatus sessionStatus = data.getParcelableExtra("key_session_status");
+                    assert sessionStatus != null;
+                    sendError(promise, sessionStatus.getSessionStatusCode().name(), sessionStatus.getSessionStatusCode().getMessage(), sessionStatus.getSessionTask().name(), sessionStatus.getData());
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+
+    }
+}

package/android/src/main/java/io/sdk/uqudoid/UqudoIdPackage.java

@@ -0,0 +1,23 @@
+package io.sdk.uqudoid;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+
+public class UqudoIdPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new UqudoIdModule(reactContext));
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/index.js

@@ -0,0 +1 @@
+export * from "./uqudoBuilder/uqudo";

package/ios/MyTracer.h

@@ -0,0 +1,6 @@
+#import <UqudoSDK/UQTracer.h>
+
+@interface MyTracer : UQTracer
+@property(nonatomic, retain) RCTEventEmitter *emitter;
+@property(nonatomic, assign) bool hasListeners;
+@end

package/ios/UqudoId.h

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+#import <UqudoSDK/UqudoSDK.h>
+#import <React/RCTEventEmitter.h>
+
+@interface UqudoId : RCTEventEmitter <RCTBridgeModule, UQBuilderControllerDelegate>
+@property (nonatomic, strong) RCTPromiseResolveBlock promiseResolve;
+@property (nonatomic, strong) RCTPromiseRejectBlock promiseReject;
+@end