Fonctionnalités de KitKat

  • Article

Android 4.4 (KitKat) est fourni avec une abondance 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 : les animations faciles avec infrastructure de transition, status translucides et barres de navigation et mode immersif plein écran permettent de créer une meilleure expérience pour l’utilisateur.

  • Contenu utilisateur : 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 grâce aux API d’impression améliorées.

  • Matériel : transformez n’importe quelle application en un carte NFC avec l’émulation de carte nfc Host-Based ; exécutez des capteurs de faible puissance avec .SensorManager

  • Outils de développement - Capture d’écran des applications en action avec le client Android Debug Bridge, 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 de KitKat pour les développeurs Xamarin.Android.

Spécifications

Pour développer des applications Xamarin.Android à l’aide de KitKat, vous devez installer Xamarin.Android 4.11.0 ou version ultérieure et Android 4.4 (niveau API 19) via le Gestionnaire de sdk Android, comme illustré par la capture d’écran suivante :

Sélection d’Android 4.4 dans le Gestionnaire du SDK Android

Migration de votre application vers KitKat

Cette section fournit des éléments de première réponse pour faciliter la transition des 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 les services d’alarme pour réveiller une application en arrière-plan à un moment spécifié. KitKat va encore plus loin en lotant des alarmes pour préserver l’alimentation. Cela signifie que, au lieu de réveiller chaque application à une heure exacte, KitKat préfère regrouper plusieurs applications qui sont 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 sur , AlarmManageren passant le temps minimal et maximal, en millisecondes, qui peut s’écouler avant que l’application ne soit réveillée, et l’opération à effectuer au réveil. 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 à l’heure exacte, utilisez SetExact, en passant 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 utilisentSetRepeating et exiger des alarmes exactes pour fonctionner devra 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 READ_EXTERNAL_STORAGE ou WRITE_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 ouGetExternalStoragePublicDirectory , votre application nécessite l’autorisation READ_EXTERNAL_STORAGE ou WRITE_EXTERNAL_STORAGE .

Notes

WRITE_EXTERNAL_STORAGE implique l’autorisation READ_EXTERNAL_STORAGE . Vous ne devez donc définir qu’une seule autorisation.

SMS Consolidation

KitKat simplifie la messagerie pour 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 en tant qu’application de messagerie par défaut et de se comporter de manière appropriée 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, consultez le guide Getting Your SMS Apps Ready for KitKat de Google.

Applications WebView

WebView a fait l’objet d’un looking dans KitKat. La plus grande modification est l’ajout de la sécurité pour le chargement du contenu dans un WebView. Bien que la plupart des applications ciblant des versions d’API plus anciennes fonctionnent comme prévu, il est vivement recommandé de tester les applications qui utilisent la WebView classe. Pour plus d’informations sur les API WebView affectées, consultez la documentation Migration d’Android vers WebView dans Android 4.4 .

Expérience de l'utilisateur

KitKat est fourni avec plusieurs nouvelles API pour améliorer l’expérience utilisateur, notamment la nouvelle infrastructure 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

L’infrastructure 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 Scenes.

Animation de propriété simple

La nouvelle bibliothèque Transitions Android simplifie les animations de propriété du code derrière. L’infrastructure vous permet d’effectuer des animations simples avec un minimum de code. Par exemple, l’exemple de code suivant utiliseTransitionManager.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 par défaut entre les valeurs de propriété modifiées. Étant donné que l’animation est gérée par une seule ligne de code, vous pouvez facilement la 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 :

Capture d’écran de l’application avant le démarrage de l’animation

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

Capture d’écran de l’application une fois l’animation terminée

Vous pouvez obtenir plus de contrôle sur la transition avec Les scènes, qui sont abordées dans la section suivante.

Scènes Android

Les scènes ont été introduites dans le cadre de l’infrastructure 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. Les scènes Android vous permettent 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 Designer Android pour créer un RelativeLayout appelé container:

Utilisation du Designer Android pour créer un conteneur RelativeLayout

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 respectivement « Kit » et « Kat », 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 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();

Cliquer sur le bouton bascule entre les deux Scènes, qu’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 :

Capture d’écran de l’application avant le démarrage de l’animation

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

Capture d’écran de l’application une fois l’animation terminée

Notes

Il existe un bogue connu dans la bibliothèque de transitions Android qui provoque l’arrêt des scènes créées à l’aide GetSceneForLayout de quand 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 :

Emplacement du fichier transition.xml sous le répertoire Ressources/transition

L’exemple de code suivant définit une transition qui s’anime pendant 5 secondes. Pour plus d’informations sur l’animation, voir .

<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 le thème de votre application avec des status et des barres de navigation translucides facultatives. Vous pouvez modifier la translucidité des éléments d’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 supérieure status est translucide.

  • windowTranslucentNavigation - Lorsque la valeur est true, la barre de navigation inférieure est translucide.

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

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

<?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 status translucides et des barres de navigation :

Exemple de capture d’écran d’application avec status translucides et barres de navigation

Contenu utilisateur

Storage-Access Framework

L’infrastructure d’accès au stockage (SAF) est une nouvelle façon pour les utilisateurs d’interagir avec du contenu stocké, tel que des images, des vidéos et des documents. Au lieu de présenter aux utilisateurs une boîte de dialogue leur permettant de 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 agrégé. 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 : premièrement, les applications qui nécessitent du contenu des fournisseurs doivent être mises à jour vers une nouvelle façon de demander du contenu. Deuxièmement, les applications qui écrivent des données dans un ContentProvider doivent être modifiées pour utiliser le nouveau framework. Les deux scénarios dépendent du nouveauDocumentsProvider API.

DocumentsProvider

Dans KitKat, les interactions avec ContentProviders sont abstraites avec la DocumentsProvider classe . Cela signifie que SAF ne se soucie pas de l’emplacement physique des données, tant qu’elles sont accessibles via l’API DocumentsProvider . Les fournisseurs locaux, les services cloud et les périphériques de stockage externes utilisent tous 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 au stockage.

Demander du contenu à partir d’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 sur 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’est-à-dire le contenu accessible et utilisable) sera 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 :

Exemple de capture d’écran d’une application utilisant l’infrastructure d’accès au stockage pour accéder à une image

Une fois que l’utilisateur a choisi une image, OnActivityResult retourne le Android.Net.Uri du 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

En plus de charger du contenu à partir de l’interface utilisateur SAF, KitKat vous permet également d’enregistrer du contenu dans tous ContentProvider les éléments qui implémentent 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 de fichier et de sélectionner un répertoire pour héberger le nouveau fichier :

Capture d’écran de l’utilisateur qui remplace le nom de fichier par NewDoc dans le répertoire Téléchargements

Lorsque l’utilisateur appuie sur Enregistrer, OnActivityResult obtient le Android.Net.Uri du fichier nouvellement créé, qui est accessible avec data.Data. 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 les points suivants :ContentResolver.OpenOutputStream(Android.Net.Uri) retourne un System.IO.Stream, de sorte que l’intégralité du processus de diffusion en continu puisse être écrite en .NET.

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

Impression

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

Exemple de capture d’écran de l’écran Paramètres d’impression

Notes

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 l’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 un PrintDocumentAdapter pour une 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 d’options, et l’activité, qui attend que l’utilisateur sélectionne l’option Imprimer et appelle 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 :

Définition d’une autorisation Internet dans les options de l’application

L’option d’impression s’affiche généralement dans le menu options de l’activité. Le menu d’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 :

Exemple de capture d’écran de l’élément de menu Imprimer affiché dans le coin supérieur droit de l’écran

Des éléments de menu supplémentaires peuvent être définis dans le répertoire de menusous 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 d’options de l’activité se produit par le biais des OnCreateOptionsMenu méthodes et OnOptionsItemSelected . 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 l’impression :

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 effectuer le suivi de la status du contenu HTML. définit WebViewClient cette variable sur true lorsque tout le contenu est chargé, de sorte que l’activité sait ajouter l’élément de menu Imprimer au menu d’options.

WebViewClient

Le travail du WebViewClient consiste à s’assurer que les WebView données du sont entièrement chargées avant que l’option d’impression apparaisse dans le menu, ce qu’elle fait avec la OnPageFinished méthode . OnPageFinished écoute la fin du chargement du contenu web et indique à l’activité de recréer son menu d’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 sur true, de sorte que OnCreateOptionsMenu peut 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 comme arguments : un nom pour le travail d’impression (« MyWebPage » dans cet exemple), unPrintDocumentAdapter qui génère le document d’impression à partir du contenu, etPrintAttributes (null dans l’exemple ci-dessus). Vous pouvez spécifier PrintAttributes pour faciliter la configuration 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 offre aux utilisateurs la possibilité d’imprimer ou d’enregistrer le contenu HTML dans un fichier PDF, comme illustré par les captures d’écran ci-dessous :

Capture d’écran de PrintHtmlActivity affichant le menu Imprimer

Capture d’écran de PrintHtmlActivity affichant le menu Enregistrer au format PDF

Matériel

KitKat ajoute plusieurs API pour prendre en charge les nouvelles fonctionnalités de l’appareil. Les plus notables d’entre eux sont Host-Based Card Emulation et le nouveau SensorManager.

émulation de carte Host-Based dans NFC

L’émulation de carte Host-Based (HCE) permet aux applications de se comporter comme des cartes NFC ou des lecteurs de carte NFC sans dépendre de 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 nécessite que la fonctionnalité HCE et l’autorisation Nfc soient inscrites auprès de AndroidManifest.xmll’application :

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

Définition de l’autorisation NFC dans les options de l’application

Pour fonctionner, HCE doit être en mesure de s’exécuter en arrière-plan, et il doit démarrer lorsque 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 envoyée 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 est 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, le filtre d’intention et les métadonnées appropriés. Le code suivant est un exemple d’un HostApduService inscrit auprès du manifeste Android à 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 émut les carte NFC dont il a besoin pour analyser. Pour aider le lecteur NFC à identifier le service, nous pouvons lui attribuer un ID d’application (AID) unique. Nous spécifions une AIDE, ainsi que d’autres métadonnées sur le service HCE, dans un fichier de ressource xml inscrit avec l’attribut (voir l’exemple MetaData 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 lecteurs 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>

Outre les filtres AID, le fichier de ressources xml fournit également une description du service HCE accessible à l’utilisateur, spécifie un groupe d’aide (application de paiement par opposition à « 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 émulant une carte NFC. Nfc lui-même nécessite plusieurs étapes supplémentaires et des tests supplémentaires pour la configuration. 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 permet au système d’exploitation de planifier la livraison des informations de capteur à une application par lots, ce qui préserve l’autonomie de la batterie.

KitKat est également fourni avec deux nouveaux types de capteurs pour le suivi des é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 montre le compteur d’étapes en action :

Capture d’écran de l’application SensorsActivity affichant un compteur d’étapes

Vous pouvez créer un SensorManager en appelant GetSystemService(SensorService) et en castant le résultat sous la forme d’un SensorManager. Pour utiliser le compteur d’étapes, appelez GetDefaultSensor sur le SensorManager. Vous pouvez inscrire le capteur et écouter les modifications apportées au nombre d’étapes à l’aide duISensorEventListener 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 alors que l’application se trouve au premier plan. Si l’application entre en arrière-plan, ou si l’appareil est en veille, OnSensorChanged ne sera pas appelé. Toutefois, les étapes continueront à être comptées jusqu’à ce UnregisterListener que soit appelé.

N’oubliez pas que la valeur du nombre d’étapes est cumulative pour 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 restera le nombre total de étapes effectuées pendant l’inscription du capteur, que ce soit par votre application ou une autre. Vous pouvez empêcher votre application d’ajouter au compteur d’étapes en appelant UnregisterListener sur le SensorManager, comme illustré par le code ci-dessous :

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

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

Notes

Bien que l’API pour la détection et le comptage des étapes soit fournie 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 retournée de GetDefaultSensor n’est pas null.

Outils de développement

Enregistrement d’écran

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

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

adb shell screenrecord /sdcard/screencast.mp4

La commande ci-dessus enregistre une vidéo de 3 minutes par défaut à la résolution par défaut de 4 Mbits/s. 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 d’une minute à 8 Mbits/s :

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 :

  • Utiliser le mode plein écran - KitKat introduit un nouveau mode immersif pour parcourir du contenu, jouer à des jeux et exécuter d’autres applications qui pourraient bénéficier d’une expérience en plein écran.

  • Personnaliser les notifications : obtenez des détails supplémentaires sur les notifications système avec leNotificationListenerService . Cela vous permet de présenter les informations d’une autre manière à l’intérieur de votre application.

  • Ressources dessinables en miroir : les ressources drawables ont un nouveauautoMirrored qui indique au système de créer une version mise en miroir pour les images qui nécessitent un basculement pour les dispositions de gauche à droite.

  • Suspendre les animations : suspendre et reprendre les animations créées avec leClasseAnimator .

  • Lire le texte changeant dynamiquement : indique les parties de l’interface utilisateur qui se mettent à jour dynamiquement avec le nouveau texte en tant que « régions actives » avec le nouveauaccessibilityLiveRegion afin que le nouveau texte soit lu automatiquement en mode d’accessibilité.

  • Améliorer l’expérience audio - Rendre les pistes plus puissantes avec leLoudnessEnhancer , recherchez les valeurs Peak et RMS d’un flux audio avec leVisualizer 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 à l’heure ou à l’intervalle personnalisé en appelant ContentResolver.RequestSync et en transmettant un SyncRequest.

  • Distinguer les contrôleurs : dans KitKat, les contrôleurs se voient attribuer des identificateurs entiers uniques accessibles via la propriété de l’appareil ControllerNumber . Cela permet de distinguer plus facilement les joueurs d’un jeu.

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

Pour plus d’informations sur les modifications d’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 l’infrastructure de transition et les nouvelles options de thème. Ensuite, il a introduit l’infrastructure et DocumentsProvider la classe Storage-Access, ainsi que les nouvelles API d’impression. Il a exploré l’émulation carte basée sur l’hôte NFC et la façon de travailler avec des capteurs de 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 l’enregistrement d’écran, et a fourni une liste détaillée des modifications et des ajouts de l’API KitKat.