> ## 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.

> Cómo usar Auth0.Android para administrar usuarios

# Auth0.Android: Administración de usuarios

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) + "*****ENMASCARADO*****";
          }
          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 producto que permite a los clientes realizar tareas administrativas." cta="Ver glosario" href="/es/docs/glossary?term=Management+API">Management API</Tooltip> ofrece funcionalidades que puede usar para administrar los usuarios de su aplicación, incluidas las siguientes tareas:

* Vincular cuentas de usuario independientes de distintos proveedores y asociarlas a un único perfil. Para obtener más información, consulte [Vinculación de cuentas de usuario](/es/docs/manage-users/user-accounts/user-account-linking).
* Desvincular cuentas de usuario y devolverlas a identidades independientes.
* Actualizar los metadatos del usuario. Para obtener más información, consulte [Comprender cómo funcionan los metadatos en los perfiles de usuario](/es/docs/manage-users/user-accounts/metadata).

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

Para empezar, crea una nueva instancia de `UsersAPIClient` pasando `account` y el token de la identidad principal. En el caso de la vinculación de usuarios, esta identidad principal es el perfil del usuario cuyos datos quieres "conservar" y al que planeas vincular otras identidades.

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

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

<div id="link-users">
  ## Vincular usuarios
</div>

La vinculación de cuentas de usuario permite que un usuario se autentique con cualquiera de sus cuentas. Independientemente de con qué cuenta se autentique, iniciará sesión con el mismo perfil. Sin la vinculación de cuentas, Auth0 trata cada cuenta distinta como un perfil independiente.

El método `link` acepta dos parámetros: el id del usuario principal y el token del usuario secundario (el token obtenido después de iniciar sesión con esta identidad). El id del usuario en cuestión es el identificador único de esta cuenta de usuario. Si el id tiene el formato `facebook|1234567890`, el id requerido es la parte situada después de la barra vertical de separación.

```kotlin lines theme={null}
client
    .link("primary user id", "secondary user token")
    .start(object: Callback<List<UserIdentity>, ManagementException>() {
        override fun onSuccess(payload: List<UserIdentity>) {
            // ¡Se obtuvieron las identidades actualizadas! Cuentas vinculadas.
        }

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

<div id="unlink-users">
  ## Desvincular usuarios
</div>

Al desvincular usuarios, las cuentas vuelven a ser perfiles separados. El método `unlink` acepta tres parámetros: el id del usuario principal, el id del usuario secundario y el proveedor secundario (del usuario secundario).

```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>) {
            // ¡Se obtuvieron las identidades actualizadas! Cuentas vinculadas.
        }

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

Cuando se vinculan cuentas, los metadatos de la cuenta secundaria no se combinan con los de la cuenta principal. Del mismo modo, al desvincular dos cuentas, la cuenta secundaria no conserva los metadatos de la cuenta principal.

<div id="updating-user-metadata">
  ## Actualizar los metadatos del usuario
</div>

Al actualizar los metadatos del usuario, cree un objeto `metadata` y, a continuación, llame al método `updateMetadata` y páseles el id del usuario y el objeto `metadata`. Los valores de este objeto sobrescriben los valores existentes con la misma clave o agregan valores nuevos para las claves que aún no existen en los metadatos del usuario.

```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) {
            // Metadatos actualizados
        }

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