Estrarre le nuove API

Supponiamo di voler utilizzare le schede della barra delle azioni come forma principale di navigazione di primo livello nella tua applicazione. Purtroppo le API ActionBar sono disponibili solo in Android 3.0 o versioni successive (livello API 11 o versioni successive). Pertanto, se vuoi distribuire la tua applicazione ai dispositivi che eseguono versioni precedenti della piattaforma, devi fornire un'implementazione che supporti la nuova API, fornendo al contempo un meccanismo di fallback che utilizzi API meno recenti.

In questa lezione, creerai un componente dell'interfaccia utente a schede che utilizza classi astratte con implementazioni specifiche della versione per garantire la compatibilità con le versioni precedenti. Questa lezione descrive come creare un livello di astrazione per le API Nuova scheda come primo passaggio nella creazione del componente della scheda.

Prepararsi all'astrazione

L'astrazione nel linguaggio di programmazione Java prevede la creazione di una o più interfacce o classi astratte per nascondere i dettagli di implementazione. Nel caso delle API Android più recenti, puoi utilizzare l'astrazione per creare componenti sensibili alla versione che utilizzano le API attuali sui dispositivi più recenti e passare ad API più vecchie e più compatibili sui dispositivi meno recenti.

Quando utilizzi questo approccio, devi prima determinare quali classi più recenti vuoi poter utilizzare in modo compatibile con le versioni precedenti, quindi creare classi astratte in base alle interfacce pubbliche delle classi più recenti. Nel definire le interfacce di astrazione, dovresti eseguire il mirroring più possibile dell'API più recente. Questo massimizza la compatibilità con l'inoltro e semplifica il rilascio del livello di astrazione in futuro quando non sarà più necessario.

Dopo aver creato classi astratte per queste nuove API, è possibile creare e scegliere qualsiasi numero di implementazioni in fase di runtime. Per motivi di compatibilità con le versioni precedenti, queste implementazioni possono variare in base al livello API richiesto. Pertanto, un'implementazione può utilizzare API rilasciate di recente, mentre altre possono utilizzare API meno recenti.

Crea un'interfaccia a schede astratta

Per creare una versione delle schede compatibile con le versioni precedenti, devi prima determinare le funzionalità e le API specifiche richieste dalla tua applicazione. Nel caso delle schede delle sezioni di primo livello, supponiamo che tu disponga dei seguenti requisiti funzionali:

1. Gli indicatori di scheda dovrebbero mostrare testo e un'icona.
2. Le schede possono essere associate a un'istanza di frammento.
3. L'attività deve essere in grado di rilevare le modifiche alle schede.

La preparazione anticipata di questi requisiti consente di controllare l'ambito del livello di astrazione. Ciò significa che puoi dedicare meno tempo a creare più implementazioni del tuo livello di astrazione e iniziare a utilizzare prima la nuova implementazione compatibile con le versioni precedenti.

Le API principali per le schede sono in ActionBar e ActionBar.Tab. Queste sono le API da astrarre per rendere le tue schede sensibili alla versione. I requisiti per questo progetto di esempio richiedono la compatibilità con Eclair (livello API 5) sfruttando al contempo le nuove funzionalità delle schede in Honeycomb (livello API 11). Di seguito è riportato un diagramma della struttura delle classi per supportare queste due implementazioni e le relative classi di base astratte (o interfacce).

Figura 1. Diagramma delle classi di classi base astratte e implementazioni specifiche della versione.

Scheda.barra delle azioni astratta

Inizia a creare il tuo livello di astrazione delle schede creando una classe astratta che rappresenta una scheda, che rispecchia l'interfaccia di 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();
    ...
}

In questo caso, puoi utilizzare una classe astratta anziché un'interfaccia per semplificare l'implementazione di funzionalità comuni, come l'associazione di oggetti tab con attività (non mostrate nello snippet di codice).

Metodi della scheda ActionBar astratta

Poi definisci una classe astratta che ti consenta di creare e aggiungere schede a un'attività, come ActionBar.newTab() e 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);

    ...
}

Nelle prossime lezioni imparerai a creare implementazioni per TabHelper e CompatTab che funzionano sia su entrambe le versioni della piattaforma precedenti che su quelle più recenti.

Dovresti leggere inoltre

• Barra delle azioni
• Schede della barra delle azioni