react-native-authsignal 1.0.13 → 1.1.2

package/android/build.gradle

@@ -1,24 +1,19 @@
 buildscript {
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Authsignal_kotlinVersion"]
+
   repositories {
       google()
       mavenCentral()
   }
 
   dependencies {
-    classpath 'com.android.tools.build:gradle:7.4.2'
+    classpath 'com.android.tools.build:gradle:8.1.4'
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
-}
-
 apply plugin: 'com.android.library'
-
-
-if (isNewArchitectureEnabled()) {
-  apply plugin: 'com.facebook.react'
-}
+apply plugin: 'org.jetbrains.kotlin.android'
 
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Authsignal_' + name]
@@ -29,13 +24,21 @@ def getExtOrIntegerDefault(name) {
 }
 
 android {
+  namespace "com.authsignal"
+
+  sourceSets {
+    main {
+      manifest.srcFile "src/main/AndroidManifestNew.xml"
+    }
+  }
+
   compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault('minSdkVersion')
     targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
   }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -47,95 +50,32 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
   }
 
+  buildFeatures {
+    buildConfig true
+  }
 }
 
 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."
-    )
-  }
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
 dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
   implementation "androidx.browser:browser:1.2.0"
 
-  implementation("com.authsignal:authsignal-android:1.0.15")
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Authsignal"
-    codegenJavaPackageName = "com.reactnativeauthsignal"
-  }
+  implementation("com.authsignal:authsignal-android:1.1.2")
 }

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
-#Fri Aug 16 14:14:32 NZST 2024
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-all.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/android/gradle.properties

@@ -1,5 +1,6 @@
+Authsignal_kotlinVersion=1.9.24
 Authsignal_minSdkVersion=24
-Authsignal_targetSdkVersion=33
-Authsignal_compileSdkVersion=33
-Authsignal_ndkversion=21.4.7075529
+Authsignal_targetSdkVersion=34
+Authsignal_compileSdkVersion=34
+Authsignal_ndkversion=26.1.10909125
 android.useAndroidX=true

package/android/src/main/java/com/authsignal/react/AuthenticationActivity.kt

@@ -0,0 +1,69 @@
+package com.authsignal.react
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import androidx.browser.customtabs.CustomTabsIntent
+
+class AuthenticationActivity : Activity() {
+  private var intentLaunched = false
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    if (savedInstanceState != null) {
+      intentLaunched = savedInstanceState.getBoolean(EXTRA_INTENT_LAUNCHED, false)
+    }
+  }
+
+  override fun onResume() {
+    super.onResume()
+    val authenticationIntent = intent
+
+    if (!intentLaunched && authenticationIntent.extras == null) {
+      finish()
+      return
+    } else if (!intentLaunched) {
+      intentLaunched = true
+      launchAuthenticationIntent()
+      return
+    }
+
+    val resultMissing = authenticationIntent.data == null
+    if (resultMissing) setResult(RESULT_CANCELED)
+    else setResult(RESULT_OK, authenticationIntent)
+    finish()
+  }
+
+  override fun onSaveInstanceState(outState: Bundle) {
+    super.onSaveInstanceState(outState)
+    outState.putBoolean(EXTRA_INTENT_LAUNCHED, intentLaunched)
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+  }
+
+  private fun launchAuthenticationIntent() {
+    val extras = intent.extras
+    val authorizeUri = extras!!.getParcelable<Uri>(EXTRA_AUTHORIZE_URI)
+    val builder = CustomTabsIntent.Builder()
+    val customTabsIntent = builder.build()
+    customTabsIntent.launchUrl(this, authorizeUri!!)
+  }
+
+  companion object {
+    const val AUTHENTICATION_REQUEST: Int = 1000
+    const val EXTRA_AUTHORIZE_URI: String = "com.authsignal.react.EXTRA_AUTHORIZE_URI"
+    private const val EXTRA_INTENT_LAUNCHED = "com.authsignal.react.EXTRA_INTENT_LAUNCHED"
+
+    @JvmStatic
+    fun authenticateUsingBrowser(activity: Activity, authorizeUri: Uri) {
+      val intent = Intent(activity, AuthenticationActivity::class.java)
+      intent.putExtra(EXTRA_AUTHORIZE_URI, authorizeUri)
+      intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      activity.startActivityForResult(intent, AUTHENTICATION_REQUEST)
+    }
+  }
+}

package/android/src/main/java/com/authsignal/react/AuthsignalEmailModule.kt

@@ -0,0 +1,113 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.email.AuthsignalEmail
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class AuthsignalEmailModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    reactContext
+  ) {
+  private var authsignal: AuthsignalEmail? = null
+
+  private val defaultError = "unexpected_error"
+
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+  override fun getConstants(): Map<String, Any>? {
+    val constants: MutableMap<String, Any> = HashMap()
+    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
+    return constants
+  }
+
+  override fun getName(): String {
+    return "AuthsignalEmailModule"
+  }
+
+  @ReactMethod
+  fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+    val currentActivity = reactContext.currentActivity
+
+    if (currentActivity != null) {
+      authsignal = AuthsignalEmail(tenantID, baseURL)
+    }
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun enroll(email: String, promise: Promise) {
+    launch(promise) {
+      val response = it.enroll(email)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val enrollResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("userAuthenticatorId", enrollResponse!!.userAuthenticatorId)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun challenge(promise: Promise) {
+    launch(promise) {
+      val response = it.challenge()
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val challengeResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("challengeId", challengeResponse!!.challengeId)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun verify(code: String, promise: Promise) {
+    launch(promise) {
+      val response = it.verify(code)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val verifyResponse = response.data
+        val map = Arguments.createMap()
+        map.putBoolean("isVerified", verifyResponse!!.isVerified)
+        map.putString("token", verifyResponse.token)
+        map.putString("failureReason", verifyResponse.failureReason)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalEmail) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalEmailModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}

package/android/src/main/java/com/authsignal/react/AuthsignalModule.kt

@@ -0,0 +1,115 @@
+package com.authsignal.react
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import com.authsignal.TokenCache.Companion.shared
+import com.authsignal.react.AuthenticationActivity.Companion.authenticateUsingBrowser
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+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 java.net.URLDecoder
+
+class AuthsignalModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(
+    reactContext
+  ), ActivityEventListener {
+  private var callback: Callback? = null
+
+  init {
+    reactContext.addActivityEventListener(this)
+  }
+
+  override fun getConstants(): Map<String, Any>? {
+    val constants: MutableMap<String, Any> = HashMap()
+    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
+    return constants
+  }
+
+  override fun getName(): String {
+    return "AuthsignalModule"
+  }
+
+  @ReactMethod
+  fun setToken(token: String?, promise: Promise) {
+    shared.token = token
+
+    promise.resolve("token_set")
+  }
+
+  @ReactMethod
+  fun launch(url: String?, callback: Callback) {
+    val activity = currentActivity
+    val parsedUrl = Uri.parse(url)
+    this.callback = callback
+
+    try {
+      if (activity != null) {
+        authenticateUsingBrowser(activity, parsedUrl)
+      } else {
+        val error = Arguments.createMap()
+        error.putString("error", "activity_not_available")
+        error.putString("error_description", "Android Activity is null.")
+        callback.invoke(error)
+      }
+    } catch (e: ActivityNotFoundException) {
+      val error = Arguments.createMap()
+      error.putString("error", "browser_not_available")
+      error.putString("error_description", "No browser app is installed")
+      callback.invoke(error)
+    }
+  }
+
+  override fun onActivityResult(
+    activity: Activity,
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    val cb = this@AuthsignalModule.callback ?: return
+
+    val hasResult =
+      resultCode == Activity.RESULT_OK && requestCode == AuthenticationActivity.AUTHENTICATION_REQUEST && data!!.data != null
+
+    if (hasResult) {
+      try {
+        val redirectUrl = data!!.data.toString()
+        val query = redirectUrl.split("[?]".toRegex()).dropLastWhile { it.isEmpty() }
+          .toTypedArray()[1]
+        val pairs = query.split("&".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        var token: String? = null
+        for (pair in pairs) {
+          val index = pair.indexOf("=")
+          val name = URLDecoder.decode(pair.substring(0, index), "UTF-8")
+          val value = URLDecoder.decode(pair.substring(index + 1), "UTF-8")
+          if (name == "token") {
+            token = value
+
+            shared.token = value
+          }
+        }
+        cb.invoke(null, token)
+      } catch (ex: Exception) {
+        val error = Arguments.createMap()
+        error.putString("error", "malformed_url")
+        error.putString("error_description", "Malformed redirect url")
+        cb.invoke(error)
+      }
+    } else {
+      val error = Arguments.createMap()
+      error.putString("error", "user_cancelled")
+      error.putString("error_description", "User cancelled")
+      cb.invoke(error)
+    }
+
+    this@AuthsignalModule.callback = null
+  }
+
+  override fun onNewIntent(intent: Intent) {
+  }
+}

package/android/src/main/java/com/authsignal/react/AuthsignalPackage.kt

@@ -0,0 +1,23 @@
+package com.authsignal.react
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class AuthsignalPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf<NativeModule>(
+      AuthsignalModule(reactContext),
+      AuthsignalEmailModule(reactContext),
+      AuthsignalPasskeyModule(reactContext),
+      AuthsignalPushModule(reactContext),
+      AuthsignalSMSModule(reactContext),
+      AuthsignalTOTPModule(reactContext)
+    )
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/authsignal/react/AuthsignalPasskeyModule.kt

@@ -0,0 +1,103 @@
+package com.authsignal.react
+
+import android.util.Log
+import com.authsignal.passkey.AuthsignalPasskey
+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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class AuthsignalPasskeyModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+  private var authsignal: AuthsignalPasskey? = null
+  private var defaultError = "unexpected_error"
+
+  override fun getConstants(): Map<String, Any>? {
+    val constants: MutableMap<String, Any> = HashMap()
+    constants["bundleIdentifier"] = reactContext.applicationInfo.packageName
+    return constants
+  }
+
+  override fun getName(): String {
+    return "AuthsignalPasskeyModule"
+  }
+
+  @ReactMethod
+  fun initialize(tenantID: String, baseURL: String, promise: Promise) {
+    val activity = reactContext.currentActivity
+
+    if (activity != null) {
+      authsignal = AuthsignalPasskey(tenantID, baseURL, activity)
+    }
+
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun signUp(token: String?, username: String?, displayName: String?, promise: Promise) {
+    launch(promise) {
+      val response = it.signUp(token, username, displayName)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val signUpResponse = response.data
+        val map = Arguments.createMap()
+        map.putString("token", signUpResponse!!.token)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun signIn(action: String?, token: String?, promise: Promise) {
+    launch(promise) {
+      val response = it.signIn(action, token)
+
+      if (response.error != null) {
+        val errorCode = response.errorType ?: defaultError
+
+        promise.reject(errorCode, response.error)
+      } else {
+        val signInResponse = response.data
+        val map = Arguments.createMap()
+        map.putBoolean("isVerified", signInResponse!!.isVerified)
+        map.putString("token", signInResponse.token)
+        map.putString("userId", signInResponse.userId)
+        map.putString("userAuthenticatorId", signInResponse.userAuthenticatorId)
+        map.putString("username", signInResponse.username)
+        map.putString("displayName", signInResponse.displayName)
+        promise.resolve(map)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun isAvailableOnDevice(promise: Promise) {
+    launch(promise) {
+      val response = it.isAvailableOnDevice()
+
+      promise.resolve(response.data ?: false)
+    }
+  }
+
+  private fun launch(promise: Promise, fn: suspend (client: AuthsignalPasskey) -> Unit) {
+    coroutineScope.launch {
+      authsignal?.let {
+        fn(it)
+      }  ?: run {
+        Log.w("init_error", "AuthsignalTOTPModule is not initialized.")
+
+        promise.resolve(null)
+      }
+    }
+  }
+}