Extraire les nouvelles API

Supposons 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 supérieur). 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 proposant un mécanisme de remplacement qui utilise d'anciennes API.

Dans cette classe, 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 "New Tab" (Nouvel onglet) afin de créer le composant d'onglet.

Se préparer à l'abstraction

L'abstraction dans le langage de programmation Java implique la création d'une ou de 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 qui utilisent 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 les 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 les plus récentes. Lorsque vous définissez les interfaces d'abstraction, vous devez dupliquer autant que possible la nouvelle API. Cela optimise la compatibilité ascendante et facilite l'abandon de la couche d'abstraction à l'avenir, lorsqu'elle n'est plus nécessaire.

Après avoir créé des classes abstraites pour ces nouvelles API, vous pouvez créer et choisir n'importe quel nombre 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. Ainsi, 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 dont votre application a besoin. Dans le cas des onglets de section de premier niveau, supposons que vous ayez les 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'onglets.

Préparer ces exigences à l'avance vous permet de contrôler le champ d'application de votre couche d'abstraction. Vous pouvez ainsi passer moins de temps à créer plusieurs implémentations de votre couche d'abstraction et commencer à utiliser votre nouvelle implémentation rétrocompatible plus rapidement.

Les principales API pour les onglets se trouvent dans ActionBar et ActionBar.Tab. Ce sont les API à extraire afin de rendre vos onglets compatibles avec la version. Les exigences de cet exemple de projet nécessitent de rétablir la compatibilité avec Eclair (niveau d'API 5) tout en tirant parti des fonctionnalités des nouveaux onglets dans Honeycomb (niveau d'API 11). Vous trouverez ci-dessous un schéma de la structure de classe compatible avec ces deux implémentations et leurs classes de base (ou interfaces) abstraites.

Figure 1 : Diagramme de classes de classes de base abstraites et d'implémentations spécifiques à une version.

Barre d'action abstraite.Tab

Commencez à compiler votre couche d'abstraction des onglets en créant une classe abstraite représentant un onglet, reflétant 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 au lieu d'une interface pour simplifier l'implémentation de fonctionnalités courantes telles que l'association d'objets de type onglet à des activités (non illustrés dans l'extrait de code).

Méthodes abstraites de l'onglet ActionBar

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 sur les anciennes et les nouvelles versions de la plate-forme.

Vous devriez également lire

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