@octopus-community/react-native 1.0.8 → 1.9.1

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

@@ -9,11 +9,11 @@ import android.graphics.Color
 
 class OctopusSDKInitializer {
 
-  fun initialize(context: ReactApplicationContext, options: ReadableMap, promise: Promise) {
+  fun initialize(context: ReactApplicationContext, options: ReadableMap, promise: Promise): Boolean {
     val apiKey = options.getString("apiKey")
     if (apiKey == null) {
       promise.reject("INITIALIZE_ERROR", "Missing API key")
-      return
+      return false
     }
 
     try {
@@ -27,16 +27,28 @@ class OctopusSDKInitializer {
       val uiConfiguration = parseUIConfiguration(options)
       OctopusUIConfigurationManager.setUIConfiguration(uiConfiguration)
 
-      OctopusSDK.initialize(
-        context = context,
-        apiKey = apiKey,
-        connectionMode = connectionMode
-      )
+      // For "octopus" mode, don't pass connectionMode (it's the default)
+      // For "sso" mode, pass the ConnectionMode.SSO
+      if (connectionMode != null) {
+        OctopusSDK.initialize(
+          context = context,
+          apiKey = apiKey,
+          connectionMode = connectionMode
+        )
+      } else {
+        OctopusSDK.initialize(
+          context = context,
+          apiKey = apiKey
+        )
+      }
       promise.resolve(null)
+      return true
     } catch (e: InvalidConnectionModeException) {
       promise.reject("INITIALIZE_ERROR", e.message, e)
+      return false
     } catch (e: Exception) {
       promise.reject("INITIALIZE_ERROR", "Failed to initialize Octopus SDK", e)
+      return false
     }
   }
 
@@ -209,7 +221,7 @@ class OctopusSDKInitializer {
     }
   }
 
-  private fun parseConnectionMode(options: ReadableMap): ConnectionMode {
+  private fun parseConnectionMode(options: ReadableMap): ConnectionMode? {
     val connectionModeMap = options.getMap("connectionMode")
     return when (val connectionModeType = connectionModeMap?.getString("type")) {
       "sso" -> {
@@ -221,7 +233,8 @@ class OctopusSDKInitializer {
       }
 
       "octopus" -> {
-        ConnectionMode.Octopus
+        // For "octopus" mode, return null - OctopusSDK.initialize() will use default mode
+        null
       }
 
       else -> {

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

@@ -4,8 +4,7 @@ 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 com.octopuscommunity.sdk.domain.model.Resource
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -103,24 +102,16 @@ class OctopusSSOAuthenticator(
       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)
+        Resource.Remote(url = pictureUrl)
       } else if (pictureUrl.startsWith("file") || pictureUrl.startsWith("android.resource")) {
-        Image.Local(pictureUrl)
+        Resource.Local(pictureUrl)
       } else if(pictureUrl.isNotBlank()) {
         // Asset names like "assets_images_logo" need conversion
         // Convert to drawable resource URI
         val resourceId = context.resources.getIdentifier(pictureUrl, "drawable", context.packageName)
-        Image.Local(
+        Resource.Local(
           if (resourceId != 0) {
             "android.resource://${context.packageName}/$resourceId"
           } else {
@@ -136,8 +127,7 @@ class OctopusSSOAuthenticator(
     return ClientUser.Profile(
       nickname = profileParams.getString("username"),
       bio = profileParams.getString("biography"),
-      ageInformation = ageInformation,
-      avatar = profilePicture
+      picture = profilePicture
     )
   }
 }

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

@@ -1,15 +1,20 @@
 package com.octopuscommunity.octopusreactnativesdk
 
 import android.content.Intent
+import android.net.Uri
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
 
 class OctopusUIController(private val reactContext: ReactApplicationContext) {
 
-  fun openUI(promise: Promise) {
+  fun openUI(options: ReadableMap?, promise: Promise) {
     try {
-      val intent = Intent(reactContext, OctopusUIActivity::class.java)
+      val intent = Intent(reactContext, OctopusActivity::class.java)
       intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      val interceptUrls = options?.hasKey("interceptUrls") == true &&
+        options.getBoolean("interceptUrls")
+      intent.putExtra(OctopusActivity.EXTRA_INTERCEPT_URLS, interceptUrls)
       reactContext.startActivity(intent)
       promise.resolve(null)
     } catch (e: Exception) {
@@ -28,6 +33,16 @@ class OctopusUIController(private val reactContext: ReactApplicationContext) {
     }
   }
 
+  fun openUrlInBrowser(url: String) {
+    try {
+      val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      reactContext.startActivity(intent)
+    } catch (e: Exception) {
+      // Ignore if no app can handle the URL
+    }
+  }
+
   companion object {
     const val CLOSE_UI_ACTION = "com.octopuscommunity.octopusreactnativesdk.CLOSE_UI"
   }

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

@@ -0,0 +1,63 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import android.view.ViewGroup
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.captionBar
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.mandatorySystemGestures
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.foundation.layout.safeContent
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.safeGestures
+import androidx.compose.foundation.layout.statusBars
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.systemGestures
+import androidx.compose.foundation.layout.tappableElement
+import androidx.compose.foundation.layout.waterfall
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.ComposeView
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class OctopusUIViewManager(private val reactContext: ReactApplicationContext) :
+    SimpleViewManager<ComposeView>() {
+
+    private var interceptUrls: Boolean = false
+
+    override fun getName(): String = REACT_CLASS_NAME
+
+    override fun createViewInstance(reactContext: ThemedReactContext) =
+        ComposeView(reactContext).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+
+            setContent {
+                MaterialTheme {
+                    OctopusContent(
+                        modifier = Modifier.fillMaxSize()
+                            .consumeWindowInsets(WindowInsets.statusBars)
+                            .consumeWindowInsets(WindowInsets.navigationBars)
+                            .consumeWindowInsets(WindowInsets.systemBars),
+                        interceptUrls = interceptUrls
+                    )
+                }
+            }
+        }
+
+    @ReactProp(name = "interceptUrls")
+    fun setInterceptUrls(view: ComposeView, interceptUrls: Boolean) {
+        this.interceptUrls = interceptUrls
+    }
+
+    companion object Companion {
+        const val REACT_CLASS_NAME = "OctopusUIView"
+    }
+}

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

@@ -23,7 +23,7 @@ object ProfileFieldMapper {
     return when (fieldName) {
       "username" -> ProfileField.NICKNAME
       "biography" -> ProfileField.BIO
-      "profilePicture" -> ProfileField.AVATAR
+      "profilePicture" -> ProfileField.PICTURE
       else -> null
     }
   }
@@ -32,7 +32,7 @@ object ProfileFieldMapper {
     return when (profileField) {
       ProfileField.NICKNAME -> "username"
       ProfileField.BIO -> "biography"
-      ProfileField.AVATAR -> "profilePicture"
+      ProfileField.PICTURE -> "profilePicture"
       else -> null
     }
   }

package/ios/OctopusEventManager.swift

@@ -30,6 +30,33 @@ class OctopusEventManager {
     }
   }
   
+  func emitNotSeenNotificationsCountChanged(count: Int) {
+    if hasListeners {
+      let eventBody = ["count": count]
+      bridge?.eventDispatcher().sendAppEvent(withName: "notSeenNotificationsCountChanged", body: eventBody)
+    }
+  }
+  
+  func emitHasAccessToCommunityChanged(hasAccess: Bool) {
+    if hasListeners {
+      let eventBody = ["hasAccess": hasAccess]
+      bridge?.eventDispatcher().sendAppEvent(withName: "hasAccessToCommunityChanged", body: eventBody)
+    }
+  }
+  
+  func emitSDKEvent(eventData: [String: Any]) {
+    if hasListeners {
+      bridge?.eventDispatcher().sendAppEvent(withName: "sdkEvent", body: eventData)
+    }
+  }
+  
+  func emitNavigateToUrl(url: String) {
+    if hasListeners {
+      let eventBody = ["url": url]
+      bridge?.eventDispatcher().sendAppEvent(withName: "navigateToUrl", body: eventBody)
+    }
+  }
+  
   func startObserving() {
     hasListeners = true
   }

package/ios/OctopusEventSerializer.swift

@@ -0,0 +1,271 @@
+import Foundation
+import Octopus
+
+/**
+ * Serializes OctopusEvent objects to dictionaries for React Native bridge.
+ */
+class OctopusEventSerializer {
+  
+  static func serializeEvent(_ event: OctopusEvent) -> [String: Any]? {
+    switch event {
+    case .postCreated(let context):
+      var contentList: [String] = []
+      if context.content.contains(.text) { contentList.append("text") }
+      if context.content.contains(.image) { contentList.append("image") }
+      if context.content.contains(.poll) { contentList.append("poll") }
+      return [
+        "type": "postCreated",
+        "postId": context.postId,
+        "content": contentList,
+        "topicId": context.topicId,
+        "textLength": context.textLength
+      ]
+      
+    case .commentCreated(let context):
+      return [
+        "type": "commentCreated",
+        "commentId": context.commentId,
+        "postId": context.postId,
+        "textLength": context.textLength
+      ]
+      
+    case .replyCreated(let context):
+      return [
+        "type": "replyCreated",
+        "replyId": context.replyId,
+        "commentId": context.commentId,
+        "textLength": context.textLength
+      ]
+      
+    case .contentDeleted(let context):
+      return [
+        "type": "contentDeleted",
+        "contentId": context.contentId,
+        "contentKind": serializeContentKind(context.kind)
+      ]
+      
+    case .reactionModified(let context):
+      var data: [String: Any] = [
+        "type": "reactionModified",
+        "contentId": context.contentId,
+        "contentKind": serializeContentKind(context.contentKind)
+      ]
+      if let prev = context.previousReaction {
+        data["previousReaction"] = serializeReactionKind(prev)
+      }
+      if let next = context.newReaction {
+        data["newReaction"] = serializeReactionKind(next)
+      }
+      return data
+      
+    case .pollVoted(let context):
+      return [
+        "type": "pollVoted",
+        "contentId": context.contentId,
+        "optionId": context.optionId
+      ]
+      
+    case .contentReported(let context):
+      return [
+        "type": "contentReported",
+        "contentId": context.contentId,
+        "reasons": context.reasons.map { serializeReportReason($0) }
+      ]
+      
+    case .gamificationPointsGained(let context):
+      return [
+        "type": "gamificationPointsGained",
+        "points": context.pointsGained,
+        "action": serializeGamificationPointsGainedAction(context.action)
+      ]
+      
+    case .gamificationPointsRemoved(let context):
+      return [
+        "type": "gamificationPointsRemoved",
+        "points": context.pointsRemoved,
+        "action": serializeGamificationPointsRemovedAction(context.action)
+      ]
+      
+    case .screenDisplayed(let context):
+      return [
+        "type": "screenDisplayed",
+        "screen": serializeScreen(context.screen)
+      ]
+      
+    case .notificationClicked(let context):
+      var data: [String: Any] = [
+        "type": "notificationClicked",
+        "notificationId": context.notificationId
+      ]
+      if let contentId = context.contentId {
+        data["contentId"] = contentId
+      }
+      return data
+      
+    case .postClicked(let context):
+      return [
+        "type": "postClicked",
+        "postId": context.postId,
+        "source": serializePostClickedSource(context.source)
+      ]
+      
+    case .translationButtonClicked(let context):
+      return [
+        "type": "translationButtonClicked",
+        "contentId": context.contentId,
+        "viewTranslated": context.viewTranslated,
+        "contentKind": serializeContentKind(context.contentKind)
+      ]
+      
+    case .commentButtonClicked(let context):
+      return [
+        "type": "commentButtonClicked",
+        "postId": context.postId
+      ]
+      
+    case .replyButtonClicked(let context):
+      return [
+        "type": "replyButtonClicked",
+        "commentId": context.commentId
+      ]
+      
+    case .seeRepliesButtonClicked(let context):
+      return [
+        "type": "seeRepliesButtonClicked",
+        "commentId": context.commentId
+      ]
+      
+    case .profileModified(let context):
+      var data: [String: Any] = [
+        "type": "profileModified",
+        "nicknameUpdated": context.nickname.isUpdated,
+        "bioUpdated": context.bio.isUpdated,
+        "pictureUpdated": context.picture.isUpdated
+      ]
+      if case .updated(let bioContext) = context.bio {
+        data["bioLength"] = bioContext.bioLength
+      }
+      if case .updated(let pictureContext) = context.picture {
+        data["hasPicture"] = pictureContext.hasPicture
+      }
+      return data
+      
+    case .sessionStarted(let context):
+      return [
+        "type": "sessionStarted",
+        "sessionId": context.sessionId
+      ]
+      
+    case .sessionStopped(let context):
+      return [
+        "type": "sessionStopped",
+        "sessionId": context.sessionId
+      ]
+      
+    @unknown default:
+      return nil
+    }
+  }
+  
+  private static func serializeContentKind(_ kind: OctopusEvent.ContentKind) -> String {
+    switch kind {
+    case .post: return "post"
+    case .comment: return "comment"
+    case .reply: return "reply"
+    }
+  }
+  
+  private static func serializeReactionKind(_ kind: OctopusEvent.ReactionKind) -> String {
+    switch kind {
+    case .heart: return "heart"
+    case .joy: return "joy"
+    case .mouthOpen: return "mouthOpen"
+    case .clap: return "clap"
+    case .cry: return "cry"
+    case .rage: return "rage"
+    case .unknown: return "unknown"
+    }
+  }
+  
+  private static func serializeReportReason(_ reason: OctopusEvent.ReportReason) -> String {
+    switch reason {
+    case .hateSpeechOrDiscriminationOrHarassment: return "hateSpeech"
+    case .explicitOrInappropriateContent: return "explicit"
+    case .violenceAndTerrorism: return "violence"
+    case .spamAndScams: return "spam"
+    case .suicideAndSelfHarm: return "suicide"
+    case .fakeProfilesAndImpersonation: return "fakeProfile"
+    case .childExploitationOrAbuse: return "childExploitation"
+    case .intellectualPropertyViolation: return "intellectualProperty"
+    case .other: return "other"
+    }
+  }
+  
+  private static func serializeGamificationPointsGainedAction(_ action: OctopusEvent.GamificationPointsGainedAction) -> String {
+    switch action {
+    case .post: return "post"
+    case .comment: return "comment"
+    case .reply: return "reply"
+    case .reaction: return "reaction"
+    case .vote: return "vote"
+    case .postCommented: return "postCommented"
+    case .profileCompleted: return "profileCompleted"
+    case .dailySession: return "dailySession"
+    }
+  }
+  
+  private static func serializeGamificationPointsRemovedAction(_ action: OctopusEvent.GamificationPointsRemovedAction) -> String {
+    switch action {
+    case .postDeleted: return "postDeleted"
+    case .commentDeleted: return "commentDeleted"
+    case .replyDeleted: return "replyDeleted"
+    case .reactionDeleted: return "reactionDeleted"
+    }
+  }
+  
+  private static func serializePostClickedSource(_ source: OctopusEvent.PostClickedSource) -> String {
+    switch source {
+    case .feed: return "feed"
+    case .profile: return "profile"
+    }
+  }
+  
+  private static func serializeScreen(_ screen: OctopusEvent.Screen) -> [String: Any] {
+    switch screen {
+    case .postsFeed(let context):
+      var data: [String: Any] = ["type": "postsFeed", "feedId": context.feedId]
+      if let relatedTopicId = context.relatedTopicId {
+        data["relatedTopicId"] = relatedTopicId
+      }
+      return data
+    case .postDetail(let context):
+      return ["type": "postDetail", "postId": context.postId]
+    case .commentDetail(let context):
+      return ["type": "commentDetail", "commentId": context.commentId]
+    case .createPost:
+      return ["type": "createPost"]
+    case .profile:
+      return ["type": "profile"]
+    case .otherUserProfile(let context):
+      return ["type": "otherUserProfile", "profileId": context.profileId]
+    case .editProfile:
+      return ["type": "editProfile"]
+    case .reportContent:
+      return ["type": "reportContent"]
+    case .reportProfile:
+      return ["type": "reportProfile"]
+    case .validateNickname:
+      return ["type": "validateNickname"]
+    case .settingsList:
+      return ["type": "settingsList"]
+    case .settingsAccount:
+      return ["type": "settingsAccount"]
+    case .settingsAbout:
+      return ["type": "settingsAbout"]
+    case .reportExplanation:
+      return ["type": "reportExplanation"]
+    case .deleteAccount:
+      return ["type": "deleteAccount"]
+    }
+  }
+}

package/ios/OctopusReactNativeSdk.mm

@@ -6,9 +6,13 @@ RCT_EXTERN_METHOD(initialize:(NSDictionary *)options
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(openUI:(RCTPromiseResolveBlock)resolve
+RCT_EXTERN_METHOD(openUI:(NSDictionary *)options
+                  withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(handleUrlStrategy:(NSString *)url
+                  withStrategy:(NSString *)strategy)
+
 RCT_EXTERN_METHOD(closeUI:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
@@ -36,6 +40,27 @@ RCT_EXTERN_METHOD(updateTheme:(NSDictionary *)themeOptions
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(updateNotSeenNotificationsCount:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackCustomEvent:(NSString *)name
+                  withProperties:(NSDictionary *)properties
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(overrideDefaultLocale:(NSString *)languageCode
+                  withCountryCode:(NSString *)countryCode
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(overrideCommunityAccess:(BOOL)hasAccess
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackCommunityAccess:(BOOL)hasAccess
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(addListener:(NSString *)eventName)
 
 RCT_EXTERN_METHOD(removeListeners:(NSInteger)count)