Descripción general de la administración de dispositivos

Baja del administrador de dispositivos. A partir de Android 9 (nivel de API 28), algunas políticas de administrador se marcarán como obsoletas cuando las invoque un administrador de dispositivos. Te recomendamos que comiences a prepararte ahora para este cambio. Para obtener más información y ver las opciones de migración, consulta Baja del administrador de dispositivos.

Android incluye compatibilidad con apps empresariales a través de la API de administración de dispositivos Android. La API de Device Administration proporciona funciones de administración de dispositivos a nivel del sistema. Estas APIs te permiten crear apps que tengan en cuenta la seguridad y que sean útiles en entornos empresariales, en los que los profesionales de TI requieren un control exhaustivo de los dispositivos de los empleados. Por ejemplo, la app de correo electrónico integrada de Android aprovechó estas APIs para mejorar la compatibilidad con Exchange. A través de la app de correo electrónico, los administradores de Exchange pueden aplicar políticas de contraseñas, incluidas las contraseñas alfanuméricas o los PIN numéricos, en todos los dispositivos. Los administradores también pueden limpiar de manera remota (es decir, restablecer la configuración de fábrica) los teléfonos perdidos o robados. Los usuarios de Exchange pueden sincronizar sus datos de correo electrónico y calendario.

Este documento está dirigido a desarrolladores que quieran crear soluciones empresariales para dispositivos con Android. En este documento, se analizan las diversas funciones que proporciona la API de administración de dispositivos para brindar una mayor seguridad a los dispositivos de los empleados que ejecutan Android.

Nota: Si deseas obtener información para compilar un controlador de políticas de trabajo para implementaciones de Android for Work, consulta Cómo compilar un controlador de políticas de dispositivos.

Modo Propietario del dispositivo sin interfaz gráfica

Android 14 (nivel de API 34) presenta el modo de usuario del sistema sin interfaz gráfica (dispositivos en los que UserManager.isHeadlessSystemUserMode devuelve true). En este modo, el usuario del sistema es un usuario en segundo plano y depende de usuarios adicionales en primer plano para la interacción con el usuario final. Android 14 también presenta un modo afiliado de propietario del dispositivo sin interfaz gráfica, que agrega un propietario del perfil a todos los usuarios afiliados, excepto al usuario del sistema en el que se estableció el propietario del dispositivo.

En los dispositivos configurados con un usuario del sistema sin interfaz gráfica (en el que el usuario del sistema se ejecuta en segundo plano), solo se aplican al usuario o los usuarios en primer plano las políticas de dispositivo que tienen un alcance global (políticas que se aplican a todos los usuarios). Consulta addUserRestriction para obtener más información.

Los fabricantes de dispositivos Android pueden consultar la guía publicada en source.android.com.

Descripción general de la API de administración de dispositivos

Estos son ejemplos de los tipos de apps que podrían usar la API de administración de dispositivos:

• Clientes de correo electrónico
• Apps de seguridad que limpian de manera remota
• Servicios y apps de administración de dispositivos

¿Cómo funciona?

Usa la API de administración de dispositivos para escribir apps de administración de dispositivos que los usuarios instalan en sus dispositivos. La app de administrador de dispositivos aplica las políticas deseadas. A continuación, te explicamos cómo funciona:

• Un administrador del sistema escribe una app de administrador de dispositivos que aplica políticas de seguridad de dispositivos remotos o locales. Estas políticas podrían estar codificadas en la app, o bien la app podría recuperar políticas de forma dinámica desde un servidor de terceros.
• La app se instala en los dispositivos de los usuarios. Actualmente, Android no tiene una solución de aprovisionamiento automatizada. Estas son algunas de las formas en que un administrador del sistema puede distribuir la app a los usuarios:
  • Google Play
  • Mediante la habilitación de la instalación desde otra tienda
  • Mediante la distribución de la app a través de otros medios, como correos electrónico o sitios web
• El sistema le solicita al usuario que habilite la app de administrador de dispositivos. El momento y la forma en que esto sucede dependen de cómo se implemente la app.
• Una vez que los usuarios habilitan la app de administrador de dispositivos, están sujetos a sus políticas. El cumplimiento de esas políticas suele otorgar beneficios, como el acceso a sistemas y datos sensibles.

Si los usuarios no habilitan la app de administración de dispositivos, esta permanece en el dispositivo, pero en estado inactivo. Los usuarios no estarán sujetos a sus políticas y, por el contrario, no obtendrán ninguno de los beneficios de la app, por ejemplo, quizás no puedan sincronizar datos.

Si un usuario no cumple con las políticas (por ejemplo, si establece una contraseña que incumple los lineamientos), la app debe decidir cómo manejar esta situación. Sin embargo, por lo general, esto hará que el usuario no pueda sincronizar los datos.

Si un dispositivo intenta conectarse a un servidor que requiere políticas no admitidas en la API de Device Administration, no se permitirá la conexión. Actualmente, la API de administración de dispositivos no permite el aprovisionamiento parcial. En otras palabras, si un dispositivo (por ejemplo, uno heredado) no admite todas las políticas indicadas, no hay forma de permitir que se conecte.

Si un dispositivo contiene varias apps de administración habilitadas, se aplica la política más estricta. No hay forma de segmentar una app de administración en particular.

Para desinstalar una app de administrador de dispositivos existente, los usuarios primero deben cancelar el registro de la app como administrador.

Políticas

En un entorno empresarial, suele ocurrir que los dispositivos de los empleados deben cumplir con un conjunto estricto de políticas que rigen el uso del dispositivo. La API de administración de dispositivos admite las políticas que se indican en la Tabla 1. Ten en cuenta que, actualmente, la API de administración de dispositivos solo admite contraseñas para el bloqueo de pantalla:

Tabla 1: Políticas compatibles con la API de administración de dispositivos

Otras funciones

Además de admitir las políticas que se indican en la tabla anterior, la API de administración de dispositivos te permite hacer lo siguiente:

• Solicitar al usuario que configure una nueva contraseña
• Bloquear el dispositivo de inmediato
• Limpiar los datos del dispositivo (es decir, restablecer los valores predeterminados de fábrica del dispositivo)

App de ejemplo

Los ejemplos que se usan en esta página se basan en la muestra de la API de administración de dispositivos, que se incluye en las muestras del SDK (disponibles a través de SDK Manager de Android) y se encuentra en tu sistema como <sdk_root>/ApiDemos/app/src/main/java/com/example/android/apis/app/DeviceAdminSample.java.

La app de muestra ofrece una demostración de las funciones de administración de dispositivos. Presenta a los usuarios una interfaz de usuario que les permite habilitar la app de administrador de dispositivos. Una vez que habilitaron la app, pueden usar los botones de la interfaz de usuario para hacer lo siguiente:

• Configurar la calidad de la contraseña
• Especifica los requisitos de la contraseña del usuario, como la longitud mínima, la cantidad mínima de caracteres numéricos que debe contener, etcétera.
• Configurar la contraseña. Si la contraseña no cumple con las políticas especificadas, el sistema devuelve un error.
• Establece cuántos intentos de contraseña fallidos pueden ocurrir antes de que se borren los datos del dispositivo (es decir, se restablezca la configuración de fábrica).
• Establecer cuándo caducará la contraseña
• Establecer la longitud del historial de contraseñas (la longitud se refiere a la cantidad de contraseñas antiguas almacenadas en el historial). Esto evita que los usuarios reutilicen una de las últimas n contraseñas que usaron anteriormente.
• Especificar que el área de almacenamiento debe estar encriptada, si el dispositivo lo admite
• Establece la cantidad máxima de tiempo de inactividad que puede transcurrir antes de que se bloquee el dispositivo.
• Hacer que el dispositivo se bloquee de inmediato
• Limpiar los datos del dispositivo (es decir, restablecer la configuración de fábrica)
• Inhabilitar la cámara

Figura 1: Captura de pantalla de la app de muestra

Cómo desarrollar una app de administración de dispositivos

Los administradores del sistema pueden usar la API de Device Administration para escribir una app que aplique la política de seguridad de dispositivos remotos o locales. En esta sección, se resumen los pasos que se deben seguir para crear una app de administración de dispositivos.

Cómo crear el manifiesto

Para usar la API de administración de dispositivos, el manifiesto de la app debe incluir lo siguiente:

• Una subclase de DeviceAdminReceiver que incluye lo siguiente:
  • El permiso BIND_DEVICE_ADMIN.
  • La capacidad de responder al intent ACTION_DEVICE_ADMIN_ENABLED, expresada en el manifiesto como un filtro de intents
• Una declaración de las políticas de seguridad que se usan en los metadatos

Aquí hay un extracto del manifiesto de muestra de la administración de dispositivos:

<activity android:name=".app.DeviceAdminSample"
            android:label="@string/activity_sample_device_admin">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.SAMPLE_CODE" />
    </intent-filter>
</activity>
<receiver android:name=".app.DeviceAdminSample$DeviceAdminSampleReceiver"
        android:label="@string/sample_device_admin"
        android:description="@string/sample_device_admin_description"
        android:permission="android.permission.BIND_DEVICE_ADMIN">
    <meta-data android:name="android.app.device_admin"
            android:resource="@xml/device_admin_sample" />
    <intent-filter>
        <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
    </intent-filter>
</receiver>

Ten en cuenta lo siguiente:

• Los siguientes atributos hacen referencia a recursos de cadenas que, para la app de ejemplo, residen en ApiDemos/res/values/strings.xml. Para obtener más información sobre los recursos, consulta Recursos de la aplicación.
  • android:label="@string/activity_sample_device_admin" hace referencia a la etiqueta de la actividad que los usuarios pueden leer.
  • android:label="@string/sample_device_admin" hace referencia a la etiqueta legible por el usuario para el permiso.
  • android:description="@string/sample_device_admin_description" hace referencia a la descripción del permiso legible por el usuario. Por lo general, una descripción es más larga y más informativa que una etiqueta.
• android:permission="android.permission.BIND_DEVICE_ADMIN" es un permiso que debe tener una subclase DeviceAdminReceiver para garantizar que solo el sistema pueda interactuar con el receptor (no se puede otorgar este permiso a ninguna app). Esto evita que otras apps abusen de tu app de administrador de dispositivos.
• android.app.action.DEVICE_ADMIN_ENABLED es la acción principal que debe controlar una subclase de DeviceAdminReceiver para que se le permita administrar un dispositivo. Esto se establece en el receptor cuando el usuario habilita la app de administrador del dispositivo. Por lo general, tu código controla esto en onEnabled(). Para que sea compatible, el receptor también debe requerir el permiso BIND_DEVICE_ADMIN, de modo que otras apps no puedan abusar de él.
• Cuando un usuario habilita la app de administrador de dispositivos, se le otorga permiso al receptor para realizar acciones en respuesta a la transmisión de eventos específicos del sistema. Cuando surge un evento adecuado, la app puede imponer una política. Por ejemplo, si el usuario intenta establecer una contraseña nueva que no cumple con los requisitos de la política, la app puede solicitarle que elija otra contraseña que sí los cumpla.
• Evita cambiar el nombre del receptor después de publicar la app. Si cambia el nombre en el manifiesto, se inhabilita el administrador de dispositivos cuando los usuarios actualizan la app. Para obtener más información, consulta <receiver>.
• android:resource="@xml/device_admin_sample" declara las políticas de seguridad que se usan en los metadatos. Los metadatos proporcionan información adicional específica del administrador de dispositivos, según lo analizado por la clase DeviceAdminInfo. Este es el contenido de device_admin_sample.xml:

<device-admin xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-policies>
    <limit-password />
    <watch-login />
    <reset-password />
    <force-lock />
    <wipe-data />
    <expire-password />
    <encrypted-storage />
    <disable-camera />
  </uses-policies>
</device-admin>

Cuando diseñes tu app de administración de dispositivos, no es necesario que incluyas todas las políticas, solo las que sean relevantes para tu app.

Cómo implementar el código

La API de administración de dispositivos incluye las siguientes clases:

DeviceAdminReceiver

Clase base para implementar un componente de administración de dispositivos. Esta clase proporciona una forma conveniente de interpretar las acciones de intents sin procesar que envía el sistema. Tu app de administración de dispositivos debe incluir una subclase DeviceAdminReceiver.

DevicePolicyManager

Una clase para administrar las políticas aplicadas en un dispositivo. La mayoría de los clientes de esta clase deben haber publicado un DeviceAdminReceiver que el usuario tenga habilitado en ese momento. DevicePolicyManager administra las políticas de una o más instancias de DeviceAdminReceiver

DeviceAdminInfo

Esta clase se usa para especificar metadatos de un componente de administrador de dispositivos.

Estas clases proporcionan la base para una app de administración de dispositivos completamente funcional. En el resto de esta sección, se describe cómo usar las APIs de DeviceAdminReceiver y DevicePolicyManager para escribir una app de administración de dispositivos.

Cómo subclasificar DeviceAdminReceiver

Para crear una app de administrador de dispositivos, debes crear una subclase de DeviceAdminReceiver. La clase DeviceAdminReceiver consta de una serie de devoluciones de llamada que se activan cuando ocurren eventos específicos.

En su subclase DeviceAdminReceiver, la app de ejemplo simplemente muestra una notificación Toast en respuesta a eventos específicos. Por ejemplo:

class DeviceAdminSample : DeviceAdminReceiver() {

    private fun showToast(context: Context, msg: String) {
        context.getString(R.string.admin_receiver_status, msg).let { status ->
            Toast.makeText(context, status, Toast.LENGTH_SHORT).show()
        }
    }

    override fun onEnabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_enabled))

    override fun onDisableRequested(context: Context, intent: Intent): CharSequence =
            context.getString(R.string.admin_receiver_status_disable_warning)

    override fun onDisabled(context: Context, intent: Intent) =
            showToast(context, context.getString(R.string.admin_receiver_status_disabled))

    override fun onPasswordChanged(context: Context, intent: Intent, userHandle: UserHandle) =
            showToast(context, context.getString(R.string.admin_receiver_status_pw_changed))
...
}

public class DeviceAdminSample extends DeviceAdminReceiver {

    void showToast(Context context, String msg) {
        String status = context.getString(R.string.admin_receiver_status, msg);
        Toast.makeText(context, status, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onEnabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_enabled));
    }

    @Override
    public CharSequence onDisableRequested(Context context, Intent intent) {
        return context.getString(R.string.admin_receiver_status_disable_warning);
    }

    @Override
    public void onDisabled(Context context, Intent intent) {
        showToast(context, context.getString(R.string.admin_receiver_status_disabled));
    }

    @Override
    public void onPasswordChanged(Context context, Intent intent, UserHandle userHandle) {
        showToast(context, context.getString(R.string.admin_receiver_status_pw_changed));
    }
...
}

Cómo habilitar la app

Uno de los eventos principales que debe controlar una app de administrador de dispositivos es que el usuario habilite la app. El usuario debe habilitar la app de forma explícita para que se apliquen las políticas. Si el usuario decide no habilitar la app, esta seguirá presente en el dispositivo, pero no se aplicarán sus políticas y el usuario no obtendrá ninguno de los beneficios de la app.

El proceso de habilitación de la app comienza cuando el usuario realiza una acción que activa el intent ACTION_ADD_DEVICE_ADMIN. En la app de ejemplo, esto sucede cuando el usuario hace clic en la casilla de verificación Habilitar administrador.

Cuando el usuario hace clic en la casilla de verificación Habilitar administrador, la pantalla cambia para solicitarle que active la app de administrador de dispositivos, como se muestra en la figura 2.

Figura 2: App de muestra: activación de la app

A continuación, se muestra el código que se ejecuta cuando el usuario hace clic en la casilla de verificación Habilitar administrador. Esto tiene el efecto de activar la devolución de llamada onPreferenceChange(). Esta devolución de llamada se invoca cuando el usuario cambia el valor de este Preference y está a punto de configurarlo o conservarlo. Si el usuario habilita la app, la pantalla cambia para solicitarle que active la app de administrador de dispositivos, como se muestra en la figura 2. De lo contrario, se inhabilita la app de administración de dispositivos.

override fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {
    if (super.onPreferenceChange(preference, newValue)) return true
    val value = newValue as Boolean
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                val intent = Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN).apply {
                    putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample)
                    putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                            activity.getString(R.string.add_admin_extra_app_text))
                }
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN)
                // return false - don't update checkbox until we're really active
                return false
            } else {
                dpm.removeActiveAdmin(deviceAdminSample)
                enableDeviceCapabilitiesArea(false)
                adminActive = false
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value)
    }
    return true
}

@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
    if (super.onPreferenceChange(preference, newValue)) {
        return true;
    }
    boolean value = (Boolean) newValue;
    if (preference == enableCheckbox) {
        if (value != adminActive) {
            if (value) {
                // Launch the activity to have the user enable our admin.
                Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
                intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, deviceAdminSample);
                intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                        activity.getString(R.string.add_admin_extra_app_text));
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN);
                // return false - don't update checkbox until we're really active
                return false;
            } else {
                dpm.removeActiveAdmin(deviceAdminSample);
                enableDeviceCapabilitiesArea(false);
                adminActive = false;
            }
        }
    } else if (preference == disableCameraCheckbox) {
        dpm.setCameraDisabled(deviceAdminSample, value);
    }
    return true;
}

La línea intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN, mDeviceAdminSample) indica que mDeviceAdminSample (que es un componente DeviceAdminReceiver) es la política de destino. Esta línea invoca la interfaz de usuario que se muestra en la figura 2, que guía a los usuarios para agregar el administrador de dispositivos al sistema (o les permite rechazarlo).

Cuando la app necesita realizar una operación que depende de que la app de administración de dispositivos esté habilitada, confirma que la app esté activa. Para ello, usa el método DevicePolicyManager isAdminActive(). Ten en cuenta que el método isAdminActive() de DevicePolicyManager toma un componente DeviceAdminReceiver como argumento:

private lateinit var dpm: DevicePolicyManager
...
private fun isActiveAdmin(): Boolean = dpm.isAdminActive(deviceAdminSample)

DevicePolicyManager dpm;
...
private boolean isActiveAdmin() {
    return dpm.isAdminActive(deviceAdminSample);
}

Administra políticas

DevicePolicyManager es una clase pública para administrar las políticas que se aplican en un dispositivo. DevicePolicyManager administra las políticas de una o más instancias de DeviceAdminReceiver.

Obtienes un controlador para el DevicePolicyManager de la siguiente manera:

dpm = getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager

DevicePolicyManager dpm =
    (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);

En esta sección, se describe cómo usar DevicePolicyManager para realizar tareas administrativas:

• Cómo configurar políticas de contraseña
• Configurar el bloqueo del dispositivo
• Realizar limpieza de datos

Cómo configurar políticas de contraseña

DevicePolicyManager incluye APIs para establecer y aplicar la política de contraseñas del dispositivo. En la API de Device Administration, la contraseña solo se aplica al bloqueo de pantalla. En esta sección, se describen tareas comunes relacionadas con la contraseña.

Cómo configurar una contraseña para el dispositivo

En este código, se muestra una interfaz del usuario que le solicita que configure una contraseña:

Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD).also { intent ->
    startActivity(intent)
}

Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
startActivity(intent);

Cómo configurar la calidad de la contraseña

La calidad de la contraseña puede ser una de las siguientes constantes DevicePolicyManager:

PASSWORD_QUALITY_ALPHABETIC

El usuario debe ingresar una contraseña que contenga al menos caracteres alfabéticos (u otros símbolos).

PASSWORD_QUALITY_ALPHANUMERIC

El usuario debe ingresar una contraseña que contenga al menos tanto caracteres numéricos como alfabéticos (u otros símbolos).

PASSWORD_QUALITY_NUMERIC

El usuario debe ingresar una contraseña que contenga al menos caracteres numéricos.

PASSWORD_QUALITY_COMPLEX

El usuario debe haber ingresado una contraseña que contenga al menos una letra, un dígito numérico y un símbolo especial.

PASSWORD_QUALITY_SOMETHING

La política requiere algún tipo de contraseña, pero no importa cuál sea.

PASSWORD_QUALITY_UNSPECIFIED

La política no tiene requisitos para la contraseña.

Por ejemplo, de esta forma debes configurar la política de contraseñas para que requiera una contraseña alfanumérica:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setPasswordQuality(deviceAdminSample, DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC);

Cómo configurar los requisitos de contenido de contraseña

A partir de Android 3.0, la clase DevicePolicyManager incluye métodos que te permiten ajustar el contenido de la contraseña. Por ejemplo, puedes establecer una política que indique que las contraseñas deben contener al menos n letras mayúsculas. Estos son los métodos para ajustar el contenido de una contraseña:

• setPasswordMinimumLetters()
• setPasswordMinimumLowerCase()
• setPasswordMinimumUpperCase()
• setPasswordMinimumNonLetter()
• setPasswordMinimumNumeric()
• setPasswordMinimumSymbols()

Por ejemplo, en este fragmento, se indica que la contraseña debe tener, como mínimo, 2 letras mayúsculas:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwMinUppercase = 2
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwMinUppercase = 2;
...
dpm.setPasswordMinimumUpperCase(deviceAdminSample, pwMinUppercase);

Cómo configurar la longitud mínima de la contraseña

Puedes especificar que una contraseña debe tener al menos la longitud mínima especificada. Por ejemplo:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwLength: Int = ...
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwLength;
...
dpm.setPasswordMinimumLength(deviceAdminSample, pwLength);

Cómo configurar la cantidad máxima de intentos de contraseña fallidos

Puedes establecer la cantidad máxima de intentos fallidos de contraseña permitidos antes de que se borren los datos del dispositivo (es decir, se restablezca la configuración de fábrica). Por ejemplo:

val dPM:DevicePolicyManager
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val maxFailedPw: Int = ...
...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int maxFailedPw;
 ...
dpm.setMaximumFailedPasswordsForWipe(deviceAdminSample, maxFailedPw);

Cómo configurar el tiempo de espera de caducidad de contraseña

A partir de Android 3.0, puedes usar el método setPasswordExpirationTimeout() para establecer cuándo vencerá una contraseña, expresado como un delta en milisegundos desde el momento en que un administrador de dispositivos establece el tiempo de espera de vencimiento. Por ejemplo:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwExpiration: Long = ...
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
long pwExpiration;
...
dpm.setPasswordExpirationTimeout(deviceAdminSample, pwExpiration);

Cómo restringir la contraseña en base al historial

A partir de Android 3.0, puedes usar el método setPasswordHistoryLength() para limitar la capacidad de los usuarios de reutilizar contraseñas anteriores. Este método toma un parámetro length, que especifica cuántas contraseñas antiguas se almacenan. Cuando esta política está activa, los usuarios no pueden ingresar una contraseña nueva que coincida con las últimas n contraseñas. Esto evita que los usuarios usen la misma contraseña una y otra vez. Esta política suele usarse junto con setPasswordExpirationTimeout(), que obliga a los usuarios a actualizar sus contraseñas después de que transcurre un período especificado.

Por ejemplo, en este fragmento se prohíbe a los usuarios volver a usar cualquiera de sus últimas 5 contraseñas:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val pwHistoryLength = 5
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
int pwHistoryLength = 5;
...
dpm.setPasswordHistoryLength(deviceAdminSample, pwHistoryLength);

Cómo configurar el bloqueo del dispositivo

Puedes establecer el período máximo de inactividad del usuario que puede transcurrir antes de que se bloquee el dispositivo. Por ejemplo:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
private val timeMs: Long = 1000L * timeout.text.toString().toLong()
...
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
long timeMs = 1000L*Long.parseLong(timeout.getText().toString());
dpm.setMaximumTimeToLock(deviceAdminSample, timeMs);

También puedes indicarle de forma programática que el dispositivo se bloquee de inmediato:

private lateinit var dpm: DevicePolicyManager
dpm.lockNow()

DevicePolicyManager dpm;
dpm.lockNow();

Cómo realizar la limpieza de datos

Puedes usar el método DevicePolicyManagerwipeData() para restablecer la configuración de fábrica del dispositivo. Esto es útil si el dispositivo se pierde o se lo roban. A menudo, la decisión de borrar el dispositivo es el resultado de que se cumplan ciertas condiciones. Por ejemplo, puedes usar setMaximumFailedPasswordsForWipe() para indicar que se debe borrar un dispositivo después de una cantidad específica de intentos fallidos de contraseña.

Limpias los datos de la siguiente manera:

private lateinit var dpm: DevicePolicyManager
dpm.wipeData(0)

DevicePolicyManager dpm;
dpm.wipeData(0);

El método wipeData() toma como parámetro una máscara binaria de opciones adicionales. Actualmente, el valor debe ser 0.

Inhabilitar la cámara

A partir de Android 4.0, puedes inhabilitar la cámara. Ten en cuenta que no es necesario que sea una inhabilitación permanente. La cámara se puede habilitar o inhabilitar de forma dinámica en función del contexto, el momento, etc.

Puedes controlar si la cámara está inhabilitada con el método setCameraDisabled(). Por ejemplo, en este fragmento se establece que la cámara se habilite o inhabilite en función de la configuración de una casilla de verificación:

private lateinit var disableCameraCheckbox: CheckBoxPreference
private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked)

private CheckBoxPreference disableCameraCheckbox;
DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setCameraDisabled(deviceAdminSample, mDisableCameraCheckbox.isChecked());

Encriptación de almacenamiento

A partir de Android 3.0, puedes usar el método setStorageEncryption() para establecer una política que requiera la encriptación del área de almacenamiento, donde se admita.

Por ejemplo:

private lateinit var dpm: DevicePolicyManager
private lateinit var deviceAdminSample: ComponentName
...
dpm.setStorageEncryption(deviceAdminSample, true)

DevicePolicyManager dpm;
ComponentName deviceAdminSample;
...
dpm.setStorageEncryption(deviceAdminSample, true);

Consulta la muestra de la API de administración de dispositivos para ver un ejemplo completo de cómo habilitar la encriptación de almacenamiento.

Muestras de código adicionales

En los ejemplos de AppRestrictionEnforcer y DeviceOwner de Android, se demuestra aún más el uso de las APIs que se abordan en esta página.