Passer au contenu principal

Intégration du SDK React Native

Le SDK React Native de Dodo Payments vous permet de créer des expériences de paiement sécurisées dans vos applications Android et iOS natives. Notre SDK fournit des composants et des écrans UI personnalisables pour la collecte des détails de paiement.

Fonctionnalités

Simplified Security

Collectez les données de paiement sensibles en toute sécurité tout en restant conforme à la norme PCI

Multiple Payment Methods

Acceptez différents moyens de paiement pour étendre votre portée mondiale

Native UI

Écrans et éléments natifs pour Android et iOS
Actuellement, Apple Pay, Google Pay, Cash App et UPI ne sont pas pris en charge dans le SDK React Native. Nous travaillons activement à l’ajout de ces moyens de paiement dans de futures versions.

Installation

1

Install the SDK

Installez le SDK Dodo Payments avec le gestionnaire de paquets de votre choix :
npm install dodopayments-react-native-sdk
2

Platform-specific setup

Exécutez pod install dans votre dossier iOS :
cd ios && pod install && npm run ios

Configuration côté client

1

Get Publishable Key

Récupérez votre clé publique depuis le tableau de bord Dodo Payments. (Distincte pour les modes test et production) https://app.dodopayments.com/developer/others
2

Setup Payment Provider

Enveloppez votre application avec le 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;
Vous devrez générer des clés API depuis votre tableau de bord Dodo Payments. Consultez notre guide de génération de clés API pour des instructions détaillées.
3

Create payment utility function

Créez une fonction utilitaire pour récupérer les paramètres de paiement depuis votre 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;
Cette fonction suppose que vous disposez d’un point de terminaison API backend qui crée des intents de paiement et renvoie un client secret. Assurez-vous que votre backend est correctement configuré pour gérer la création de paiements. Consultez notre tutoriel d’intégration API pour des exemples de configuration backend.
4

Implement the payment screen

Créez votre écran de paiement en utilisant le hook useCheckout. Voici une implémentation complète :
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;
Pour des exemples complets avec style, gestion des erreurs et options de personnalisation, consultez nos dépôts de démonstration :

Options de configuration

Paramètres de session

clientSecret
string
requis
Le client secret de votre intent de paiement, obtenu via l’API de paiement unique ou d’abonnement.
mode
string
requis
Le mode de la session de paiement (test ou production).
configuration.appearance
object
Options de personnalisation pour l’apparence de la feuille de paiement
configuration.appearance.themes
string
Mode du thème : 'light' ou 'dark'

Personnalisation de l’apparence

Vous pouvez personnaliser l’Unified Checkout React Native pour qu’il corresponde au design de votre application en modifiant les couleurs, les polices, etc. via le paramètre appearance lors de l’appel de initPaymentSession().

Personnalisation des couleurs

Chaque catégorie de couleur détermine la couleur d’un ou plusieurs composants de l’interface. Par exemple, primary définit la couleur du bouton Payer.
Catégorie de couleurUtilisation
primaryCouleur principale pour le bouton Payer et les éléments sélectionnés
backgroundCouleur d’arrière-plan de la page de paiement
componentBackgroundCouleur d’arrière-plan pour les champs, onglets et autres composants
componentBorderCouleur de bordure externe pour les champs, onglets et autres composants
componentDividerCouleur de bordure interne (bords partagés) pour les composants
primaryTextCouleur du texte d’en-tête
secondaryTextCouleur du texte des étiquettes des champs
componentTextCouleur du texte des champs (par ex., numéro de carte, code postal)
placeholderTextCouleur du texte des espaces réservés pour les champs
iconCouleur des icônes (par ex., bouton de fermeture)
errorCouleur des messages d’erreur et des actions destructrices
Configuration d’exemple avec support pour les modes clair et sombre :
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',
    },
  },
};

Personnalisation de la forme

Vous pouvez personnaliser le rayon de bordure, la largeur de bordure et l’ombre utilisées dans toute l’interface de paiement :
const appearance = {
  shapes: {
    borderRadius: 10, // Border radius for input fields, tabs, and components
    borderWidth: 1,   // Border width for components
  },
};

Personnalisation spécifique aux composants

Vous pouvez personnaliser des composants UI spécifiques comme le bouton principal (bouton de paiement). Ces paramètres ont la priorité sur les paramètres d’apparence globaux :
const appearance = {
  primaryButton: {
    colors: {
      background: '#000000',
      text: '#ffffff',
      border: '#ff00ff',
    },
    shapes: {
      borderRadius: 10,
      borderWidth: 1.5,
    },
  },
};
Pour appliquer ces personnalisations, incluez-les dans votre configuration de session de paiement :
const params: sessionParams = {
  ...paymentSheetParams,
  configuration: {
    appearance: {
      themes: isDarkMode ? 'dark' : 'light',
      ...appearance, // Include your custom appearance settings
    },
  },
};

Gestion des erreurs

Gérez différents états de paiement dans votre fonction de paiement :
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);
  }
};
  • Problèmes de connectivité réseau : Assurez une connexion internet stable
  • Client secret invalide : Vérifiez que votre backend génère des intents de paiement valides
  • Dépendances manquantes : Installez toutes les dépendances requises
  • Configuration spécifique à la plateforme : Finalisez les étapes de configuration iOS et Android
  • Erreurs d’API : Consultez notre référence des codes d’erreur pour la gestion détaillée des erreurs
  • Activez la journalisation de débogage en développement
  • Vérifiez les requêtes réseau vers votre backend
  • Assurez-vous que les clés API sont correctement configurées
  • Testez à la fois sur iOS et Android
  • Consultez nos FAQ techniques pour les problèmes courants
  • Utilisez Mode test vs mode production de manière appropriée

Méthodes de paiement de test

Utilisez des numéros de carte de test en développement pour vérifier votre intégration sans traiter de paiements réels. En savoir plus sur notre processus de test et les environnements de test disponibles.