Terminal SDK 移行ガイド

// Step 1: Collect payment method
Terminal.getInstance().collectPaymentMethod(
    paymentIntent,
    collectConfig,
    object : PaymentIntentCallback {
        override fun onSuccess(paymentIntent: PaymentIntent) {
            // Step 2: Confirm the payment
            Terminal.getInstance().confirmPaymentIntent(paymentIntent, object : PaymentIntentCallback {
                override fun onSuccess(confirmedPaymentIntent: PaymentIntent) {
                    // Payment successful
                }
                override fun onFailure(e: TerminalException) {
                    // Payment confirmation failed
                }
            })
        }
        override fun onFailure(e: TerminalException) {
            // Payment method collection failed
        }
    }
)

// Process and confirm the payment in one step
Terminal.getInstance().processPaymentIntent(
    paymentIntent,
    collectConfig,
    confirmConfig,
    object : PaymentIntentCallback {
        override fun onSuccess(paymentIntent: PaymentIntent) {
            // Payment successful
        }
        override fun onFailure(e: TerminalException) {
            // Payment failed
        }
    }
)

// Step 1: Collect refund payment method
val refundParams = RefundParameters.ByChargeId(
    id = "ch_123",
    amount = 1000L,
    currency = "cad"
).build()

Terminal.getInstance().collectRefundPaymentMethod(
    refundParams,
    object : Callback {
        override fun onSuccess() {
            // Step 2: Confirm the refund
            Terminal.getInstance().confirmRefund(object : RefundCallback {
                override fun onSuccess(refund: Refund) {
                    // Refund successful
                }
                override fun onFailure(e: TerminalException) {
                    // Refund confirmation failed
                }
            })
        }
        override fun onFailure(e: TerminalException) {
            // Refund collection failed
        }
    }
)

val refundParams = RefundParameters.ByChargeId(
    id = "ch_123",
    amount = 1000,
    currency = "cad"
).build()

// Process the refund in one step
Terminal.getInstance().processRefund(
    refundParams,
    object : RefundCallback {
        override fun onSuccess(refund: Refund) {
            // Refund successful
        }
        override fun onFailure(e: TerminalException) {
            // Refund failed
        }
    }
)

// Step 1: Collect setup intent payment method
Terminal.getInstance().collectSetupIntentPaymentMethod(
    intent = setupIntent,
    allowRedisplay = AllowRedisplay.ALWAYS,
    callback = object : SetupIntentCallback {
        override fun onSuccess(setupIntent: SetupIntent) {
            // Step 2: Confirm the setup intent
            Terminal.getInstance().confirmSetupIntent(setupIntent, object : SetupIntentCallback {
                override fun onSuccess(confirmedSetupIntent: SetupIntent) {
                    // Setup intent successful
                }
                override fun onFailure(e: TerminalException) {
                    // Setup intent confirmation failed
                }
            })
        }
        override fun onFailure(e: TerminalException) {
            // Setup intent collection failed
        }
    }
)

// Configure with allowRedisplay
val config = CollectSetupIntentConfiguration.Builder()
    .build()

// Process the setup intent in one step
Terminal.getInstance().processSetupIntent(
    intent = setupIntent,
    allowRedisplay = AllowRedisplay.ALWAYS,
    collectConfig = config,
    callback = object : SetupIntentCallback {
        override fun onSuccess(setupIntent: SetupIntent) {
            // Setup intent successful
        }
        override fun onFailure(e: TerminalException) {
            // Setup intent failed
        }
    }
)

Terminal.initTerminal(applicationContext, LogLevel.VERBOSE, tokenProvider, terminalListener)

Terminal.init(applicationContext, LogLevel.VERBOSE, tokenProvider, terminalListener, offlineListener)

override fun onConnectionStatusChange(status: ConnectionStatus) {
    when (status) {
        ConnectionStatus.NOT_CONNECTED -> {
            // Handle not connected
        }
        ConnectionStatus.CONNECTED -> {
            // Handle connected
        }
    }
}

override fun onConnectionStatusChange(status: ConnectionStatus) {
    when (status) {
        ConnectionStatus.NOT_CONNECTED -> {
            // Handle not connected
        }
        ConnectionStatus.CONNECTED -> {
            // Handle connected
        }
        ConnectionStatus.RECONNECTING -> {
            // Handle reconnection in progress
        }
    }
}

// Step 1: Discover the reader
Terminal.getInstance().discoverReaders(config, object : DiscoveryListener {
    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        val selectedReader = readers[0]
        // Step 2: Connect to the reader
        Terminal.getInstance().connectReader(selectedReader, connectionConfig, readerCallback)
    }
})

// Discover and connect in one step by providing discovery filter
val easyConnectConfig = InternetEasyConnectConfiguration(
    discoveryConfiguration = DiscoveryConfiguration.InternetDiscoveryConfiguration(
        location = "YOUR-LOCATION-ID", // optional
        discoveryFilter = DiscoveryFilter.BySerial("YOUR-READER-SERIAL-NUMBER"),
    ),
    connectionConfiguration = ConnectionConfiguration.InternetConnectionConfiguration(
        internetReaderListener = internetReaderListener,
    )
)

Terminal.getInstance().easyConnect(
    easyConnectConfig,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Handle successful connection
        }
        override fun onFailure(e: TerminalException) {
            // Handle failure
        }
    }
)

val config = InternetDiscoveryConfiguration(location = "tml_1234567890")

val config = InternetDiscoveryConfiguration(
    location = "tml_1234567890", // optional
    discoveryFilter = DiscoveryFilter.BySerial("READER-SERIAL-NUMBER"), // or DiscoveryFilter.ByReaderId("tmr_YOUR-READER-STRIPE-ID) to filter by reader id
)

val config = CollectConfiguration.Builder()
    .setEnableCustomerCancellation(false)
    .build()

val config = CollectPaymentIntentConfiguration.Builder()
    .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE)
    .build()

val refundParams = RefundParameters.Builder(
    RefundParameters.Id.PaymentIntent("pi_123"),
    1000,
    "cad"
).build()

val refundParams = RefundParameters.ByPaymentIntentId(
    paymentIntentId = "pi_123",
    clientSecret = "pi_123_secret_abc",
    amount = 1000,
    currency = "cad"
).build()

dependencies {
    implementation("com.stripe:stripeterminal-handoffclient:4.0.0")
}

dependencies {
    implementation("com.stripe:stripeterminal-appsondevices:5.0.0")
}

val discoveryConfig = HandoffDiscoveryConfiguration()

Terminal.getInstance().discoverReaders(
    discoveryConfig,
    object : DiscoveryListener {
        override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
            val reader = readers.first()
            val connectionConfig = HandoffConnectionConfiguration(
                handoffReaderListener = object : HandoffReaderListener {
                    override fun onDisconnect(reason: DisconnectReason) {
                        // Handle disconnect
                    }
                }
            )
            Terminal.getInstance().connectReader(reader, connectionConfig, readerCallback)
        }
    }
)

val tokenProvider = HandoffConnectionTokenProvider()

val discoveryConfig = AppsOnDevicesDiscoveryConfiguration()

Terminal.getInstance().discoverReaders(
    discoveryConfig,
    object : DiscoveryListener {
        override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
            val reader = readers.first()
            val connectionConfig = AppsOnDevicesConnectionConfiguration(
                appsOnDevicesListener = object : AppsOnDevicesListener {
                    override fun onDisconnect(reason: DisconnectReason) {
                        // Handle disconnect
                    }
                }
            )
            Terminal.getInstance().connectReader(reader, connectionConfig, readerCallback)
        }
    }
)

val tokenProvider = AppsOnDevicesConnectionTokenProvider()

val config = TapToPayUxConfiguration.Builder()
    .setTapZone(
        indicator = TapZoneIndicator.ABOVE,
        position = TapZonePosition.Manual(0.5f, 0.2f)
    )
    .build()

// Position the tap zone above the reader UI
val config = TapToPayUxConfiguration.Builder()
    .setTapZone(TapZone.Above(horizontalBias = 0.2f))
    .build()

// Or position it on the left side of the screen
val config2 = TapToPayUxConfiguration.Builder()
    .setTapZone(TapZone.Left()) // Center vertically by default
    .build()