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

Sicurezza semplificata

Raccogli dati di pagamento sensibili in modo sicuro mantenendo la conformità PCI

Metodi di pagamento multipli

Accetta vari metodi di pagamento per espandere la portata globale

UI nativa

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 supporto per questi metodi di pagamento nelle future versioni.

Installazione

1

Installa il SDK

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

Configurazione specifica della piattaforma

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

Configurazione lato client

1

Ottieni la chiave pubblicabile

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

Configura il fornitore di pagamento

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 chiavi API dal tuo dashboard di Dodo Payments. Consulta la nostra guida alla generazione delle chiavi API per istruzioni dettagliate.
3

Crea una funzione utility per i pagamenti

Crea una funzione utility 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 presuppone che tu abbia un endpoint API backend che crea intenti di pagamento e restituisce un client secret. Assicurati che il tuo backend sia configurato correttamente per gestire la creazione dei pagamenti. Consulta il nostro Tutorial di integrazione API per esempi di configurazione del backend.
4

Implementa la schermata di pagamento

Crea la tua schermata di pagamento utilizzando il useCheckout hook. 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, dai un’occhiata ai nostri repository demo:

Opzioni di configurazione

Parametri di sessione

clientSecret
string
obbligatorio
Il client secret dal tuo intento di pagamento, ottenuto dall’API di pagamento una tantum o abbonamento.
mode
string
obbligatorio
La modalità della sessione di pagamento (test o live).
configuration.appearance
object
Opzioni di personalizzazione per l’aspetto della schermata di pagamento
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, caratteri e altro tramite il parametro appearance quando chiami initPaymentSession().

Personalizzazione dei colori

Ogni categoria di colore determina il colore di uno o più componenti nell’interfaccia utente. Ad esempio, primary definisce il colore del pulsante di pagamento.
Categoria di coloreUtilizzo
primaryColore primario per il pulsante di pagamento 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 dell’etichetta per i campi di input
componentTextColore del testo di input (es. numero di carta, codice postale)
placeholderTextColore del testo segnaposto per i campi di input
iconColore per le icone (es. pulsante di chiusura)
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 stia generando 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: Controlla il nostro Riferimento ai codici di errore per una gestione degli errori dettagliata
  • Abilita il logging di debug in fase di sviluppo
  • Controlla le richieste di rete al tuo backend
  • Verifica che le chiavi API siano configurate correttamente
  • Testa su entrambe le piattaforme iOS e Android
  • Rivedi le nostre FAQ tecniche per problemi comuni
  • Usa Modalità di test vs live in modo appropriato

Metodi di pagamento di test

Utilizza numeri di carta di test in fase di sviluppo per verificare la tua integrazione senza elaborare pagamenti reali. Scopri di più sul nostro processo di test e sugli ambienti di test disponibili.