2.1 Encontre a estrutura que guarda as opções de desbloqueio disponíveis - hendriomm/Hands-On-Android GitHub Wiki

Relatório de Desenvolvimento - Tarefa 2.1


Especificação

Existe uma estrutura em formato Enum que guarda todas as opções de desbloqueio disponíveis no código fonte encontrado na atividade 1.2, encontre-a.

Procedimento

1º Passo

Utilizando a tela "Choose a new screen lock" presente na questão 2, tentamos encontrar a o nome da string que armazena esse texto.

Captura de tela em 2024-07-10 13-55-19

Assim encontramos que o nome da string é

lock_settings_picker_update_lock_title

2º Passo

Usamos o nome da string encontrado para procurar o componente ou classe que o utiliza para criar a tela.

Captura de tela em 2024-07-10 14-02-04

Dessa forma encontramos a classe ChooseLockGeneric.java, cujo caminho é:

packages/apps/Settings/src/com/android/settings/password/ChooseLockGeneric.java

3º Passo

Dada a forma que as opções são mostradas na tela

346722058-92c874bd-21b2-4713-8387-52192ef00309

tentamos, nesse passo, encontrar alguma estrutura que se assemelhe a um switch case ou algo parecido. Em algum ponto do código deve haver uma sequência de condicionais relacionadas com as opções de desbloqueio.

Seguindo essa ideia, encontramos a função updatePreferenceText(), que parece fazer isso.

Captura de tela em 2024-07-10 14-10-48

Existe um fator comum a todas as opções, que é este enumerador chamado ScreenLockType. Parece ser o que queremos encontrar.

Seu caminho no AOSP é:

packages/apps/Settings/src/com/android/settings/password/ScreenLockType.java

Seu código completo é descrito a seguir:

/**
 * List of screen lock type options that are available in ChooseLockGeneric. Provides the key and
 * the associated quality, and also some helper functions to translate between them.
 */
public enum ScreenLockType {

    NONE(
            DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED,
            "unlock_set_off"),
    SWIPE(
            DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED,
            "unlock_set_none"),
    PATTERN(
            DevicePolicyManager.PASSWORD_QUALITY_SOMETHING,
            "unlock_set_pattern"),
    PIN(
            DevicePolicyManager.PASSWORD_QUALITY_NUMERIC,
            DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX,
            "unlock_set_pin"),
    PASSWORD(
            DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC,
            DevicePolicyManager.PASSWORD_QUALITY_COMPLEX,
            "unlock_set_password"),
    MANAGED(
            DevicePolicyManager.PASSWORD_QUALITY_MANAGED,
            "unlock_set_managed");

    /**
     * The default quality of the type of lock used. For example, in the case of PIN, the default
     * quality if PASSWORD_QUALITY_NUMERIC, while the highest quality is
     * PASSWORD_QUALITY_NUMERIC_COMPLEX.
     */
    public final int defaultQuality;

    /**
     * The highest quality for the given type of lock. For example, in the case of password, the
     * default quality is PASSWORD_QUALITY_ALPHABETIC, but the highest possible quality is
     * PASSWORD_QUALITY_COMPLEX.
     */
    public final int maxQuality;

    public final String preferenceKey;

    ScreenLockType(int quality, String preferenceKey) {
        this(quality, quality, preferenceKey);
    }

    ScreenLockType(int defaultQuality, int maxQuality, String preferenceKey) {
        this.defaultQuality = defaultQuality;
        this.maxQuality = maxQuality;
        this.preferenceKey = preferenceKey;
    }

    /**
     * Gets the screen lock type for the given quality. Note that this method assumes that a screen
     * lock is enabled, which means if the quality is
     * {@link DevicePolicyManager#PASSWORD_QUALITY_UNSPECIFIED}, the returned type will be
     * {@link #SWIPE} and not {@link #NONE}.
     */
    public static ScreenLockType fromQuality(int quality) {
        switch (quality) {
            case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:
                return ScreenLockType.PATTERN;
            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
            case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX:
                return ScreenLockType.PIN;
            case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:
            case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:
            case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:
                return ScreenLockType.PASSWORD;
            case DevicePolicyManager.PASSWORD_QUALITY_MANAGED:
                return ScreenLockType.MANAGED;
            case DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED:
                return ScreenLockType.SWIPE;
        }
        return null;
    }

    public static ScreenLockType fromKey(String key) {
        for (ScreenLockType lock : ScreenLockType.values()) {
            if (lock.preferenceKey.equals(key)) {
                return lock;
            }
        }
        return null;
    }

O enumerador condiz bem com que se pede na descrição do problema.


Sobre o atributo Quality do enumerador encontrado

Este atributo representa o nível de segurança que cada um dos métodos de desbloqueio contém. É representado por um número inteiro, quanto mais seguro for o método maior será seu valor.

PASSWORD_QUALITY_UNSPECIFIED

Pode ser NONE ou SWIPE, métodos que não possuem nenhuma segurança. Seu valor é 0.

PASSWORD_QUALITY_BIOMETRIC_WEAK

Desbloqueio biométrico, cujo valor é 0x8000;

PASSWORD_QUALITY_SOMETHING

Este método exige algum tipo de bloqueio, sem especificar qual. O padrão ("pattern") se encaixa aqui. Seu valor é 0x10000.

PASSWORD_QUALITY_NUMERIC

Senha númerica. Valor é 0x20000.

PASSWORD_QUALITY_NUMERIC_COMPLEX

Senha númerica sem números repetidos. Valor é 0x30000.

PASSWORD_QUALITY_ALPHABETIC

Senha deve conter letras. Valor é 0x40000.

PASSWORD_QUALITY_ALPHANUMERIC

Senha deve conter números e letras. Valor é 0x50000.

PASSWORD_QUALITY_COMPLEX

Senha deve atender às políticas exigidas por um administrador (ex.: símbolos, maiúsculas e minúsculas, quantidade mínima de caracteres, etc.). Valor é 0x60000.

PASSWORD_QUALITY_MANAGED

A senha não é administrada pelo usuário, mas por um administrador do dispositivo. Seu valor é 0x80000.