Extraire les nouvelles API

Supposons que vous souhaitiez utiliser des onglets de barre d'action comme principale forme de navigation de premier niveau dans votre application. Malheureusement, les API ActionBar ne sont disponibles que dans Android 3.0 ou version ultérieure (niveau d'API 11+). Par conséquent, 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 des API plus anciennes.

Dans cette classe, vous allez créer un composant d'interface utilisateur à 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 nouvelles API d'onglet comme première étape de la création du composant d'onglet.

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 d'implémentation. Dans le cas des nouvelles API Android, 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 reviennent à des API plus anciennes et plus compatibles sur les appareils plus anciens.

Lorsque vous utilisez cette approche, vous déterminez d'abord les nouvelles classes que vous souhaitez pouvoir utiliser de manière rétrocompatible, puis vous créez des classes abstraites basées sur les interfaces publiques des nouvelles classes. Lorsque vous définissez les interfaces d'abstraction, vous devez refléter l'API plus récente autant que possible. Cela maximise la compatibilité ascendante et facilite la suppression de la couche d'abstraction à l'avenir, lorsqu'elle ne sera 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. À des fins 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 modifications d'onglet.

Préparer ces exigences à l'avance vous permet de contrôler la portée 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 API clés pour les onglets se trouvent dans ActionBar et ActionBar.Tab. Il s'agit des API à abstraire pour rendre vos onglets compatibles avec les versions. Les exigences de cet exemple de projet nécessitent une compatibilité avec Eclair (niveau d'API 5) tout en tirant parti des nouvelles fonctionnalités d'onglet de 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 leurs classes de base abstraites (ou interfaces).

Abstraire ActionBar.Tab

Commencez à créer votre 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 au lieu d'une interface ici pour simplifier l'implémentation de fonctionnalités courantes telles que l'association d'objets d'onglet à des activités (non affichée dans l'extrait de code).

Abstraire les méthodes d'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 versions de plate-forme anciennes et récentes.

Vous devriez également lire

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