Funzionalità di KitKat

Android 4.4 (KitKat) viene caricato con una cornucopia di funzionalità per utenti e sviluppatori. Questa guida evidenzia diverse di queste funzionalità e fornisce esempi di codice e dettagli di implementazione per aiutarti a sfruttare al meglio KitKat.

Panoramica

Android 4.4 (livello API 19), noto anche come "KitKat", è stato rilasciato alla fine del 2013. KitKat offre una varietà di nuove funzionalità e miglioramenti, tra cui:

• Esperienza utente: animazioni semplici con framework di transizione, barre di spostamento e stato traslucente e modalità immersive a schermo intero consentono di creare un'esperienza migliore per l'utente.

• Contenuto utente: la gestione dei file utente è semplificata con il framework di accesso alle risorse di archiviazione; la stampa di immagini, siti Web e altro contenuto è più semplice con API di stampa migliorate.

• Hardware: trasformare qualsiasi app in una scheda NFC con l'emulazione di schede basate su host NFC; eseguire sensori a basso consumo con .SensorManager

• Strumenti di sviluppo: applicazioni Screencast in azione con il client Android Debug Bridge, disponibile come parte di Android SDK.

Questa guida fornisce indicazioni per la migrazione di un'applicazione Xamarin.Android esistente a KitKat, nonché una panoramica generale di KitKat per sviluppatori Xamarin.Android.

Requisiti

Per sviluppare applicazioni Xamarin.Android con KitKat, è necessario Xamarin.Android 4.11.0 o versione successiva e Android 4.4 (livello API 19) installato tramite Android SDK Manager, come illustrato nello screenshot seguente:

Migrazione dell'app a KitKat

Questa sezione fornisce alcuni elementi di prima risposta che consentono di eseguire la transizione di applicazioni esistenti ad Android 4.4.

Controllare la versione di sistema

Se un'applicazione deve essere compatibile con le versioni precedenti di Android, assicurarsi di eseguire il wrapping di qualsiasi codice specifico di KitKat in un controllo della versione di sistema, come illustrato nell'esempio di codice seguente:

if (Build.VERSION.SdkInt >= BuildVersionCodes.Kitkat) {
    //KitKat only code here
}

Invio di avvisi in batch

Android usa i servizi di allarme per riattivare un'app in background in un determinato momento. KitKat fa un ulteriore passo avanti eseguendo l'invio in batch di allarmi per mantenere l'alimentazione. Ciò significa che, invece di svegliare ogni app in un momento esatto, KitKat preferisce raggruppare diverse applicazioni registrate per la riattivazione nello stesso intervallo di tempo e riattivarle contemporaneamente. Per indicare ad Android di riattivare un'app durante un intervallo di tempo specificato, chiamare SetWindow su AlarmManager, passando il tempo minimo e massimo, in millisecondi, che può trascorrere prima che l'app venga riattivata e l'operazione da eseguire alla riattivazione. Il codice seguente fornisce un esempio di applicazione che deve essere svegliata tra mezz'ora e un'ora dal momento in cui viene impostata la finestra:

AlarmManager alarmManager = (AlarmManager)GetSystemService(AlarmService);
alarmManager.SetWindow (AlarmType.Rtc, AlarmManager.IntervalHalfHour, AlarmManager.IntervalHour, pendingIntent);

Per continuare a svegliare un'app in un momento esatto, usare SetExact, passando l'ora esatta in cui l'app deve essere svegliata e l'operazione da eseguire:

alarmManager.SetExact (AlarmType.Rtc, AlarmManager.IntervalDay, pendingIntent);

KitKat non consente più di impostare un allarme ripetuto esatto. Applicazioni che usano SetRepeating e richiedono allarmi esatti per funzionare ora dovranno attivare ogni allarme manualmente.

Archiviazione esterna

L'archiviazione esterna è ora suddivisa in due tipi, ovvero l'archiviazione univoca per l'applicazione e i dati condivisi da più applicazioni. La lettura e la scrittura nella posizione specifica dell'app nell'archiviazione esterna non richiedono autorizzazioni speciali. L'interazione con i dati nell'archiviazione condivisa richiede ora l'autorizzazione READ_EXTERNAL_STORAGE o WRITE_EXTERNAL_STORAGE . I due tipi possono essere classificati come tali:

• Se si ottiene un file o un percorso di directory chiamando un metodo su Context , ad esempio GetExternalFilesDir oppure GetExternalCacheDirs

  • l'app non richiede autorizzazioni aggiuntive.

• Se si ottiene un file o un percorso di directory accedendo a una proprietà o chiamando un metodo in Environment , ad esempio GetExternalStorageDirectory O GetExternalStoragePublicDirectory , l'app richiede l'autorizzazione READ_EXTERNAL_STORAGE o WRITE_EXTERNAL_STORAGE .

Nota

WRITE_EXTERNAL_STORAGE implica l'autorizzazione READ_EXTERNAL_STORAGE , pertanto è necessario impostare una sola autorizzazione.

Consolidamento SMS

KitKat semplifica la messaggistica per l'utente aggregando tutto il contenuto SMS in un'unica applicazione predefinita selezionata dall'utente. Lo sviluppatore è responsabile della selezione dell'app come applicazione di messaggistica predefinita e del comportamento appropriato nel codice e nella vita se l'applicazione non è selezionata. Per altre informazioni sulla transizione dell'app SMS a KitKat, vedere la guida Getting Your SMS Apps Ready for KitKat (Preparazione delle app SMS per KitKat ) da Google.

App WebView

WebView ha ottenuto un makeover in KitKat. La modifica più importante è la sicurezza aggiunta per il caricamento del contenuto in un oggetto WebView. Anche se la maggior parte delle applicazioni destinate alle versioni API precedenti dovrebbe funzionare come previsto, è consigliabile testare le applicazioni che usano la WebView classe . Per altre informazioni sulle API WebView interessate, vedere la documentazione relativa alla migrazione di Android a WebView in Android 4.4 .

Esperienza utente

KitKat include diverse nuove API per migliorare l'esperienza utente, tra cui il nuovo framework di transizione per la gestione delle animazioni delle proprietà e un'opzione di interfaccia utente traslucente per il tema. Queste modifiche sono descritte di seguito.

Framework di transizione

Il framework di transizione semplifica l'implementazione delle animazioni. KitKat consente di eseguire un'animazione di proprietà semplice con una sola riga di codice o personalizzare le transizioni usando Scene.

Animazione di proprietà semplice

La nuova libreria di transizioni Android semplifica le animazioni delle proprietà code-behind. Il framework consente di eseguire animazioni semplici con codice minimo. Ad esempio, l'esempio di codice seguente usa TransitionManager.BeginDelayedTransition per animare la visualizzazione e nascondere un oggetto TextView:

using Android.Transitions;

public class MainActivity : Activity
{
    LinearLayout linear;
    Button button;
    TextView text;

    protected override void OnCreate (Bundle bundle)
    {
        base.OnCreate (bundle);
        SetContentView (Resource.Layout.Main);

        linear = FindViewById<LinearLayout> (Resource.Id.linearLayout);
        button = FindViewById<Button> (Resource.Id.button);
        text = FindViewById<TextView> (Resource.Id.textView);

        button.Click += (o, e) => {

            TransitionManager.BeginDelayedTransition (linear);

            if(text.Visibility != ViewStates.Visible)
            {
                text.Visibility = ViewStates.Visible;
            }
            else
            {
                text.Visibility = ViewStates.Invisible;
            }
        };
    }
}

Nell'esempio precedente viene usato il framework di transizione per creare una transizione automatica predefinita tra i valori delle proprietà che cambiano. Poiché l'animazione viene gestita da una singola riga di codice, è possibile renderla compatibile facilmente con le versioni precedenti di Android eseguendo il wrapping della BeginDelayedTransition chiamata in un controllo della versione di sistema. Per altre informazioni, vedere la sezione Migrazione dell'app a KitKat .

Lo screenshot seguente mostra l'app prima dell'animazione:

Lo screenshot seguente mostra l'app dopo l'animazione:

È possibile ottenere un maggiore controllo sulla transizione con Scene, descritte nella sezione successiva.

Scene Android

Le scene sono state introdotte come parte del framework di transizione per offrire allo sviluppatore un maggiore controllo sulle animazioni. Le scene creano un'area dinamica nell'interfaccia utente: si specifica un contenitore e diverse versioni o "scene", per il contenuto XML all'interno del contenitore e Android esegue il resto del lavoro per animare le transizioni tra le scene. Le scene Android consentono di creare animazioni complesse con un lavoro minimo sul lato sviluppo.

L'elemento statico dell'interfaccia utente che ospita il contenuto dinamico è un contenitore o una base della scena. L'esempio seguente usa Android Designer per creare un RelativeLayout denominato container:

Il layout di esempio definisce anche un pulsante denominato sceneButton sotto .container Questo pulsante attiverà la transizione.

Il contenuto dinamico all'interno del contenitore richiede due nuovi layout Android. Questi layout specificano solo il codice all'interno del contenitore. Il codice di esempio seguente definisce un layout denominato Scene1 che contiene due campi di testo che leggono rispettivamente "Kit" e "Kat" e un secondo layout denominato Scene2 che contiene gli stessi campi di testo invertiti. Il codice XML è il seguente:

Scene1.axml:

<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android">
    <TextView
        android:id="@+id/textA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Kit"
        android:textSize="35sp" />
    <TextView
        android:id="@+id/textB"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/textA"
        android:text="Kat"
        android:textSize="35sp" />
</merge>

Scene2.axml:

<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android">
    <TextView
        android:id="@+id/textB"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Kat"
        android:textSize="35sp" />
    <TextView
        android:id="@+id/textA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/textB"
        android:text="Kit"
        android:textSize="35sp" />
</merge>

Nell'esempio precedente viene merge usato per rendere il codice di visualizzazione più breve e semplificare la gerarchia di visualizzazione. Altre informazioni sui merge layout sono disponibili qui.

Una scena viene creata chiamando Scene.GetSceneForLayout, passando l'oggetto contenitore, l'ID risorsa del file di layout della scena e l'oggetto corrente Context, come illustrato nell'esempio di codice seguente:

RelativeLayout container = FindViewById<RelativeLayout> (Resource.Id.container);

Scene scene1 = Scene.GetSceneForLayout(container, Resource.Layout.Scene1, this);
Scene scene2 = Scene.GetSceneForLayout(container, Resource.Layout.Scene2, this);

scene1.Enter();

Facendo clic sul pulsante si capovolge tra le due scene, che Android anima con i valori di transizione predefiniti:

sceneButton.Click += (o, e) => {
    Scene temp = scene2;
    scene2 = scene1;
    scene1 = temp;

    TransitionManager.Go (scene1);
};

Lo screenshot seguente illustra la scena prima dell'animazione:

Lo screenshot seguente illustra la scena dopo l'animazione:

Nota

Esiste un bug noto nella libreria Transizioni Android che causa l'interruzione delle scene create usando GetSceneForLayout quando un utente passa attraverso un'attività la seconda volta.

Transizioni personalizzate in scene

Una transizione personalizzata può essere definita in un file di risorse xml nella transition directory in Resources, come illustrato nello screenshot seguente:

L'esempio di codice seguente definisce una transizione che anima per 5 secondi. Vedi altre informazioni sull'animazione all'indirizzo.

<changeBounds
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:duration="5000"
  android:interpolator="@android:anim/overshoot_interpolator" />

La transizione viene creata nell'attività usando TransitionInflater, come illustrato nel codice seguente:

Transition transition = TransitionInflater.From(this).InflateTransition(Resource.Transition.transition);

La nuova transizione viene quindi aggiunta alla Go chiamata che avvia l'animazione:

TransitionManager.Go (scene1, transition);

Interfaccia utente traslucente

KitKat offre un maggiore controllo sul tema dell'app con lo stato traslucente facoltativo e le barre di spostamento. È possibile modificare la traslucidanza degli elementi dell'interfaccia utente di sistema nello stesso file XML usato per definire il tema Android. KitKat introduce le proprietà seguenti:

• windowTranslucentStatus - Se impostato su true, rende la barra di stato superiore traslucente.

• windowTranslucentNavigation - Se impostato su true, rende la barra di spostamento inferiore traslucente.

• fitsSystemWindows - L'impostazione della barra superiore o inferiore su sposta il contenuto trascludente sotto gli elementi dell'interfaccia utente trasparente per impostazione predefinita. L'impostazione di questa proprietà su true è un modo semplice per evitare che il contenuto si sovrapponga agli elementi dell'interfaccia utente di sistema traslucenti.

Il codice seguente definisce un tema con stato traslucente e barre di spostamento:

<?xml version="1.0" encoding="UTF-8" ?>
<resources>
    <style name="KitKatTheme" parent="android:Theme.Holo.Light">
        <item name="android:windowBackground">@color/xamgray</item>
        <item name="android:windowTranslucentStatus">true</item>
        <item name="android:windowTranslucentNavigation">true</item>
        <item name="android:fitsSystemWindows">true</item>
        <item name="android:actionBarStyle">@style/ActionBar.Solid.KitKat</item>
    </style>

    <style name="ActionBar.Solid.KitKat" parent="@android:style/Widget.Holo.Light.ActionBar.Solid">
        <item name="android:background">@color/xampurple</item>
    </style>
</resources>

Lo screenshot seguente mostra il tema precedente con stato traslucente e barre di spostamento:

Contenuto dell’Utente

Archiviazione-Access Framework

L'Archiviazione Access Framework (SAF) è un nuovo modo per consentire agli utenti di interagire con contenuti archiviati, ad esempio immagini, video e documenti. Invece di presentare agli utenti una finestra di dialogo per scegliere un'applicazione per gestire il contenuto, KitKat apre una nuova interfaccia utente che consente agli utenti di accedere ai dati in un'unica posizione di aggregazione. Dopo aver scelto il contenuto, l'utente tornerà all'applicazione che ha richiesto il contenuto e l'esperienza dell'app continuerà normalmente.

Questa modifica richiede due azioni sul lato sviluppatore: prima, le app che richiedono contenuto dai provider devono essere aggiornate a un nuovo modo di richiedere il contenuto. In secondo luogo, le applicazioni che scrivono dati in devono ContentProvider essere modificate per usare il nuovo framework. Entrambi gli scenari dipendono dal nuovo DocumentsProvider API.

DocumentsProvider

In KitKat le interazioni con ContentProviders sono astratte con la DocumentsProvider classe . Ciò significa che SAF non importa dove i dati sono fisicamente, purché siano accessibili tramite l'API DocumentsProvider . I provider locali, i servizi cloud e i dispositivi di archiviazione esterni usano la stessa interfaccia e vengono trattati allo stesso modo, fornendo all'utente e allo sviluppatore un'unica posizione per interagire con il contenuto dell'utente.

Questa sezione illustra come caricare e salvare il contenuto con Archiviazione Access Framework.

Richiedere contenuto da un provider

È possibile indicare a KitKat che si vuole selezionare il contenuto usando l'interfaccia utente SAF con la ActionOpenDocument finalità , che indica che si vuole connettersi a tutti i provider di contenuti disponibili per il dispositivo. È possibile aggiungere un filtro a questa finalità specificando CategoryOpenable, il che significa che verrà restituito solo il contenuto che può essere aperto (ovvero accessibile, contenuto utilizzabile). KitKat consente anche di filtrare il contenuto con .MimeType Ad esempio, il codice seguente filtra i risultati dell'immagine specificando l'immagine MimeType:

Intent intent = new Intent (Intent.ActionOpenDocument);
intent.AddCategory (Intent.CategoryOpenable);
intent.SetType ("image/*");
StartActivityForResult (intent, save_request_code);

La chiamata StartActivityForResult avvia l'interfaccia utente DI SAF, che l'utente può quindi esplorare per scegliere un'immagine:

Dopo che l'utente ha scelto un'immagine, OnActivityResult restituisce l'oggetto Android.Net.Uri del file scelto. L'esempio di codice seguente mostra la selezione dell'immagine dell'utente:

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);

    if (resultCode == Result.Ok && data != null && requestCode == save_request_code) {
        imageView = FindViewById<ImageView> (Resource.Id.imageView);
        imageView.SetImageURI (data.Data);
    }
}

Scrivere contenuto in un provider

Oltre al caricamento del contenuto dall'interfaccia utente DI SAF, KitKat consente anche di salvare il contenuto in qualsiasi ContentProvider elemento che implementa l'API DocumentProvider . Il salvataggio del contenuto usa un oggetto Intent con ActionCreateDocument:

Intent intentCreate = new Intent (Intent.ActionCreateDocument);
intentCreate.AddCategory (Intent.CategoryOpenable);
intentCreate.SetType ("text/plain");
intentCreate.PutExtra (Intent.ExtraTitle, "NewDoc");
StartActivityForResult (intentCreate, write_request_code);

L'esempio di codice precedente carica l'interfaccia utente DI SAF, consentendo all'utente di modificare il nome del file e selezionare una directory per ospitare il nuovo file:

Quando l'utente preme Salva, OnActivityResult ottiene passato l'oggetto Android.Net.Uri del file appena creato, accessibile con data.Data. L'URI può essere usato per trasmettere i dati nel nuovo file:

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
    base.OnActivityResult(requestCode, resultCode, data);

    if (resultCode == Result.Ok && data != null && requestCode == write_request_code) {
        using (Stream stream = ContentResolver.OpenOutputStream(data.Data)) {
            Encoding u8 = Encoding.UTF8;
            string content = "Hello, world!";
            stream.Write (u8.GetBytes(content), 0, content.Length);
        }
    }
}

Si noti che ContentResolver.OpenOutputStream(Android.Net.Uri) restituisce un System.IO.Streamoggetto , in modo che l'intero processo di streaming possa essere scritto in .NET.

Per altre informazioni sul caricamento, la creazione e la modifica del contenuto con Archiviazione Access Framework, vedere la documentazione di Android per Archiviazione Access Framework.

Stampa

La stampa del contenuto è semplificata in KitKat con l'introduzione di Servizi di stampa e PrintManager. KitKat è anche la prima versione dell'API per sfruttare appieno le API del servizio Di stampa cloud di Google usando le applicazioni Google Cloud Print. La maggior parte dei dispositivi forniti con KitKat scarica automaticamente l'app Google Cloud Print e il plug-inHP Print Service quando si connettono per la prima volta al WiFi. Un utente può controllare le impostazioni di stampa del dispositivo passando a Impostazioni Stampa di sistema>: >

Nota

Anche se le API di stampa sono configurate per funzionare con Google Cloud Print per impostazione predefinita, Android consente comunque agli sviluppatori di preparare il contenuto di stampa usando le nuove API e inviarlo ad altre applicazioni per gestire la stampa.

Stampa di contenuto HTML

KitKat crea automaticamente un oggetto PrintDocumentAdapter per una visualizzazione Web con WebView.CreatePrintDocumentAdapter. La stampa di contenuto Web è uno sforzo coordinato tra un WebViewClient oggetto che attende il caricamento del contenuto HTML e consente all'attività di sapere di rendere disponibile l'opzione di stampa nel menu delle opzioni e l'attività, che attende che l'utente selezioni l'opzione Stampa e chiami Printsu PrintManager. Questa sezione illustra la configurazione di base necessaria per stampare contenuto HTML sullo schermo.

Si noti che il caricamento e la stampa di contenuto Web richiede l'autorizzazione Internet:

Stampa voce di menu

L'opzione di stampa verrà in genere visualizzata nel menu opzioni dell'attività. Il menu opzioni consente agli utenti di eseguire azioni su un'attività. Si trova nell'angolo superiore destro dello schermo e ha un aspetto simile al seguente:

È possibile definire voci di menu aggiuntive nella directory dei menuin Risorse. Il codice seguente definisce una voce di menu di esempio denominata Stampa:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/menu_print"
        android:title="Print"
        android:showAsAction="never" />
</menu>

L'interazione con il menu delle opzioni nell'attività avviene tramite i OnCreateOptionsMenu metodi e OnOptionsItemSelected . OnCreateOptionsMenu è il posto in cui aggiungere nuove voci di menu, come l'opzione Stampa, dalla directory delle risorse del menu . OnOptionsItemSelected ascolta l'utente selezionando l'opzione Stampa dal menu e inizia la stampa:

bool dataLoaded;

public override bool OnCreateOptionsMenu (IMenu menu)
{
    base.OnCreateOptionsMenu (menu);
    if (dataLoaded) {
        MenuInflater.Inflate (Resource.Menu.print, menu);
    }
    return true;
}

public override bool OnOptionsItemSelected (IMenuItem item)
{
    if (item.ItemId == Resource.Id.menu_print) {
        PrintPage ();
        return true;
    }
    return base.OnOptionsItemSelected (item);
}

Il codice precedente definisce anche una variabile denominata dataLoaded per tenere traccia dello stato del contenuto HTML. La WebViewClient variabile verrà impostata su true quando tutto il contenuto è stato caricato, in modo che l'attività sappia aggiungere la voce di menu Stampa al menu delle opzioni.

WebViewClient

Il processo di WebViewClient è garantire che i dati in WebView siano caricati completamente prima che l'opzione di stampa venga visualizzata nel menu, che esegue con il OnPageFinished metodo . OnPageFinished rimane in ascolto del completamento del caricamento del contenuto Web e indica all'attività di ricreare il menu delle opzioni con InvalidateOptionsMenu:

class MyWebViewClient : WebViewClient
{
    PrintHtmlActivity caller;

    public MyWebViewClient (PrintHtmlActivity caller)
    {
        this.caller = caller;
    }

    public override void OnPageFinished (WebView view, string url)
    {
        caller.dataLoaded = true;
        caller.InvalidateOptionsMenu ();
    }
}

OnPageFinished imposta anche il dataLoaded valore su true, in modo da OnCreateOptionsMenu poter ricreare il menu con l'opzione Stampa sul posto.

PrintManager

Nell'esempio di codice seguente viene stampato il contenuto di un oggetto WebView:

void PrintPage ()
{
    PrintManager printManager = (PrintManager)GetSystemService (Context.PrintService);
    PrintDocumentAdapter printDocumentAdapter = myWebView.CreatePrintDocumentAdapter ();
    printManager.Print ("MyWebPage", printDocumentAdapter, null);
}

Print accetta come argomenti: un nome per il processo di stampa ("MyWebPage" in questo esempio), un PrintDocumentAdapter che genera il documento di stampa dal contenuto e PrintAttributes (null nell'esempio precedente). È possibile specificare PrintAttributes la disposizione del contenuto nella pagina stampata, anche se gli attributi predefiniti devono gestire la maggior parte degli scenari.

La chiamata Print carica l'interfaccia utente di stampa, che elenca le opzioni per il processo di stampa. L'interfaccia utente offre agli utenti la possibilità di stampare o salvare il contenuto HTML in un PDF, come illustrato negli screenshot seguenti:

Hardware

KitKat aggiunge diverse API per supportare nuove funzionalità del dispositivo. I più importanti di questi sono l'emulazione di carte basate su host e il nuovo SensorManager.

Emulazione di schede basate su host in NFC

HCE (Host-Based Card Emulation) consente alle applicazioni di comportarsi come schede NFC o lettori di schede NFC senza basarsi sull'elemento secure proprietario del gestore telefonico. Prima di configurare HCE, assicurarsi che HCE sia disponibile nel dispositivo con PackageManager.HasSystemFeature:

bool hceSupport = PackageManager.HasSystemFeature(PackageManager.FeatureNfcHostCardEmulation);

HCE richiede che sia la funzionalità HCE che l'autorizzazione NfcAndroidManifest.xmlsiano registrate con :

<uses-feature android:name="android.hardware.nfc.hce" />

Per funzionare, HCE deve essere in grado di essere eseguito in background e deve iniziare quando l'utente effettua una transazione NFC, anche se l'applicazione che usa HCE non è in esecuzione. A tale scopo, scrivere il codice HCE come .Service Un servizio HCE implementa l'interfaccia HostApduService , che implementa i metodi seguenti:

• ProcessCommandApdu : un'unità di dati APDU (Application Protocol Data Unit) è ciò che viene inviato tra il lettore NFC e il servizio HCE. Questo metodo utilizza una ADPU dal lettore e restituisce un'unità dati in risposta.

• OnDeactivated : l'oggetto HostAdpuService viene disattivato quando il servizio HCE non comunica più con il lettore NFC.

Un servizio HCE deve anche essere registrato con il manifesto dell'applicazione e decorato con le autorizzazioni, il filtro finalità e i metadati appropriati. Il codice seguente è un esempio di registrato HostApduService con il manifesto Android usando l'attributo Service (per altre informazioni sugli attributi, vedere la guida Xamarin Working with Android Manifest ):

[Service(Exported=true, Permission="android.permissions.BIND_NFC_SERVICE"),
    IntentFilter(new[] {"android.nfc.cardemulation.HOST_APDU_SERVICE"}),
    MetaData("android.nfc.cardemulation.host.apdu_service",
    Resource="@xml/hceservice")]

class HceService : HostApduService
{
    public override byte[] ProcessCommandApdu(byte[] apdu, Bundle extras)
    {
        ...
    }

    public override void OnDeactivated (DeactivationReason reason)
    {
        ...
    }
}

Il servizio precedente fornisce un modo per consentire al lettore NFC di interagire con l'applicazione, ma il lettore NFC non ha ancora modo di sapere se questo servizio sta simulando la scheda NFC che deve analizzare. Per consentire al lettore NFC di identificare il servizio, è possibile assegnare al servizio un ID applicazione univoco (AID). Si specifica un AID, insieme ad altri metadati relativi al servizio HCE, in un file di risorse xml registrato con l'attributo (vedere l'esempio MetaData di codice precedente). Questo file di risorse specifica uno o più filtri AID: stringhe di identificatori univoci in formato esadecimale che corrispondono agli ID di intelligenza artificiale di uno o più dispositivi di lettura NFC:

<host-apdu-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:description="@string/hce_service_description"
    android:requireDeviceUnlock="false"
    android:apduServiceBanner="@drawable/service_banner">
    <aid-group android:description="@string/aid_group_description"
                android:category="payment">
        <aid-filter android:name="1111111111111111"/>
        <aid-filter android:name="0123456789012345"/>
    </aid-group>
</host-apdu-service>

Oltre ai filtri AID, il file di risorse xml fornisce anche una descrizione rivolta all'utente del servizio HCE, specifica un gruppo di AID (applicazione di pagamento rispetto a "altro") e, nel caso di un'applicazione di pagamento, un banner dp 260x96 da visualizzare all'utente.

La configurazione descritta in precedenza fornisce i blocchi predefiniti di base per un'applicazione che emula una scheda NFC. NFC richiede diversi passaggi e ulteriori test da configurare. Per altre informazioni sull'emulazione di schede basate su host, vedere il portale della documentazione di Android. Per altre informazioni sull'uso di NFC con Xamarin, vedere gli esempi di Xamarin NFC.

Sensors

KitKat consente l'accesso ai sensori del dispositivo tramite un oggetto SensorManager. SensorManager Consente al sistema operativo di pianificare il recapito delle informazioni del sensore a un'applicazione in batch, mantenendo la durata della batteria.

KitKat include anche due nuovi tipi di sensori per tenere traccia dei passaggi dell'utente. Questi sono basati sull'accelerometro e includono:

• StepDetector : l'app riceve una notifica o un woken quando l'utente esegue un passaggio e il rilevatore fornisce un valore di ora per il momento in cui si è verificato il passaggio.

• StepCounter : tiene traccia del numero di passaggi eseguiti dall'utente dopo la registrazione del sensore fino al successivo riavvio del dispositivo.

Lo screenshot seguente illustra il contatore dei passaggi in azione:

È possibile creare un oggetto SensorManager chiamando GetSystemService(SensorService) e eseguendo il cast del risultato come .SensorManager Per usare il contatore dei passaggi, chiamare GetDefaultSensor su SensorManager. È possibile registrare il sensore e ascoltare le modifiche nel conteggio dei passaggi con l'aiuto di ISensorEventListener interfaccia, come illustrato nell'esempio di codice seguente:

public class MainActivity : Activity, ISensorEventListener
{
    float count = 0;

    protected override void OnCreate (Bundle bundle)
    {
        base.OnCreate (bundle);
        SetContentView (Resource.Layout.Main);

        SensorManager senMgr = (SensorManager) GetSystemService (SensorService);
        Sensor counter = senMgr.GetDefaultSensor (SensorType.StepCounter);
        if (counter != null) {
            senMgr.RegisterListener(this, counter, SensorDelay.Normal);
        }
    }

    public void OnAccuracyChanged (Sensor sensor, SensorStatus accuracy)
    {
        Log.Info ("SensorManager", "Sensor accuracy changed");
    }

    public void OnSensorChanged (SensorEvent e)
    {
        count = e.Values [0];
    }
}

OnSensorChanged viene chiamato se il conteggio dei passaggi viene aggiornato mentre l'applicazione è in primo piano. Se l'applicazione entra in background o il dispositivo è in stato di sospensione, non verrà chiamato, OnSensorChanged ma i passaggi continueranno a essere conteggiati fino a quando UnregisterListener non viene chiamato.

Tenere presente che il valore del conteggio dei passaggi è cumulativo in tutte le applicazioni che registrano il sensore. Ciò significa che anche se si disinstalla e reinstalla l'applicazione e si inizializza la count variabile all'avvio dell'applicazione, il valore segnalato dal sensore rimarrà il numero totale di passaggi eseguiti durante la registrazione del sensore, indipendentemente dall'applicazione o da un altro. È possibile impedire all'applicazione di aggiungere al contatore dei passaggi chiamando UnregisterListener su SensorManager, come illustrato nel codice seguente:

protected override void OnPause()
{
    base.OnPause ();
    senMgr.UnregisterListener(this);
}

Il riavvio del dispositivo reimposta il numero di passaggi su 0. L'app richiederà codice aggiuntivo per assicurarsi che segnali un conteggio accurato per l'applicazione, indipendentemente dalle altre applicazioni che usano il sensore o lo stato del dispositivo.

Nota

Mentre l'API per il rilevamento dei passaggi e il conteggio viene fornito con KitKat, non tutti i telefoni sono dotati del sensore. È possibile verificare se il sensore è disponibile eseguendo PackageManager.HasSystemFeature(PackageManager.FeatureSensorStepCounter);o verificando che il valore restituito di GetDefaultSensor non nullsia .

Strumenti di sviluppo

Registrazione dello schermo

KitKat include nuove funzionalità di registrazione dello schermo in modo che gli sviluppatori possano registrare le applicazioni in azione. La registrazione dello schermo è disponibile tramite il client Android Debug Bridge (ADB), che può essere scaricato come parte di Android SDK.

Per registrare lo schermo, connettere il dispositivo; individuare quindi l'installazione di Android SDK, passare alla directory platform-tools ed eseguire il client adb :

adb shell screenrecord /sdcard/screencast.mp4

Il comando precedente registrerà un video predefinito di 3 minuti alla risoluzione predefinita di 4 Mbps. Per modificare la lunghezza, aggiungere il flag --time-limit . Per modificare la risoluzione, aggiungere il flag --bit-rate . Il comando seguente registrerà un video di minuti a 8 Mbps:

adb shell screenrecord --bit-rate 8000000 --time-limit 60 /sdcard/screencast.mp4

È possibile trovare il video sul dispositivo, che verrà visualizzato nella raccolta al termine della registrazione.

Altre aggiunte kitkat

Oltre alle modifiche descritte in precedenza, KitKat consente di:

• Usa schermo intero - KitKat introduce una nuova modalità immersiva per esplorare contenuti, giocare ed eseguire altre applicazioni che potrebbero trarre vantaggio da un'esperienza a schermo intero.

• Personalizzare le notifiche : ottenere altri dettagli sulle notifiche di sistema con il NotificationListenerService . In questo modo è possibile presentare le informazioni in modo diverso all'interno dell'app.

• Risorse disegnabili mirror: le risorse disegnabili hanno un nuovo autoMirrored attributo che indica al sistema di creare una versione con mirroring per le immagini che richiedono lo scorrimento per i layout da sinistra a destra.

• Sospendi animazioni - Sospendi e riprendi animazioni create con ClasseAnimator .

• Leggi testo in modo dinamico- Indica parti dell'interfaccia utente che vengono aggiornate dinamicamente con il nuovo testo come "aree dinamiche" con il nuovo accessibilityLiveRegion attributo in modo che il nuovo testo verrà letto automaticamente in modalità di accessibilità.

• Migliorare l'esperienza audio - Rendere le tracce più rumorose con il LoudnessEnhancer , trovare peak e RMS di un flusso audio con Visualizer classe e ottenere informazioni da un timestamp audio per facilitare la sincronizzazione audio-video.

• Sincronizza ContentResolver a intervalli personalizzati: KitKat aggiunge una certa variabilità al momento in cui viene eseguita una richiesta di sincronizzazione. Sincronizzare un oggetto ContentResolver a un intervallo di tempo o un intervallo personalizzato chiamando ContentResolver.RequestSync e passando un oggetto SyncRequest.

• Distinguere tra i controller : in KitKat, ai controller vengono assegnati identificatori integer univoci a cui è possibile accedere tramite la proprietà del ControllerNumber dispositivo. In questo modo è più facile distinguere i giocatori in un gioco.

• Telecomando - Con alcune modifiche sul lato hardware e software, KitKat consente di trasformare un dispositivo dotato di un trasmettitore IR in un telecomando utilizzando e ConsumerIrServiceinteragire con i dispositivi periferici con il nuovo RemoteController Api.

Per altre informazioni sulle modifiche dell'API precedente, vedere la panoramica delle API di Google Android 4.4.

Riepilogo

Questo articolo ha introdotto alcune delle nuove API disponibili in Android 4.4 (livello API 19) e sono state illustrate le procedure consigliate per la transizione di un'applicazione a KitKat. Sono state descritte le modifiche apportate alle API che influiscono sull'esperienza utente, tra cui il framework di transizione e le nuove opzioni per il tema. Successivamente, ha introdotto il framework e la classe Archiviazione-Access, nonché le nuove API di DocumentsProvider stampa. Ha esplorato l'emulazione della scheda basata su host NFC e come lavorare con sensori a basso consumo, inclusi due nuovi sensori per tenere traccia dei passaggi dell'utente. Infine, ha dimostrato di acquisire demo in tempo reale delle applicazioni con la registrazione dello schermo e ha fornito un elenco dettagliato delle modifiche e delle aggiunte dell'API KitKat.

Collegamenti correlati

• API Android 4.4
• Android KitKat