Suportando Várias Telas

Android classifica as telas de dispositivos usando duas propriedades gerais: tamanho e densidade. Você deve esperar que seu aplicativo fosse instalado em dispositivos com telas de varias faixas de tamanho e densidade. Para tanto, você deve incluir alguns recursos alternativos que aperfeiçoam a aparência de seu aplicativo para diferentes tamanhos de tela e densidades.

·         Existem quatro tamanhos generalizados: pequeno (small), normal, grande (large) e extragrande (xlarge).

·         E quatro densidades generalizadas: baixa (ldpi) media (mdpi), alta (hdpi) e extra-alta (xhdpi).

Para declarar diferentes esboços e bitmaps que você gostaria de usar para diferentes telas, você deve guardar estes recursos alternativos em diretórios separado, similar a maneira feita para o texto de diferentes idiomas.

Esteja alerta também de orientação da tela (retrato ou paisagem) é considerada uma variação do tamanho de tela, portanto vários aplicativos devem revisar o esboço para melhorar a experiência do usuário em cada orientação.

Criando Vários Esboços

---

Para melhorar a sua experiência de usuário em diferentes telas, você deve criar um único arquivo XML de esboço para cada tamanho de tela que deseje suportar. Cada esboço deve ser salvo dentro do diretório de recursos apropriados, nomeado com o sufixo -<screen_size>. Por exemplo, único esboço para tela grande deve ser salvo em res/layout-large/.

Nota: Android automaticamente dimensiona seu esboço para que se encaixe apropriadamente na tela. Portanto, seu esboço para diferentes tamanhos de tela não precisa se preocupar com o tamanho absoluto dos elementos de interface, mas sim com o foco do esboço da estrutura que afeta a experiência do usuário (tais como o tamanho ou posição de visualizações relativas às visualizações derivadas).

Por exemplo, este projeto inclui o esboço padrão e um esboço alternativo para telas grandes:

MyProject/

    res/

        layout/

            main.xml

        layout-large/

            main.xml

Os nomes dos arquivos devem ser exatamente iguais, mas o conteúdo deles serão diferente para que forneçam uma interface melhorada para o tamanho de tela correspondente.

Simplesmente referencie o arquivo de esboço em seu aplicativo como sempre faz:

@Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
}

O sistema carrega o arquivo de esboço a partir do diretório de esboço apropriado através do tamanho de tela do dispositivo no qual seu aplicativo está rodando. Mais informações de como o Android seleciona o recurso apropriado está disponível no guia Fornecendo Recursos.

Outro exemplo, aqui está o projeto com o esboço alternativo para uma orientação de paisagem:

MyProject/

    res/

        layout/

            main.xml

        layout-land/

            main.xml

Por padrão, o arquivo de layout/main.xml é utilizado na orientação de retrato.

Se você quer fornecer um esboço especial para paisagem, incluindo para telas grandes, então você precisa de ambos os qualificadores large e land:

MyProject/

    res/

        layout/              # default (portrait)

            main.xml

        layout-land/         # landscape

            main.xml

        layout-large/        # large (portrait)

            main.xml

        layout-large-land/   # large landscape

            main.xml

Nota: Android 3.2 e acima suportam um método avançado para definição de tamanho de telas que permite a você especificarem os recursos de tamanho de tela baseado no mínimo de largura e altura em termos independentes da densidade dos pixeis. Esta postagem não explica está nova técnica. Para maiores informações, leia Projetando para varias Telas.

Criando Vários Bitmaps

---

Você deve sempre fornecer recursos de bitmap que estejam apropriadamente proporcionais a cada recipiente de densidade generalizado: densidade pequena, média, grande e extragrande. Isto ajuda você a conseguir um bom desempenho e qualidade gráfica em todas as densidades de tela.

Para gerar tais imagens, você deve iniciar seu recurso em formato de vetor e gerar as imagens para cada densidade usando as seguintes escalas de tamanho:

·         xhdpi: 2.0

·         hdpi: 1.5

·         mdpi: 1.0 (patamar)

·         ldpi: 0.75

Isto significa que você deve gerar imagens 200x200 para dispositivos xhdpi, você deve gerar o mesmo recurso em 150x150 para hdpi, 100x100 para mdpi e 75x75 para dispositivos ldpi.

Então, colocar os arquivos no diretório de mapeamento de recurso apropriado:

MyProject/

    res/

        drawable-xhdpi/

            awesomeimage.png

        drawable-hdpi/

            awesomeimage.png

        drawable-mdpi/

            awesomeimage.png

        drawable-ldpi/

            awesomeimage.png

Sempre que referir @drawable/awesomeimage, o sistema seleciona o bitmap apropriado baseado na densidade da tela.

Nota: Recursos de baixa densidade (ldpi) não são sempre necessários. Quando você fornece valores hdpi, o sistema redimensiona para metade do tamanho para se encaixar apropriadamente nas telas ldpi.

Para mais dicas e instruções de como criar ícones para seu aplicativo, veja Guia de desenho para Iconografia.

Suportando Vários Idiomas

É sempre uma boa pratica extrair todo o texto da interface do usuário do código do seu aplicativo e manter em um arquivo externo. Android facilita essa ação com os recursos de diretório em cada projeto Android.

Se você criou seu projeto usando as ferramentas do Android SDK (leia Criando um projeto para Android), as ferramentas criam o diretório res/ em um nível superior do projeto. Dentro deste diretório res/ os subdiretórios de vários tipos de recursos. Existem também alguns poucos arquivos padrão tais como res/values/strings.xml, que mantém o valor do texto.

Criando Diretórios de Localidade e Arquivos Textos

---

Para adicionar suporte para mais idiomas, crie adicionalmente os diretórios values dentro do res/ que incluem um hífen e o código ISO para o país ao fim do nome do diretório. Por exemplo, values-es/ é um diretório contendo recursos simples para o Idioma com a linguagem de código “es”. Android carrega os recursos apropriados de acordo com as configurações de idioma no dispositivo enquanto funciona.

Uma vez que tenha decidido quais idiomas você irá dar suporte, crie subdiretórios de recursos e arquivos texto de recurso. Por exemplo:

MyProject/

    res/

       values/

           strings.xml

       values-es/

           strings.xml

       values-fr/

           strings.xml

Adicione o valor de texto para cada idioma no arquivo apropriado.

Durante a execução, o sistema Android usa as definições apropriadas do recurso de texto baseado nas configurações de idioma do dispositivo do usuário.

Por exemplo, a seguir temos diferentes arquivos de recursos de texto para diferentes idiomas.

Inglês (default locale), /values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title">My Application</string>
    <string name="hello_world">Hello World!</string>
</resources>

Espanhol, /values-es/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title">Mi Aplicación</string>
    <string name="hello_world">Hola Mundo!</string>
</resources>

Francês, /values-fr/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="title">Mon Application</string>
    <string name="hello_world">Bonjour le monde !</string>
</resources>

Nota: Você pode usar o qualificador local (ou qualquer qualificador local) em qualquer tipo de recurso, tais como se você precise fornecer versões locais. Para maiores informações, veja Localização.

Usando os Recursos de Texto

---

Você pode referenciar os recursos de texto em seu código fonte e outros arquivos XML usando o nome do recurso definidos pelo atributo name do elemento <string>.

Dentro do seu código fonte, você pode referenciar o recurso do texto com a sintaxe R.string.<string_name>. Existem vários métodos que aceitam o recurso de texto desta forma.

Por exemplo:

// Get a string resource from your app's Resources
String hello = getResources().getString(R.string.hello_world);

// Or supply a string resource to a method
// That requires a string
TextView textView = new TextView(this);
textView.setText(R.string.hello_world);

Em outros arquivos XML, você sempre pode referir a um recurso do texto com a sintaxe @string/<string_name> s sempre que o atributo XML aceitar o valor do texto.

Por exemplo:

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/hello_world" />

Suportando Vários Dispositivos

Dispositivos Android vem em varios formatos e tamanho de todo o mundo. Com uma larga variedade de tipos de disposistivos, você tem a oportunidade de alcançar uma audiência maior com seu aplicativo. Em ordem para obter o Maximo de sucesso possível no Android, seu aplicativo precisa adaptar para as varias configurações de dispositivos. Algumas das mais importante variações que você deve considerar incluem diferentes idiomas, tamanhos de tela, e versões da plataforma Android.

As proximas postagens irão ensinar como usar as características básicas da plataforma que influenciam recursos alternativos e outras características para que seu aplicativo posso fornecer uma experiência ao usuário otimizada na grande variedade de dispositivos compatíveis com Android, usando um único pacote de aplicação.(APK)

Lições

---

Suportando Varios Idiomas

Aprender a suportar múltiplos idiomas com os recursos alternativos para texto.

Suportando Varias Telas

Aprender a otimizar a experiencia do usuario para diferentes tamanho de tela e densidades. 

Suportando Varias Versões de Plataforma

Aprender em como utilizar as APIS disponíveis em novas versões do Android enquanto mantém suporte para versões anteriores do Android.

Recriando a Ação

Existem uns poucos cenários no qual sua ação é destruída devido ao comportamento normal do aplicativo, tais como quando o usuário pressiona o botão retorno ou sua ação sinaliza sua própria destruição ao chamar finish(). O sistema pode também destruir sua ação se estiver atualmente parada e não tenha sido usada a algum tempo ou a ação de primeiro plano requer mais recursos do sistema, que acaba fechando todos os processos em segundo plano para recuperar a memória.

Quando sua ação é destruída devido ao usuário pressionar o Retorno ou a ação finalizar a si mesma, o conceito do sistema de que a instancia da Ação se encerra em definitivo devido ao comportamento indicar que a ação não é mais necessária. De qualquer forma, se o sistema destruir sua ação devido às restrições do sistema (ao invés do comportamento normal do aplicativo), então mesmo que a instancia atual de Ação tenha saído, o sistema se lembra de que existiu como no caso em que o usuário navega de volta ao mesmo, o sistema cria uma nova instancia da ação usando um conjunto de dados salvos que descreve o estado da atividade quando esta foi destruída. Os dados salvos que o sistema usa para restaurar o estado anterior são chamados “estados da instancia” e é uma coleção de valores chaves armazenada no objeto Bundle.

Atenção: Sua ação será destruída e recriada cada vez que o usuário girar a tela. Quando a tela muda orietanção, o sistema destrói recria a ação de segundo plano uma vez que a configuração de tela foi alterada e sua ação pode precisar recarregar recursos alternativos (tais como o esboço).

Por padrão, o sistema usa o estado de instancia Bundle para salvar informação de cada objeto View no esboço da sua ação (tais como o valor texto adicionada em um objeto EditText).  Portanto, sua instancia de ação é destruída e recriada, o estado do esboço é restaurado para o estado anterior sem a necessidade de escrever código por você. De qualquer forma, sua ação pode ter mais informações que você gostaria de restaurar, tais como variáveis membros que mantém o progresso da ação.

Nota: Em ordem para que sistema do Android restaure o estado do campo visual de sua ação, cada campo visual tem de ter um ID único, fornecido pelo atributo android:id .

Para salvar dados adicionais sobre o estado da ação, você deve sobrescrever o método de chamada onSaveInstanceState(). O sistema chama este método quando o usuário está abandonando sua ação e passando para o objeto Bundle que será salvo no evento em que sua ação é destruída inesperadamente. Se o sistema tiver de recriar a instancia da ação depois, irá passar o mesmo objeto Bundle para ambos os métodos onRestoreInstanceState() e onCreate().

Figura. Conforme o sistema começa a parar sua ação, irá chamar onSaveInstanceState() (1) para que você possa especificar dados adicionais ao estado que você gostaria de salvar no caso da instancia da Ação precisar ser recriada. Se a ação for destruída e a mesma instancia deva ser recriada, o sistema passa os dados do estado definidos em (1) para ambos os métodos onCreate()  (2) e onRestoreInstanceState() (3).

Salvando o Estado da Sua Ação

---

Conforme sua ação começa a parar, o sistema chama onSaveInstanceState() para que sua ação possa salvar a informação do estado com uma coleção de valores chaves. A implementação padrão deste método salva a informação sobre o estado de hierarquia do campo visual da ação, tais como o texto dentro da caixa de interface EditText ou deslizando para a posição de um ListView.

Para salvar informações de estado adicionais para sua ação, você deve programar onSaveInstanceState() e adicionar valores chaves para o objeto Bundle.  Por exemplo:

static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
...

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the user's current game state
    savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
    savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);
   
    // Always call the superclass so it can save the view hierarchy state
    super.onSaveInstanceState(savedInstanceState);
}

Atenção: Sempre chame a implementação da superclasse de onSaveInstanceState() para que o padrão da implementação possa salvar o estado de hierarquia do campo visual.

Restaurando o Estado de Sua Ação

---

Quando sua ação é recriada após ter sido previamente destruída, você pode recuperar o estado salvo através do conjunto  Bundle que o sistema passou para sua ação. Ambos os métodos de chamada onCreate() e onRestoreInstanceState() recebem o mesmo Bundle que contem o estado de informações da instancia.

Pela razão do método onCreate() ter sido chamado tanto pelo sistema estar criando uma nova instancia de sua ação ou por recriar a anterior, você deve verificar se o estado de Bundle ser nulo antes de tentar ler o mesmo. Se não for nulo, então o sistema está criando uma nova instancia da ação, ao invés de restaurar ao anterior que foi destruído.

Por exemplo, aqui está como você pode restaurar alguns dados do estado em onCreate():

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first
 
    // Check whether we're recreating a previously destroyed instance
    if (savedInstanceState != null) {
        // Restore value of members from saved state
        mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
        mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
    } else {
        // Probably initialize members with default values for a new instance
    }
    ...
}

Ao invés de restaurar o estado durante onCreate() você pode escolher programar onRestoreInstanceState(), ao qual o sistema chama após o método onStart(). O sistema chama onRestoreInstanceState() somente se existe algum estado salvo para ser restaurado, para que você não precise checar quando Bundle é nulo:

public void onRestoreInstanceState(Bundle savedInstanceState) {
    // Always call the superclass so it can restore the view hierarchy
    super.onRestoreInstanceState(savedInstanceState);
 
    // Restore state members from saved instance
    mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
    mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

Atenção: Sempre chame a implementação da superclasse de onRestoreInstanceState() para que a implementação padrão restaure o estado de hierarquia do campo visual.

Para aprender mais sobre recriando sua ação devido ao evento de reinicio durante o tempo de execução (tais como as rotações de tela), veremos futuramente como  controlar mudanças no tempo de execução.