Extraire les nouvelles API

Imaginons que vous souhaitiez utiliser les onglets de la barre d'action comme forme principale de navigation de premier niveau dans votre application. Malheureusement, les API ActionBar ne sont disponibles que sur Android 3.0 ou version ultérieure (niveau d'API 11 ou version ultérieure). Ainsi, si vous souhaitez distribuer votre application sur des appareils exécutant des versions antérieures de la plate-forme, vous devez fournir une implémentation compatible avec la nouvelle API, tout en fournissant un mécanisme de remplacement qui utilise d'anciennes API.

Dans ce cours, vous allez créer un composant d'interface utilisateur (UI) à onglets qui utilise des classes abstraites avec des implémentations spécifiques à la version pour assurer la rétrocompatibilité. Cette leçon explique comment créer une couche d'abstraction pour les API du nouvel onglet. Il s'agit de la première étape de la création du composant d'onglet.

Préparer l'abstraction

Dans le langage de programmation Java, l'abstraction implique la création d'une ou plusieurs interfaces ou classes abstraites pour masquer les détails de l'implémentation. Dans le cas des API Android les plus récentes, vous pouvez utiliser l'abstraction pour créer des composants compatibles avec les versions qui utilisent les API actuelles sur les appareils plus récents, et revenir à des API plus anciennes et plus compatibles sur les appareils plus anciens.

Lorsque vous utilisez cette approche, vous devez d'abord déterminer les classes plus récentes que vous souhaitez pouvoir utiliser de manière rétrocompatible, puis créer des classes abstraites basées sur les interfaces publiques des classes plus récentes. Lorsque vous définissez les interfaces d'abstraction, vous devez mettre en miroir autant que possible la nouvelle API. Cela optimise la compatibilité ascendante et permet de supprimer plus facilement la couche d'abstraction lorsque celle-ci n'est plus nécessaire.

Après avoir créé des classes abstraites pour ces nouvelles API, vous pouvez créer et choisir un nombre illimité d'implémentations au moment de l'exécution. Pour des raisons de rétrocompatibilité, ces implémentations peuvent varier en fonction du niveau d'API requis. Par conséquent, une implémentation peut utiliser des API récemment publiées, tandis que d'autres peuvent utiliser des API plus anciennes.

Créer une interface d'onglet abstraite

Pour créer une version rétrocompatible des onglets, vous devez d'abord déterminer les fonctionnalités et les API spécifiques requises par votre application. Dans le cas des onglets de sections de premier niveau, supposons que vous disposiez des exigences fonctionnelles suivantes :

1. Les indicateurs d'onglet doivent afficher du texte et une icône.
2. Les onglets peuvent être associés à une instance de fragment.
3. L'activité doit pouvoir écouter les changements d'onglet.

La préparation de ces exigences à l'avance vous permet de contrôler le champ d'application de votre couche d'abstraction. Cela signifie que vous pouvez passer moins de temps à créer plusieurs implémentations de votre couche d'abstraction et commencer à utiliser votre nouvelle implémentation rétrocompatible plus tôt.

Les principales API pour les onglets se trouvent dans ActionBar et ActionBar.Tab. Il s'agit des API à extraire afin que vos onglets tiennent compte des versions. Les exigences de cet exemple de projet requièrent la compatibilité avec Eclair (niveau d'API 5) tout en tirant parti des fonctionnalités du nouvel onglet dans Honeycomb (niveau d'API 11). Vous trouverez ci-dessous un schéma de la structure de classe permettant de prendre en charge ces deux implémentations et de leurs classes de base (ou interfaces) abstraites.

Figure 1 : Diagramme des classes de base abstraites et des implémentations spécifiques à la version.

Barre d'action abstraite.Tab

Commencez à créer une couche d'abstraction d'onglet en créant une classe abstraite représentant un onglet, qui reflète l'interface ActionBar.Tab:

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

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();
    ...
}

Vous pouvez utiliser une classe abstraite ici au lieu d'une interface pour simplifier l'implémentation de fonctionnalités courantes telles que l'association d'objets d'onglet à des activités (non présentées dans l'extrait de code).

Méthodes d'onglet ActionBar abstraites

Ensuite, définissez une classe abstraite qui vous permet de créer et d'ajouter des onglets à une activité, comme ActionBar.newTab() et ActionBar.addTab():

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)

    ...
}

public abstract class TabHelper {
    ...

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

    public abstract void addTab(CompatTab tab);

    ...
}

Dans les leçons suivantes, vous allez créer des implémentations pour TabHelper et CompatTab qui fonctionnent avec les anciennes et les nouvelles versions de la plate-forme.

Vous devez également lire

• Barre d'action
• Onglets de la barre d'action