Vai al contenuto principale

Integrazione del SDK React Native

Il Dodo Payments React Native SDK ti consente di creare esperienze di pagamento sicure nelle tue app native Android e iOS. Il nostro SDK fornisce componenti e schermate UI personalizzabili per la raccolta dei dettagli di pagamento.
  • 📦 Installa il nostro SDK da NPM
  • 📚 Visualizza il nostro repository demo per esempi completi di implementazione
  • 🎥 Guarda il nostro video demo per vedere il Dodo Payments SDK in azione

Caratteristiche

Simplified Security

Raccogli in modo sicuro i dati di pagamento sensibili mantenendoti conforme a PCI

Multiple Payment Methods

Accetta vari metodi di pagamento per ampliare la portata globale

Native UI

Schermate ed elementi nativi per Android e iOS
Attualmente, Apple Pay, Google Pay, Cash App e UPI non sono supportati nel SDK React Native. Stiamo lavorando attivamente per aggiungere il supporto a questi metodi di pagamento nelle prossime release.

Installazione

1

Install the SDK

Installa il Dodo Payments SDK utilizzando il tuo gestore di pacchetti preferito:
npm install dodopayments-react-native-sdk
2

Platform-specific setup

Esegui pod install nella cartella iOS:
cd ios && pod install && npm run ios

Configurazione lato client

1

Get Publishable Key

Ottieni la tua chiave pubblicabile dalla dashboard di Dodo Payments. (Distinta per le modalità test e live) https://app.dodopayments.com/developer/others
2

Setup Payment Provider

Avvolgi la tua app con il DodoPaymentProvider:
App.tsx
import React from 'react';
import { DodoPaymentProvider } from 'dodopayments-react-native-sdk';
import PaymentScreen from './PaymentScreen';

function App() {
  return (
    <DodoPaymentProvider publishableKey="YOUR_PUBLISHABLE_KEY">
      <PaymentScreen />
    </DodoPaymentProvider>
  );
}

export default App;
Dovrai generare le chiavi API dalla dashboard di Dodo Payments. Consulta la nostra guida alla generazione delle chiavi API per istruzioni dettagliate.
3

Create payment utility function

Crea una funzione di utilità per recuperare i parametri di pagamento dalla tua API backend:
utils/fetchPaymentParams.ts
const API_URL = 'YOUR_BACKEND_URL'; // Replace with your server URL

const fetchPaymentParams = async () => {
  const response = await fetch(`${API_URL}/create-payment`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
  });
  
  if (!response.ok) {
    throw new Error('Failed to fetch payment parameters');
  }
  
  return await response.json();
};

export default fetchPaymentParams;
Questa funzione presume che tu abbia un endpoint API backend che crea intenti di pagamento e restituisce un client secret. Assicurati che il backend sia configurato correttamente per gestire la creazione dei pagamenti. Consulta il nostro Tutorial sull’integrazione API per esempi di configurazione del backend.
4

Implement the payment screen

Crea la tua schermata di pagamento utilizzando il hook useCheckout. Ecco un’implementazione completa:
PaymentScreen.tsx
import React from 'react';
import { View, Text, useColorScheme } from 'react-native';
import { useCheckout, type sessionParams } from 'dodopayments-react-native-sdk';
import fetchPaymentParams from './utils/fetchPaymentParams';

const PaymentScreen = () => {
  const { initPaymentSession, presentPaymentSheet } = useCheckout();
  const [error, setError] = React.useState('');
  const [message, setMessage] = React.useState('');
  const [loading, setLoading] = React.useState(false);
  const [showSuccessScreen, setShowSuccessScreen] = React.useState(false);
  const isDarkMode = useColorScheme() === 'dark';

  const processPayment = async () => {
    setLoading(true);
    setMessage('');
    setError('');

    try {
      // 1. Get payment parameters from your backend
      const key = await fetchPaymentParams();
      
      // 2. Initialize payment session
      const paymentSheetParamsResult = await initPaymentSession({
        clientSecret: key.clientSecret,
      });
      
      // 3. Configure and present payment sheet
      const params: sessionParams = {
        ...(paymentSheetParamsResult as sessionParams),
        configuration: {
          appearance: {
            themes: isDarkMode ? 'dark' : 'light',
            primaryButton: {
              colors: {
                light: {
                  background: 'green',
                  componentBorder: 'green',
                  placeholderText: 'yellow',
                },
                dark: {
                  background: 'green',
                  componentBorder: 'green',
                  placeholderText: 'yellow',
                },
              },
              shapes: {
                borderRadius: 30,
                borderWidth: 3,
              },
            },
          },
          mode: 'test', // DEFAULTS TO TEST MODE
        },
      };

      const paymentSheetResponse = await presentPaymentSheet(params);

      // 4. Handle payment result
      switch (paymentSheetResponse?.status) {
        case 'cancelled':
          setError('Payment cancelled by user.');
          break;
        case 'succeeded':
          setMessage('');
          setShowSuccessScreen(true);
          break;
        case 'failed':
          setError('Payment failed : \n' + paymentSheetResponse?.message);
          break;
        default:
          setError(paymentSheetResponse?.message);
          setMessage('');
      }
    } catch (err) {
      setError('Failed to process payment');
    } finally {
      setLoading(false);
    }
  };

  return (
    <View>
      <Button 
        onPress={processPayment}
        disabled={loading}
        title={loading ? 'Processing...' : 'Pay Now'}
      />
      {error && <Text style={{ color: 'red' }}>{error}</Text>}
      {message && <Text style={{ color: 'green' }}>{message}</Text>}
      {showSuccessScreen && (
        <PaymentSuccessScreen
          amount={total}
          onContinue={() => setShowSuccessScreen(false)}
        />
      )}
    </View>
  );
};

export default PaymentScreen;
Per esempi completi con styling, gestione degli errori e opzioni di personalizzazione, consulta i nostri repository demo:

Opzioni di configurazione

Parametri di sessione

clientSecret
string
obbligatorio
Il client secret del tuo intento di pagamento, ottenuto dall’API One time payment o subscription.
mode
string
obbligatorio
La modalità della sessione di pagamento (test o live).
configuration.appearance
object
Opzioni di personalizzazione per l’aspetto della payment sheet
configuration.appearance.themes
string
Modalità tema: 'light' o 'dark'

Personalizzazione dell’aspetto

Puoi personalizzare il React Native Unified Checkout per adattarlo al design della tua app modificando colori, font e altro tramite il parametro appearance quando chiami initPaymentSession().

Personalizzazione dei colori

Ogni categoria di colore determina il colore di uno o più componenti dell’interfaccia. Ad esempio, primary definisce il colore del pulsante Paga.
Categoria di coloreUtilizzo
primaryColore principale per il pulsante Paga e gli elementi selezionati
backgroundColore di sfondo della pagina di pagamento
componentBackgroundColore di sfondo per input, schede e altri componenti
componentBorderColore del bordo esterno per input, schede e altri componenti
componentDividerColore del bordo interno (bordi condivisi) per i componenti
primaryTextColore del testo dell’intestazione
secondaryTextColore del testo delle etichette per i campi di input
componentTextColore del testo dell’input (ad esempio, numero della carta, CAP)
placeholderTextColore del testo segnaposto per i campi di input
iconColore delle icone (ad esempio, pulsante Chiudi)
errorColore per i messaggi di errore e azioni distruttive
Esempio di configurazione con supporto per modalità chiara e scura:
const appearance = {
  colors: {
    light: {
      primary: '#F8F8F2',
      background: '#ffffff',
      componentBackground: '#E6DB74',
      componentBorder: '#FD971F',
      componentDivider: '#FD971F',
      primaryText: '#F8F8F2',
      secondaryText: '#75715E',
      componentText: '#AE81FF',
      placeholderText: '#E69F66',
      icon: '#F92672',
      error: '#FF0000',
    },
    dark: {
      primary: '#00ff0099',
      background: '#ff0000',
      componentBackground: '#ff0080',
      componentBorder: '#62ff08',
      componentDivider: '#d6de00',
      primaryText: '#5181fc',
      secondaryText: '#ff7b00',
      componentText: '#00ffff',
      placeholderText: '#00ffff',
      icon: '#f0f0f0',
      error: '#0f0f0f',
    },
  },
};

Personalizzazione della forma

Puoi personalizzare il raggio del bordo, la larghezza del bordo e l’ombra utilizzati nell’interfaccia di pagamento:
const appearance = {
  shapes: {
    borderRadius: 10, // Border radius for input fields, tabs, and components
    borderWidth: 1,   // Border width for components
  },
};

Personalizzazione specifica dei componenti

Puoi personalizzare componenti UI specifici come il pulsante primario (pulsante di pagamento). Queste impostazioni hanno la precedenza sulle impostazioni di aspetto globali:
const appearance = {
  primaryButton: {
    colors: {
      background: '#000000',
      text: '#ffffff',
      border: '#ff00ff',
    },
    shapes: {
      borderRadius: 10,
      borderWidth: 1.5,
    },
  },
};
Per applicare queste personalizzazioni, includile nella configurazione della tua sessione di pagamento:
const params: sessionParams = {
  ...paymentSheetParams,
  configuration: {
    appearance: {
      themes: isDarkMode ? 'dark' : 'light',
      ...appearance, // Include your custom appearance settings
    },
  },
};

Gestione degli errori

Gestisci diversi stati di pagamento nella tua funzione di checkout:
const handlePaymentResult = (paymentSheetResponse) => {
  switch (paymentSheetResponse?.status) {
    case 'cancelled':
      // User cancelled the payment
      console.log('Payment cancelled by user');
      break;
    case 'succeeded':
      // Payment completed successfully
      console.log('Payment succeeded');
      // Navigate to success screen or update UI
      break;
    case 'failed':
      // Payment failed
      console.log('Payment failed:', paymentSheetResponse?.message);
      // Show error message to user
      break;
    default:
      console.log('Unknown payment status:', paymentSheetResponse?.status);
  }
};
  • Problemi di connettività di rete: assicurati di avere una connessione Internet stabile
  • Client secret non valido: verifica che il backend generi intenti di pagamento validi
  • Dipendenze peer mancanti: installa tutte le dipendenze richieste
  • Configurazione specifica della piattaforma: completa i passaggi di configurazione per iOS e Android
  • Errori API: consulta il nostro Riferimento codici di errore per una gestione dettagliata degli errori
  • Abilita il logging di debug in sviluppo
  • Controlla le richieste di rete verso il tuo backend
  • Verifica che le chiavi API siano configurate correttamente
  • Testa sia su piattaforme iOS che Android
  • Consulta le nostre FAQ tecniche per problemi comuni
  • Utilizza correttamente Modalità test vs live

Metodi di pagamento di test

Usa numeri di carta di test durante lo sviluppo per verificare l’integrazione senza processare pagamenti reali. Scopri di più sul nostro processo di testing e sugli ambienti di test disponibili.