> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-docs-event-stream-action-templates.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Auth0.Android: User Management

> Comment utiliser Auth0.Android pour gérer les 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 href="/docs/fr-ca/glossary?term=management-api" tip="Management API
Un produit permettant aux clients d’effectuer des tâches administratives." cta="Voir le glossaire">Management API</Tooltip> fournit des fonctionnalités que vous pouvez utiliser pour gérer les utilisateurs de votre application, y compris les types de tâches suivants :

* Associer à un profil unique des comptes d’utilisateurs distincts de différents fournisseurs. Pour en savoir plus, lisez [Association de comptes d’utilisateur](/docs/fr-ca/manage-users/user-accounts/user-account-linking).
* Désassocier des comptes d’utilisateurs, les renvoyant à des identités distinctes.
* Mettre à jour les métadonnées de l’utilisateur. Pour en savoir plus, lisez [Comprendre le fonctionnement des métadonnées dans les profils d’utilisateurs](/docs/fr-ca/manage-users/user-accounts/metadata).

## Initialiser UsersAPIClient

Pour commencer, créez une nouvelle instance `UsersAPIClient` en lui transmettant l’élément `account` et le jeton de l’identité principale. Dans le cas de l’association d’utilisateurs, cette identité principale est le profil utilisateur pour lequel vous souhaitez « conserver » les données et auquel vous envisagez d’associer d’autres identités.

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

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

## Associer des utilisateurs

L’association de comptes d’utilisateurs permet à un utilisateur de s’authentifier à partir de n’importe lequel de ses comptes. Ainsi, quel que soit le compte avec lequel il s’authentifie, il se connecte avec le même profil. Sans association de comptes, Auth0 traite chaque compte différent comme un profil distinct.

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

```kotlin lines theme={null}
client
    .link("primary user id", "secondary user token")
    .start(object: Callback<List<UserIdentity>, ManagementException>() {
        override fun onSuccess(payload: List<UserIdentity>) {
            // Got the updated identities! Accounts linked.
        }

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

## Dissocier les utilisateurs

La dissociation des utilisateurs renvoie les comptes à des profils distincts. La méthode `unlink` nécessite trois paramètres : l’identifiant d’utilisateur principal, l’identifiant d’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>) {
            // Got the updated identities! Accounts linked.
        }

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

Lorsque les comptes sont liés, les métadonnées du compte secondaire ne fusionnent pas avec les métadonnées du compte principal. De même, lors de la dissociation de deux comptes, le compte secondaire ne conserve pas les métadonnées du compte principal.

## Mettre à jour des métadonnées de l’utilisateur

Lors de la mise à jour des métadonnées de l’utilisateur, vous créez un objet `metadata`, puis vous appelez la méthode `updateMetadata` en lui transmettant l’identifiant de l’utilisateur et l’objet `metadata`. Les valeurs de cet objet remplacent les valeurs de la même clé, ou en ajoutent de nouvelles pour celles qui n’existent pas encore pour 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) {
            // Metadata updated
        }

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