> ## 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 utiliser Auth0.Android pour gérer les utilisateurs

# 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) + "*****MASKED*****";
          }
          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="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip> fournit des fonctionnalités que vous pouvez utiliser pour gérer les utilisateurs de votre application, notamment pour effectuer les tâches suivantes :

* Lier des comptes d’utilisateur distincts provenant de différents fournisseurs pour les rattacher à un seul profil. Pour en savoir plus, consultez [Liaison de comptes d’utilisateur](/fr-CA/docs/manage-users/user-accounts/user-account-linking).
* Dissocier des comptes d’utilisateur afin qu’ils redeviennent des identités distinctes.
* Mettre à jour les métadonnées de l’utilisateur. Pour en savoir plus, consultez [Comprendre le fonctionnement des métadonnées dans les profils d’utilisateur](/fr-CA/docs/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 transmettant `account` et le jeton de l’identité principale. Dans le cas de la liaison d’utilisateurs, cette identité principale correspond au profil de l’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 à partir de n’importe lequel de ses comptes. Peu importe le compte avec lequel il s’authentifie, il se connecte avec le 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 de l’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 les comptes en profils distincts. La méthode `unlink` accepte trois paramètres : l’id de l’utilisateur principal, l’id de l’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 dissocié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, lorsque vous dissociez 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 utilisateur
</div>

Pour mettre à jour les métadonnées utilisateur, créez un objet `metadata`, puis appelez la méthode `updateMetadata` en lui transmettant l’id de l’utilisateur et l’objet `metadata`. Les valeurs de cet objet remplacent les valeurs existantes ayant la même clé, ou ajoutent de nouvelles valeurs si elles n’existent pas encore dans les métadonnées 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 !
        }
    })
```