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

> Comment gérer les utilisateurs avec Auth0.Android

# Auth0.Android: Gestion des utilisateurs

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

La <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> offre des fonctionnalités que vous pouvez utiliser pour gérer les utilisateurs de votre application, notamment les tâches suivantes :

* Lier des comptes d’utilisateur distincts provenant de différents fournisseurs afin de les associer à un seul profil. Pour en savoir plus, consultez [Liaison de comptes d’utilisateur](/docs/fr-ca/manage-users/user-accounts/user-account-linking).
* Dissocier des comptes d’utilisateur pour en refaire des identités distinctes.
* Mettre à jour les métadonnées utilisateur. Pour en savoir plus, consultez [Comprendre le fonctionnement des métadonnées dans les profils utilisateur](/docs/fr-ca/manage-users/user-accounts/metadata).

<div id="initialize-the-usersapiclient">
  ## Initialiser le UsersAPIClient
</div>

Pour commencer, créez une nouvelle instance de `UsersAPIClient` en lui passant le `account` et le jeton de l’identité principale. Dans le cas de la liaison d’utilisateurs, cette identité principale correspond au profil utilisateur dont vous souhaitez "conserver" les données et auquel vous prévoyez de lier d’autres identités.

export const codeExample = `val account = Auth0("{yourClientId}", "{yourDomain}")
val client = UsersAPIClient(account, "token")`;

<AuthCodeBlock children={codeExample} language="kotlin" />

<div id="link-users">
  ## Lier des utilisateurs
</div>

La liaison de comptes d’utilisateur permet à un utilisateur de s’authentifier avec n’importe lequel de ses comptes. Peu importe le compte utilisé pour s’authentifier, il se connecte au même profil. Sans liaison de comptes, Auth0 traite chaque compte différent comme un profil distinct.

La méthode `link` accepte deux paramètres : l’ID de l’utilisateur principal et le jeton de l’utilisateur secondaire (le jeton obtenu après la connexion avec cette identité). L’ID utilisateur en question est l’identifiant unique de ce compte d’utilisateur. Si l’ID est au format `facebook|1234567890`, l’ID requis correspond à la partie après la barre verticale de séparation.

```kotlin lines theme={null}
client
    .link("primary user id", "secondary user token")
    .start(object: Callback<List<UserIdentity>, ManagementException>() {
        override fun onSuccess(payload: List<UserIdentity>) {
            // Identités mises à jour ! Comptes liés.
        }

        override fun onFailure(error: ManagementException) {
            // Erreur !
        }
    })
```

<div id="unlink-users">
  ## Dissocier des utilisateurs
</div>

La dissociation d’utilisateurs rétablit des profils distincts pour les comptes. La méthode `unlink` prend trois paramètres : l’ID utilisateur principal, l’ID utilisateur secondaire et le fournisseur secondaire (de l’utilisateur secondaire).

```kotlin lines theme={null}
users
    .unlink("primary user id", "secondary user id", "secondary provider")
    .start(object: Callback<List<UserIdentity>, ManagementException>() {
        override fun onSuccess(payload: List<UserIdentity>) {
            // Identités mises à jour ! Comptes liés.
        }

        override fun onFailure(error: ManagementException) {
            // Erreur !
        }
    })
```

Lorsque des comptes sont liés, les métadonnées du compte secondaire ne sont pas fusionnées avec celles du compte principal. De même, lorsqu’on dissocie deux comptes, le compte secondaire ne conserve pas les métadonnées du compte principal.

<div id="updating-user-metadata">
  ## Mise à jour des métadonnées de l’utilisateur
</div>

Lorsque vous mettez à jour les métadonnées de l’utilisateur, créez un objet `metadata`, puis appelez la méthode `updateMetadata` en lui passant l’ID de l’utilisateur et l’objet `metadata`. Les valeurs de cet objet remplacent les valeurs existantes associées à la même clé ou ajoutent de nouvelles valeurs pour les clés qui n’existent pas encore dans les métadonnées de l’utilisateur.

```kotlin lines theme={null}
val metadata = mutableMapOf<String, Any?>()
metadata.put("name", listOf("My", "Name", "Is"));
metadata.put("phoneNumber", "1234567890");

users
    .updateMetadata("user id", metadata)
    .start(object: Callback<UserProfile, ManagementException>() {
        override fun onSuccess(payload: UserProfile) {
            // Métadonnées mises à jour
        }

        override fun onFailure(error: ManagementException) {
            // Erreur !
        }
    })
```