react-native-okhi 1.2.31 → 1.2.32-beta.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 OkHi
+Copyright (c) 2026 OkHi <kiano@okhi.co> (https://okhi.com)
 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

package/README.md

@@ -1,7 +1,37 @@
-# OkHi React Native
+# react-native-okhi
 
-The official OkHi React Native library will enable you to start collecting and verifying your user's addresses.
+The OkHi React Native library enables you to collect and verify addresses from your users
 
-[Documentation](https://docs.okhi.com/okhi-documentation/code-libraries/react-native-guide)
+## Installation
 
-[API reference](https://okhi.github.io/react-native-okhi/)
+
+```sh
+npm install react-native-okhi
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-okhi';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/ReactNativeOkhi.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeOkHi"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OkHi/react-native-okhi.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  s.dependency "OkHi", "~> 1.10.5"
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -1,41 +1,44 @@
 buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Okhi_' + name]
+  }
+
   repositories {
-      google()
-      mavenCentral()
-      maven { url "https://repo.okhi.io/artifactory/maven" }
+    google()
+    mavenCentral()
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:7.2.2'
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
-}
-
-apply plugin: 'com.android.library'
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: 'com.facebook.react'
-}
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Okhi_' + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['Okhi_' + name]).toInteger()
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Okhi_" + name]).toInteger()
 }
 
 android {
-  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+  namespace "com.okhi"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
-    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
   }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -43,98 +46,34 @@ android {
   }
 
   lintOptions {
-    disable 'GradleCompatible'
+    disable "GradleCompatible"
   }
 
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
 }
 
 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."
-    )
-  }
+  maven { url "https://repo.okhi.io/artifactory/maven" }
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-    //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
-  implementation 'io.okhi.android:core:1.7.40'
-  implementation 'io.okhi.android:okverify:1.9.82'
-// From node_modules
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Okhi"
-    codegenJavaPackageName = "com.reactnativeokhi"
-  }
+  implementation 'io.okhi.android:okhi:1.0.0'
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 }

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Okhi_kotlinVersion=1.7.0
+Okhi_kotlinVersion=2.0.21
 Okhi_minSdkVersion=21
-Okhi_targetSdkVersion=35
+Okhi_targetSdkVersion=34
 Okhi_compileSdkVersion=35
-Okhi_ndkversion=21.4.7075529
+Okhi_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/com/okhi/OkhiModule.kt

@@ -0,0 +1,336 @@
+package com.okhi
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import io.okhi.android.OkHi
+import io.okhi.android.collect.OkCollect
+import io.okhi.android.collect.OkCollectConfig
+import io.okhi.android.collect.OkCollectStyle
+import io.okhi.android.collect.models.OkHiSuccessResponse
+import io.okhi.android.core.interfaces.OkHiAddressVerificationCallback
+import io.okhi.android.core.model.OkHiAuth
+import io.okhi.android.core.model.OkHiException
+import io.okhi.android.core.model.OkHiLocation
+import io.okhi.android.core.model.OkHiUser
+
+@ReactModule(name = OkhiModule.NAME)
+class OkhiModule(reactContext: ReactApplicationContext) : NativeOkhiSpec(reactContext) {
+  var currentCallback: Callback? = null
+
+  val okhiAddressVerificationCallback = object : OkHiAddressVerificationCallback() {
+    override fun onClose() {
+      val error = Arguments.createMap().apply {
+        putString("code", "user_closed")
+        putString("message", "user closed address creation")
+      }
+      currentCallback?.invoke(null, error)
+    }
+
+    override fun onError(e: OkHiException) {
+      val error = Arguments.createMap().apply {
+        putString("code", e.code)
+        putString("message", e.message)
+      }
+      currentCallback?.invoke(null, error)
+    }
+
+    override fun onSuccess(response: OkHiSuccessResponse) {
+      val response = Arguments.createMap().apply {
+        putString("user", response.user.toJSON().toString())
+        putString("location", response.location.toJSON().toString())
+      }
+      currentCallback?.invoke(response, null)
+    }
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun multiply(a: Double, b: Double): Double {
+    return a * b
+  }
+
+  override fun login(credentials: ReadableMap?, callback: Callback?) {
+    if (credentials == null) {
+      callback?.invoke(null)
+      return
+    }
+
+    val authMap = credentials.getMap("auth")
+    val userMap = credentials.getMap("user")
+
+    if (authMap == null || userMap == null) {
+      callback?.invoke(null)
+      return
+    }
+
+    val branchId = authMap.getString("branchId") ?: ""
+    val clientKey = authMap.getString("clientKey") ?: ""
+    val env = authMap.getString("env") ?: "prod"
+
+    val phone = userMap.getString("phone") ?: ""
+    val firstName = userMap.getString("firstName") ?: ""
+    val lastName = userMap.getString("lastName") ?: ""
+    val email = userMap.getString("email") ?: ""
+    val appUserId = if (userMap.hasKey("appUserId")) userMap.getString("appUserId") else null
+
+    val auth = OkHiAuth(
+      branchId = branchId,
+      clientKey = clientKey,
+      env = env
+    )
+
+    val user = OkHiUser(
+      firstName = firstName,
+      lastName = lastName,
+      phone = phone,
+      email = email,
+      appUserId = appUserId
+    )
+
+    OkHi.login(reactApplicationContext.applicationContext, auth, user) { results ->
+      if (results != null) {
+        val writableArray = Arguments.createArray()
+        for (result in results) {
+          writableArray.pushString(result)
+        }
+        callback?.invoke(writableArray)
+      } else {
+        callback?.invoke(null)
+      }
+    }
+  }
+
+  override fun startDigitalAddressVerification(okcollect: ReadableMap?, callback: Callback?) {
+    currentCallback = callback
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.startDigitalAddressVerification(
+        activity = activity,
+        collect = parseOkCollect(okcollect),
+        callback = okhiAddressVerificationCallback
+      )
+    }
+  }
+
+  override fun startPhysicalAddressVerification(okcollect: ReadableMap?, callback: Callback?) {
+    currentCallback = callback
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.startPhysicalAddressVerification(
+        activity = activity,
+        collect = parseOkCollect(okcollect),
+        callback = okhiAddressVerificationCallback
+      )
+    }
+  }
+
+  override fun startDigitalAndPhysicalAddressVerification(okcollect: ReadableMap?, callback: Callback?) {
+    currentCallback = callback
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.startDigitalAndPhysicalAddressVerification(
+        activity = activity,
+        collect = parseOkCollect(okcollect),
+        callback = okhiAddressVerificationCallback
+      )
+    }
+  }
+
+  override fun createAddress(okcollect: ReadableMap?, callback: Callback?) {
+    currentCallback = callback
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.createAddress(
+        activity = activity,
+        collect = parseOkCollect(okcollect),
+        callback = okhiAddressVerificationCallback
+      )
+    }
+  }
+
+  private fun parseOkCollect(okcollect: ReadableMap?): OkCollect {
+    var nativeOkCollect: OkCollect? = null
+    if (okcollect == null) {
+      nativeOkCollect = OkCollect()
+    } else {
+      val styleMap = okcollect.getMap("style")
+      val color = styleMap?.getString("color") ?: "#005D67"
+      val logo = styleMap?.getString("color") ?: "https://cdn.okhi.co/icon.png"
+
+      val configurationMap = okcollect.getMap("configuration")
+      val streetView = configurationMap?.getBoolean("streetView") ?: true
+      val withHomeAddressType = configurationMap?.getBoolean("withHomeAddressType") ?: true
+      val withWorkAddressType = configurationMap?.getBoolean("withWorkAddressType") ?: false
+      val withAppBar = configurationMap?.getBoolean("withAppBar") ?: true
+
+      val locationId = if (okcollect.hasKey("locationId")) okcollect.getString("locationId") else null
+
+      val style = OkCollectStyle(
+        color = color,
+        name = name,
+        logo = logo
+      )
+
+      val config = OkCollectConfig(
+        streetView = streetView,
+        withHomeAddressType = withHomeAddressType,
+        withWorkAddressType = withWorkAddressType,
+        withAppBar = withAppBar
+      )
+
+      var nativeLocation: OkHiLocation? = null
+      if (locationId != null) {
+        nativeLocation = OkHiLocation(locationId)
+      }
+
+      nativeOkCollect = OkCollect(
+        style,
+        config,
+        nativeLocation
+      )
+    }
+
+    return nativeOkCollect
+  }
+
+  // Helper Methods
+
+  override fun isLocationServicesEnabled(callback: Callback?) {
+    val result = OkHi.isLocationServicesEnabled(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun canOpenProtectedApps(callback: Callback?) {
+    val result = OkHi.canOpenProtectedApps(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun getLocationAccuracyLevel(callback: Callback?) {
+    val result = OkHi.getLocationAccuracyLevel(reactApplicationContext.applicationContext)
+    callback?.invoke(result.toString(), null)
+  }
+
+  override fun isBackgroundLocationPermissionGranted(callback: Callback?) {
+    val result = OkHi.isBackgroundLocationPermissionGranted(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun isCoarseLocationPermissionGranted(callback: Callback?) {
+    val result = OkHi.isCoarseLocationPermissionGranted(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun isFineLocationPermissionGranted(callback: Callback?) {
+    val result = OkHi.isFineLocationPermissionGranted(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun isPlayServicesAvailable(callback: Callback?) {
+    val result = OkHi.isPlayServicesAvailable(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun isPostNotificationPermissionGranted(callback: Callback?) {
+    val result = OkHi.isPostNotificationPermissionGranted(reactApplicationContext.applicationContext)
+    callback?.invoke(result, null)
+  }
+
+  override fun openProtectedApps() {
+    OkHi.openProtectedApps(reactApplicationContext.applicationContext)
+  }
+
+  // Request Helpers
+
+  override fun requestLocationPermission(callback: Callback?) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.requestLocationPermission(activity) { result ->
+        callback?.invoke(result, null)
+      }
+    }
+  }
+
+  override fun requestBackgroundLocationPermission(callback: Callback?) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.requestBackgroundLocationPermission(activity) { result ->
+        callback?.invoke(result, null)
+      }
+    }
+  }
+
+  override fun requestEnableLocationServices(callback: Callback?) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.requestEnableLocationServices(activity) { result ->
+        callback?.invoke(result, null)
+      }
+    }
+  }
+
+  override fun requestPostNotificationPermissions(callback: Callback?) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap().apply {
+        putString("code", "unknown")
+        putString("message", "unable to get current activity")
+      }
+      callback?.invoke(null, error)
+    } else {
+      OkHi.requestPostNotificationPermissions(activity) { result ->
+        callback?.invoke(result, null)
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "Okhi"
+  }
+}

package/android/src/main/java/com/okhi/OkhiPackage.kt

@@ -0,0 +1,33 @@
+package com.okhi
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class OkhiPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == OkhiModule.NAME) {
+      OkhiModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[OkhiModule.NAME] = ReactModuleInfo(
+        OkhiModule.NAME,
+        OkhiModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}