react-native-okhi 1.0.3-2.beta.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2022 OkHi
+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,174 @@
+# OkHi React Native
+
+The official OkHi React Native library will enable you to start collecting and verifying your user's addresses.
+
+# Prerequisites
+
+## OkHi Client Key and Branch Id
+
+First you need to obtain your OkHi client key and branch ID. You can get these by signing up [here](https://docs.google.com/forms/d/e/1FAIpQLSed2rhgKQ8iv-xiJrJnDqOTaPiP6c7oE7DzrhTPF_d3VTihDQ/viewform).
+Use your sandbox keys while you test and develop, and your production mode keys before you publish your app.
+
+## Android
+
+### Change your minSdkVersion target
+
+This library targets android devices >= SDK 23. Make sure you're targeting at-least the same by modifying your `android/build.gradle` file
+
+```gradle
+minSdkVersion = 23
+```
+
+### Add necessary permissions to your `AndroidManifest.xml`
+
+```xml
+<manifest ...>
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    ...
+
+    <application>
+    ...
+    </application>
+​
+</manifest>
+```
+
+If you're targeting Android versions > 8 and you're using the OkVerify library you need to make sure your users select on "Allow always" when granting permissions otherwise the verification process won't work.
+
+## iOS
+
+### Enable background mode in your application
+
+OkHi obtains verification signals in the background, to enable this make sure to add "Location updates" and "Background fetch" to your Background Modes under Signing & Capabilities of your target.
+
+![background modes](https://storage.googleapis.com/okhi-cdn/files/Screenshot%202021-11-02%20at%2008.01.13.png)
+
+### Change your deployment target
+
+All OkHi React Native libraries target ios devices >= 12. Make sure you're targeting at-least the same by modifying your both your Podfile and deployment target in xcode.
+
+![deployemnttarget](https://storage.googleapis.com/okhi-cdn/files/Screenshot%202021-11-02%20at%2018.09.04.png)
+
+Podile located under: `ios/Podfile`
+
+```xml
+platform :ios, '12.0'
+```
+
+### Add necessary permissions to your `Info.plist`
+
+```xml
+<key>NSLocationWhenInUseUsageDescription</key>
+<string>String that explains why you need when in use location permission</string>
+<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
+<string>String that explains why you need always location permission</string>
+```
+
+## Installation
+
+Run the bellow command in the root directory of your React Native project.
+
+```yaml
+yarn add react-native-okhi react-native-webview
+```
+
+Finally install all required pods by running the following command in the ios directory
+
+```
+cd ios/ && pod install && cd ../
+```
+
+# Usage
+
+## Initialization
+
+Add the following initialization code to your index.js file. Replace my_branch_id and my_client_key with the keys provided to you after sign up.
+
+```javascript
+import * as OkHi from 'react-native-okhi';
+
+OkHi.initialize({
+  credentials: {
+    branchId: '<my_branch_id>',
+    clientKey: '<my_client_key>',
+  },
+  context: {
+    mode: 'sandbox',
+  },
+  notification: {
+    title: 'Address verification in progress',
+    text: 'Tap here to view your verification status.',
+    channelId: 'okhi',
+    channelName: 'OkHi Channel',
+    channelDescription: 'OkHi verification alerts',
+  },
+})
+  .then(() => console.log('init done'))
+  .catch(console.log);
+```
+
+## Address Creation and Verification
+
+```javascript
+import React, { useState, useEffect } from 'react';
+import { View, Text } from 'react-native';
+import { OkHiLocationManager, canStartVerification } from 'react-native-okhi';
+
+const App = () => {
+  const [launch, setLaunch] = useState(false);
+
+  useEffect(() => {
+    canStartVerification({ requestServices: true }).then((result) => {
+      setLaunch(result);
+    }); // checks & requests for required services for verification to run
+  });
+
+  const user = {
+    phone: '+254712345678', // required
+    firstName: 'Julius',
+    lastName: 'Kiano',
+  };
+
+  const handleOnSuccess = async (response) => {
+    console.log(response.user); // user information
+    console.log(response.location); // address information
+    await response.startVerification();
+  };
+
+  const handleOnError = (error) => {
+    console.log(error.code); // user information
+    console.log(error.message); // address information
+    setLaunch(false);
+  };
+
+  if (launch) {
+    return (
+      <View style={{ flex: 1 }}>
+        <OkHiLocationManager
+          user={user}
+          launch={launch}
+          onSuccess={handleOnSuccess}
+          onCloseRequest={() => setLaunch(false)} // called when user taps on the top right close button
+          onError={handleOnError}
+        />
+      </View>
+    );
+  }
+
+  return (
+    <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
+      <Text>Loading..</Text>
+    </View>
+  );
+};
+
+export default App;
+```
+
+# Documentation
+
+- [Guide](https://docs.okhi.co/v/v5.1-beta/okhi-on-your-react-native-app)
+- [Best practices](https://docs.google.com/document/d/1kxolQJ4n6tEgReuqVLYpDVMW--xvqv5UQ7AdvrN0Uw0/edit)

package/android/build.gradle

@@ -0,0 +1,139 @@
+buildscript {
+  repositories {
+      google()
+      mavenCentral()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:7.2.2'
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: 'com.android.library'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Okhi_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['Okhi_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+      "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+
+dependencies {
+    //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation 'com.github.OkHi:android-core:v1.5.9'
+  implementation 'com.github.OkHi:android-okverify:v1.9.10'
+// From node_modules
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Okhi"
+    codegenJavaPackageName = "com.reactnativeokhi"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Okhi_kotlinVersion=1.7.0
+Okhi_minSdkVersion=21
+Okhi_targetSdkVersion=33
+Okhi_compileSdkVersion=33
+Okhi_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/com/reactnativeokhi/OkhiModule.java

@@ -0,0 +1,317 @@
+package com.reactnativeokhi;
+
+import android.app.Activity;
+import android.app.NotificationManager;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.Settings;
+import android.util.Base64;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Dynamic;
+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.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.module.annotations.ReactModule;
+
+import org.json.JSONObject;
+
+import io.okhi.android_core.OkHi;
+import io.okhi.android_core.interfaces.OkHiRequestHandler;
+import io.okhi.android_core.models.OkHiAppContext;
+import io.okhi.android_core.models.OkHiAuth;
+import io.okhi.android_core.models.OkHiException;
+import io.okhi.android_core.models.OkHiLocation;
+import io.okhi.android_core.models.OkHiPermissionService;
+import io.okhi.android_core.models.OkHiUser;
+import io.okhi.android_core.models.OkPreference;
+import io.okhi.android_okverify.OkVerify;
+import io.okhi.android_okverify.interfaces.OkVerifyCallback;
+import io.okhi.android_okverify.models.OkHiNotification;
+
+@ReactModule(name = OkhiModule.NAME)
+public class OkhiModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "Okhi";
+  OkHi okHi;
+  OkVerify okVerify;
+  OkHiAuth auth;
+
+  public OkhiModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    try {
+      ActivityEventListener activityEventListener = new ActivityEventListener() {
+        @Override
+        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+          if (okHi != null) {
+            okHi.onActivityResult(requestCode, resultCode, data);
+          }
+        }
+
+        @Override
+        public void onNewIntent(Intent intent) {
+        }
+      };
+      reactContext.addActivityEventListener(activityEventListener);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  class RequestHandler implements OkHiRequestHandler<Boolean> {
+    Promise promise;
+
+    RequestHandler(Promise promise) {
+      this.promise = promise;
+    }
+
+    @Override
+    public void onResult(Boolean result) {
+      promise.resolve(result);
+    }
+
+    @Override
+    public void onError(OkHiException exception) {
+      promise.reject(exception);
+    }
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void isLocationServicesEnabled(Promise promise) {
+    boolean result = OkHi.isLocationServicesEnabled(getReactApplicationContext());
+    promise.resolve(result);
+  }
+
+  @ReactMethod
+  public void isLocationPermissionGranted(Promise promise) {
+    boolean result = OkHi.isLocationPermissionGranted(getReactApplicationContext());
+    promise.resolve(result);
+  }
+
+  @ReactMethod
+  public void isBackgroundLocationPermissionGranted(Promise promise) {
+    boolean result = OkHi.isBackgroundLocationPermissionGranted(getReactApplicationContext());
+    promise.resolve(result);
+  }
+
+  @ReactMethod
+  public void isGooglePlayServicesAvailable(Promise promise) {
+    promise.resolve(OkHi.isGooglePlayServicesAvailable(getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void requestEnableLocationServices(Promise promise) {
+    if (OkHi.isLocationServicesEnabled(getReactApplicationContext())) {
+      promise.resolve(true);
+    } else if (getCurrentActivity() == null) {
+      promise.reject(new OkHiException(OkHiException.UNKNOWN_ERROR_CODE, "Main activity hasn't loaded yet"));
+    } else {
+      okHi = new OkHi(getCurrentActivity());
+      okHi.requestEnableLocationServices(new RequestHandler(promise));
+    }
+  }
+
+  @ReactMethod
+  public void requestEnableGooglePlayServices(Promise promise) {
+    if (OkHi.isGooglePlayServicesAvailable(getReactApplicationContext())) {
+      promise.resolve(true);
+    } else if (getCurrentActivity() == null) {
+      promise.reject(new OkHiException(OkHiException.UNKNOWN_ERROR_CODE, "Main activity hasn't loaded yet"));
+    } else {
+      okHi = new OkHi(getCurrentActivity());
+      okHi.requestEnableGooglePlayServices(new RequestHandler(promise));
+    }
+  }
+
+  @ReactMethod
+  public void getSystemVersion (Promise promise) {
+    promise.resolve(android.os.Build.VERSION.SDK_INT);
+  }
+
+  @ReactMethod
+  public void getAuthToken(String branchId, String clientKey, Promise promise) {
+    String concat = branchId + ":" + clientKey;
+    String token = Base64.encodeToString(concat.getBytes(), Base64.NO_WRAP);
+    promise.resolve("Token " + token);
+  }
+
+  @ReactMethod
+  public void initialize(String configuration, Promise promise) {
+    try {
+      JSONObject config = new JSONObject(configuration);
+      String branchId = config.getJSONObject("credentials").getString("branchId");
+      String clientKey = config.getJSONObject("credentials").getString("clientKey");
+      String mode = config.getJSONObject("context").getString("mode");
+      String developer = config.getJSONObject("context").optString("developer", "external");
+      OkHiAppContext context = new OkHiAppContext(getReactApplicationContext(), mode, "react-native", developer);
+      auth = new OkHiAuth(getReactApplicationContext(), branchId, clientKey, context);
+      if (getCurrentActivity() != null && getCurrentActivity().getApplicationContext() != null) {
+        okVerify = new OkVerify.Builder(getCurrentActivity(), auth).build();
+        if (config.has("notification")) {
+          JSONObject notificationConfig = config.getJSONObject("notification");
+          int importance = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ? NotificationManager.IMPORTANCE_DEFAULT : 3;
+          OkVerify.init(getReactApplicationContext(), new OkHiNotification(
+            notificationConfig.optString("title", "Verification in progress"),
+            notificationConfig.optString("text", "Address Verification in progress"),
+            notificationConfig.optString("channelId", "okhi"),
+            notificationConfig.optString("channelName", "OkHi Channel"),
+            notificationConfig.optString("channelDescription", "OkHi verification alerts"),
+            importance
+          ));
+        }
+        promise.resolve(true);
+      } else {
+        promise.resolve(false);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+      promise.reject("unauthorized", "unable to parse credentials", e);
+    }
+  }
+
+  @ReactMethod
+  public void startAddressVerification(String phoneNumber, String locationId, Float lat, Float lon, ReadableMap config, Promise promise) {
+    if (okVerify == null) {
+      promise.reject("unauthorized", "failed to initialise okhi");
+      return;
+    }
+    OkHiUser user = new OkHiUser.Builder(phoneNumber).build();
+    OkHiLocation location = new OkHiLocation.Builder(locationId, lat, lon).build();
+    Boolean withForeground = true;
+    Dynamic foregroundConfig = getConfig(config, "withForeground");
+    if(foregroundConfig != null) {
+      withForeground = foregroundConfig.asBoolean();
+    }
+    okVerify.start(user, location, withForeground, new OkVerifyCallback<String>() {
+      @Override
+      public void onSuccess(String result) {
+        promise.resolve(result);
+      }
+      @Override
+      public void onError(OkHiException e) {
+        promise.reject(e.getCode(), e.getMessage(), e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void stopAddressVerification(String phoneNumber, String locationId, Promise promise) {
+    OkVerify.stop(getReactApplicationContext(), locationId, new OkVerifyCallback<String>() {
+      @Override
+      public void onSuccess(String result) {
+        promise.resolve(result);
+      }
+      @Override
+      public void onError(OkHiException e) {
+        promise.reject(e.getCode(), e.getMessage(), e);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void startForegroundService(Promise promise) {
+    try {
+      OkVerify.startForegroundService(getReactApplicationContext());
+      promise.resolve(true);
+    } catch (OkHiException e) {
+      e.printStackTrace();
+      promise.reject(e.getCode(), e.getMessage(), e);
+    }
+  }
+
+  @ReactMethod
+  public void stopForegroundService(Promise promise) {
+    OkVerify.stopForegroundService(getReactApplicationContext());
+    promise.resolve(true);
+  }
+
+  @ReactMethod
+  public void isForegroundServiceRunning(Promise promise) {
+    Boolean result = OkVerify.isForegroundServiceRunning(getReactApplicationContext());
+    promise.resolve(result);
+  }
+
+  @ReactMethod
+  public void openAppSettings(Promise promise) {
+    Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+    Uri uri = Uri.fromParts("package", getReactApplicationContext().getPackageName(), null);
+    intent.setData(uri);
+    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    getReactApplicationContext().startActivity(intent);
+  }
+
+  @ReactMethod
+  public void canOpenProtectedAppsSettings(Promise promise) {
+    promise.resolve(OkHiPermissionService.canOpenProtectedApps(getReactApplicationContext()));
+  }
+
+  @ReactMethod
+  public void openProtectedAppsSettings(Promise promise) {
+    try {
+      Activity activity = getCurrentActivity();
+      if (activity != null) {
+        OkHiPermissionService.openProtectedAppsSettings(getCurrentActivity(), 69);
+        promise.resolve(true);
+      } else {
+        throw new OkHiException(OkHiException.UNKNOWN_ERROR_CODE, "unable to retrieve current activity");
+      }
+    } catch (OkHiException e) {
+      promise.reject(e.getCode(), e.getMessage(), e);
+    }
+  }
+
+  @ReactMethod
+  public void retrieveDeviceInfo(Promise promise) {
+    WritableMap map = new WritableNativeMap();
+    map.putString("manufacturer", Build.MANUFACTURER);
+    map.putString("model", Build.MODEL);
+    promise.resolve(map);
+  }
+
+  private Dynamic getConfig(ReadableMap map, String prop) {
+    if (map != null && map.hasKey("android")) {
+      ReadableMap config = map.getMap("android");
+      if (config.hasKey("withForeground")) {
+        return config.getDynamic("withForeground");
+      } else {
+        return null;
+      }
+    }
+    return  null;
+  }
+
+  // Required for rn built in EventEmitter Calls.
+  @ReactMethod
+  public void addListener(String eventName) {
+
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+
+  }
+
+  @ReactMethod
+  public void setItem(String key, String value, Promise promise) {
+    try {
+      OkPreference.setItem(key, value, getReactApplicationContext());
+      promise.resolve(true);
+    } catch (OkHiException e) {
+      promise.reject(e.getCode(), e.getMessage(), e);
+      e.printStackTrace();
+    }
+  }
+
+}

package/android/src/main/java/com/reactnativeokhi/OkhiPackage.java

@@ -0,0 +1,28 @@
+package com.reactnativeokhi;
+
+import androidx.annotation.NonNull;
+
+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 OkhiPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new OkhiModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}