@octopus-community/react-native 1.0.8 → 1.9.1

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

@@ -0,0 +1,339 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.octopuscommunity.sdk.domain.model.Gamification
+import com.octopuscommunity.sdk.domain.model.Moderation
+import com.octopuscommunity.sdk.domain.model.OctopusEvent
+import com.octopuscommunity.sdk.domain.model.OctopusItem
+
+/**
+ * Serializes OctopusEvent objects to WritableMap for React Native bridge.
+ */
+object OctopusEventSerializer {
+
+  fun serializeEvent(event: OctopusEvent): WritableMap? {
+    val map = Arguments.createMap()
+    
+    return when (event) {
+      is OctopusEvent.PostCreated -> {
+        val contentList = event.content.map { content ->
+          when (content) {
+            OctopusEvent.PostCreated.Content.TEXT -> "text"
+            OctopusEvent.PostCreated.Content.IMAGE -> "image"
+            OctopusEvent.PostCreated.Content.POLL -> "poll"
+          }
+        }
+        map.putString("type", "postCreated")
+        map.putString("postId", event.postId)
+        val contentArray = Arguments.createArray()
+        contentList.forEach { contentArray.pushString(it) }
+        map.putArray("content", contentArray)
+        map.putString("topicId", event.topicId)
+        map.putInt("textLength", event.textLength)
+        map
+      }
+
+      is OctopusEvent.CommentCreated -> {
+        map.putString("type", "commentCreated")
+        map.putString("commentId", event.commentId)
+        map.putString("postId", event.postId)
+        map.putInt("textLength", event.textLength)
+        map
+      }
+
+      is OctopusEvent.ReplyCreated -> {
+        map.putString("type", "replyCreated")
+        map.putString("replyId", event.replyId)
+        map.putString("commentId", event.commentId)
+        map.putInt("textLength", event.textLength)
+        map
+      }
+
+      is OctopusEvent.PostDeleted -> {
+        map.putString("type", "contentDeleted")
+        map.putString("contentId", event.contentId)
+        map.putString("contentKind", "post")
+        map
+      }
+
+      is OctopusEvent.CommentDeleted -> {
+        map.putString("type", "contentDeleted")
+        map.putString("contentId", event.contentId)
+        map.putString("contentKind", "comment")
+        map
+      }
+
+      is OctopusEvent.ReplyDeleted -> {
+        map.putString("type", "contentDeleted")
+        map.putString("contentId", event.contentId)
+        map.putString("contentKind", "reply")
+        map
+      }
+
+      is OctopusEvent.ReactionModified -> {
+        map.putString("type", "reactionModified")
+        map.putString("contentId", event.contentId)
+        map.putString("contentKind", serializeContentKind(event.contentKind))
+        event.previousReaction?.let {
+          map.putString("previousReaction", serializeReactionKind(it))
+        }
+        event.newReaction?.let {
+          map.putString("newReaction", serializeReactionKind(it))
+        }
+        map
+      }
+
+      is OctopusEvent.PollVote -> {
+        map.putString("type", "pollVoted")
+        map.putString("contentId", event.contentId)
+        map.putString("optionId", event.optionId)
+        map
+      }
+
+      is OctopusEvent.ContentReported -> {
+        map.putString("type", "contentReported")
+        map.putString("contentId", event.contentId)
+        val reasonsArray = Arguments.createArray()
+        event.reasons.forEach { reason ->
+          reasonsArray.pushString(serializeReportReason(reason))
+        }
+        map.putArray("reasons", reasonsArray)
+        map
+      }
+
+      is OctopusEvent.ProfileReported -> {
+        map.putString("type", "profileReported")
+        map.putString("profileId", event.profileId)
+        val reasonsArray = Arguments.createArray()
+        event.reasons.forEach { reason ->
+          reasonsArray.pushString(serializeReportReason(reason))
+        }
+        map.putArray("reasons", reasonsArray)
+        map
+      }
+
+      is OctopusEvent.GamificationPointsGained -> {
+        map.putString("type", "gamificationPointsGained")
+        map.putInt("points", event.points)
+        map.putString("action", serializeGamificationAction(event.action))
+        map
+      }
+
+      is OctopusEvent.GamificationPointsRemoved -> {
+        map.putString("type", "gamificationPointsRemoved")
+        map.putInt("points", event.points)
+        map.putString("action", serializeGamificationPointsRemovedAction(event.action))
+        map
+      }
+
+      is OctopusEvent.ScreenDisplayed -> {
+        map.putString("type", "screenDisplayed")
+        val screenMap = serializeScreen(event)
+        map.putMap("screen", screenMap)
+        map
+      }
+
+      is OctopusEvent.NotificationClicked -> {
+        map.putString("type", "notificationClicked")
+        map.putString("notificationId", event.notificationId)
+        event.contentId?.let {
+          map.putString("contentId", it)
+        }
+        map
+      }
+
+      is OctopusEvent.PostClicked -> {
+        map.putString("type", "postClicked")
+        map.putString("postId", event.postId)
+        map.putString("source", when (event.source) {
+          OctopusEvent.PostClicked.Source.FEED -> "feed"
+          OctopusEvent.PostClicked.Source.PROFILE -> "profile"
+        })
+        map
+      }
+
+      is OctopusEvent.TranslationButtonClicked -> {
+        map.putString("type", "translationButtonClicked")
+        map.putString("contentId", event.contentId)
+        map.putBoolean("viewTranslated", event.viewTranslated)
+        map.putString("contentKind", serializeContentKind(event.contentKind))
+        map
+      }
+
+      is OctopusEvent.CommentButtonClicked -> {
+        map.putString("type", "commentButtonClicked")
+        map.putString("postId", event.postId)
+        map
+      }
+
+      is OctopusEvent.ReplyButtonClicked -> {
+        map.putString("type", "replyButtonClicked")
+        map.putString("commentId", event.commentId)
+        map
+      }
+
+      is OctopusEvent.SeeRepliesButtonClicked -> {
+        map.putString("type", "seeRepliesButtonClicked")
+        map.putString("commentId", event.commentId)
+        map
+      }
+
+      is OctopusEvent.ProfileModified -> {
+        val prev = event.previousProfile
+        val new = event.newProfile
+        val nicknameUpdated = prev?.nickname != new.nickname
+        val bioUpdated = prev?.bio != new.bio
+        val pictureUpdated = prev?.picture != new.picture
+        
+        map.putString("type", "profileModified")
+        map.putBoolean("nicknameUpdated", nicknameUpdated)
+        map.putBoolean("bioUpdated", bioUpdated)
+        if (bioUpdated) {
+          new.bio?.length?.let { map.putInt("bioLength", it) }
+        }
+        map.putBoolean("pictureUpdated", pictureUpdated)
+        if (pictureUpdated) {
+          map.putBoolean("hasPicture", new.picture != null)
+        }
+        map
+      }
+
+      is OctopusEvent.SessionStarted -> {
+        map.putString("type", "sessionStarted")
+        map.putString("sessionId", event.sessionId)
+        map
+      }
+
+      is OctopusEvent.SessionStopped -> {
+        map.putString("type", "sessionStopped")
+        map.putString("sessionId", event.sessionId)
+        map
+      }
+
+      else -> null
+    }
+  }
+
+  private fun serializeContentKind(kind: OctopusItem.ContentKind): String {
+    return when (kind) {
+      OctopusItem.ContentKind.POST -> "post"
+      OctopusItem.ContentKind.COMMENT -> "comment"
+      OctopusItem.ContentKind.REPLY -> "reply"
+    }
+  }
+
+  private fun serializeReactionKind(kind: OctopusItem.Reaction.Kind): String {
+    return when (kind) {
+      is OctopusItem.Reaction.Kind.Heart -> "heart"
+      is OctopusItem.Reaction.Kind.Joy -> "joy"
+      is OctopusItem.Reaction.Kind.MouthOpen -> "mouthOpen"
+      is OctopusItem.Reaction.Kind.Clap -> "clap"
+      is OctopusItem.Reaction.Kind.Cry -> "cry"
+      is OctopusItem.Reaction.Kind.Rage -> "rage"
+      is OctopusItem.Reaction.Kind.Unknown -> "unknown"
+    }
+  }
+
+  private fun serializeReportReason(reason: Moderation.ReportReason): String {
+    return when (reason) {
+      is Moderation.ReportReason.HateSpeechOrDiscriminatoryContent -> "hateSpeech"
+      is Moderation.ReportReason.ExplicitOrInappropriateContent -> "explicit"
+      is Moderation.ReportReason.ViolenceAndTerrorism -> "violence"
+      is Moderation.ReportReason.SpamAndScams -> "spam"
+      is Moderation.ReportReason.SuicideAndSelfHarm -> "suicide"
+      is Moderation.ReportReason.FakeProfilesAndImpersonation -> "fakeProfile"
+      is Moderation.ReportReason.ChildExploitationOrAbuse -> "childExploitation"
+      is Moderation.ReportReason.IntellectualPropertyViolation -> "intellectualProperty"
+      is Moderation.ReportReason.Other -> "other"
+    }
+  }
+
+  private fun serializeGamificationAction(action: Gamification.Action): String {
+    return when (action) {
+      Gamification.Action.POST -> "post"
+      Gamification.Action.COMMENT -> "comment"
+      Gamification.Action.REPLY -> "reply"
+      Gamification.Action.REACTION -> "reaction"
+      Gamification.Action.VOTE -> "vote"
+      Gamification.Action.POST_COMMENTED -> "postCommented"
+      Gamification.Action.PROFILE_COMPLETED -> "profileCompleted"
+      Gamification.Action.DAILY_SESSION -> "dailySession"
+    }
+  }
+
+  private fun serializeGamificationPointsRemovedAction(action: Gamification.Action): String {
+    // In Android SDK, GamificationPointsRemoved uses the same enum values as GamificationPointsGained,
+    // but the context (removed vs gained) determines the meaning.
+    // Map the action values to their "removed" equivalents
+    return when (action) {
+      Gamification.Action.POST -> "postDeleted"
+      Gamification.Action.COMMENT -> "commentDeleted"
+      Gamification.Action.REPLY -> "replyDeleted"
+      Gamification.Action.REACTION -> "reactionDeleted"
+      // For other actions, use the regular serialization (shouldn't happen for removed events)
+      else -> serializeGamificationAction(action)
+    }
+  }
+
+  private fun serializeScreen(event: OctopusEvent.ScreenDisplayed): WritableMap {
+    val screenMap = Arguments.createMap()
+    
+    when (event) {
+      is OctopusEvent.ScreenDisplayed.PostsFeed -> {
+        screenMap.putString("type", "postsFeed")
+        screenMap.putString("feedId", event.feedId)
+        event.relatedTopicId?.let {
+          screenMap.putString("relatedTopicId", it)
+        }
+      }
+      is OctopusEvent.ScreenDisplayed.PostDetail -> {
+        screenMap.putString("type", "postDetail")
+        screenMap.putString("postId", event.postId)
+      }
+      is OctopusEvent.ScreenDisplayed.CommentDetail -> {
+        screenMap.putString("type", "commentDetail")
+        screenMap.putString("commentId", event.commentId)
+      }
+      is OctopusEvent.ScreenDisplayed.CreatePost -> {
+        screenMap.putString("type", "createPost")
+      }
+      is OctopusEvent.ScreenDisplayed.Profile -> {
+        screenMap.putString("type", "profile")
+      }
+      is OctopusEvent.ScreenDisplayed.OtherUserProfile -> {
+        screenMap.putString("type", "otherUserProfile")
+        screenMap.putString("profileId", event.profileId)
+      }
+      is OctopusEvent.ScreenDisplayed.EditProfile -> {
+        screenMap.putString("type", "editProfile")
+      }
+      is OctopusEvent.ScreenDisplayed.ReportContent -> {
+        screenMap.putString("type", "reportContent")
+      }
+      is OctopusEvent.ScreenDisplayed.ReportProfile -> {
+        screenMap.putString("type", "reportProfile")
+      }
+      is OctopusEvent.ScreenDisplayed.ValidateNickname -> {
+        screenMap.putString("type", "validateNickname")
+      }
+      is OctopusEvent.ScreenDisplayed.SettingsList -> {
+        screenMap.putString("type", "settingsList")
+      }
+      is OctopusEvent.ScreenDisplayed.SettingsAccount -> {
+        screenMap.putString("type", "settingsAccount")
+      }
+      is OctopusEvent.ScreenDisplayed.SettingsAbout -> {
+        screenMap.putString("type", "settingsAbout")
+      }
+      is OctopusEvent.ScreenDisplayed.ReportExplanation -> {
+        screenMap.putString("type", "reportExplanation")
+      }
+      is OctopusEvent.ScreenDisplayed.DeleteAccount -> {
+        screenMap.putString("type", "deleteAccount")
+      }
+    }
+    
+    return screenMap
+  }
+}

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

@@ -0,0 +1,326 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.octopuscommunity.sdk.OctopusSDK
+import com.octopuscommunity.sdk.domain.model.TrackerEvent
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class OctopusReactModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val sdkInitializer = OctopusSDKInitializer()
+  private val eventEmitter = OctopusEventEmitter(reactContext)
+  private val uiController = OctopusUIController(reactContext)
+  private val ssoAuthenticator = OctopusSSOAuthenticator(reactContext, eventEmitter)
+  private val coroutineScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+  private var notSeenNotificationsJob: Job? = null
+  private var hasAccessToCommunityJob: Job? = null
+  private var eventsJob: Job? = null
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun initialize(options: ReadableMap, promise: Promise) {
+    val success = sdkInitializer.initialize(reactApplicationContext, options, promise)
+    // Start observing reactive events after SDK initialization succeeds
+    if (success) {
+      startObservingReactiveEvents()
+    }
+  }
+
+  @ReactMethod
+  fun openUI(options: ReadableMap?, promise: Promise) {
+    uiController.openUI(options, promise)
+  }
+
+  @ReactMethod
+  fun handleUrlStrategy(url: String, strategy: String) {
+    if (strategy == "handledByOctopus") {
+      uiController.openUrlInBrowser(url)
+    }
+  }
+
+  @ReactMethod
+  fun closeUI(promise: Promise) {
+    uiController.closeUI(promise)
+  }
+
+  @ReactMethod
+  fun connectUser(params: ReadableMap, promise: Promise) {
+    ssoAuthenticator.connectUser(params, promise)
+  }
+
+  @ReactMethod
+  fun disconnectUser(promise: Promise) {
+    ssoAuthenticator.disconnectUser(promise)
+  }
+
+  @ReactMethod
+  fun completeUserTokenRequest(requestId: String, token: String, promise: Promise) {
+    ssoAuthenticator.completeTokenRequest(requestId, token)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun cancelUserTokenRequest(requestId: String, promise: Promise) {
+    ssoAuthenticator.cancelTokenRequest(requestId)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    eventEmitter.addListener(eventName)
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    eventEmitter.removeListeners(count)
+  }
+
+  @ReactMethod
+  fun updateColorScheme(colorScheme: String?, promise: Promise) {
+    // Update the theme config with the new color scheme
+    val currentThemeConfig = OctopusThemeManager.getThemeConfig()
+    if (currentThemeConfig != null) {
+      val updatedThemeConfig = currentThemeConfig.copy(colorScheme = colorScheme)
+      OctopusThemeManager.setThemeConfig(updatedThemeConfig)
+    }
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun updateTheme(themeOptions: ReadableMap, promise: Promise) {
+    try {
+      // Parse theme using the standard initializer
+      val themeConfig = sdkInitializer.parseThemeConfig(themeOptions)
+      OctopusThemeManager.setThemeConfig(themeConfig)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("UPDATE_THEME_ERROR", "Failed to update theme", e)
+    }
+  }
+
+  @ReactMethod
+  fun updateNotSeenNotificationsCount(promise: Promise) {
+    coroutineScope.launch {
+      try {
+        OctopusSDK.updateNotSeenNotificationsCount()
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("UPDATE_ERROR", e.message ?: "Failed to update notification count", e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun trackCustomEvent(name: String, properties: ReadableMap?, promise: Promise) {
+    val trimmedName = name.trim()
+    if (trimmedName.isEmpty()) {
+      promise.reject("INVALID_ARGS", "name is required and must be non-empty", null)
+      return
+    }
+    val propsMap = readableMapToStringMap(properties)
+    coroutineScope.launch {
+      try {
+        OctopusSDK.track(
+          TrackerEvent.Custom(
+            name = trimmedName,
+            properties = propsMap.mapValues { TrackerEvent.Custom.Property(it.value) }
+          )
+        )
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("TRACK_ERROR", e.message ?: "Failed to track custom event", e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun overrideDefaultLocale(
+    languageCode: String?,
+    countryCode: String?,
+    promise: Promise
+  ) {
+    coroutineScope.launch {
+      try {
+        val locale = when {
+          languageCode != null && countryCode != null ->
+            java.util.Locale(languageCode, countryCode)
+          languageCode != null -> java.util.Locale(languageCode)
+          else -> null
+        }
+        OctopusSDK.overrideDefaultLocale(locale)
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          "LOCALE_ERROR",
+          e.message ?: "Failed to override default locale",
+          e
+        )
+      }
+    }
+  }
+
+  @ReactMethod
+  fun overrideCommunityAccess(hasAccess: Boolean, promise: Promise) {
+    coroutineScope.launch {
+      try {
+        OctopusSDK.overrideCommunityAccess(hasAccess)
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          "OVERRIDE_ERROR",
+          e.message ?: "Failed to override community access",
+          e
+        )
+      }
+    }
+  }
+
+  /**
+   * Tracks community access for analytics only. Does not change the actual access.
+   * Use when the app manages its own A/B logic and only needs to report the value.
+   */
+  @ReactMethod
+  fun trackCommunityAccess(hasAccess: Boolean, promise: Promise) {
+    try {
+      OctopusSDK.trackAccessToCommunity(hasAccess)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject(
+        "TRACK_ACCESS_ERROR",
+        e.message ?: "Failed to track community access",
+        e
+      )
+    }
+  }
+
+  /**
+   * Converts a ReadableMap to a Map<String, String>. Only string values are included;
+   * other types are skipped so that the result is valid for TrackerEvent.Custom properties.
+   */
+  private fun readableMapToStringMap(map: ReadableMap?): Map<String, String> {
+    if (map == null) return emptyMap()
+    val result = mutableMapOf<String, String>()
+    val iterator = map.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      if (map.getType(key) == ReadableType.String) {
+        map.getString(key)?.let { value -> result[key] = value }
+      }
+    }
+    return result
+  }
+
+  private fun parseColor(colorString: String?): String? {
+    if (colorString == null) return null
+
+    return try {
+      // Validate that the color string is a valid hex color
+      android.graphics.Color.parseColor(colorString)
+      // Return the original string if parsing succeeds
+      colorString
+    } catch (e: IllegalArgumentException) {
+      // Invalid color format - return null to skip this color
+      null
+    }
+  }
+
+  private fun parseFontsConfig(fontsMap: ReadableMap): OctopusFontsConfig? {
+    // Use pre-processed configuration from TypeScript layer
+    val parsedConfig = fontsMap.getMap("parsedConfig")
+    if (parsedConfig != null) {
+      return parsePreProcessedFontsConfig(parsedConfig)
+    }
+
+    return null
+  }
+
+  private fun parsePreProcessedFontsConfig(parsedConfig: ReadableMap): OctopusFontsConfig? {
+    val textStylesMap = parsedConfig.getMap("textStyles")
+    val textStyles = mutableMapOf<String, OctopusTextStyleConfig>()
+
+    // Parse pre-processed font configuration from TypeScript layer
+    textStylesMap?.let { textStylesMap ->
+      val textStyleKeys = arrayOf("title1", "title2", "body1", "body2", "caption1", "caption2")
+
+      textStyleKeys.forEach { key ->
+        val textStyleMap = textStylesMap.getMap(key)
+        textStyleMap?.let { style ->
+          val fontType = style.getString("fontType")
+          val fontSize = if (style.hasKey("fontSize")) style.getDouble("fontSize") else Double.NaN
+
+          if (fontType != null || (!fontSize.isNaN() && fontSize > 0)) {
+            textStyles[key] = OctopusTextStyleConfig(
+              fontType = fontType,
+              fontSize = if (fontSize.isNaN() || fontSize <= 0) null else fontSize
+            )
+          }
+        }
+      }
+    }
+
+    // Only create fonts config if we have text styles
+    if (textStyles.isNotEmpty()) {
+      return OctopusFontsConfig(
+        textStyles = textStyles
+      )
+    }
+
+    return null
+  }
+
+  private fun startObservingReactiveEvents() {
+    startNotSeenNotificationsCollection()
+    startHasAccessToCommunityCollection()
+    startEventsCollection()
+  }
+
+  private fun startNotSeenNotificationsCollection() {
+    notSeenNotificationsJob?.cancel()
+    notSeenNotificationsJob = coroutineScope.launch {
+      OctopusSDK.notSeenNotificationsCount.collect { count ->
+        eventEmitter.emitNotSeenNotificationsCountChanged(count)
+      }
+    }
+  }
+
+  private fun startHasAccessToCommunityCollection() {
+    hasAccessToCommunityJob?.cancel()
+    hasAccessToCommunityJob = coroutineScope.launch {
+      OctopusSDK.hasAccessToCommunity.collect { hasAccess ->
+        eventEmitter.emitHasAccessToCommunityChanged(hasAccess)
+      }
+    }
+  }
+
+  private fun startEventsCollection() {
+    eventsJob?.cancel()
+    eventsJob = coroutineScope.launch {
+      OctopusSDK.events.collect { event ->
+        val eventData = OctopusEventSerializer.serializeEvent(event)
+        if (eventData != null) {
+          eventEmitter.emitSDKEvent(eventData)
+        }
+      }
+    }
+  }
+
+
+  companion object {
+    const val NAME = "OctopusReactNativeSdk"
+  }
+
+  init {
+    OctopusEventEmitter.instance = eventEmitter
+  }
+}

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/{OctopusReactNativeSdkPackage.kt → OctopusReactPackage.kt}

@@ -6,12 +6,12 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 
-class OctopusReactNativeSdkPackage : ReactPackage {
+class OctopusReactPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(OctopusReactNativeSdkModule(reactContext))
+    return listOf(OctopusReactModule(reactContext))
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+    return listOf(OctopusUIViewManager(reactContext))
   }
 }