O segundo Visualização do Desenvolvedor do Android 11 já está disponível, teste e compartilhe seu feedback.

Abstração das novas APIs

Suponha que você queira usar as guias da barra de ações como a forma principal de navegação de nível superior no seu aplicativo. Infelizmente, as APIs ActionBar estão disponíveis apenas no Android 3.0 ou versões posteriores (API de nível 11 ou mais). Assim, se você quiser distribuir seu aplicativo para dispositivos que executam versões anteriores da plataforma, será necessário fornecer uma implementação compatível com a API mais recente e um mecanismo substituto que use APIs mais antigas.

Nesta classe, você cria um componente de interface do usuário (IU) com guias que usa classes abstratas com implementações específicas da versão para fornecer compatibilidade com versões anteriores. Esta lição mostra como criar uma camada de abstração para as novas APIs de guia como a primeira etapa para criar o componente de guia.

Preparar-se para a abstração

A abstração na linguagem de programação Java envolve a criação de uma ou mais interfaces ou classes abstratas para ocultar detalhes de implementação. No caso das APIs mais recentes do Android, você pode usar a abstração para criar componentes com reconhecimento de versão que usem as APIs atuais em dispositivos mais recentes e façam substituições com as APIs mais antigas e mais compatíveis em dispositivos mais antigos.

Ao usar essa abordagem, determine primeiro quais classes mais recentes você quer poder usar de maneira compatível com versões anteriores e crie classes abstratas com base nas interfaces públicas das classes mais recentes. Na definição das interfaces de abstração, espelhe a API mais recente o máximo possível. Isso maximiza a compatibilidade com versões futuras e facilita o descarte da camada de abstração quando ela não for mais necessária.

Depois de criar classes abstratas para essas APIs mais recentes, qualquer número de implementações pode ser criado e escolhido durante a execução. Para fins de compatibilidade com versões anteriores, essas implementações podem variar de acordo com o nível de API exigido. Assim, uma implementação pode usar APIs lançadas recentemente, enquanto outras podem usar APIs mais antigas.

Criar uma interface de guia abstrata

Para criar uma versão de guias compatível com versões anteriores, determine primeiro de quais recursos e APIs específicas seu aplicativo precisa. No caso das guias de seção de nível superior, vamos supor que você tenha os seguintes requisitos funcionais:

  1. Os indicadores de guia mostram texto e um ícone.
  2. As guias podem ser associadas a uma instância de fragmento.
  3. A atividade é capaz de detectar mudanças de guia.

Preparar esses requisitos com antecedência permite que você controle o escopo da camada de abstração. Isso significa que você pode gastar menos tempo criando várias implementações da camada de abstração e começar a usar a nova implementação compatível com versões anteriores.

As principais APIs para guias estão em ActionBar e ActionBar.Tab. Essas são as APIs a serem abstraídas para fazer com que suas guias reconheçam a versão. Os requisitos para esse exemplo de chamada de projeto para compatibilidade com o Eclair (API de nível 5) aproveitam os novos recursos de guia no Honeycomb (API de nível 11). Veja abaixo um diagrama da estrutura da classe para oferecer compatibilidade com essas duas implementações e as classes base abstratas (ou interfaces) delas.

Diagrama das classes base abstratas e implementações específicas da versão.

Figura 1. Diagrama das classes base abstratas e implementações específicas da versão.

Abstração de ActionBar.Tab

Comece a criar a camada de abstração da guia criando uma classe abstrata que represente uma guia, que espelha a interface ActionBar.Tab:

Kotlin

    sealed class CompatTab(val tag: String) {
        ...
        abstract fun getText(): CharSequence
        abstract fun getIcon(): Drawable
        abstract fun getCallback(): CompatTabListener
        abstract fun getFragment(): Fragment

        abstract fun setText(text: String): CompatTab
        abstract fun setIcon(icon: Drawable): CompatTab
        abstract fun setCallback(callback: CompatTabListener): CompatTab
        abstract fun setFragment(fragment: Fragment): CompatTab
        ...
    }
    

Java

    public abstract class CompatTab {
        ...
        public abstract CompatTab setText(int resId);
        public abstract CompatTab setIcon(int resId);
        public abstract CompatTab setTabListener(
                CompatTabListener callback);
        public abstract CompatTab setFragment(Fragment fragment);

        public abstract CharSequence getText();
        public abstract Drawable getIcon();
        public abstract CompatTabListener getCallback();
        public abstract Fragment getFragment();
        ...
    }
    

Use uma classe abstrata em vez de uma interface para simplificar a implementação de recursos comuns, como a associação de objetos de guia com atividades (não mostrada no snippet de código).

Métodos abstratos de guia ActionBar

Em seguida, defina uma classe abstrata que permita criar e adicionar guias a uma atividade, como ActionBar.newTab() e ActionBar.addTab():

Kotlin

    sealed class TabHelper(protected val activity: FragmentActivity) {
        ...

        abstract fun setUp()

        fun newTab(tag: String): CompatTab {
            // This method is implemented in a later lesson.
        }

        abstract fun addTab(tab: CompatTab)

        ...
    }
    

Java

    public abstract class TabHelper {
        ...

        public CompatTab newTab(String tag) {
            // This method is implemented in a later lesson.
        }

        public abstract void addTab(CompatTab tab);

        ...
    }
    

Nas próximas lições, você criará implementações para TabHelper e CompatTab, que funcionam tanto nas versões mais antigas quanto nas mais recentes da plataforma.

Leia também