> ## 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 : configuration du SDK et identité utilisateur

> Comment l'application d'exemple Clean Beans installe le SDK OneSignal dans Expo, rattache chaque appareil à un utilisateur avec un External ID et ajoute l'e-mail.

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.

Tout le reste dépend de quatre éléments : le SDK est installé, il démarre en même temps que l'application, chaque appareil est rattaché à un utilisateur et les utilisateurs peuvent contrôler ce qu'ils reçoivent.

## Installer avec le plugin Expo \\

Le `onesignal-expo-plugin` configure les projets natifs iOS et Android au moment de la compilation. Il ajoute la capacité push, l'App Group et la Notification Service Extension dont OneSignal a besoin pour les images, les badges et la confirmation de livraison.

```json app.json theme={null}
{
  "expo": {
    "plugins": [
      ["onesignal-expo-plugin", { "mode": "production" }],
      "expo-router",
      "./plugins/withLiveActivityWidget"
    ],
    "ios": {
      "bundleIdentifier": "com.onesignal.cleaningapp",
      "infoPlist": {
        "UIBackgroundModes": ["remote-notification"],
        "NSSupportsLiveActivities": true
      },
      "entitlements": {
        "aps-environment": "production",
        "com.apple.security.application-groups": [
          "group.com.onesignal.cleaningapp.onesignal"
        ]
      }
    }
  }
}
```

## Initialiser une seule fois, à la racine \\

Clean Beans initialise OneSignal dans son layout racine, de sorte que l'initialisation s'exécute une fois à chaque lancement, avant l'affichage de tout écran.

```typescript app/_layout.tsx theme={null}
// Verbose logging is for debugging during the beta. Remove it, or lower
// the level, before a public release.
OneSignal.Debug.setLogLevel(LogLevel.Verbose);
OneSignal.initialize('YOUR_ONESIGNAL_APP_ID');
OneSignal.Notifications.requestPermission(true);
```

> [!TIP]
>
> Demander l'autorisation au premier lancement est l'approche la plus simple. Pour expliquer d'abord l'intérêt, affichez un message in-app avant l'invite système. Clean Beans en a un prêt à l'emploi : consultez [Pré-invite d'autorisation push](https://documentation.onesignal.com/docs/fr/example-full-integration-in-app-messages.md#push-permission-pre-prompt).

## Rattacher chaque appareil à un utilisateur \\

Lorsqu'une personne se connecte, l'application transmet son ID utilisateur Supabase à `OneSignal.login()`. Cet ID devient l'External ID. Lorsqu'elle se déconnecte, `logout()` détache l'appareil afin que la personne suivante qui se connecte n'hérite pas de ses messages.

```typescript app/_layout.tsx theme={null}
// Link OneSignal identity to authenticated user and sync timezone
//
// Wait until the saved session has been restored. On a cold start `user`
// is null for a moment while it loads; calling logout() then, followed by
// login() a moment later, can leave this device's push subscription on an
// anonymous OneSignal user, so pushes sent to the External ID never reach
// the phone. logout() is only called on a real sign-out.
const wasSignedIn = useRef(false);
useEffect(() => {
  if (loading) return;

  if (user) {
    wasSignedIn.current = true;
    OneSignal.login(user.id);
    syncDeviceTimezone();
    // Add email subscription and sync data tags to OneSignal
    if (user.email) syncOneSignalEmail(user.email);
    // Add the SMS subscription if the user has a verified phone number
    syncOneSignalSms();
    syncOneSignalTags();
  } else if (wasSignedIn.current) {
    wasSignedIn.current = false;
    OneSignal.logout();
  }
}, [user, loading]);
```

> [!WARNING]
>
> Attendez que la session enregistrée soit chargée avant d'appeler l'une ou l'autre méthode. Lors d'un démarrage à froid, l'utilisateur connecté est brièvement inconnu. Si l'application appelle `logout()` à ce moment-là puis `login()` un instant plus tard, l'abonnement push de l'appareil peut rester rattaché à un utilisateur anonyme, et les push adressés à l'External ID n'atteignent plus le téléphone. N'appelez `logout()` que lorsqu'une personne se déconnecte réellement.

C'est cet unique appel qui rend possibles tous les envois backend de ce guide. Une fonction qui connaît l'ID d'un utilisateur dans la base de données peut lui envoyer des messages sans rien savoir de ses appareils.

## Ajouter le canal e-mail \\

L'application connaît déjà l'adresse e-mail de chaque utilisateur depuis son inscription, elle l'enregistre donc comme abonnement e-mail à la connexion. OneSignal ignore les appels répétés avec la même adresse.

```typescript src/lib/onesignalSync.ts theme={null}
export function syncOneSignalEmail(email: string): void {
  try {
    if (!email) return;
    OneSignal.User.addEmail(email);
    console.log('[onesignalSync] Email subscription added');
  } catch (e) {
    console.warn('[onesignalSync] syncOneSignalEmail error:', e);
  }
}
```

Le SMS s'ajoute de la même manière avec `addSms()`, mais uniquement après la vérification du numéro. Consultez [SMS : codes de vérification et invitations](https://documentation.onesignal.com/docs/fr/example-full-integration-sms.md).

## Laisser les utilisateurs contrôler ce qu'ils reçoivent \\

L'écran des paramètres de notification comporte un interrupteur principal et un interrupteur par type de message.

![L'écran des paramètres de notification avec un interrupteur principal et des interrupteurs par type](https://mintcdn.com/onesignal/XdN288-p34EfpfHk/images/tutorials/cleanbeans-notifications.png?fit=max\&auto=format\&n=XdN288-p34EfpfHk\&q=85\&s=57fef32f8987a51e7bdf8c40a6273087)

Paramètres de notification : un interrupteur principal, des interrupteurs par type et l'heure du rappel quotidien.

L'interrupteur principal appelle `optOut()` et `optIn()` sur l'abonnement push, de sorte que OneSignal interrompt puis reprend la livraison vers cet appareil.

```typescript app/notification-settings.tsx theme={null}
const handlePushMasterToggle = async (enabled: boolean) => {
  try {
    if (enabled) {
      OneSignal.User.pushSubscription.optIn();
    } else {
      OneSignal.User.pushSubscription.optOut();
    }
  } catch (e) {
    console.warn('OneSignal subscription toggle failed:', e);
  }
  save({ ...prefs, pushEnabled: enabled });
};
```

Chaque interrupteur est aussi enregistré dans la ligne du profil de l'utilisateur. Le backend lit ces colonnes avant d'envoyer quoi que ce soit, ce qui permet d'appliquer les préférences par type.

```typescript src/lib/database.ts theme={null}
  const { error } = await supabase
    .from('profiles')
    .update({
      notifications_enabled: prefs.pushEnabled,
      push_daily_reminders: prefs.pushDailyReminders,
      push_streak_reminders: prefs.pushStreakReminders,
      push_cleaning_done: prefs.pushCleaningDone,
      push_leaderboard_updates: prefs.pushLeaderboardUpdates,
      push_upcoming_cleaning: prefs.pushUpcomingCleaning,
      push_overdue_reminders: prefs.pushOverdueReminders,
      email_weekly_summary: prefs.emailWeeklySummary,
      notification_hour: prefs.notificationHour,
      timezone: prefs.timezone,
    })
    .eq('id', user.id);
```

> [!NOTE]
>
> Stocker les préférences dans votre propre base de données et les vérifier avant chaque envoi permet de garder la logique au même endroit. L'alternative consiste à les stocker sous forme de tags et à filtrer par tag dans OneSignal. Cela fonctionne bien lorsque vous envoyez à des segments. Clean Beans envoie à des utilisateurs précis, il est donc plus simple de vérifier la base de données.

> [card] [Référence du SDK mobile](https://documentation.onesignal.com/docs/fr/mobile-sdk-reference.md)
>
> Toutes les méthodes client utilisées dans ce guide.

> [card] [Utilisateurs et External IDs](https://documentation.onesignal.com/docs/fr/users.md)
>
> Comment l'identité relie les abonnements entre canaux et appareils.


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