Créer une implémentation avec d'anciennes API

Cette page explique comment créer une implémentation qui reflète les API plus récentes, tout en étant compatible avec les appareils plus anciens.

Choisir une solution de remplacement

La tâche la plus difficile lorsque vous utilisez des fonctionnalités d'UI plus récentes de manière rétrocompatible consiste à choisir et à implémenter une solution plus ancienne (de secours) pour les anciennes versions de la plate-forme. Dans de nombreux cas, il est possible de répondre à l'objectif de ces nouveaux composants d'UI à l'aide d'anciennes fonctionnalités du framework d'UI. Exemple :

• Les barres d'action peuvent être implémentées à l'aide d'un LinearLayout horizontal contenant des boutons d'image, soit en tant que barres de titre personnalisées, soit en tant que vues dans la mise en page de votre activité. Les actions de dépassement peuvent être présentées sous le bouton Menu de l'appareil.

• Les onglets de la barre d'action peuvent être implémentés à l'aide d'un LinearLayout horizontal contenant des boutons ou à l'aide de l'élément d'UI TabWidget.

• Les widgets NumberPicker et Switch peuvent être implémentés à l'aide des widgets Spinner et ToggleButton, respectivement.

• Les widgets ListPopupWindow et PopupMenu peuvent être implémentés à l'aide des widgets PopupWindow.

En règle générale, il n'existe pas de solution unique pour le rétroportage de composants d'UI plus récents vers des appareils plus anciens. Tenez compte de l'expérience utilisateur : sur les appareils plus anciens, les utilisateurs ne sont peut-être pas familiarisés avec les nouveaux modèles de conception et composants d'UI. Réfléchissez à la manière dont la même fonctionnalité peut être fournie à l'aide d'éléments familiers. Dans de nombreux cas, cela n'est pas un problème, par exemple si les composants d'UI plus récents sont mis en avant dans l'écosystème d'applications (comme la barre d'action) ou si le modèle d'interaction est simple et intuitif (comme les vues de balayage à l'aide d'un ViewPager).

Implémenter des onglets à l'aide d'anciennes API

Pour créer une ancienne implémentation des onglets de la barre d'action, vous pouvez utiliser un TabWidget et un TabHost (vous pouvez également utiliser des widgets Button disposés horizontalement). Implémentez-les dans des classes appelées TabHelperEclair et CompatTabEclair, car cette implémentation utilise des API introduites au plus tard dans Android 2.0 (Eclair).

L'implémentation CompatTabEclair stocke les propriétés des onglets, telles que le texte et l'icône de l'onglet, dans des variables d'instance, car aucun objet ActionBar.Tab n'est disponible pour gérer ce stockage :

class CompatTabEclair internal constructor(val activity: FragmentActivity, tag: String) :
        CompatTab(tag) {

    // Store these properties in the instance,
    // as there is no ActionBar.Tab object.
    private var text: CharSequence? = null
    ...

    override fun setText(resId: Int): CompatTab {
        // Our older implementation simply stores this
        // information in the object instance.
        text = activity.resources.getText(resId)
        return this
    }

    ...
    // Do the same for other properties (icon, callback, etc.)
}

public class CompatTabEclair extends CompatTab {
    // Store these properties in the instance,
    // as there is no ActionBar.Tab object.
    private CharSequence text;
    ...

    public CompatTab setText(int resId) {
        // Our older implementation simply stores this
        // information in the object instance.
        text = activity.getResources().getText(resId);
        return this;
    }

    ...
    // Do the same for other properties (icon, callback, etc.)
}

L'implémentation TabHelperEclair utilise des méthodes sur le TabHost widget pour créer TabHost.TabSpec objets et des indicateurs d'onglet :

class TabHelperEclair internal constructor(activity: FragmentActivity) : TabHelper(activity) {

    private var tabHost: TabHost? = null
    ...

    override fun setUp() {
        // Our activity layout for pre-Honeycomb devices
        // must contain a TabHost.
        tabHost = tabHost ?: mActivity.findViewById<TabHost>(android.R.id.tabhost).apply {
            setup()
        }
    }

    override fun addTab(tab: CompatTab) {
        ...
        tabHost?.newTabSpec(tab.tag)?.run {
            setIndicator(tab.getText()) // And optional icon
            ...
            tabHost?.addTab(this)
        }
    }
    // The other important method, newTab() is part of
    // the base implementation.
}

public class TabHelperEclair extends TabHelper {
    private TabHost tabHost;
    ...

    protected void setUp() {
        if (tabHost == null) {
            // Our activity layout for pre-Honeycomb devices
            // must contain a TabHost.
            tabHost = (TabHost) mActivity.findViewById(
                    android.R.id.tabhost);
            tabHost.setup();
        }
    }

    public void addTab(CompatTab tab) {
        ...
        TabSpec spec = tabHost
                .newTabSpec(tag)
                .setIndicator(tab.getText()); // And optional icon
        ...
        tabHost.addTab(spec);
    }

    // The other important method, newTab() is part of
    // the base implementation.
}

Vous disposez maintenant de deux implémentations de CompatTab et TabHelper : l'une fonctionne sur les appareils équipés d'Android 3.0 ou version ultérieure et utilise de nouvelles API, tandis que l'autre fonctionne sur les appareils équipés d'Android 2.0 ou version ultérieure et utilise d'anciennes API. La leçon suivante explique comment utiliser ces implémentations dans votre application.