> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Application d'exemple : deep links et clics sur les notifications

> Comment l'application d'exemple Clean Beans dirige un push touché vers le bon écran, gère les boutons d'action et le report, et s'ouvre depuis des Universal Links.

Cette page fait partie de [Application d'exemple : une intégration OneSignal complète](https://documentation.onesignal.com/docs/fr/example-full-integration-overview.md), qui suit une application réelle de bout en bout. L'application s'appelle **Clean Beans**, un planning de ménage pour les logements partagés, construite avec Expo (React Native) et un backend Supabase.

Une notification n'est utile que si un appui dessus vous mène au bon endroit. Clean Beans gère quatre façons d'entrer dans l'application : un push touché, un bouton touché sur un push, un lien à schéma personnalisé et un lien web ordinaire.

## Router un push touché \\

Chaque push contient un champ `data.type`. L'application écoute les appuis, lit le type et ouvre l'écran correspondant.

```typescript app/_layout.tsx theme={null}
OneSignal.Notifications.addEventListener('click', (event: NotificationClickEvent) => {
  const data = event.notification.additionalData as Record<string, string> | undefined;
  if (!data?.type) return;

  // Mark inbox message as read (best-effort, fire-and-forget)
  const notificationId = event.notification.notificationId;
  if (notificationId) {
    supabase
      .from('inbox_messages')
      .update({ read: true })
      .eq('onesignal_message_id', notificationId)
      .then();
  }

  // Small delay to let the app finish initialising if cold-launched
  setTimeout(() => {
    // A tap on an action button ("Snooze 1h", "Send kudos", ...) carries an
    // actionId. A tap on the notification itself does not.
    const action = handlePushAction(event.result.actionId, data);
    if (action.handled) {
      if (action.route) router.push(action.route as any);
      return;
    }

    switch (data.type) {
      case 'daily_digest':
      case 'upcoming_cleaning':
      case 'overdue_reminder':
      case 'reengagement':
        router.push('/(tabs)/clean');
        break;
      case 'session_completed':
      case 'kudos':
        router.push('/activity');
        break;
      case 'join_approved':
      case 'member_lapsed':
        router.push('/household');
        break;
      default:
        break;
    }
  }, 500);
});
```

| `data.type` | Ouvre |
| - | - |
| `daily_digest`, `overdue_reminder`, `upcoming_cleaning` | L'onglet Clean |
| `session_completed`, `kudos` | Le fil d'activité |
| `join_approved`, `member_lapsed` | L'écran du foyer |
| `reengagement` | L'onglet Clean |

Deux de ces types proviennent de Journeys, que ce guide ne couvre pas. `reengagement` est défini sur les push d'un Journey de reconquête créé dans le tableau de bord. `member_lapsed` est un push destiné aux propriétaires et administrateurs d'un foyer, envoyé par le backend lorsque ce Journey signale qu'un membre a cessé de faire le ménage. Ils sont routés ici comme n'importe quel autre push.

> [!TIP]
>
> Router selon un type que vous contrôlez est plus robuste que d'analyser une URL. Si un écran change d'emplacement, vous modifiez une seule instruction `switch` et tous les push envoyés avant le changement continuent de s'ouvrir correctement.

## Boutons d'action : plus d'un endroit où appuyer \\

Un push peut contenir des boutons. Les push de tâches proposent **Start cleaning** et **Snooze 1h**, et le push « un colocataire a terminé le ménage » propose **Send kudos**. Les utilisateurs font apparaître les boutons en développant la notification, ce qui correspond à un appui long sur iOS.

![Une notification push développée avec les boutons Start cleaning et Snooze 1h](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-action-buttons.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=0a850d439deea8f483c8dfe532fb8e93)

Un rappel développé avec ses deux boutons d'action.

Le backend ajoute les boutons à la requête. Chacun possède un `id` et un libellé.

```typescript supabase/functions/_shared/buttons.ts theme={null}
export const TASK_BUTTONS = [
  { id: ACTION_START_CLEANING, text: 'Start cleaning' },
  { id: ACTION_SNOOZE, text: 'Snooze 1h' },
];
```

Appuyer sur un bouton ouvre l'application, et l'écouteur de clic présenté ci-dessus reçoit l'`id` du bouton sous la forme `event.result.actionId`. Un appui sur la notification elle-même n'a pas d'`actionId`. L'application vérifie d'abord s'il s'agit d'un bouton, puis revient au routage normal.

```typescript src/lib/pushActions.ts theme={null}
export function handlePushAction(actionId: string | undefined, data: PushData): ActionOutcome {
  if (!actionId) return { handled: false };

  // Record which button was tapped. As a custom event it can branch a
  // Journey (Wait Until this event) or feed a Conversion Metric.
  OneSignal.User.trackEvent('push_action_clicked', {
    action_id: actionId,
    notification_type: data?.type ?? 'unknown',
  });

  switch (actionId) {
    case ACTION_START_CLEANING:
      return { handled: true, route: '/(tabs)/clean' };

    case ACTION_SNOOZE:
      snoozeReminder();
      return { handled: true, route: null };

    case ACTION_SEND_KUDOS:
      sendKudosFromPush(data);
      return { handled: true, route: '/activity' };

    default:
      return { handled: false };
  }
}
```

Le **report** nécessite le backend, car l'application ne peut pas envoyer de push. Elle appelle une fonction qui planifie un autre rappel avec `send_after`. OneSignal conserve le message jusqu'à ce moment-là, rien n'a donc besoin de tourner pendant une heure.

```typescript supabase/functions/snooze-reminder/index.ts theme={null}
const sendAt = new Date(Date.now() + SNOOZE_MINUTES * 60_000);

const onesignalPayload = {
  app_id: ONESIGNAL_APP_ID,
  include_aliases: { external_id: [user.id] },
  target_channel: 'push',
  // OneSignal holds the message and delivers it at this time
  send_after: sendAt.toISOString(),
  // ...
};
```

> [!NOTE]
>
> Chaque appui sur un bouton est aussi enregistré comme événement personnalisé, `push_action_clicked`. Un Journey ne peut pas créer de branche directement sur un bouton, mais il peut attendre cet événement et créer une branche selon sa propriété `action_id`.

> [!NOTE]
>
> Appuyer sur un bouton ouvre l'application par défaut. Gérer un appui sans ouvrir l'application nécessite du code natif : une catégorie de notification sur iOS et une notification service extension sur Android.

## Réécrire les liens entrants \\

Les liens provenant de l'extérieur de l'application utilisent des chemins courts comme `/clean`. Le hook native intent d'Expo Router les réécrit vers les vraies routes de l'application avant la navigation, de sorte que rien à l'extérieur de l'application n'a besoin de connaître l'organisation des écrans.

```typescript app/+native-intent.tsx theme={null}
const PATH_REWRITES: Record<string, string> = {
  // Tab screens — simplified path → grouped route
  '/clean': '/(tabs)/clean',
  '/tasks': '/(tabs)/tasks',
  '/rota': '/(tabs)/rota',
  '/settings': '/(tabs)/settings',
  '/dashboard': '/(tabs)',

  // Standalone screens
  '/streaks': '/streaks',
  '/activity': '/activity',

  // Convenience aliases
  '/join': '/join-household',
  '/notifications': '/notification-settings',
};

export function redirectSystemPath({
  path,
  initial,
}: {
  path: string;
  initial: boolean;
}): string {
  try {
    // Parse the incoming URL to extract path and query string
    const url = new URL(path, 'cleaning-rota://app');
    const pathname = url.pathname || '/';
    const search = url.search || '';

    // Check for a rewrite match (exact path without query string)
    const rewritten = PATH_REWRITES[pathname];
    if (rewritten) {
      return rewritten + search;
    }

    // Universal Link / App Link with no rewrite: hand the router just the
    // path, not the full https URL
    if (url.protocol === 'https:' || url.protocol === 'http:') {
      return pathname + search;
    }

    // No rewrite needed — pass through as-is
    return path;
  } catch {
    // Never crash in this function — fall back to home screen
    return '/(tabs)';
  }
}
```

## Ouvrir l'application depuis des liens web ordinaires \\

Un schéma personnalisé comme `cleaning-rota://` ne fonctionne que si l'application est installée, et de nombreuses applications refusent de le rendre cliquable. Les Universal Links sur iOS et les App Links sur Android résolvent ce problème. Ce sont des liens `https://` classiques qui ouvrent l'application lorsqu'elle est installée et le site web dans le cas contraire. C'est donc le bon choix pour les liens dans les e-mails, les SMS et les messages partagés.

Leur configuration demande une déclaration de chaque côté : l'application indique à quel domaine elle appartient, et le site web indique quelle application peut ouvrir ses liens.

**1. Déclarer le domaine dans l'application**

```json app.json theme={null}
{
  "expo": {
    "ios": {
      "associatedDomains": ["applinks:cleanbeansapp.com"]
    },
    "android": {
      "intentFilters": [
        {
          "action": "VIEW",
          "autoVerify": true,
          "data": [
            { "scheme": "https", "host": "cleanbeansapp.com", "pathPrefix": "/join" },
            { "scheme": "https", "host": "cleanbeansapp.com", "pathPrefix": "/clean" }
          ],
          "category": ["BROWSABLE", "DEFAULT"]
        }
      ]
    }
  }
}
```

**2. Publier le fichier d'association Apple**

Hébergez-le à `/.well-known/apple-app-site-association`, en HTTPS, servi en JSON. L'ID de l'application est votre Apple Team ID suivi de l'identifiant du bundle.

```json website/.well-known/apple-app-site-association theme={null}
{
  "applinks": {
    "details": [
      {
        "appIDs": ["YOUR_TEAM_ID.com.onesignal.cleaningapp"],
        "components": [
          { "/": "/join", "comment": "Opens /join in the Clean Beans app" },
          { "/": "/clean", "comment": "Opens /clean in the Clean Beans app" }
        ]
      }
    ]
  }
}
```

**3. Publier le fichier d'association Android**

Hébergez-le à `/.well-known/assetlinks.json`. L'empreinte provient du certificat de signature de votre application. Avec EAS, exécutez `eas credentials -p android` pour la trouver.

```json website/.well-known/assetlinks.json theme={null}
[
  {
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
      "namespace": "android_app",
      "package_name": "com.onesignal.cleaningapp",
      "sha256_cert_fingerprints": ["YOUR_SHA256_FINGERPRINT"]
    }
  }
]
```

**4. Utiliser le lien**

L'écran du foyer partage un lien d'invitation. Un appui sur ce lien ouvre l'écran d'adhésion avec le code déjà renseigné.

```typescript app/household.tsx theme={null}
message: `Join my household "${activeHousehold.name}" on Clean Beans! Tap https://cleanbeansapp.com/join?code=${encodeURIComponent(activeHousehold.inviteCode)} or use invite code: ${activeHousehold.inviteCode}`,
```

```typescript app/join-household.tsx theme={null}
const params = useLocalSearchParams<{ code?: string }>();
const [code, setCode] = useState(typeof params.code === 'string' ? params.code : '');
```

> [!NOTE]
>
> Clean Beans ne revendique que les chemins que l'application peut afficher. La page d'accueil n'est pas concernée, le site marketing s'ouvre donc toujours dans le navigateur. iOS lit le fichier d'association lorsque l'application est installée ou mise à jour, publiez donc le fichier avant de diffuser la compilation.

> [card] [Deep linking](https://documentation.onesignal.com/docs/fr/deep-linking.md)
>
> Comment OneSignal gère les URL sur chaque plateforme.

> [card] [Payload de notification](https://documentation.onesignal.com/docs/fr/osnotification-payload.md)
>
> Tous les champs disponibles dans l'écouteur de clic.

> [card] [Boutons d'action](https://documentation.onesignal.com/docs/fr/action-buttons.md)
>
> Limites des plateformes, icônes et gestion des appuis.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.