Fonctionnalités KitKat

Android 4.4 (KitKat) est chargé avec une cornucopia de fonctionnalités pour les utilisateurs et les développeurs. Ce guide met en évidence plusieurs de ces fonctionnalités et fournit des exemples de code et des détails d’implémentation pour vous aider à tirer le meilleur parti de KitKat.

Vue d’ensemble

Android 4.4 (NIVEAU d’API 19), également appelé « KitKat », a été publié fin 2013. KitKat offre une variété de nouvelles fonctionnalités et améliorations, notamment :

• Expérience utilisateur : animations faciles avec le framework de transition, l’état translucide et les barres de navigation, et le mode immersif plein écran permettent de créer une meilleure expérience pour l’utilisateur.

• Contenu utilisateur : la gestion des fichiers utilisateur simplifiée avec l’infrastructure d’accès au stockage ; l’impression d’images, de sites web et d’autres contenus est plus facile avec des API d’impression améliorées.

• Matériel : transformez n’importe quelle application en carte NFC avec l’émulation de carte basée sur l’hôte NFC ; exécutez des capteurs à faible puissance avec le SensorManager .

• Outils de développement : applications de capture d’écran en action avec le client Pont de débogage Android, disponible dans le cadre du Kit de développement logiciel (SDK) Android.

Ce guide fournit des conseils pour la migration d’une application Xamarin.Android existante vers KitKat, ainsi qu’une vue d’ensemble générale de KitKat pour les développeurs Xamarin.Android.

Spécifications

Pour développer des applications Xamarin.Android à l’aide de KitKat, vous avez besoin de Xamarin.Android 4.11.0 ou version ultérieure et d’Android 4.4 (niveau d’API 19) installés via le Gestionnaire du Kit de développement logiciel (SDK) Android, comme illustré par la capture d’écran suivante :

Migration de votre application vers KitKat

Cette section fournit des éléments de première réponse pour faciliter la transition d’applications existantes vers Android 4.4.

Vérifier la version du système

Si une application doit être compatible avec les versions antérieures d’Android, veillez à encapsuler tout code spécifique à KitKat dans une version système case activée, comme illustré par l’exemple de code ci-dessous :

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

Traitement par lots d’alarmes

Android utilise des services d’alarme pour réveiller une application en arrière-plan à un moment spécifié. KitKat fait un pas plus loin en mettant en lots des alarmes pour préserver la puissance. Cela signifie que, au lieu de réveiller chaque application à un moment précis, KitKat préfère regrouper plusieurs applications inscrites pour se réveiller pendant le même intervalle de temps et les réveiller en même temps. Pour indiquer à Android de réveiller une application pendant un intervalle de temps spécifié, appelez SetWindow le AlarmManager, transmettez la durée minimale et maximale, en millisecondes, qui peut s’écouler avant que l’application soit réveillée et l’opération à effectuer au moment de la veille. Le code suivant fournit un exemple d’application qui doit être réveillée entre une demi-heure et une heure à partir du moment où la fenêtre est définie :

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

Pour continuer à réveiller une application à un moment précis, utilisez SetExact, transmettez l’heure exacte à laquelle l’application doit être réveillée et l’opération à effectuer :

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

KitKat ne vous permet plus de définir une alarme répétée exacte. Applications qui utilisent SetRepeating et exiger des alarmes exactes pour fonctionner doit maintenant déclencher chaque alarme manuellement.

Stockage externe

Le stockage externe est désormais divisé en deux types : le stockage unique à votre application et les données partagées par plusieurs applications. La lecture et l’écriture dans l’emplacement spécifique de votre application sur le stockage externe ne nécessitent aucune autorisation spéciale. L’interaction avec les données sur le stockage partagé nécessite désormais l’autorisation ou WRITE_EXTERNAL_STORAGE l’autorisationREAD_EXTERNAL_STORAGE. Les deux types peuvent être classés comme tels :

• Si vous obtenez un chemin d’accès de fichier ou de répertoire en appelant une méthode sur Context , par exemple, GetExternalFilesDir ou GetExternalCacheDirs

  • votre application ne nécessite aucune autorisation supplémentaire.

• Si vous obtenez un chemin d’accès de fichier ou de répertoire en accédant à une propriété ou en appelant une méthode sur Environment , par exemple GetExternalStorageDirectory ou GetExternalStoragePublicDirectory, votre application nécessite l’autorisation ou WRITE_EXTERNAL_STORAGE l’autorisationREAD_EXTERNAL_STORAGE.

Remarque

WRITE_EXTERNAL_STORAGE implique l’autorisation READ_EXTERNAL_STORAGE . Vous ne devez donc jamais avoir besoin de définir une seule autorisation.

SMS Consolidation

KitKat simplifie la messagerie de l’utilisateur en agrégeant tout le contenu SMS dans une application par défaut sélectionnée par l’utilisateur. Le développeur est chargé de rendre l’application sélectionnable comme application de messagerie par défaut et de se comporter correctement dans le code et dans la vie si l’application n’est pas sélectionnée. Pour plus d’informations sur la transition de votre application SMS vers KitKat, reportez-vous au guide Getting Your SMS Apps Ready for KitKat de Google.

WebView Apps

WebView a obtenu une relooking dans KitKat. La plus grande modification est la sécurité ajoutée pour le chargement du contenu dans un WebView. Bien que la plupart des applications ciblant des versions d’API antérieures fonctionnent comme prévu, les applications de test qui utilisent la WebView classe sont fortement recommandées. Pour plus d’informations sur les API WebView affectées, reportez-vous à la documentation Android Migration vers WebView dans android 4.4 .

Expérience utilisateur

KitKat est fourni avec plusieurs nouvelles API pour améliorer l’expérience utilisateur, notamment le nouveau framework de transition pour la gestion des animations de propriétés et une option d’interface utilisateur translucide pour les thèmes. Ces modifications sont décrites ci-dessous.

Infrastructure de transition

Le framework de transition facilite l’implémentation des animations. KitKat vous permet d’effectuer une animation de propriété simple avec une seule ligne de code ou de personnaliser les transitions à l’aide de Scènes.

Animation de propriété simple

La nouvelle bibliothèque Transitions Android simplifie le code derrière les animations de propriétés. L’infrastructure vous permet d’effectuer des animations simples avec du code minimal. Par exemple, l’exemple de code suivant utilise TransitionManager.BeginDelayedTransition pour animer l’affichage et le masquage d’un 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;
            }
        };
    }
}

L’exemple ci-dessus utilise l’infrastructure de transition pour créer une transition automatique et par défaut entre les valeurs de propriété de modification. Étant donné que l’animation est gérée par une seule ligne de code, vous pouvez facilement le rendre compatible avec les versions antérieures d’Android en encapsulant l’appel BeginDelayedTransition dans une version système case activée. Pour plus d’informations, consultez la section Migration de votre application vers KitKat .

La capture d’écran ci-dessous montre l’application avant l’animation :

La capture d’écran ci-dessous montre l’application après l’animation :

Vous pouvez contrôler davantage la transition avec Scènes, qui sont abordées dans la section suivante.

Scènes Android

Les scènes ont été introduites dans le cadre du framework de transition pour donner au développeur plus de contrôle sur les animations. Les scènes créent une zone dynamique dans l’interface utilisateur : vous spécifiez un conteneur et plusieurs versions, ou « scènes », pour le contenu XML à l’intérieur du conteneur, et Android effectue le reste du travail pour animer les transitions entre les scènes. Android Scenes vous permet de créer des animations complexes avec un travail minimal côté développement.

L’élément d’interface utilisateur statique qui héberge le contenu dynamique est un conteneur ou une base de scène. L’exemple ci-dessous utilise le Concepteur Android pour créer un RelativeLayout appelé container:

L’exemple de disposition définit également un bouton appelé sceneButton sous le container. Ce bouton déclenche la transition.

Le contenu dynamique à l’intérieur du conteneur nécessite deux nouvelles dispositions Android. Ces dispositions spécifient uniquement le code à l’intérieur du conteneur. L’exemple de code ci-dessous définit une disposition appelée Scene1 qui contient deux champs de texte lisant « Kit » et « Kat », respectivement, et une deuxième disposition appelée Scene2 qui contient les mêmes champs de texte inversés. Le code XML est le suivant :

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>

L’exemple ci-dessus utilise merge pour raccourcir le code d’affichage et simplifier la hiérarchie d’affichage. Vous pouvez en savoir plus sur merge les dispositions ici.

Une scène est créée en appelant Scene.GetSceneForLayout, en passant l’objet conteneur, l’ID de ressource du fichier de disposition de la scène et le fichier actuel Context, comme illustré par l’exemple de code ci-dessous :

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();

Le fait de cliquer sur le bouton bascule entre les deux Scènes, que Android anime avec les valeurs de transition par défaut :

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

    TransitionManager.Go (scene1);
};

La capture d’écran ci-dessous illustre la scène avant l’animation :

La capture d’écran ci-dessous illustre la scène après l’animation :

Remarque

Il existe un bogue connu dans la bibliothèque Transitions Android qui provoque la création de Scènes créées à l’aide GetSceneForLayout d’un saut lorsqu’un utilisateur navigue dans une activité la deuxième fois.

Transitions personnalisées dans les scènes

Une transition personnalisée peut être définie dans un fichier de ressources xml dans le transition répertoire sous Resources, comme illustré par la capture d’écran ci-dessous :

L’exemple de code suivant définit une transition qui s’anime pendant 5 secondes. Voir plus d’informations sur l’animation à l’adresse.

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

La transition est créée dans l’activité à l’aide de TransitionInflater, comme illustré par le code ci-dessous :

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

La nouvelle transition est ensuite ajoutée à l’appel Go qui commence l’animation :

TransitionManager.Go (scene1, transition);

Interface utilisateur translucide

KitKat vous donne plus de contrôle sur les thèmes de votre application avec des barres de navigation et d’état translucide facultatives. Vous pouvez modifier la transparence des éléments de l’interface utilisateur système dans le même fichier XML que vous utilisez pour définir votre thème Android. KitKat présente les propriétés suivantes :

• windowTranslucentStatus - Lorsque la valeur est true, la barre d’état supérieure est translucide.

• windowTranslucentNavigation - Lorsqu’elle est définie sur true, rend la barre de navigation inférieure translucide.

• fitsSystemWindows - Définition de la barre supérieure ou inférieure pour transcluente déplace le contenu sous les éléments d’interface utilisateur transparents par défaut. La définition de cette propriété true est un moyen simple d’empêcher le contenu de se chevaucher avec les éléments de l’interface utilisateur système translucide.

Le code suivant définit un thème avec des barres d’état et de navigation translucides :

<?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>

La capture d’écran ci-dessous montre le thème ci-dessus avec des barres d’état et de navigation translucides :

Contenu Utilisateur

Infrastructure d’accès Stockage

Le Stockage Access Framework (SAF) est un nouveau moyen pour les utilisateurs d’interagir avec du contenu stocké, comme des images, des vidéos et des documents. Au lieu de présenter aux utilisateurs une boîte de dialogue pour choisir une application pour gérer le contenu, KitKat ouvre une nouvelle interface utilisateur qui permet aux utilisateurs d’accéder à leurs données dans un emplacement d’agrégation. Une fois le contenu choisi, l’utilisateur retourne à l’application qui a demandé le contenu, et l’expérience de l’application se poursuit normalement.

Cette modification nécessite deux actions côté développeur : tout d’abord, les applications qui nécessitent du contenu provenant de fournisseurs doivent être mises à jour vers une nouvelle façon de demander du contenu. Deuxièmement, les applications qui écrivent des données doivent ContentProvider être modifiées pour utiliser le nouveau framework. Les deux scénarios dépendent du nouveau DocumentsProvider API.

DocumentsProvider

Dans KitKat, les interactions avec ContentProviders sont abstraites avec la DocumentsProvider classe. Cela signifie que SAF ne s’occupe pas de l’endroit où les données sont physiquement, tant qu’elles sont accessibles via l’API DocumentsProvider . Les fournisseurs locaux, les services cloud et les appareils de stockage externe utilisent toutes la même interface et sont traités de la même façon, ce qui permet à l’utilisateur et au développeur d’interagir avec le contenu de l’utilisateur.

Cette section explique comment charger et enregistrer du contenu avec l’infrastructure d’accès Stockage.

Demander du contenu à un fournisseur

Nous pouvons indiquer à KitKat que nous voulons choisir du contenu à l’aide de l’interface utilisateur SAF avec l’intention ActionOpenDocument , ce qui signifie que nous voulons nous connecter à tous les fournisseurs de contenu disponibles pour l’appareil. Vous pouvez ajouter un filtrage à cette intention en spécifiant CategoryOpenable, ce qui signifie que seul le contenu qui peut être ouvert (c.-à-d. le contenu accessible et utilisable) est retourné. KitKat permet également le filtrage du contenu avec le MimeType. Par exemple, le code ci-dessous filtre les résultats de l’image en spécifiant l’image MimeType:

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

L’appel StartActivityForResult lance l’interface utilisateur SAF, que l’utilisateur peut ensuite parcourir pour choisir une image :

Une fois que l’utilisateur a choisi une image, OnActivityResult retourne le Android.Net.Uri fichier choisi. L’exemple de code ci-dessous affiche la sélection de l’image de l’utilisateur :

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);
    }
}

Écrire du contenu dans un fournisseur

Outre le chargement de contenu à partir de l’interface utilisateur SAF, KitKat vous permet également d’enregistrer du contenu dans tout ContentProvider élément qui implémente l’API DocumentProvider . L’enregistrement de contenu utilise un Intent avec 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’exemple de code ci-dessus charge l’interface utilisateur SAF, ce qui permet à l’utilisateur de modifier le nom du fichier et de sélectionner un répertoire pour héberger le nouveau fichier :

Lorsque l’utilisateur appuie sur Enregistrer, reçoit le Android.Net.Uri fichier nouvellement créé, accessible avec data.Data. OnActivityResult L’URI peut être utilisé pour diffuser des données dans le nouveau fichier :

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);
        }
    }
}

Notez que ContentResolver.OpenOutputStream(Android.Net.Uri) retourne un System.IO.Stream, afin que l’intégralité du processus de diffusion en continu puisse être écrit dans .NET.

Pour plus d’informations sur le chargement, la création et la modification de contenu avec l’infrastructure d’accès Stockage, reportez-vous à la documentation Android de l’infrastructure d’accès Stockage.

Impression

Le contenu d’impression est simplifié dans KitKat avec l’introduction des services d’impression et PrintManager. KitKat est également la première version de l’API pour tirer pleinement parti des API du service Google Cloud Print à l’aide des applications Google Cloud Print. La plupart des appareils fournis avec KitKat téléchargent automatiquement l’application Google Cloud Print et le plug-inhp Print Service lorsqu’ils se connectent pour la première fois au WiFi. Un utilisateur peut case activée les paramètres d’impression de son appareil en accédant à Paramètres Impression >système > :

Remarque

Bien que les API d’impression soient configurées pour fonctionner avec Google Cloud Print par défaut, Android permet toujours aux développeurs de préparer le contenu d’impression à l’aide des nouvelles API et de l’envoyer à d’autres applications pour gérer l’impression.

Impression de contenu HTML

KitKat crée automatiquement une PrintDocumentAdapter vue web avec WebView.CreatePrintDocumentAdapter. L’impression de contenu web est un effort coordonné entre un WebViewClient qui attend que le contenu HTML soit chargé et indique à l’activité de rendre l’option d’impression disponible dans le menu options, et l’activité, qui attend que l’utilisateur sélectionne l’option Imprimer et les appels Printsur le PrintManager. Cette section décrit la configuration de base requise pour imprimer du contenu HTML à l’écran.

Notez que le chargement et l’impression de contenu web nécessitent l’autorisation Internet :

Imprimer l’élément de menu

L’option d’impression apparaît généralement dans le menu options de l’activité. Le menu options permet aux utilisateurs d’effectuer des actions sur une activité. Il se trouve dans le coin supérieur droit de l’écran et ressemble à ceci :

Des éléments de menu supplémentaires peuvent être définis dans le répertoire de menussous Ressources. Le code ci-dessous définit un exemple d’élément de menu appelé Imprimer :

<?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’interaction avec le menu options de l’activité se produit via les méthodes et OnOptionsItemSelected les OnCreateOptionsMenu méthodes. OnCreateOptionsMenu est l’endroit où ajouter de nouveaux éléments de menu, comme l’option Imprimer, à partir du répertoire des ressources de menu . OnOptionsItemSelected écoute l’utilisateur qui sélectionne l’option Imprimer dans le menu et commence à imprimer :

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);
}

Le code ci-dessus définit également une variable appelée dataLoaded pour suivre l’état du contenu HTML. La WebViewClient variable définit cette variable sur true lorsque tout le contenu a chargé, de sorte que l’activité sait ajouter l’élément de menu Imprimer au menu options.

WebViewClient

Le travail du fichier WebViewClient consiste à garantir que les données dans le WebView fichier sont entièrement chargées avant l’affichage de l’option d’impression dans le menu, qu’elle effectue avec la OnPageFinished méthode. OnPageFinished écoute le contenu web pour terminer le chargement et indique à l’activité de recréer son menu options avec 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 définit également la dataLoaded valeur truesur , afin de OnCreateOptionsMenu pouvoir recréer le menu avec l’option Imprimer en place.

PrintManager

L’exemple de code suivant imprime le contenu d’un WebView:

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

Print prend en tant qu’arguments : nom de la tâche d’impression (« MyWebPage » dans cet exemple), un PrintDocumentAdapter qui génère le document imprimé à partir du contenu et PrintAttributes (null dans l’exemple ci-dessus). Vous pouvez spécifier pour vous aider à définir PrintAttributes du contenu sur la page imprimée, bien que les attributs par défaut doivent gérer la plupart des scénarios.

L’appel Print charge l’interface utilisateur d’impression, qui répertorie les options du travail d’impression. L’interface utilisateur permet aux utilisateurs d’imprimer ou d’enregistrer le contenu HTML dans un fichier PDF, comme illustré par les captures d’écran ci-dessous :

Matériel

KitKat ajoute plusieurs API pour prendre en charge de nouvelles fonctionnalités d’appareil. Les plus notables sont l’émulation de carte basée sur l’hôte et la nouvelle SensorManager.

Émulation de carte basée sur l’hôte dans NFC

L’émulation de carte basée sur l’hôte (HCE) permet aux applications de se comporter comme des carte NFC ou des lecteurs de carte NFC sans compter sur l’élément sécurisé propriétaire de l’opérateur. Avant de configurer HCE, vérifiez que HCE est disponible sur l’appareil avec PackageManager.HasSystemFeature:

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

HCE exige que la fonctionnalité HCE et l’autorisation Nfc soient inscrites auprès de AndroidManifest.xmll’application :

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

Pour fonctionner, HCE doit être en mesure d’exécuter en arrière-plan et doit commencer quand l’utilisateur effectue une transaction NFC, même si l’application utilisant HCE n’est pas en cours d’exécution. Pour ce faire, nous pouvons écrire le code HCE en tant que Service. Un service HCE implémente l’interface HostApduService , qui implémente les méthodes suivantes :

• ProcessCommandApdu - Une unité de données DE PROTOCOLE D’application (APDU) est ce qui est envoyé entre le lecteur NFC et le service HCE. Cette méthode consomme un ADPU à partir du lecteur et retourne une unité de données en réponse.

• OnDeactivated : HostAdpuService désactivé lorsque le service HCE ne communique plus avec le lecteur NFC.

Un service HCE doit également être inscrit auprès du manifeste de l’application et décoré avec les autorisations appropriées, le filtre d’intention et les métadonnées. Le code suivant est un exemple d’un HostApduService manifeste Android inscrit à l’aide de l’attribut Service (pour plus d’informations sur les attributs, reportez-vous au guide 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)
    {
        ...
    }
}

Le service ci-dessus permet au lecteur NFC d’interagir avec l’application, mais le lecteur NFC n’a toujours aucun moyen de savoir si ce service émule le carte NFC dont il a besoin pour analyser. Pour aider le lecteur NFC à identifier le service, nous pouvons affecter au service un ID d’application unique (AID). Nous spécifions un AID, ainsi que d’autres métadonnées sur le service HCE, dans un fichier de ressources xml inscrit auprès de l’attribut MetaData (voir l’exemple de code ci-dessus). Ce fichier de ressources spécifie un ou plusieurs filtres AID : chaînes d’identificateur uniques au format hexadécimal qui correspondent aux AID d’un ou de plusieurs périphériques de lecteur 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>

En plus des filtres AID, le fichier de ressources xml fournit également une description orientée utilisateur du service HCE, spécifie un groupe d’AIDE (application de paiement par rapport à « autre ») et, dans le cas d’une application de paiement, une bannière dp 260x96 à afficher à l’utilisateur.

La configuration décrite ci-dessus fournit les blocs de construction de base d’une application qui émule un carte NFC. NFC lui-même nécessite plusieurs étapes supplémentaires et des tests supplémentaires pour configurer. Pour plus d’informations sur l’émulation de carte basée sur l’hôte, reportez-vous au portail de documentation Android. Pour plus d’informations sur l’utilisation de NFC avec Xamarin, case activée les exemples NFC Xamarin.

Capteurs

KitKat fournit l’accès aux capteurs de l’appareil via un SensorManager. Le SensorManager système d’exploitation permet au système d’exploitation de planifier la livraison d’informations de capteur à une application par lots, en préservant la durée de vie de la batterie.

KitKat est également fourni avec deux nouveaux types de capteurs pour suivre les étapes de l’utilisateur. Celles-ci sont basées sur l’accéléromètre et incluent :

• StepDetector : l’application est avertie/réveillée lorsque l’utilisateur effectue une étape, et le détecteur fournit une valeur de temps pour le moment où l’étape s’est produite.

• StepCounter : effectue le suivi du nombre d’étapes effectuées par l’utilisateur depuis l’inscription du capteur jusqu’au prochain redémarrage de l’appareil.

La capture d’écran ci-dessous illustre le compteur d’étapes en action :

Vous pouvez créer un SensorManager appel GetSystemService(SensorService) et un cast du résultat en tant SensorManagerque . Pour utiliser le compteur d’étapes, appelez GetDefaultSensor le SensorManager. Vous pouvez inscrire le capteur et écouter les modifications apportées au nombre d’étapes à l’aide du ISensorEventListener interface, comme illustré par l’exemple de code ci-dessous :

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 est appelé si le nombre d’étapes est mis à jour pendant que l’application est au premier plan. Si l’application entre en arrière-plan ou si l’appareil est endormi, OnSensorChanged ne sera pas appelé. Toutefois, les étapes continueront d’être comptées jusqu’à ce qu’elle UnregisterListener soit appelée.

N’oubliez pas que la valeur du nombre d’étapes est cumulative dans toutes les applications qui inscrivent le capteur. Cela signifie que même si vous désinstallez et réinstallez votre application et initialisez la count variable à 0 au démarrage de l’application, la valeur signalée par le capteur reste le nombre total d’étapes effectuées pendant l’inscription du capteur, que ce soit par votre application ou par un autre. Vous pouvez empêcher votre application d’ajouter au compteur d’étapes en appelant UnregisterListener le SensorManagercode ci-dessous :

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

Le redémarrage de l’appareil réinitialise le nombre d’étapes à 0. Votre application nécessite un code supplémentaire pour s’assurer qu’elle signale un nombre précis pour l’application, quelles que soient les autres applications utilisant le capteur ou l’état de l’appareil.

Remarque

Bien que l’API pour la détection des étapes et le comptage des navires avec KitKat, tous les téléphones ne sont pas équipés du capteur. Vous pouvez case activée si le capteur est disponible en exécutant PackageManager.HasSystemFeature(PackageManager.FeatureSensorStepCounter);ou case activée pour vous assurer que la valeur GetDefaultSensor retournée n’est pas null.

Outils pour développeurs

Enregistrement d’écran

KitKat inclut de nouvelles fonctionnalités d’enregistrement d’écran afin que les développeurs puissent enregistrer des applications en action. L’enregistrement d’écran est disponible via le client ADB (Android Debug Bridge), qui peut être téléchargé dans le cadre du Kit de développement logiciel (SDK) Android.

Pour enregistrer votre écran, connectez votre appareil ; recherchez ensuite votre installation du Kit de développement logiciel (SDK) Android, accédez au répertoire des outils de plateforme et exécutez le client adb :

adb shell screenrecord /sdcard/screencast.mp4

La commande ci-dessus enregistre une vidéo par défaut de 3 minutes à la résolution par défaut de 4 Mops. Pour modifier la longueur, ajoutez l’indicateur --time-limit . Pour modifier la résolution, ajoutez l’indicateur --bit-rate . La commande suivante enregistre une vidéo longue minute à 8 Mops :

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

Vous pouvez trouver votre vidéo sur votre appareil : elle apparaît dans votre galerie une fois l’enregistrement terminé.

Autres ajouts KitKat

En plus des modifications décrites ci-dessus, KitKat vous permet de :

• Utilisez l’écran plein écran - KitKat introduit un nouveau mode immersif pour la navigation de contenu, la lecture de jeux et l’exécution d’autres applications qui pourraient bénéficier d’une expérience en plein écran.

• Personnaliser les notifications - Obtenir des détails supplémentaires sur les notifications système avec NotificationListenerService . Cela vous permet de présenter les informations de manière différente à l’intérieur de votre application.

• Ressources dessinables miroir - Les ressources pouvant être dessinées ont une nouvelle autoMirroredattribut qui indique au système de créer une version miroir ed pour les images qui nécessitent un détourage pour les dispositions de gauche à droite.

• Suspendre les animations - Suspendre et reprendre les animations créées avec le ClasseAnimator .

• Lire dynamiquement le texte à modification : désigne les parties de l’interface utilisateur qui sont mises à jour dynamiquement avec le nouveau texte en tant que « régions dynamiques » avec le nouveau accessibilityLiveRegion attribut de sorte que le nouveau texte soit lu automatiquement en mode d’accessibilité.

• Améliorer l’expérience audio - Rendre les pistes plus fortes avec le LoudnessEnhancer , recherchez le pic et RMS d’un flux audio avec le Visualizer classe et obtenir des informations à partir d’un horodatage audio pour faciliter la synchronisation audio-vidéo.

• Synchroniser ContentResolver à intervalle personnalisé - KitKat ajoute une certaine variabilité au moment où une demande de synchronisation est effectuée. Synchronisez un ContentResolver moment ou un intervalle personnalisé en appelant ContentResolver.RequestSync et en transmettant un SyncRequest.

• Faire la distinction entre les contrôleurs - Dans KitKat, les contrôleurs reçoivent des identificateurs entiers uniques accessibles via la propriété de ControllerNumber l’appareil. Cela permet de distinguer plus facilement les joueurs d’un jeu.

• Contrôle à distance - Avec quelques modifications sur le côté matériel et logiciel, KitKat vous permet de transformer un appareil équipé d’un émetteur IR en un contrôle à distance à l’aide du ConsumerIrService, et d’interagir avec les appareils périphériques avec le nouveau RemoteController Api.

Pour plus d’informations sur les modifications apportées à l’API ci-dessus, reportez-vous à la vue d’ensemble des API Google Android 4.4.

Résumé

Cet article a présenté certaines des nouvelles API disponibles dans Android 4.4 (niveau d’API 19) et décrit les meilleures pratiques lors de la transition d’une application vers KitKat. Il a décrit les modifications apportées aux API affectant l’expérience utilisateur, notamment le framework de transition et les nouvelles options pour les thèmes. Ensuite, il a introduit le framework et la classe Stockage-Access, ainsi que les nouvelles API d’impression.DocumentsProvider Il a exploré l’émulation basée sur l’hôte NFC carte et comment utiliser des capteurs à faible puissance, y compris deux nouveaux capteurs pour suivre les étapes de l’utilisateur. Enfin, il a montré la capture de démonstrations en temps réel d’applications avec enregistrement d’écran et fourni une liste détaillée des modifications et ajouts de l’API KitKat.

Liens associés

• API Android 4.4
• Android KitKat