@octopus-community/react-native 1.0.0

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusSSOAuthenticator.kt

@@ -0,0 +1,124 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.Promise
+import com.octopuscommunity.sdk.OctopusSDK
+import com.octopuscommunity.sdk.domain.model.ClientUser
+import com.octopuscommunity.sdk.domain.model.ClientUser.Profile.AgeInformation
+import com.octopuscommunity.sdk.domain.model.Image
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.CancellationException
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class OctopusSSOAuthenticator(private val eventEmitter: OctopusEventEmitter) {
+
+  private val coroutineScope = CoroutineScope(Dispatchers.Main)
+  private val pendingTokenRequests =
+    ConcurrentHashMap<String, kotlin.coroutines.Continuation<String>>()
+
+  fun connectUser(params: ReadableMap, promise: Promise) {
+    coroutineScope.launch {
+      try {
+        val clientUser = parseClientUser(params)
+
+        OctopusSDK.connectUser(
+          user = clientUser,
+          tokenProvider = { requestTokenFromRN() }
+        )
+
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("CONNECT_USER_ERROR", "Failed to connect user: ${e.message}", e)
+      }
+    }
+  }
+
+  fun disconnectUser(promise: Promise) {
+    coroutineScope.launch {
+      try {
+        OctopusSDK.disconnectUser()
+
+        // Cancel all pending token requests
+        for ((_, continuation) in pendingTokenRequests) {
+          continuation.resumeWithException(CancellationException("User disconnected"))
+        }
+        pendingTokenRequests.clear()
+
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("DISCONNECT_USER_ERROR", "Failed to disconnect user: ${e.message}", e)
+      }
+    }
+  }
+
+  fun completeTokenRequest(requestId: String, token: String) {
+    val continuation = pendingTokenRequests.remove(requestId)
+    continuation?.resume(token)
+  }
+
+  fun cancelTokenRequest(requestId: String) {
+    val continuation = pendingTokenRequests.remove(requestId)
+    continuation?.resumeWithException(CancellationException("Token request cancelled"))
+  }
+
+  private suspend fun requestTokenFromRN(): String {
+    val requestId = UUID.randomUUID().toString()
+
+    return suspendCancellableCoroutine { continuation ->
+      pendingTokenRequests[requestId] = continuation
+
+      continuation.invokeOnCancellation {
+        pendingTokenRequests.remove(requestId)
+      }
+
+      eventEmitter.emitUserTokenRequest(requestId)
+    }
+  }
+
+  private fun parseClientUser(params: ReadableMap): ClientUser {
+    val userId = params.getString("userId")
+      ?: throw IllegalArgumentException("Missing user id")
+
+    val profile = parseUserProfile(params.getMap("profile"))
+
+    return ClientUser(
+      userId = userId,
+      profile = profile
+    )
+  }
+
+  private fun parseUserProfile(profileParams: ReadableMap?): ClientUser.Profile {
+    if (profileParams == null) {
+      return ClientUser.Profile()
+    }
+
+    val ageInformation = if (profileParams.hasKey("legalAgeReached")) {
+      if (profileParams.getBoolean("legalAgeReached")) {
+        AgeInformation.LegalAgeReached
+      } else {
+        AgeInformation.Underage
+      }
+    } else null
+
+    val profilePicture = profileParams.getString("profilePicture")?.let { pictureUrl ->
+      if (pictureUrl.startsWith("http://") || pictureUrl.startsWith("https://")) {
+        Image.Remote(pictureUrl)
+      } else {
+        Image.Local(pictureUrl)
+      }
+    }
+
+    return ClientUser.Profile(
+      nickname = profileParams.getString("username"),
+      bio = profileParams.getString("biography"),
+      ageInformation = ageInformation,
+      avatar = profilePicture
+    )
+  }
+}

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusUIActivity.kt

@@ -0,0 +1,71 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.rememberNavController
+import com.octopuscommunity.sdk.ui.OctopusDestination
+import com.octopuscommunity.sdk.ui.octopusComposables
+
+class OctopusUIActivity : ComponentActivity() {
+  private val closeUIReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+      finish()
+    }
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    registerCloseUIReceiver()
+    setContent {
+      OctopusUI()
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    unregisterReceiver(closeUIReceiver)
+  }
+
+  private fun registerCloseUIReceiver() {
+    val intentFilter = IntentFilter(OctopusUIController.CLOSE_UI_ACTION)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      registerReceiver(closeUIReceiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
+    } else {
+      @Suppress("UnspecifiedRegisterReceiverFlag")
+      registerReceiver(closeUIReceiver, intentFilter)
+    }
+  }
+}
+
+@Composable
+private fun OctopusUI() {
+  Box(modifier = Modifier.fillMaxSize()) {
+    val navController = rememberNavController()
+
+    NavHost(
+      navController = navController,
+      startDestination = OctopusDestination.Home
+    ) {
+      octopusComposables(
+        navController = navController,
+        onNavigateToLogin = {
+          OctopusEventEmitter.instance?.emitLoginRequired()
+        },
+        onNavigateToProfileEdit = { fieldToEdit ->
+          OctopusEventEmitter.instance?.emitEditUser(fieldToEdit)
+        }
+      )
+    }
+  }
+}

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusUIController.kt

@@ -0,0 +1,34 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import android.content.Intent
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+
+class OctopusUIController(private val reactContext: ReactApplicationContext) {
+
+  fun openUI(promise: Promise) {
+    try {
+      val intent = Intent(reactContext, OctopusUIActivity::class.java)
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      reactContext.startActivity(intent)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("OPEN_UI_ERROR", "Failed to open Octopus UI", e)
+    }
+  }
+
+  fun closeUI(promise: Promise) {
+    try {
+      val intent = Intent(CLOSE_UI_ACTION)
+      intent.setPackage(reactContext.packageName)
+      reactContext.sendBroadcast(intent)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("CLOSE_UI_ERROR", "Failed to close Octopus UI", e)
+    }
+  }
+
+  companion object {
+    const val CLOSE_UI_ACTION = "com.octopuscommunity.octopusreactnativesdk.CLOSE_UI"
+  }
+}

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/ProfileFieldMapper.kt

@@ -0,0 +1,39 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import com.facebook.react.bridge.ReadableArray
+import com.octopuscommunity.sdk.domain.model.ProfileField
+
+object ProfileFieldMapper {
+
+  fun fromReactNativeArray(appManagedFields: ReadableArray?): Set<ProfileField> {
+    if (appManagedFields == null) {
+      return emptySet()
+    }
+
+    val profileFields = mutableSetOf<ProfileField>()
+    for (i in 0 until appManagedFields.size()) {
+      fromReactNativeString(appManagedFields.getString(i))?.let { profileField ->
+        profileFields.add(profileField)
+      }
+    }
+    return profileFields
+  }
+
+  fun fromReactNativeString(fieldName: String?): ProfileField? {
+    return when (fieldName) {
+      "username" -> ProfileField.NICKNAME
+      "biography" -> ProfileField.BIO
+      "profilePicture" -> ProfileField.AVATAR
+      else -> null
+    }
+  }
+
+  fun toReactNativeString(profileField: ProfileField?): String? {
+    return when (profileField) {
+      ProfileField.NICKNAME -> "username"
+      ProfileField.BIO -> "biography"
+      ProfileField.AVATAR -> "profilePicture"
+      else -> null
+    }
+  }
+}

package/ios/OctopusEventManager.swift

@@ -0,0 +1,44 @@
+import React
+import Octopus
+
+class OctopusEventManager {
+  private weak var eventEmitter: RCTEventEmitter?
+  private var hasListeners = false
+  
+  init(eventEmitter: RCTEventEmitter) {
+    self.eventEmitter = eventEmitter
+  }
+  
+  func emitLoginRequired() {
+    if hasListeners {
+      eventEmitter?.sendEvent(withName: "loginRequired", body: nil)
+    }
+  }
+  
+  func emitEditUser(profileField: ConnectionMode.SSOConfiguration.ProfileField?) {
+    if hasListeners {
+      let fieldToEdit = ProfileFieldMapper.toReactNativeString(profileField)
+      let eventBody = ["fieldToEdit": fieldToEdit]
+      eventEmitter?.sendEvent(withName: "editUser", body: eventBody)
+    }
+  }
+  
+  func emitUserTokenRequest(requestId: String) {
+    if hasListeners {
+      let eventBody = ["requestId": requestId]
+      eventEmitter?.sendEvent(withName: "userTokenRequest", body: eventBody)
+    }
+  }
+  
+  func startObserving() {
+    hasListeners = true
+  }
+  
+  func stopObserving() {
+    hasListeners = false
+  }
+  
+  func supportedEvents() -> [String] {
+    return ["loginRequired", "editUser", "userTokenRequest"]
+  }
+}

package/ios/OctopusReactNativeSdk-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>

package/ios/OctopusReactNativeSdk.mm

@@ -0,0 +1,37 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(OctopusReactNativeSdk, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)options
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(openUI:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(closeUI:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(connectUser:(NSDictionary *)params
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(completeUserTokenRequest:(NSString *)requestId
+                  withToken:(NSString *)token
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cancelUserTokenRequest:(NSString *)requestId
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(disconnectUser:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/OctopusReactNativeSdk.swift

@@ -0,0 +1,148 @@
+import Octopus
+import OctopusUI
+import SwiftUI
+import UIKit
+
+@objc(OctopusReactNativeSdk)
+class OctopusReactNativeSdk: RCTEventEmitter {
+  
+  // MARK: - Properties
+  
+  private var octopusSDK: OctopusSDK?
+  private lazy var uiManager = OctopusUIManager()
+  private lazy var eventManager = OctopusEventManager(eventEmitter: self)
+  private let sdkInitializer = OctopusSDKInitializer()
+  private var ssoAuthenticator: OctopusSSOAuthenticator?
+  
+  // MARK: - Initialization
+  
+  @objc(initialize:withResolver:withRejecter:)
+  func initialize(options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    do {
+      self.octopusSDK = try sdkInitializer.initialize(options: options, eventManager: eventManager)
+      self.ssoAuthenticator = OctopusSSOAuthenticator(octopusSDK: self.octopusSDK!, eventManager: eventManager)
+      resolve(nil)
+    } catch {
+      reject("INITIALIZE_ERROR", "Failed to initialize Octopus SDK: \(error.localizedDescription)", error)
+    }
+  }
+  
+  // MARK: - User authentication
+  
+  @objc(connectUser:withResolver:withRejecter:)
+  func connectUser(params: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    guard let authenticator = ssoAuthenticator else {
+      reject("CONNECT_USER_ERROR", "SDK not initialized. Call initialize() first.", nil)
+      return
+    }
+    
+    Task {
+      do {
+        try await authenticator.connectUser(params: params)
+        resolve(nil)
+      } catch {
+        reject("CONNECT_USER_ERROR", "Failed to connect user: \(error.localizedDescription)", error)
+      }
+    }
+    
+  }
+  
+  @objc(completeUserTokenRequest:withToken:withResolver:withRejecter:)
+  func completeUserTokenRequest(requestId: String, token: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    guard let authenticator = ssoAuthenticator else {
+      reject("PROVIDE_TOKEN_ERROR", "SDK not initialized", nil)
+      return
+    }
+    
+    authenticator.completeTokenRequest(requestId: requestId, token: token)
+    resolve(nil)
+  }
+  
+  @objc(cancelUserTokenRequest:withResolver:withRejecter:)
+  func cancelUserTokenRequest(requestId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    guard let authenticator = ssoAuthenticator else {
+      reject("PROVIDE_TOKEN_ERROR", "SDK not initialized", nil)
+      return
+    }
+    
+    authenticator.cancelTokenRequest(requestId: requestId)
+    resolve(nil)
+  }
+  
+  @objc(disconnectUser:withRejecter:)
+  func disconnectUser(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    guard let authenticator = ssoAuthenticator else {
+      reject("DISCONNECT_USER_ERROR", "SDK not initialized. Call initialize() first.", nil)
+      return
+    }
+    
+    do {
+      try authenticator.disconnectUser()
+      resolve(nil)
+    } catch {
+      reject("DISCONNECT_USER_ERROR", "Failed to disconnect user: \(error.localizedDescription)", error)
+    }
+    
+  }
+  
+  // MARK: - UI management
+  
+  @objc(openUI:withRejecter:)
+  func openUI(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    guard let octopus = octopusSDK else {
+      reject("OPEN_UI_ERROR", "SDK not initialized. Call initialize() first.", nil)
+      return
+    }
+    
+    DispatchQueue.main.async {
+      do {
+        try self.uiManager.openUI(octopus: octopus)
+        resolve(nil)
+      } catch {
+        reject("OPEN_UI_ERROR", error.localizedDescription, error)
+      }
+    }
+  }
+  
+  @objc(closeUI:withRejecter:)
+  func closeUI(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    DispatchQueue.main.async {
+      do {
+        try self.uiManager.closeUI()
+        resolve(nil)
+      } catch {
+        reject("CLOSE_UI_ERROR", error.localizedDescription, error)
+      }
+    }
+  }
+  
+  // MARK: - Lifecycle management
+  
+  deinit {
+    cleanup()
+  }
+  
+  private func cleanup() {
+    uiManager.cleanup()
+    octopusSDK = nil
+  }
+  
+  @objc override func invalidate() {
+    cleanup()
+    super.invalidate()
+  }
+  
+  // MARK: - RCTEventEmitter overrides
+  
+  @objc override func supportedEvents() -> [String]! {
+    return eventManager.supportedEvents()
+  }
+  
+  @objc override func startObserving() {
+    eventManager.startObserving()
+  }
+  
+  @objc override func stopObserving() {
+    eventManager.stopObserving()
+  }
+}

package/ios/OctopusSDKInitializer.swift

@@ -0,0 +1,62 @@
+import Octopus
+
+class OctopusSDKInitializer {
+  func initialize(options: [String: Any], eventManager: OctopusEventManager) throws -> OctopusSDK {
+    guard let apiKey = options["apiKey"] as? String else {
+      throw InitializationError.missingAPIKey
+    }
+    
+    guard let connectionModeMap = options["connectionMode"] as? [String: Any] else {
+      throw InitializationError.missingConnectionMode
+    }
+    
+    let connectionMode = try parseConnectionMode(from: connectionModeMap, eventManager: eventManager)
+    return try OctopusSDK(apiKey: apiKey, connectionMode: connectionMode)
+  }
+  
+  private func parseConnectionMode(from connectionModeMap: [String: Any], eventManager: OctopusEventManager) throws -> ConnectionMode {
+    let connectionModeType = connectionModeMap["type"] as? String
+    
+    switch connectionModeType {
+    case "sso":
+      return try createSSOConnectionMode(from: connectionModeMap, eventManager: eventManager)
+    case "octopus":
+      return .octopus(deepLink: nil)
+    default:
+      throw InitializationError.invalidConnectionModeType
+    }
+  }
+  
+  private func createSSOConnectionMode(from connectionModeMap: [String: Any], eventManager: OctopusEventManager) throws -> ConnectionMode {
+    let appManagedFields = ProfileFieldMapper.fromReactNativeArray(connectionModeMap["appManagedFields"] as? [String])
+    
+    return .sso(
+      .init(
+        appManagedFields: appManagedFields,
+        loginRequired: {
+          eventManager.emitLoginRequired()
+        },
+        modifyUser: { profileField in
+          eventManager.emitEditUser(profileField: profileField)
+        }
+      )
+    )
+  }
+}
+
+enum InitializationError: Error, LocalizedError {
+  case missingAPIKey
+  case missingConnectionMode
+  case invalidConnectionModeType
+  
+  var errorDescription: String? {
+    switch self {
+    case .missingAPIKey:
+      return "API key is required"
+    case .missingConnectionMode:
+      return "Connection mode is required"
+    case .invalidConnectionModeType:
+      return "Invalid connection mode type"
+    }
+  }
+}