Asynchronous APIs on D1 SDK 4.4.0

Asynchronous APIs on D1 SDK 4.4.0

Overview

D1 SDK 4.4.0 introduces asynchronous API updates for Android and iOS.

On Android, the updated APIs support coroutine-based integrations. On iOS, the updated APIs support Swift concurrency. These changes apply to the Secure Card Display and Push Provisioning APIs.

Use this guide to review the affected APIs and update your issuer application.

What changed

The previous API surface is deprecated in D1 SDK 4.4.0. The deprecated APIs are now provided under the relevant product:

• Use Secure Card Display for card display flows.
• Use Push Provisioning for wallet digitization flows.

If your issuer application uses asynchronous calls, update those calls during the migration:

• On Android, use the Kotlin coroutine-based APIs.
• On iOS, use the Swift concurrency-based APIs.

This page lists the APIs changed in 4.4.0.

Migrate to the product-specific APIs

1

Review your current integration

Identify the deprecated D1 SDK APIs used by your issuer application.

Focus on the APIs used for Secure Card Display and Push Provisioning flows.

2

Move to the product-specific APIs

• Replace each deprecated API with the corresponding product-specific API.
• Use Secure Card Display APIs for card display features.
• Use Push Provisioning APIs for wallet digitization features.

3

Update asynchronous calls

• On Android, replace existing asynchronous calls with the Kotlin coroutine-based APIs.
• On iOS, replace existing asynchronous calls with the Swift concurrency APIs.

4

Validate the migrated flows

• Build and test your issuer application after the migration.
• Validate Secure Card Display and Push Provisioning flows.

Update asynchronous handling

Android

Use the Kotlin coroutine-based APIs if your issuer application uses Kotlin coroutines.

This simplifies asynchronous code and reduces callback handling.

Secure Card Display and Push Provisioning calls now return Task<T> instead of using Callback.

Use await() in coroutine-based integrations

Import the await extension explicitly:

import com.thalesgroup.gemalto.d1.await

Coroutine-based example:

fun getCardMetaData(d1Task: D1Task, cardID: String, activity: FragmentActivity) {
   activity.lifecycleScope.launch {
       try {
           val cardMetadata = d1Task.secureCardDisplayService.getCardMetadata(cardID).await()

           // Last 4 digits of PAN
           val last4Pan = cardMetadata.last4Pan

           // CardAsset is used to display Card Artwork
           val cardAssets = cardMetadata.getAssetList().await()
           // Proceeds with the application logic
       } catch (exception: D1Exception) {
           // Refer to D1 SDK Integration – Error Management section
       }
   }
}

Use execute(callback) in non-coroutine integrations

public void getCardMetaData(@NonNull D1Task d1Task, @NonNull String cardID) {
   D1Task.Callback<CardMetadata> callback = new D1Task.Callback<CardMetadata>() {
       @Override
       public void onSuccess(CardMetadata cardMetadata) {
           // Last 4 digits of PAN
           String last4Pan = cardMetadata.getLast4Pan();

           // Note: Asset list retrieval is handled separately in getAssetList() method
           // Proceeds with the application logic
       }

       @Override
       public void onError(D1Exception exception) {
           // Refer to D1 SDK Integration – Error Management section
       }
   };

   d1Task.getSecureCardDisplayService().getCardMetadata(cardID).execute(callback);
}

iOS

API changes in 4.4.0

Use this section to review the APIs changed in D1 SDK 4.4.0.

Initialize each product service from d1Task before calling the product APIs.

Android

val pushProvisioningService = d1Task.pushProvisioningService
val secureCardDisplayService = d1Task.secureCardDisplayService

iOS

Secure Card Display

Android

getCardMetadata

Before:

getCardMetadata(String cardID, Callback<CardMetadata> callback)

Now:

Task<CardMetadata> getCardMetadata(String cardID)

getCardDetails

Before:

getCardDetails(String cardID, Callback<CardDetails> callback)

Now:

Task<CardDetails> getCardDetails(String cardID)

displayCardDetails

Before:

displayCardDetails(String cardID, CardDetailsUI cardDetailsUI, Callback<Void> callback)

Now:

Task<Void> displayCardDetails(String cardID, CardDetailsUI cardDetailsUI)

iOS

Push Provisioning

Android

addDigitalCardToScheme

Before:

addDigitalCardToScheme(String cardID, TokenRequestor tokenRequestor, String appURL, boolean tcsAccepted, Callback<String> callback)

Now:

Task<String> addDigitalCardToScheme(String cardID, TokenRequestor tokenRequestor, String appURL, boolean tcsAccepted)

addDigitalCardToOEM

Before:

addDigitalCardToOEM(String cardID, OEMPayType oemType, Activity activity, D1Task.Callback<Object> callback)

Now:

Task<Object> addDigitalCardToOEM(String cardID, OEMPayType oemType, Activity activity, int options)

getTokenRequestorList

Before:

getTokenRequestorList(String cardID, Callback<List<TokenRequestor>> callback)

Now:

Task<List<TokenRequestor>> getTokenRequestorList(String cardID)

getCardDigitizationState

Before:

getCardDigitizationState(String cardID, OEMPayType oemType, D1Task.Callback<CardDigitizationState> callback)

Now:

Task<CardDigitizationState> getCardDigitizationState(String cardID, OEMPayType oemType)

New in 4.4.0:

Task<CardDigitizationState> getCardDigitizationState(OEMPayType oemType, String last4)

iOS