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

Sécurité simplifiée

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

Méthodes de paiement multiples

Acceptez diverses méthodes de paiement pour étendre votre portée mondiale

UI native

É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 à ajouter le support de ces méthodes de paiement dans les futures versions.

Installation

1

Installer le SDK

Installez le SDK Dodo Payments en utilisant votre gestionnaire de paquets préféré :
npm install dodopayments-react-native-sdk
2

Configuration spécifique à la plateforme

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

Configuration côté client

1

Obtenir la clé publiable

Obtenez votre clé publiable depuis le tableau de bord Dodo Payments. (Distinct pour les modes test et live) https://app.dodopayments.com/developer/others
2

Configurer le fournisseur de paiement

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

Créer une fonction utilitaire de paiement

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 avez un point de terminaison API backend qui crée des intentions de paiement et renvoie un secret client. 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

Implémenter l'écran de paiement

Créez votre écran de paiement en utilisant le useCheckout hook. 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
required
Le secret client de votre intention de paiement, obtenu depuis l’API de paiement unique ou d’abonnement.
mode
string
required
Le mode de la session de paiement (test ou live).
configuration.appearance
object
Options de personnalisation pour l’apparence de la feuille de paiement
configuration.appearance.themes
string
Mode de thème : 'light' ou 'dark'

Personnalisation de l’apparence

Vous pouvez personnaliser le Checkout Unifié React Native pour correspondre au design de votre application en modifiant les couleurs, les polices, et plus encore via le paramètre d’apparence lors de l’appel à initPaymentSession().

Personnalisation des couleurs

Chaque catégorie de couleur détermine la couleur d’un ou plusieurs composants de l’UI. Par exemple, primary définit la couleur du bouton de paiement.
Catégorie de couleurUtilisation
primaryCouleur principale pour le bouton de paiement et les éléments sélectionnés
backgroundCouleur de fond de la page de paiement
componentBackgroundCouleur de fond pour les entrées, les onglets et d’autres composants
componentBorderCouleur de bordure externe pour les entrées, les onglets et d’autres composants
componentDividerCouleur de bordure interne (bords partagés) pour les composants
primaryTextCouleur du texte d’en-tête
secondaryTextCouleur du texte des étiquettes pour les champs de saisie
componentTextCouleur du texte d’entrée (par exemple, numéro de carte, code postal)
placeholderTextCouleur du texte d’espace réservé pour les champs de saisie
iconCouleur pour les icônes (par exemple, bouton de fermeture)
errorCouleur pour les messages d’erreur et les 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-vous d’une connexion Internet stable
  • Secret client invalide : Vérifiez que le backend génère des intentions de paiement valides
  • Dépendances manquantes : Installez toutes les dépendances requises
  • Configuration spécifique à la plateforme : Complétez les étapes de configuration iOS et Android
  • Erreurs API : Consultez notre Référence des codes d’erreur pour une gestion des erreurs détaillée
  • Activez la journalisation de débogage en développement
  • Vérifiez les requêtes réseau vers votre backend
  • Vérifiez que les clés API sont correctement configurées
  • Testez sur les plateformes iOS et Android
  • Consultez nos FAQ techniques pour des problèmes courants
  • Utilisez Mode test vs Mode live 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.