Skip to content

Création de liens profonds dans les messages in-app

Découvrez comment créer des liens profonds dans un message in-app pour le SDK de Braze.

Conditions préalables

Avant de pouvoir utiliser cette fonctionnalité, vous devrez intégrer le SDK Android Braze.

Création d’un délégué universel

Le SDK Android offre la possibilité de définir un objet de délégué unique pour personnaliser les liens profonds ouverts par Braze sur les cartes de contenu, les messages in-app et les notifications push.

Votre objet délégué doit implémenter l’interface IBrazeDeeplinkHandler et être défini à l’aide de BrazeDeeplinkHandler.setBrazeDeeplinkHandler(). Dans la plupart des cas, le délégué doit être défini dans le Application.onCreate() de l’application.

Voici un exemple de contournement du comportement par défaut UriAction avec des indicateurs d’intention personnalisés et un comportement personnalisé pour les URL YouTube :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class CustomDeeplinkHandler implements IBrazeDeeplinkHandler {
  private static final String TAG = BrazeLogger.getBrazeLogTag(CustomDeeplinkHandler.class);

  @Override
  public void gotoNewsFeed(Context context, NewsfeedAction newsfeedAction) {
    newsfeedAction.execute(context);
  }

  @Override
  public void gotoUri(Context context, UriAction uriAction) {
    String uri = uriAction.getUri().toString();
    // Open YouTube URLs in the YouTube app and not our app
    if (!StringUtils.isNullOrBlank(uri) && uri.contains("youtube.com")) {
      uriAction.setUseWebView(false);
    }

    CustomUriAction customUriAction = new CustomUriAction(uriAction);
    customUriAction.execute(context);
  }

  public static class CustomUriAction extends UriAction {

    public CustomUriAction(@NonNull UriAction uriAction) {
      super(uriAction);
    }

    @Override
    protected void openUriWithActionView(Context context, Uri uri, Bundle extras) {
      Intent intent = getActionViewIntent(context, uri, extras);
      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
      if (intent.resolveActivity(context.getPackageManager()) != null) {
        context.startActivity(intent);
      } else {
        BrazeLogger.w(TAG, "Could not find appropriate activity to open for deep link " + uri + ".");
      }
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class CustomDeeplinkHandler : IBrazeDeeplinkHandler {

  override fun gotoNewsFeed(context: Context, newsfeedAction: NewsfeedAction) {
    newsfeedAction.execute(context)
  }

  override fun gotoUri(context: Context, uriAction: UriAction) {
    val uri = uriAction.uri.toString()
    // Open YouTube URLs in the YouTube app and not our app
    if (!StringUtils.isNullOrBlank(uri) && uri.contains("youtube.com")) {
      uriAction.useWebView = false
    }

    val customUriAction = CustomUriAction(uriAction)
    customUriAction.execute(context)
  }

  class CustomUriAction(uriAction: UriAction) : UriAction(uriAction) {

    override fun openUriWithActionView(context: Context, uri: Uri, extras: Bundle) {
      val intent = getActionViewIntent(context, uri, extras)
      intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
      if (intent.resolveActivity(context.packageManager) != null) {
        context.startActivity(intent)
      } else {
        BrazeLogger.w(TAG, "Could not find appropriate activity to open for deep link $uri.")
      }
    }
  }

  companion object {
    private val TAG = BrazeLogger.getBrazeLogTag(CustomDeeplinkHandler::class.java)
  }
}

Création de liens profonds vers les paramètres d’application

Pour permettre aux liens profonds d’ouvrir directement les paramètres de votre application, vous aurez besoin d’un BrazeDeeplinkHandler personnalisé. Dans l’exemple suivant, la présence d’une paire clé-valeur personnalisée appelée open_notification_page fera en sorte que le lien profond ouvre la page paramètres de l’application :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

BrazeDeeplinkHandler.setBrazeDeeplinkHandler(new IBrazeDeeplinkHandler() {
  @Override
  public void gotoUri(Context context, UriAction uriAction) {
    final Bundle extras = uriAction.getExtras();
    if (extras.containsKey("open_notification_page")) {
      Intent intent = new Intent();
      intent.setAction("android.settings.APP_NOTIFICATION_SETTINGS");
      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

      //for Android 5-7
      intent.putExtra("app_package", context.getPackageName());
      intent.putExtra("app_uid", context.getApplicationInfo().uid);

      // for Android 8 and later
      intent.putExtra("android.provider.extra.APP_PACKAGE", context.getPackageName());
      context.startActivity(intent);
    }
  }

  @Override
  public void gotoNewsFeed(Context context, NewsfeedAction newsfeedAction) {}
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

BrazeDeeplinkHandler.setBrazeDeeplinkHandler(object : IBrazeDeeplinkHandler {
  override fun gotoUri(context: Context, uriAction: UriAction) {
    val extras = uriAction.extras
    if (extras.containsKey("open_notification_page")) {
      val intent = Intent()
      intent.action = "android.settings.APP_NOTIFICATION_SETTINGS"
      intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK

      //for Android 5-7
      intent.putExtra("app_package", context.packageName)
      intent.putExtra("app_uid", context.applicationInfo.uid)

      // for Android 8 and later
      intent.putExtra("android.provider.extra.APP_PACKAGE", context.packageName)
      context.startActivity(intent)
    }
  }

  override fun gotoNewsFeed(context: Context, newsfeedAction: NewsfeedAction) {}
})

Création de liens profonds avec le Fil d’actualité{#Android_Deep_Advance}

Pour réaliser un lien profond avec le fil d’actualité de Braze à partir d’une notification push, créez un lien profond personnalisé pour votre activité de fil d’actualité.

Ensuite, lorsque vous configurez votre campagne de notification push (via le tableau de bord ou l’API), configurez la notification pour qu’elle navigue vers votre lien profond du fil d’actualité.

Personnalisation de l’activité WebView

Par défaut, lorsque les liens profonds du site Internet sont ouverts à l’intérieur de l’application par Braze, ils sont gérés par BrazeWebViewActivity. Pour modifier ceci :

  1. Créez une nouvelle activité qui gère l’URL cible de Intent.getExtras() avec la clé com.braze.Constants.BRAZE_WEBVIEW_URL_EXTRA. Pour un exemple, voir BrazeWebViewActivity.java.
  2. Ajoutez cette activité à AndroidManifest.xml et définir exported sur false. 
    1
2
3

     <activity
     android:name=".MyCustomWebViewActivity"
     android:exported="false" />
  3. Définissez votre objet personnalisé Activity dans un objet générateur BrazeConfig. Créez le générateur et passez-le à Braze.configure() dans votre Application.onCreate().
1
2
3
4
5

BrazeConfig brazeConfig = new BrazeConfig.Builder()
    .setCustomWebViewActivityClass(MyCustomWebViewActivity::class)
    ...
    .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5

val brazeConfig = BrazeConfig.Builder()
    .setCustomWebViewActivityClass(MyCustomWebViewActivity::class.java)
    ...
    .build()
Braze.configure(this, brazeConfig)

Utiliser Jetpack Compose

Pour gérer les liens profonds lorsque vous utilisez Jetpack Compose avec NavHost :

  1. Assurez-vous que l’activité qui gère votre lien profond est enregistrée dans le manifeste Android. 
    1
2
3
4
5
6
7
8
9
10
11

     <activity
   ...
   <intent-filter>
     <action android:name="android.intent.action.VIEW" />
     <category android:name="android.intent.category.BROWSABLE" />
     <category android:name="android.intent.category.DEFAULT" />
     <data
         android:host="articles"
         android:scheme="myapp" />
   </intent-filter>
 </activity>
  2. Dans NavHost, indiquez les liens profonds que vous souhaitez qu’il gère. 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

     composableWithCompositionLocal(
     route = "YOUR_ROUTE_HERE",
     deepLinks = listOf(navDeepLink {
         uriPattern = "myapp://articles/{${MainDestinations.ARTICLE_ID_KEY}}"
     }),
     arguments = listOf(
         navArgument(MainDestinations.ARTICLE_ID_KEY) {
             type = NavType.LongType
         }
     ),
 ) { backStackEntry ->
     val arguments = requireNotNull(backStackEntry.arguments)
     val articleId = arguments.getLong(MainDestinations.ARTICLE_ID_KEY)
     ArticleDetail(
         articleId
     )
 }
  3. En fonction de l’architecture de votre application, il se peut que vous deviez également gérer la nouvelle intention envoyée à votre activité actuelle. 
    1
2
3
4
5
6
7

     DisposableEffect(Unit) {
     val listener = Consumer<Intent> {
         navHostController.handleDeepLink(it)
     }
     addOnNewIntentListener(listener)
     onDispose { removeOnNewIntentListener(listener) }
 }

guide/swift/deep_linking.md%} developer_

Github   Modifier cette page sur GitHub
CETTE PAGE A-T-ELLE ÉTÉ UTILE?
New Stuff!