react-native-candle 1.0.1 → 19.0.6-beta

package/android/src/main/java/com/margelo/nitro/rncandle/HybridRNCandle.kt

@@ -0,0 +1,251 @@
+package com.margelo.nitro.rncandle
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import fi.candle.Candle
+import fi.candle.client.supportedServices
+import fi.candle.ui.CandleUiContent
+import fi.candle.ui.models.PresentationStyle as CandlePresentationStyle
+import java.util.concurrent.atomic.AtomicBoolean
+
+class HybridRNCandle : HybridRNCandleSpec() {
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private var linkSheetView: ComposeView? = null
+    private var tradeSheetView: ComposeView? = null
+
+    override fun initialize(appKey: String, appSecret: String, accessGroup: String?) {
+        ReactNativeCandleOnLoad.initializeNative()
+        val context =
+            NitroModules.applicationContext
+                ?: error(
+                    "React application context is unavailable. NitroModules was not initialized."
+                )
+
+        // Android does not use the iOS keychain access-group concept.
+        accessGroup?.let {}
+        Candle.Client.initialize(context, appKey, appSecret)
+    }
+
+    override fun candleLinkSheet(
+        isPresented: Boolean,
+        services: Array<Service>?,
+        cornerRadius: Double,
+        customerName: String?,
+        showDynamicLoading: Boolean,
+        presentationBackground: PresentationBackground,
+        presentationStyle: PresentationStyle,
+        onSuccess: (account: LinkedAccount) -> Unit,
+    ) {
+        runOnMainThread {
+            if (!isPresented) {
+                removeLinkSheet()
+                return@runOnMainThread
+            }
+
+            val activity = requireCurrentActivity()
+            removeLinkSheet()
+
+            val callbackDelivered = AtomicBoolean(false)
+            val composeView = createOverlayView(activity)
+            composeView.setContent(
+                CandleUiContent.candleLinkSheet(
+                    services = services?.map { it.toCandleModel() } ?: supportedServices,
+                    customerName = customerName,
+                    cornerRadiusDp = cornerRadius.toFloat(),
+                    showDynamicLoading = showDynamicLoading,
+                    presentationStyle = presentationStyle.toCandleModel(),
+                    presentationBackgroundArgb = presentationBackground.toCandleArgb(),
+                    onDismiss = ::removeLinkSheet,
+                    onLinkedAccount = { account ->
+                        if (callbackDelivered.compareAndSet(false, true)) {
+                            onSuccess(account.toReactModel())
+                        }
+                    },
+                )
+            )
+
+            linkSheetView = composeView
+            attachOverlay(activity, composeView)
+        }
+    }
+
+    override fun candleTradeExecutionSheet(
+        tradeQuote: TradeQuote,
+        presentationBackground: PresentationBackground,
+        completion: (result: TradeExecutionResult) -> Unit,
+    ) {
+        runOnMainThread {
+            val activity = requireCurrentActivity()
+            removeTradeSheet()
+
+            val callbackDelivered = AtomicBoolean(false)
+            val quote = tradeQuote.toCandleModel()
+            val composeView = createOverlayView(activity)
+
+            composeView.setContent(
+                CandleUiContent.candleTradeExecutionSheet(
+                    quote = quote,
+                    presentationBackgroundArgb = presentationBackground.toCandleArgb(),
+                    onDismiss = ::removeTradeSheet,
+                    onComplete = { result ->
+                        if (callbackDelivered.compareAndSet(false, true)) {
+                            val tradeExecutionResult =
+                                result.fold(
+                                    onSuccess = { trade ->
+                                        TradeExecutionResult(
+                                            trade = trade.toReactModel(),
+                                            error = null,
+                                        )
+                                    },
+                                    onFailure = { error ->
+                                        TradeExecutionResult(
+                                            trade = null,
+                                            error = error.message ?: error.toString(),
+                                        )
+                                    },
+                                )
+                            completion(tradeExecutionResult)
+                        }
+                    },
+                )
+            )
+
+            tradeSheetView = composeView
+            attachOverlay(activity, composeView)
+        }
+    }
+
+    override fun getLinkedAccounts(): Promise<Array<LinkedAccount>> {
+        return Promise.async {
+            Candle.Client.shared.getLinkedAccounts().map { it.toReactModel() }.toTypedArray()
+        }
+    }
+
+    override fun getLinkedAccount(ref: LinkedAccountRef): Promise<LinkedAccount> {
+        return Promise.async {
+            Candle.Client.shared.getLinkedAccount(ref.toGetLinkedAccountRef()).toReactModel()
+        }
+    }
+
+    override fun unlinkAccount(ref: LinkedAccountRef): Promise<Unit> {
+        return Promise.async { Candle.Client.shared.unlinkAccount(ref.toDeleteLinkedAccountRef()) }
+    }
+
+    override fun getAssetAccounts(query: AssetAccountsQuery): Promise<AssetAccountsResponse> {
+        return Promise.async {
+            Candle.Client.shared.getAssetAccounts(query.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun getAssetAccount(ref: AssetAccountRef): Promise<AssetAccount> {
+        return Promise.async {
+            Candle.Client.shared.getAssetAccount(ref.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun getTrades(query: TradesQuery): Promise<TradesResponse> {
+        return Promise.async {
+            Candle.Client.shared.getTrades(query.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun getTrade(ref: TradeRef): Promise<Trade> {
+        return Promise.async { Candle.Client.shared.getTrade(ref.toCandleModel()).toReactModel() }
+    }
+
+    override fun cancelTrade(ref: TradeRef): Promise<Trade> {
+        return Promise.async {
+            Candle.Client.shared.cancelTrade(ref.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun getTradeQuotes(request: TradeQuotesRequest): Promise<TradeQuotesResponse> {
+        return Promise.async {
+            Candle.Client.shared.getTradeQuotes(request.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun executeTrade(quote: TradeQuote): Promise<Trade> {
+        return Promise.async {
+            Candle.Client.shared.executeTrade(quote.toCandleModel()).toReactModel()
+        }
+    }
+
+    override fun createUser(appUserID: String): Promise<Unit> {
+        return Promise.async { Candle.Client.shared.createUser(appUserID) }
+    }
+
+    override fun deleteUser(): Promise<Unit> {
+        return Promise.async { Candle.Client.shared.deleteUser() }
+    }
+
+    private fun runOnMainThread(block: () -> Unit) {
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            block()
+        } else {
+            mainHandler.post(block)
+        }
+    }
+
+    private fun requireCurrentActivity(): Activity {
+        return NitroModules.applicationContext?.currentActivity
+            ?: error("React activity is unavailable. Candle UI requires a foreground activity.")
+    }
+
+    private fun createOverlayView(activity: Activity): ComposeView {
+        return ComposeView(activity).apply {
+            layoutParams =
+                FrameLayout.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                )
+            setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnDetachedFromWindow)
+        }
+    }
+
+    private fun attachOverlay(activity: Activity, composeView: ComposeView) {
+        val root =
+            activity.findViewById<ViewGroup>(android.R.id.content)
+                ?: error("Activity content view is unavailable.")
+        root.addView(composeView)
+    }
+
+    private fun removeLinkSheet() {
+        linkSheetView?.removeFromParentAndDispose()
+        linkSheetView = null
+    }
+
+    private fun removeTradeSheet() {
+        tradeSheetView?.removeFromParentAndDispose()
+        tradeSheetView = null
+    }
+
+    private fun ComposeView.removeFromParentAndDispose() {
+        (parent as? ViewGroup)?.removeView(this)
+        disposeComposition()
+    }
+
+    private fun PresentationStyle.toCandleModel(): CandlePresentationStyle {
+        return when (this) {
+            PresentationStyle.SHEET -> CandlePresentationStyle.Sheet
+            PresentationStyle.FULLSCREEN -> CandlePresentationStyle.FullScreen
+        }
+    }
+
+    private fun PresentationBackground.toCandleArgb(): Long? {
+        return when (this) {
+            PresentationBackground.DEFAULT -> null
+            // Android has no matching blur-backed sheet treatment here, so avoid a fake translucent
+            // overlay and fall back to the SDK's normal opaque presentation background.
+            PresentationBackground.BLUR -> null
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/rncandle/ReactNativeCandlePackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.rncandle
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ReactNativeCandlePackage : ReactPackage {
+    init {
+        ReactNativeCandleOnLoad.initializeNative()
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return emptyList()
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/ios/Sources/RNCandle.swift

@@ -9,6 +9,8 @@ import UIKit
     private var rootVC: UIHostingController<CandleLinkSheetWrapper>?
 
     private var cancellables = Set<AnyCancellable>()
+    private var linkSheetPresentationCancellable: AnyCancellable?
+    private var linkSheetSuccessCancellable: AnyCancellable?
 
     var viewModel: CandleLinkViewModel {
         get throws {
@@ -39,6 +41,10 @@ import UIKit
         onSuccess: @escaping (LinkedAccount) -> Void
     ) throws {
         Task { @MainActor in
+            linkSheetPresentationCancellable?.cancel()
+            linkSheetSuccessCancellable?.cancel()
+
+            try viewModel.linkedAccount = nil
             try viewModel.isPresented = isPresented
             try viewModel.services = services
             try viewModel.cornerRadius = cornerRadius
@@ -68,13 +74,14 @@ import UIKit
                     #endif
                 }
             }
-            try viewModel.$isPresented.removeDuplicates().receive(on: RunLoop.main)
+            linkSheetPresentationCancellable = try viewModel.$isPresented.removeDuplicates()
+                .receive(on: RunLoop.main)
                 .sink(receiveValue: { [weak self] isPresented in
                     if let rootVC = self?.rootVC, !isPresented { parentVC.removeEmbedded(rootVC) }
                 })
-                .store(in: &cancellables)
-            try viewModel.$linkedAccount.removeDuplicates().compactMap(\.?.reactModel)
-                .receive(on: RunLoop.main).sink(receiveValue: onSuccess).store(in: &cancellables)
+            linkSheetSuccessCancellable = try viewModel.$linkedAccount.removeDuplicates()
+                .compactMap(\.?.reactModel).prefix(1).receive(on: RunLoop.main)
+                .sink(receiveValue: onSuccess)
         }
     }
 
@@ -172,6 +179,13 @@ import UIKit
         }
     }
 
+    public func cancelTrade(ref: TradeRef) throws -> Promise<Trade> {
+        .async {
+            let trade = try await Client.shared.cancelTrade(ref: .init(reactModel: ref))
+            return trade.reactModel
+        }
+    }
+
     public func getTrades(query: TradesQuery) throws -> Promise<TradesResponse> {
         .async {
             let trades = try await Client.shared.getTrades(query: .init(reactModel: query))