@upscopeio/react-native-sdk 2026.3.0

package/README.md

@@ -0,0 +1,291 @@
+# @upscopeio/react-native-sdk
+
+React Native SDK for Upscope cobrowsing — screen sharing, agent annotations, and remote control for iOS and Android.
+
+## Requirements
+
+- React Native 0.76+
+- iOS 14+
+- Android API 26+ (Android 8.0 Oreo)
+- New Architecture (Fabric + TurboModules) required
+
+## Installation
+
+```bash
+npm install @upscopeio/react-native-sdk
+```
+
+### iOS
+
+1. **Add UpscopeSDK via SPM** — In Xcode, go to your project > Package Dependencies > `+` and add:
+   ```
+   https://github.com/upscopeio/cobrowsing-ios
+   ```
+   Set version to `~> 1.0`.
+
+2. **Install pods** (for the RN bridge module):
+   ```bash
+   cd ios && pod install
+   ```
+
+### Android
+
+No extra steps — the native module and Upscope Android SDK are linked automatically via autolinking.
+
+## Quick Start
+
+Initialize in your app entry point (before rendering any components that use Upscope hooks):
+
+```tsx
+import Upscope from '@upscopeio/react-native-sdk';
+
+// App.tsx — call once, as early as possible
+Upscope.initialize({
+  apiKey: 'your-api-key',
+  autoConnect: true,
+  requireAuthorizationForSession: true,
+});
+
+// Identify the visitor
+Upscope.updateConnection({
+  uniqueId: 'user-123',
+  callName: 'Jane Doe',
+  tags: ['support'],
+  identities: ['jane@example.com'],
+  metadata: { plan: 'premium' },
+});
+```
+
+If `autoConnect` is `false`, call `Upscope.connect()` manually after initialization.
+
+## Hooks
+
+All hooks are reactive — they re-render the component when the underlying state changes.
+
+### `useConnectionState`
+
+Returns the current WebSocket connection state.
+
+```tsx
+import { useConnectionState } from '@upscopeio/react-native-sdk';
+
+function StatusBadge() {
+  const state = useConnectionState();
+  // state: 'inactive' | 'connecting' | 'connected' | 'reconnecting' | 'error'
+  return <Text>Connection: {state}</Text>;
+}
+```
+
+### `useSessionState`
+
+Returns the current co-browsing session state.
+
+```tsx
+import { useSessionState } from '@upscopeio/react-native-sdk';
+
+function SessionBanner() {
+  const session = useSessionState();
+  // session: 'inactive' | 'pendingRequest' | 'active' | 'paused' | 'ended'
+  if (session !== 'active') return null;
+  return <Text>Session in progress</Text>;
+}
+```
+
+### `useShortId`
+
+Returns the SDK short ID (used to look up the visitor in the Upscope dashboard), or `null` until assigned.
+
+```tsx
+import { useShortId } from '@upscopeio/react-native-sdk';
+
+function VisitorId() {
+  const shortId = useShortId();
+  return <Text>Short ID: {shortId ?? 'pending...'}</Text>;
+}
+```
+
+### `useLookupCode`
+
+Returns the current lookup code shown to the visitor for phone-based agent lookup, or `null` until emitted.
+
+```tsx
+import { useLookupCode } from '@upscopeio/react-native-sdk';
+
+function LookupCode() {
+  const code = useLookupCode();
+  return <Text>Your code: {code ?? '—'}</Text>;
+}
+```
+
+### `useUpscope`
+
+Returns a stable object of imperative action methods — safe to destructure and pass as deps.
+
+```tsx
+import { useUpscope } from '@upscopeio/react-native-sdk';
+
+function Controls() {
+  const { connect, disconnect, stopSession, sendCustomMessage } = useUpscope();
+  return (
+    <>
+      <Button title="Connect" onPress={connect} />
+      <Button title="Disconnect" onPress={disconnect} />
+      <Button title="End Session" onPress={stopSession} />
+    </>
+  );
+}
+```
+
+## Events
+
+Subscribe to native events imperatively via `Upscope.addListener`. Always call `.remove()` on cleanup.
+
+```tsx
+import Upscope from '@upscopeio/react-native-sdk';
+import { useEffect } from 'react';
+
+useEffect(() => {
+  const sub = Upscope.addListener('sessionStarted', ({ agentName }) => {
+    console.log(`Session started with ${agentName}`);
+  });
+  return () => sub.remove();
+}, []);
+```
+
+### Event names
+
+| Event name                | Payload type                  | Description                              |
+| ------------------------- | ----------------------------- | ---------------------------------------- |
+| `connectionStateChanged`  | `ConnectionStateChangedEvent` | Connection state transitioned            |
+| `sessionStarted`          | `SessionStartedEvent`         | Agent joined and session is active       |
+| `sessionEnded`            | `SessionEndedEvent`           | Session ended (includes reason)          |
+| `customMessageReceived`   | `CustomMessageEvent`          | Arbitrary string from an observer        |
+| `error`                   | `UpscopeError`                | Non-fatal SDK error                      |
+| `observerJoined`          | `Observer`                    | New observer connected                   |
+| `observerLeft`            | `ObserverLeftEvent`           | Observer disconnected                    |
+| `observerCountChanged`    | `ObserverCountChangedEvent`   | Total observer count changed             |
+| `shortIdChanged`          | `ShortIdChangedEvent`         | Short ID assigned or rotated             |
+| `lookupCodeChanged`       | `LookupCodeChangedEvent`      | Lookup code issued or changed            |
+
+## View Masking
+
+Wrap any sensitive content in `UpscopeMasked` to hide it from the agent's view during a session. The masked region appears as a solid block in the screen share.
+
+```tsx
+import { UpscopeMasked } from '@upscopeio/react-native-sdk';
+
+function PaymentForm() {
+  return (
+    <View>
+      <Text>Card number</Text>
+      <UpscopeMasked>
+        <TextInput secureTextEntry placeholder="•••• •••• •••• ••••" />
+      </UpscopeMasked>
+    </View>
+  );
+}
+```
+
+`UpscopeMasked` accepts all standard `ViewProps` in addition to `children`.
+
+## Configuration
+
+Pass a `UpscopeConfig` object to `Upscope.initialize()`:
+
+```ts
+interface UpscopeConfig {
+  apiKey: string;                        // Required. Your Upscope API key.
+  requireAuthorizationForSession?: boolean; // Show a prompt before allowing a session. Default: true.
+  autoConnect?: boolean;                 // Connect on initialize(). Default: false.
+  region?: string;                       // Override the server region.
+  showBanner?: boolean;                  // Show the native in-session banner.
+  showTerminateButton?: boolean;         // Show an end-session button in the banner.
+  authorizationPromptTitle?: string;     // Custom title for the session request dialog.
+  authorizationPromptMessage?: string;   // Custom message for the session request dialog.
+  endOfSessionMessage?: string;          // Message shown when a session ends.
+  stopSessionText?: string;              // Label for the terminate-session button.
+  allowRemoteClick?: boolean;            // Allow agent to send tap events. Default: true.
+  allowRemoteScroll?: boolean;           // Allow agent to send scroll events. Default: true.
+  requireControlRequest?: boolean;       // Require visitor approval before remote control starts.
+}
+```
+
+## API Reference
+
+### Initialization
+
+| Method                              | Description                                         |
+| ----------------------------------- | --------------------------------------------------- |
+| `initialize(config)`                | Initialize the SDK. Call once before everything else. |
+| `connect()`                         | Open the WebSocket connection.                      |
+| `disconnect()`                      | Close the WebSocket connection.                     |
+| `reset(reconnect?)`                 | Reset connection state. Reconnects by default.      |
+
+### Visitor Identity
+
+| Method                              | Description                                         |
+| ----------------------------------- | --------------------------------------------------- |
+| `updateConnection(params)`          | Set/update `uniqueId`, `callName`, `tags`, `identities`, `metadata`. |
+
+### Session
+
+| Method                              | Description                                         |
+| ----------------------------------- | --------------------------------------------------- |
+| `stopSession()`                     | Terminate the active session.                       |
+| `requestAgent()`                    | Request that an agent join.                         |
+| `cancelAgentRequest()`              | Cancel a pending agent-join request.                |
+
+### Data
+
+| Method                              | Returns              | Description                           |
+| ----------------------------------- | -------------------- | ------------------------------------- |
+| `getShortId()`                      | `Promise<string \| null>` | Resolve the current short ID.    |
+| `getWatchLink()`                    | `Promise<string \| null>` | Resolve the session watch link.  |
+| `getLookupCode()`                   | `void`               | Trigger a `lookupCodeChanged` event.  |
+
+### Messaging
+
+| Method                              | Description                                         |
+| ----------------------------------- | --------------------------------------------------- |
+| `sendCustomMessage(message)`        | Send a string to all connected observers.           |
+
+### Events
+
+| Method                              | Description                                         |
+| ----------------------------------- | --------------------------------------------------- |
+| `addListener(eventName, callback)`  | Subscribe to an event. Returns `{ remove() }`.     |
+
+## Example App
+
+A full-featured example app is included in `example/`. It demonstrates initialization, connection, visitor identification, view masking, and event logging.
+
+### Running the example
+
+```bash
+# Install dependencies
+cd example
+npm install
+
+# iOS
+cd ios && pod install && cd ..
+npm run ios
+
+# Android
+npm run android
+```
+
+The app prompts for an API key on launch, then shows all SDK features in a scrollable demo screen.
+
+## Troubleshooting
+
+**"SDK not initialized"** — `Upscope.initialize()` must be called before `connect()` or any hook mounts.
+
+**Session prompt never appears** — Ensure `requireAuthorizationForSession: true` (default). On Android, the app must be in the foreground.
+
+**Masked views visible to agent** — `UpscopeMasked` must be a direct native view wrapper. Confirm autolinking ran and `pod install` completed on iOS.
+
+**TypeScript errors on event payloads** — Import the specific payload type from `@upscopeio/react-native-sdk`, e.g. `import type { SessionStartedEvent } from '@upscopeio/react-native-sdk'`.
+
+## License
+
+MIT

package/android/build.gradle.kts

@@ -0,0 +1,36 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+    id("com.facebook.react")
+}
+
+android {
+    namespace = "io.upscope.reactnative"
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 26
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlin {
+        compilerOptions {
+            jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
+        }
+    }
+
+    sourceSets {
+        named("main") {
+            java.srcDirs("src/main/kotlin")
+        }
+    }
+}
+
+dependencies {
+    implementation("com.facebook.react:react-android")
+    implementation("io.github.upscopeio:upscope-android-sdk:2026.3.6")
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/kotlin/io/upscope/reactnative/UpscopeMaskedViewManager.kt

@@ -0,0 +1,31 @@
+package io.upscope.reactnative
+
+import android.widget.FrameLayout
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import io.upscope.sdk.Upscope
+
+@ReactModule(name = UpscopeMaskedViewManager.NAME)
+class UpscopeMaskedViewManager : ViewGroupManager<FrameLayout>() {
+
+    companion object {
+        const val NAME = "UpscopeMaskedView"
+    }
+
+    override fun getName(): String = NAME
+
+    override fun createViewInstance(reactContext: ThemedReactContext): FrameLayout {
+        val view = FrameLayout(reactContext)
+        view.addOnAttachStateChangeListener(object : android.view.View.OnAttachStateChangeListener {
+            override fun onViewAttachedToWindow(v: android.view.View) {
+                Upscope.addMaskedView(v)
+            }
+
+            override fun onViewDetachedFromWindow(v: android.view.View) {
+                Upscope.removeMaskedView(v)
+            }
+        })
+        return view
+    }
+}

package/android/src/main/kotlin/io/upscope/reactnative/UpscopeModule.kt

@@ -0,0 +1,297 @@
+package io.upscope.reactnative
+
+import android.app.AlertDialog
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.upscope.sdk.Cancellable
+import io.upscope.sdk.ConnectionState
+import io.upscope.sdk.Observer
+import io.upscope.sdk.SessionEndReason
+import io.upscope.sdk.SessionRequestResponse
+import io.upscope.sdk.Upscope
+import io.upscope.sdk.UpscopeConfiguration
+import io.upscope.sdk.UpscopeError
+import io.upscope.sdk.UpscopeListener
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+
+@ReactModule(name = UpscopeModule.NAME)
+class UpscopeModule(
+    private val reactContext: ReactApplicationContext
+) : NativeUpscopeModuleSpec(reactContext) {
+
+    companion object {
+        const val NAME = "UpscopeModule"
+    }
+
+    override fun getName(): String = NAME
+
+    private var listenerCount = 0
+    private var shortIdJob: Job? = null
+    private var lookupCodeJob: Job? = null
+
+    private val upscopeListener = object : UpscopeListener {
+        override fun onConnectionStateChanged(state: ConnectionState) {
+            val params = Arguments.createMap().apply {
+                putString("state", serializeConnectionState(state))
+                if (state is ConnectionState.Error) {
+                    putMap("error", serializeError(state.error))
+                }
+            }
+            sendEvent("connectionStateChanged", params)
+        }
+
+        override fun onSessionStarted(agentName: String?) {
+            val params = Arguments.createMap().apply {
+                putString("agentName", agentName)
+            }
+            sendEvent("sessionStarted", params)
+        }
+
+        override fun onSessionEnded(reason: SessionEndReason) {
+            val params = Arguments.createMap().apply {
+                putString("reason", serializeEndReason(reason))
+                if (reason is SessionEndReason.Error) {
+                    putMap("error", serializeError(reason.error))
+                }
+            }
+            sendEvent("sessionEnded", params)
+        }
+
+        override fun onCustomMessageReceived(message: String, observerId: String) {
+            val params = Arguments.createMap().apply {
+                putString("message", message)
+                putString("observerId", observerId)
+            }
+            sendEvent("customMessageReceived", params)
+        }
+
+        override fun onError(error: UpscopeError) {
+            sendEvent("error", serializeError(error))
+        }
+
+        override fun onObserverJoined(observer: Observer) {
+            sendEvent("observerJoined", serializeObserver(observer))
+        }
+
+        override fun onObserverLeft(observerId: String) {
+            val params = Arguments.createMap().apply {
+                putString("observerId", observerId)
+            }
+            sendEvent("observerLeft", params)
+        }
+
+        override fun onObserverCountChanged(count: Int) {
+            val params = Arguments.createMap().apply {
+                putInt("count", count)
+            }
+            sendEvent("observerCountChanged", params)
+        }
+    }
+
+    override fun initialize(config: ReadableMap) {
+        val apiKey = config.getString("apiKey")
+            ?: throw IllegalArgumentException("apiKey is required")
+
+        val builder = UpscopeConfiguration.Builder(apiKey)
+            .wrapper("react-native")
+
+        if (config.hasKey("requireAuthorizationForSession")) {
+            builder.requireAuthorizationForSession(config.getBoolean("requireAuthorizationForSession"))
+        }
+        if (config.hasKey("autoConnect")) {
+            builder.autoConnect(config.getBoolean("autoConnect"))
+        }
+        if (config.hasKey("region")) {
+            builder.region(checkNotNull(config.getString("region")))
+        }
+        if (config.hasKey("showTerminateButton")) {
+            builder.showTerminateButton(config.getBoolean("showTerminateButton"))
+        }
+        if (config.hasKey("authorizationPromptTitle")) {
+            builder.authorizationPromptTitle(
+                checkNotNull(config.getString("authorizationPromptTitle"))
+            )
+        }
+        if (config.hasKey("authorizationPromptMessage")) {
+            builder.authorizationPromptMessage(
+                checkNotNull(config.getString("authorizationPromptMessage"))
+            )
+        }
+        if (config.hasKey("endOfSessionMessage")) {
+            builder.endOfSessionMessage(checkNotNull(config.getString("endOfSessionMessage")))
+        }
+        if (config.hasKey("stopSessionText")) {
+            builder.stopSessionText(checkNotNull(config.getString("stopSessionText")))
+        }
+        if (config.hasKey("allowRemoteClick")) {
+            builder.allowRemoteClick(config.getBoolean("allowRemoteClick"))
+        }
+        if (config.hasKey("allowRemoteScroll")) {
+            builder.allowRemoteScroll(config.getBoolean("allowRemoteScroll"))
+        }
+        if (config.hasKey("requireControlRequest")) {
+            builder.requireControlRequest(config.getBoolean("requireControlRequest"))
+        }
+
+        val promptTitle = config.getString("authorizationPromptTitle") ?: "Screen Sharing Request"
+        val promptMessage = config.getString("authorizationPromptMessage")
+            ?: "An agent wants to view your screen. Do you accept?"
+        val yesLabel = config.getString("translationYes") ?: "Yes"
+        val noLabel = config.getString("translationNo") ?: "No"
+
+        builder.onSessionRequest { response: SessionRequestResponse, agentName: String? ->
+            val activity = reactContext.currentActivity
+            if (activity == null) {
+                response.reject()
+                return@onSessionRequest null
+            }
+
+            val appLabel = activity.packageManager
+                .getApplicationLabel(activity.applicationInfo)
+                .toString()
+
+            fun String.fillTemplates() = this
+                .replace("{%agentName%}", agentName ?: "")
+                .replace("{%currentDomain%}", appLabel)
+
+            val dialog = AlertDialog.Builder(activity)
+                .setTitle(promptTitle.fillTemplates())
+                .setMessage(promptMessage.fillTemplates())
+                .setCancelable(false)
+                .setPositiveButton(yesLabel) { _, _ -> response.accept() }
+                .setNegativeButton(noLabel) { _, _ -> response.reject() }
+                .create()
+
+            dialog.show()
+            Cancellable { dialog.dismiss() }
+        }
+
+        val configuration = builder.build()
+        com.facebook.react.bridge.UiThreadUtil.runOnUiThread {
+            Upscope.initialize(reactContext.applicationContext, configuration)
+            Upscope.listener = upscopeListener
+            reactContext.currentActivity?.let { Upscope.setCurrentActivity(it) }
+        }
+    }
+
+    override fun connect() { Upscope.connect() }
+
+    override fun disconnect() { Upscope.disconnect() }
+
+    override fun reset(reconnect: Boolean) { Upscope.reset(reconnect) }
+
+    override fun updateConnection(params: ReadableMap) {
+        Upscope.updateConnection(
+            uniqueId = if (params.hasKey("uniqueId")) params.getString("uniqueId") else null,
+            callName = if (params.hasKey("callName")) params.getString("callName") else null,
+            tags = if (params.hasKey("tags")) params.getArray("tags")?.toArrayList()?.filterIsInstance<String>() else null,
+            identities = if (params.hasKey("identities")) params.getArray("identities")?.toArrayList()?.filterIsInstance<String>() else null,
+            metadata = if (params.hasKey("metadata")) {
+                val map = params.getMap("metadata")
+                val result = mutableMapOf<String, String>()
+                map?.entryIterator?.forEach { entry ->
+                    result[entry.key] = entry.value.toString()
+                }
+                result
+            } else null
+        )
+    }
+
+    override fun stopSession() { Upscope.stopSession() }
+
+    override fun requestAgent() { Upscope.requestAgent() }
+
+    override fun cancelAgentRequest() { Upscope.cancelAgentRequest() }
+
+    override fun getLookupCode() { Upscope.getLookupCode() }
+
+    override fun getShortId(promise: Promise) { promise.resolve(Upscope.getShortId()) }
+
+    override fun getWatchLink(promise: Promise) { promise.resolve(Upscope.getWatchLink()) }
+
+    override fun sendCustomMessage(message: String) { Upscope.sendCustomMessage(message) }
+
+    /**
+     * Called by RN when the JS side adds an event listener. Starts collecting Flow emissions
+     * for shortId and lookupCode on the first listener so we only run these coroutines when
+     * something is actually subscribed.
+     */
+    override fun addListener(eventName: String) {
+        listenerCount++
+        if (listenerCount == 1) {
+            val scope = CoroutineScope(Dispatchers.Main)
+            shortIdJob = scope.launch {
+                Upscope.shortIdFlow.collect { shortId ->
+                    val p = Arguments.createMap().apply { putString("shortId", shortId) }
+                    sendEvent("shortIdChanged", p)
+                }
+            }
+            lookupCodeJob = scope.launch {
+                Upscope.lookupCodeFlow.collect { code ->
+                    val p = Arguments.createMap().apply { putString("lookupCode", code) }
+                    sendEvent("lookupCodeChanged", p)
+                }
+            }
+        }
+    }
+
+    /**
+     * Called by RN when JS listeners are removed. Cancels Flow collection jobs when the
+     * subscriber count drops to zero to avoid unnecessary work.
+     */
+    override fun removeListeners(count: Double) {
+        listenerCount -= count.toInt()
+        if (listenerCount <= 0) {
+            listenerCount = 0
+            shortIdJob?.cancel()
+            lookupCodeJob?.cancel()
+            shortIdJob = null
+            lookupCodeJob = null
+        }
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        if (listenerCount <= 0) return
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    private fun serializeConnectionState(state: ConnectionState): String = when (state) {
+        is ConnectionState.Inactive -> "inactive"
+        is ConnectionState.Connecting -> "connecting"
+        is ConnectionState.Connected -> "connected"
+        is ConnectionState.Reconnecting -> "reconnecting"
+        is ConnectionState.Error -> "error"
+    }
+
+    private fun serializeEndReason(reason: SessionEndReason): String = when (reason) {
+        is SessionEndReason.UserStopped -> "userStopped"
+        is SessionEndReason.AgentStopped -> "agentStopped"
+        is SessionEndReason.Timeout -> "timeout"
+        is SessionEndReason.Error -> "error"
+    }
+
+    private fun serializeError(error: UpscopeError): WritableMap = Arguments.createMap().apply {
+        putString("code", error.code)
+        putString("message", error.message)
+    }
+
+    private fun serializeObserver(observer: Observer): WritableMap = Arguments.createMap().apply {
+        putString("id", observer.id)
+        putString("name", observer.name)
+        putDouble("screenWidth", observer.screenWidth)
+        putDouble("screenHeight", observer.screenHeight)
+        putDouble("windowWidth", observer.windowWidth)
+        putDouble("windowHeight", observer.windowHeight)
+        putBoolean("hasFocus", observer.hasFocus)
+    }
+}

package/android/src/main/kotlin/io/upscope/reactnative/UpscopePackage.kt

@@ -0,0 +1,31 @@
+package io.upscope.reactnative
+
+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 com.facebook.react.uimanager.ViewManager
+
+class UpscopePackage : BaseReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == UpscopeModule.NAME) UpscopeModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+        mapOf(
+            UpscopeModule.NAME to ReactModuleInfo(
+                name = UpscopeModule.NAME,
+                className = UpscopeModule.NAME,
+                canOverrideExistingModule = false,
+                needsEagerInit = false,
+                isCxxModule = false,
+                isTurboModule = true
+            )
+        )
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(UpscopeMaskedViewManager())
+    }
+}