import React, { useCallback, useState, useMemo, useRef } from 'react'; import { type Reader, type LogLevel, type InitParams, type LocaleConfig, type ConnectionStatus, type EventResult, type PaymentStatus, type OfflineStatus, type PaymentIntent, type SetupIntent, type ReaderEvent, } from '../types'; import type { StripeError } from '../types/StripeError'; import { StripeTerminalContext } from './StripeTerminalContext'; import { initialize, setConnectionToken } from '../functions'; import { useListener } from '../hooks/useListener'; import { NativeModules } from 'react-native'; import EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter'; import { createInternalStripeError } from '../Errors/StripeErrorHelpers'; import { ErrorCode } from '../Errors/ErrorCodes'; import Logger from '../logger'; const { FETCH_TOKEN_PROVIDER, CHANGE_CONNECTION_STATUS, CHANGE_PAYMENT_STATUS, FINISH_DISCOVERING_READERS, FINISH_INSTALLING_UPDATE, REQUEST_READER_DISPLAY_MESSAGE, REQUEST_READER_INPUT, REPORT_AVAILABLE_UPDATE, UPDATE_REQUIREMENTS_AVAILABLE, REPORT_UPDATE_PROGRESS, START_INSTALLING_UPDATE, UPDATE_DISCOVERED_READERS, START_READER_RECONNECT, READER_RECONNECT_SUCCEED, READER_RECONNECT_FAIL, CHANGE_OFFLINE_STATUS, FORWARD_PAYMENT_INTENT, FORWARD_SETUP_INTENT, REPORT_FORWARDING_ERROR, DISCONNECT, UPDATE_BATTERY_LEVEL, REPORT_LOW_BATTERY_WARNING, REPORT_READER_EVENT, ACCEPT_TERMS_OF_SERVICE, } = NativeModules.StripeTerminalReactNative.getConstants(); const emitter = new EventEmitter(); const TOKEN_PROVIDER_ERROR_MESSAGE = "Couldn't fetch connection token. Please check your tokenProvider method"; /** * When using the Stripe Terminal SDK to build Apps on Devices that run on Stripe readers, * the AppsOnDevicesConnectionTokenProvider can be used to obtain connection tokens without * contacting your backend server. * * This feature is currently in development and is not yet available for use. To express interest * in the private preview, contact your Stripe account team. * * @example * ```ts * import { AppsOnDevicesConnectionTokenProvider } from '@stripe/stripe-terminal-react-native'; * * * * ``` */ export const AppsOnDevicesConnectionTokenProvider = async (): Promise => { throw new Error( 'Potential misconfiguration detected. Please check your integration.' ); }; // Helper: Initialize for serverless Apps-on-Devices mode const initializeWithServerlessAppsOnDevices = async (initParams: InitParams) => { return initialize({ initParams, useAppsOnDevicesConnectionTokenProvider: true }); }; // Helper: Initialize with standard token provider const initializeWithTokenProvider = async ( initParams: InitParams, tokenProvider: () => Promise ) => { try { await tokenProvider(); } catch { console.error(TOKEN_PROVIDER_ERROR_MESSAGE); return { error: createInternalStripeError( { code: ErrorCode.CONNECTION_TOKEN_PROVIDER_ERROR, message: TOKEN_PROVIDER_ERROR_MESSAGE, }, 'rn' ), }; } const result = await initialize({ initParams, useAppsOnDevicesConnectionTokenProvider: false, }); return result; }; /** * StripeTerminalProvider Component Props */ export interface Props { children: React.ReactElement | React.ReactElement[]; /* You must set a token provider before calling any Stripe terminal method. This should fetch a connection token from your server and return it as a string. * @example * ```ts * const fetchTokenProvider = async () => { * const response = await fetch('http://api_url/connection_token'); * const { secret } = await response.json(); * return secret; * }; * ``` */ tokenProvider: () => Promise; logLevel?: LogLevel; localeConfig: LocaleConfig; } /** * StripeTerminalProvider Component * * @example * ```ts * // Using a custom token provider (standard setup) * * * * * // Using Apps-on-Devices serverless mode (Android only, on Stripe smart readers) * import { AppsOnDevicesConnectionTokenProvider } from '@stripe/stripe-terminal-react-native'; * * * * ``` * @param __namedParameters Props * @returns React.JSX.Element * @category ReactComponents */ export function StripeTerminalProvider({ children, tokenProvider, logLevel, localeConfig, }: Props) { // Detect if using Apps-on-Devices mode by checking if the sentinel function was passed const isAppsOnDevicesMode = tokenProvider === AppsOnDevicesConnectionTokenProvider; const isInitializedRef = useRef(false); const getIsInitialized = useCallback(() => isInitializedRef.current, []); const [loading, setLoading] = useState(true); const [connectedReader, setConnectedReader] = useState(); const [discoveredReaders, setDiscoveredReaders] = useState([]); const log = useCallback( (code: string) => { if (logLevel === 'verbose') { console.log(`[Stripe terminal] ${code}`); } }, [logLevel] ); const didUpdateDiscoveredReaders = useCallback( ({ readers }: { readers: Reader.Type[] }) => { log('didUpdateDiscoveredReaders'); emitter?.emit(UPDATE_DISCOVERED_READERS, readers); }, [log] ); const didFinishDiscoveringReaders = useCallback( ({ result }: EventResult<{ error?: StripeError }>) => { log('didFinishDiscoveringReaders'); // result.error is already rehydrated by useListener when present emitter?.emit(FINISH_DISCOVERING_READERS, result.error); }, [log] ); const didReportAvailableUpdate = useCallback( ({ result }: EventResult) => { log('didReportAvailableUpdate'); emitter?.emit(REPORT_AVAILABLE_UPDATE, result); }, [log] ); const didUpdateRequirementsAvailable = useCallback( ({ result }: EventResult) => { log('didUpdateRequirementsAvailable'); emitter?.emit(UPDATE_REQUIREMENTS_AVAILABLE, result); }, [log] ); const didStartInstallingUpdate = useCallback( ({ result, reader, }: { result: Reader.SoftwareUpdate; reader?: Reader.Type; }) => { log('didStartInstallingUpdate'); emitter?.emit(START_INSTALLING_UPDATE, result, reader); }, [log] ); const didReportReaderSoftwareUpdateProgress = useCallback( ({ result }: EventResult<{ progress: number }>) => { log('didReportReaderSoftwareUpdateProgress'); emitter?.emit(REPORT_UPDATE_PROGRESS, result.progress); }, [log] ); const didFinishInstallingUpdate = useCallback( ({ result, error, }: { result?: Reader.SoftwareUpdate; error?: StripeError; }) => { log('didFinishInstallingUpdate'); emitter?.emit(FINISH_INSTALLING_UPDATE, result, error); }, [log] ); const didRequestReaderInput = useCallback( ({ result }: EventResult) => { log('didRequestReaderInput'); emitter?.emit(REQUEST_READER_INPUT, result); }, [log] ); const didRequestReaderDisplayMessage = useCallback( ({ result }: EventResult) => { log('didRequestReaderDisplayMessage'); emitter?.emit(REQUEST_READER_DISPLAY_MESSAGE, result); }, [log] ); const didChangePaymentStatus = useCallback( ({ result }: EventResult) => { log('didChangePaymentStatus'); emitter?.emit(CHANGE_PAYMENT_STATUS, result); }, [log] ); const didChangeConnectionStatus = useCallback( ({ result }: EventResult) => { log('didChangeConnectionStatus'); emitter?.emit(CHANGE_CONNECTION_STATUS, result); }, [log] ); const didStartReaderReconnect = useCallback( ({ reader, reason, }: { reader: Reader.Type; reason: Reader.DisconnectReason; }) => { log('didStartReaderReconnect'); emitter?.emit(START_READER_RECONNECT, reader, reason); }, [log] ); const didSucceedReaderReconnect = useCallback( ({ reader }: { reader: Reader.Type }) => { log('didSucceedReaderReconnect'); emitter?.emit(READER_RECONNECT_SUCCEED, reader); }, [log] ); const didFailReaderReconnect = useCallback( ({ reader }: { reader: Reader.Type }) => { log('didFailReaderReconnect'); emitter?.emit(READER_RECONNECT_FAIL, reader); }, [log] ); const didChangeOfflineStatus = useCallback( ({ result }: { result?: OfflineStatus }) => { log('didChangeOfflineStatus'); emitter?.emit(CHANGE_OFFLINE_STATUS, result); }, [log] ); const didForwardPaymentIntent = useCallback( ({ result, error }: { result: PaymentIntent.Type; error?: StripeError }) => { log('didForwardPaymentIntent'); emitter?.emit(FORWARD_PAYMENT_INTENT, result, error); }, [log] ); const didForwardSetupIntent = useCallback( ({ result, error }: { result: SetupIntent.Type; error?: StripeError }) => { log('didForwardSetupIntent'); emitter?.emit(FORWARD_SETUP_INTENT, result, error); }, [log] ); const didReportForwardingError = useCallback( ({ result }: { result: { error: StripeError } }) => { const error = result.error; log('didReportForwardingError'); emitter?.emit(REPORT_FORWARDING_ERROR, error); }, [log] ); const didDisconnect = useCallback( ({ reason }: { reason: Reader.DisconnectReason }) => { log('didDisconnect'); emitter?.emit(DISCONNECT, reason); }, [log] ); const didUpdateBatteryLevel = useCallback( ({ result }: { result?: Reader.BatteryLevel }) => { log('didUpdateBatteryLevel'); emitter?.emit(UPDATE_BATTERY_LEVEL, result); }, [log] ); const didReportLowBatteryWarning = useCallback( ({ result }: { result?: string }) => { log('didReportLowBatteryWarning'); emitter?.emit(REPORT_LOW_BATTERY_WARNING, result); }, [log] ); const didReportReaderEvent = useCallback( ({ result }: EventResult) => { log('didReportReaderEvent'); emitter?.emit(REPORT_READER_EVENT, result); }, [log] ); const didAcceptTermsOfService = useCallback(() => { log('didAcceptTermsOfService'); emitter?.emit(ACCEPT_TERMS_OF_SERVICE); }, [log]); useListener(REPORT_AVAILABLE_UPDATE, didReportAvailableUpdate); useListener(UPDATE_REQUIREMENTS_AVAILABLE, didUpdateRequirementsAvailable); useListener(START_INSTALLING_UPDATE, didStartInstallingUpdate); useListener(REPORT_UPDATE_PROGRESS, didReportReaderSoftwareUpdateProgress); useListener(FINISH_INSTALLING_UPDATE, didFinishInstallingUpdate); useListener(UPDATE_DISCOVERED_READERS, didUpdateDiscoveredReaders); useListener(FINISH_DISCOVERING_READERS, didFinishDiscoveringReaders); useListener(REQUEST_READER_INPUT, didRequestReaderInput); useListener(REQUEST_READER_DISPLAY_MESSAGE, didRequestReaderDisplayMessage); useListener(CHANGE_PAYMENT_STATUS, didChangePaymentStatus); useListener(CHANGE_CONNECTION_STATUS, didChangeConnectionStatus); useListener(START_READER_RECONNECT, didStartReaderReconnect); useListener(READER_RECONNECT_SUCCEED, didSucceedReaderReconnect); useListener(READER_RECONNECT_FAIL, didFailReaderReconnect); useListener(CHANGE_OFFLINE_STATUS, didChangeOfflineStatus); useListener(FORWARD_PAYMENT_INTENT, didForwardPaymentIntent); useListener(FORWARD_SETUP_INTENT, didForwardSetupIntent); useListener(REPORT_FORWARDING_ERROR, didReportForwardingError); useListener(DISCONNECT, didDisconnect); useListener(UPDATE_BATTERY_LEVEL, didUpdateBatteryLevel); useListener(REPORT_LOW_BATTERY_WARNING, didReportLowBatteryWarning); useListener(REPORT_READER_EVENT, didReportReaderEvent); useListener(ACCEPT_TERMS_OF_SERVICE, didAcceptTermsOfService); const tokenProviderHandler = useCallback(async () => { try { const connectionToken = await tokenProvider(); setConnectionToken(connectionToken, undefined); } catch { setConnectionToken(undefined, TOKEN_PROVIDER_ERROR_MESSAGE); console.error(TOKEN_PROVIDER_ERROR_MESSAGE); } }, [tokenProvider]); useListener(FETCH_TOKEN_PROVIDER, tokenProviderHandler); const _initialize = useCallback(async () => { const initParams: InitParams = { logLevel, localeConfig }; setLoading(true); log('initialize'); const response = await Logger.traceSdkMethod(async () => { return isAppsOnDevicesMode ? initializeWithServerlessAppsOnDevices(initParams) : initializeWithTokenProvider(initParams, tokenProvider); }, 'initialize')(); if (response.error) { log(response.error.code); } else { if (response.reader) { log('Connected to the reader'); setConnectedReader(response.reader); } isInitializedRef.current = true; } setLoading(false); return response; }, [logLevel, localeConfig, isAppsOnDevicesMode, tokenProvider, log]); const value = useMemo( () => ({ loading, isInitialized: isInitializedRef.current, getIsInitialized, connectedReader, discoveredReaders, setLoading, setConnectedReader, setDiscoveredReaders, log, initialize: _initialize, emitter, }), [ _initialize, loading, getIsInitialized, connectedReader, discoveredReaders, setLoading, setConnectedReader, setDiscoveredReaders, log, ] ); return ( {children} ); }