SDK Android

Utilisez le SDK Android DEUNA pour afficher une expérience de paiement complète, un widget de paiement, un coffre-fort de paiement, Click to Pay, prochaine étape, coupon et Google Pay natif dans les applications Kotlin. Le SDK prend en charge Android API 22 et versions ultérieures.

Installation#

Ajoutez JitPack pour la résolution des dépendances et spécifiez une version du SDK.

dependencyResolutionManagement {
  repositories {
    google()
    mavenCentral()
    maven(url = "https://jitpack.io")
  }
}

android {
  defaultConfig {
    minSdk = 22
  }
}

dependencies {
  implementation("com.github.deuna-developers:deunasdk:<version>")
}

Sélectionnez et spécifiez <version> dans le dépôt les versions.. Effectuer des tests de mise à niveau dans l'environnement de test avant de les déployer en production.

Initialisation#

Créer une instance SDK unique avec la clé API publique pour l'environnement sélectionné et la conserver pour le flux d'intégration.

import com.deuna.maven.DeunaSDK
import com.deuna.maven.shared.Environment

val deunaSDK = DeunaSDK(
  environment = Environment.SANDBOX,
  publicApiKey = "YOUR_PUBLIC_API_KEY",
)

Pour une instance d'application, initialisez une seule fois le SDK partagé :

DeunaSDK.initialize(
  environment = Environment.SANDBOX,
  publicApiKey = "YOUR_PUBLIC_API_KEY",
)

val deunaSDK = DeunaSDK.shared

Ouvrir le Widget de Paiement dans une fenêtre modale#

Construisez des callbacks de type défini et passez un Activity ou une autre interface utilisateur valide Context:

import com.deuna.maven.initPaymentWidget
import com.deuna.maven.widgets.payment_widget.PaymentWidgetCallbacks

val callbacks = PaymentWidgetCallbacks().apply {
  onSuccess = { order ->
    deunaSDK.close()
    showConfirmation(order)
  }
  onError = { error -> showRetry(error) }
  onClosed = { action -> showCart(action) }
  onPaymentProcessing = { disablePayButton() }
  onEventDispatch = { event, payload ->
    analytics.track(event.name, payload)
  }
}

deunaSDK.initPaymentWidget(
  context = this,
  orderToken = orderToken,
  callbacks = callbacks,
  language = "en",
)

Le gestionnaire de modal gère les vues du widget et de redirection. Appeler close() Une fois que votre flux de succès ou d'erreur est terminé, il attend la fermeture de l'URL externe active avant de libérer le widget.

Expériences disponibles#

Toutes les méthodes de modal acceptent des paramètres optionnels pour la langue, la détection de fraude, l'agent utilisateur personnalisé et le domaine, si pris en charge. Ne pas les remplacer. domain sauf si DEUNA vous fournit un hôte d'intégration spécifique.

Intégrer un widget#

Le mode intégré utilise une configuration typée et DeunaWidget. Cet exemple Jetpack Compose affiche le widget de paiement et détruit son WebView avec le cycle de vie de l'écran.

import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.viewinterop.AndroidView
import com.deuna.maven.web_views.deuna.DeunaWidget
import com.deuna.maven.web_views.deuna.extensions.build
import com.deuna.maven.widgets.configuration.PaymentWidgetConfiguration

val configuration = remember(orderToken) {
  PaymentWidgetConfiguration(
    sdkInstance = deunaSDK,
    orderToken = orderToken,
    callbacks = callbacks,
  )
}

val widget = remember { mutableStateOf<DeunaWidget?>(null) }

AndroidView(
  factory = { context ->
    DeunaWidget(context).apply {
      widgetConfiguration = configuration
      build()
      widget.value = this
    }
  },
)

DisposableEffect(Unit) {
  onDispose { widget.value?.destroy() }
}

Appeler resume() et pause() lors du démarrage et de l'arrêt du cycle de vie. Pour un widget dans une barre de défilement verticale, passez AutoResizeConfig dans la configuration et connectez-vous setOnScrollByCallback à l'état de défilement du parent.

Si votre application possède le bouton de paiement, définissez hidePayButton = true dans la configuration et appelez l'extension DeunaWidget intégré submit { result -> ... } depuis le clic sur le bouton.

Coffre-fort de paiement et Paiement en un clic#

Le Coffre-fort de paiement est l'expérience par défaut Elements. Passez soit un compte authentifié userToken ou UserInfo pour identifier le client.

import com.deuna.maven.initElements
import com.deuna.maven.shared.ElementsCallbacks
import com.deuna.maven.shared.domain.UserInfo

val elementsCallbacks = ElementsCallbacks().apply {
  onSuccess = { credential -> useSavedCredential(credential) }
  onError = { error -> showRetry(error) }
  onClosed = { action -> showPaymentMethods(action) }
}

deunaSDK.initElements(
  context = this,
  orderToken = orderToken,
  userInfo = UserInfo(email = "ada@example.com"),
  types = listOf(mapOf("name" to "vault")),
  callbacks = elementsCallbacks,
)

Utilisation "click_to_pay" au lieu de "vault" pour Click to Pay.

Google Pay natif#

Vérifiez la configuration du commerçant et la compatibilité de l'appareil avant d'afficher votre bouton Google Pay. Le SDK stocke le résultat en cache.

import com.deuna.maven.wallets.GetWalletsAvailableParams
import com.deuna.maven.wallets.WalletProvider
import com.deuna.maven.wallets.getWalletsAvailable

val userInfo = UserInfo(email = "ada@example.com")

deunaSDK.getWalletsAvailable(
  context = this,
  params = GetWalletsAvailableParams(
    orderToken = orderToken,
    userInfo = userInfo,
  ),
) { wallets, error ->
  if (error != null) {
    showWalletError(error)
    return@getWalletsAvailable
  }

  googlePayButton.isVisible = WalletProvider.GOOGLE_PAY in wallets
}

Une fois la disponibilité confirmée, lancez la feuille à partir du clic sur le bouton. initElements nécessite un appel de disponibilité initial.

googlePayButton.setOnClickListener {
  deunaSDK.initElements(
    context = this,
    orderToken = orderToken,
    userInfo = userInfo,
    types = listOf(mapOf("name" to WalletProvider.GOOGLE_PAY.name)),
    callbacks = elementsCallbacks,
  )
}

Consultez Google Payer pour les détails d'inscription, de test et de tokenisation.

Poursuivre une action en attente#

Utilisez le même jeton de commande lorsque DEUNA signale que le paiement nécessite un défi ou une redirection 3DS pris en charge.

deunaSDK.initNextAction(
  context = this,
  orderToken = orderToken,
  callbacks = nextActionCallbacks,
)

Le SDK ouvre les URL externes prises en charge et retourne à l'élément actif. Utilisez l'état de rappel pour l'interface et un webhook vérifié pour la finalisation.

Ouvrir un bon de réduction#

deunaSDK.initVoucherWidget(
  context = this,
  orderToken = orderToken,
  callbacks = voucherCallbacks,
)

Les notifications de remboursement fonctionnent selon le même cycle de réussite, d'erreur, de fermeture et de déclenchement d'événements que les autres expériences de paiement.

Données des appareils frauduleux#

Initialiser les fournisseurs de fraude natifs configurés à l'avance, par exemple dans Application.onCreate, afin de réduire la latence plus tard dans le processus de paiement.

DeunaSDK.initializeFraudProviders(
  context = applicationContext,
  params = mapOf("MERCADOPAGO" to emptyMap<String, Any>()),
  onError = { message -> logFraudError(message) },
)

Générez l'identifiant combiné lorsque votre commande ou votre flux de risque en nécessite un.

deunaSDK.generateFraudId(
  context = this,
  callback = { fraudId -> attachFraudId(fraudId) },
)

Inclure uniquement les dépendances et la configuration des fournisseurs de lutte contre la fraude attribuées à votre compte. Voir Intégrer l'empreinte digitale de l'appareil.

Référence des callbacks et du cycle de vie#

Exemples et code source officiels#

Consultez le fichier ExploreViewModel.kt Pour les usines de configuration et EmbeddedScreen.kt Pour la gestion du cycle de vie de WebView.