Funkce KitKat

Android 4.4 (KitKat) se dodává s cornucopia funkcí pro uživatele a vývojáře. Tato příručka zvýrazňuje několik z těchto funkcí a poskytuje příklady kódu a podrobnosti implementace, které vám pomůžou využít KitKat na maximum.

Přehled

Android 4.4 (API Level 19), označovaný také jako KitKat, byl vydán na konci roku 2013. KitKat nabízí celou řadu nových funkcí a vylepšení, mezi které patří:

• Uživatelské prostředí – jednoduché animace s přechodovou architekturou, průsvitným stavem a navigačními panely a imerzivním režimem na celé obrazovce pomáhají uživatelům vytvářet lepší prostředí.

• Uživatelský obsah – Správa uživatelských souborů zjednodušená pomocí architektury přístupu k úložišti; tisk obrázků, webů a dalšího obsahu je jednodušší díky vylepšeným rozhraním API pro tisk.

• Hardware – Přeměňte libovolnou aplikaci na kartu NFC s emulací karet založenou na hostiteli NFC; spouštět senzory s nízkým výkonem SensorManager .

• Vývojářské nástroje – aplikace screencastu v akci s klientem mostu ladění androidu, který je k dispozici jako součást sady Android SDK.

Tato příručka obsahuje pokyny k migraci existující aplikace Xamarin.Android na KitKat a také základní přehled KitKat pro vývojáře Xamarin.Android.

Požadavky

K vývoji aplikací Xamarin.Android pomocí KitKat potřebujete Xamarin.Android 4.11.0 nebo novější a Android 4.4 (úroveň rozhraní API 19) nainstalované prostřednictvím Správce sady Android SDK, jak je znázorněno na následujícím snímku obrazovky:

Migrace aplikace na KitKat

Tato část obsahuje několik položek první odpovědi, které vám pomůžou převést existující aplikace na Android 4.4.

Kontrola verze systému

Pokud aplikace musí být kompatibilní se staršími verzemi Androidu, nezapomeňte zabalit veškerý kód specifický pro KitKat do kontroly verze systému, jak je znázorněno v ukázce kódu níže:

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

Dávkování alarmů

Android používá služby alarmů k probuzení aplikace na pozadí v zadaném čase. KitKat tento krok dále provede dávkováním alarmů za účelem zachování výkonu. To znamená, že kitKat dává přednost seskupení několika aplikací registrovaných k probuzení během stejného časového intervalu a probuzení každé aplikace ve stejnou dobu. Pokud chcete Androidu říct, aby aplikaci probudit během zadaného časového intervalu, zavolejte SetWindow na AlarmManagerminimum a maximální dobu v milisekundách, která může uplynout před tím, než se aplikace probudí, a operaci, která se má provést při probuzení. Následující kód poskytuje příklad aplikace, která se musí probudit mezi půlhodinou a hodinou od doby, kdy je okno nastaveno:

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

Pokud chcete pokračovat v probuzení aplikace v přesné době, použijte SetExactpředávání přesného času, kdy se má aplikace probudit, a operaci, která se má provést:

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

KitKat už vám umožňuje nastavit přesný opakující se alarm. Aplikace, které používají SetRepeating a vyžadují přesné alarmy, aby fungovaly, budou nyní muset každý alarm aktivovat ručně.

Externí úložiště

Externí úložiště je teď rozdělené do dvou typů – úložiště jedinečné pro vaši aplikaci a data sdílená více aplikacemi. Čtení a zápis do konkrétního umístění vaší aplikace v externím úložišti nevyžaduje žádná zvláštní oprávnění. Interakce s daty ve sdíleném úložišti teď vyžaduje READ_EXTERNAL_STORAGE oprávnění nebo WRITE_EXTERNAL_STORAGE oprávnění. Tyto dva typy lze klasifikovat takto:

• Pokud získáváte cestu k souboru nebo adresáři voláním metody Context , například GetExternalFilesDir nebo GetExternalCacheDirs

  • aplikace nevyžaduje žádná další oprávnění.

• Pokud získáváte cestu k souboru nebo adresáři tak, že přistupujete k vlastnosti nebo voláte metodu Environment , například GetExternalStorageDirectory Nebo GetExternalStoragePublicDirectory , vaše aplikace vyžaduje READ_EXTERNAL_STORAGE oprávnění nebo WRITE_EXTERNAL_STORAGE oprávnění.

Poznámka:

WRITE_EXTERNAL_STORAGEREAD_EXTERNAL_STORAGE znamená oprávnění, takže byste měli jen někdy nastavit jedno oprávnění.

Konsolidace sms

KitKat zjednodušuje zasílání zpráv pro uživatele agregací veškerého obsahu SMS v jedné výchozí aplikaci vybrané uživatelem. Vývojář zodpovídá za výběr aplikace jako výchozí aplikace pro zasílání zpráv a odpovídajícím způsobem se chová v kódu a v životě, pokud aplikace není vybraná. Další informace o přechodu aplikace SMS na KitKat najdete v příručce Getting Your SMS Apps Ready for KitKat od Googlu.

WebView Apps

WebView dostal makeover v KitKat. Největší změnou je přidání zabezpečení pro načítání obsahu do souboru WebView. I když většina aplikací, které cílí na starší verze rozhraní API, by měla fungovat podle očekávání, doporučuje se testování aplikací, které používají WebView třídu. Další informace o ovlivněných rozhraních API WebView najdete v dokumentaci k androidu Migrace na WebView v dokumentaci k Androidu 4.4 .

Uživatelské prostředí

KitKat nabízí několik nových rozhraní API pro vylepšení uživatelského prostředí, včetně nové architektury přechodu pro zpracování animací vlastností a průsvitného uživatelského rozhraní pro motivy. Tyto změny jsou popsané níže.

Přechodová architektura

Přechodová architektura usnadňuje implementaci animací. KitKat umožňuje provádět jednoduchou animaci vlastností pouze s jedním řádkem kódu nebo přizpůsobit přechody pomocí scén.

Animace jednoduché vlastnosti

Nová knihovna Android Transitions zjednodušuje kód za animacemi vlastností. Architektura umožňuje provádět jednoduché animace s minimálním kódem. Například následující ukázka kódu používá TransitionManager.BeginDelayedTransition animace zobrazení a skrytí 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;
            }
        };
    }
}

Výše uvedený příklad používá rozhraní přechodu k vytvoření automatického výchozího přechodu mezi měnícími se hodnotami vlastností. Vzhledem k tomu, že animace je zpracována jedním řádkem kódu, můžete tuto kompatibilitu se staršími verzemi Androidu snadno nastavit tak, že volání zabalíte BeginDelayedTransition do kontroly verze systému. Další informace najdete v části Migrace aplikace na KitKat .

Následující snímek obrazovky ukazuje aplikaci před animací:

Následující snímek obrazovky ukazuje aplikaci po animaci:

Můžete získat větší kontrolu nad přechodem pomocí scén, které jsou popsány v další části.

Android Scény

Scény byly představeny jako součást architektury přechodu, aby vývojáři poskytli větší kontrolu nad animacemi. Scény vytvářejí dynamickou oblast v uživatelském rozhraní: pro obsah XML uvnitř kontejneru zadáte kontejner a několik verzí nebo "scény" a Android provede zbytek práce a animuje přechody mezi scénami. Android Scény umožňují vytvářet složité animace s minimální prací na straně vývoje.

Statický prvek uživatelského rozhraní, který obsahuje dynamický obsah, je označovaný jako kontejner nebo základ scény. Následující příklad používá Android Designer k vytvoření volaný RelativeLayoutcontainer:

Ukázkové rozložení také definuje tlačítko s názvem sceneButton pod .container Toto tlačítko aktivuje přechod.

Dynamický obsah uvnitř kontejneru vyžaduje dvě nová rozložení Androidu. Tato rozložení určují pouze kód uvnitř kontejneru. Následující ukázkový kód definuje rozložení s názvem Scéna1 , které obsahuje dvě textová pole, která čtou "Kit" a "Kat" a druhé rozložení s názvem Scéna2 , které obsahuje stejná textová pole obrácená. Xml je následující:

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>

Výše uvedený příklad používá merge ke zkrácení kódu zobrazení a zjednodušení hierarchie zobrazení. Další informace o merge rozloženích si můžete přečíst tady.

Scéna je vytvořena voláním Scene.GetSceneForLayout, předáním objektu kontejneru, ID prostředku souboru rozložení scény a aktuální Context, jak je znázorněno v příkladu kódu níže:

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

Kliknutím na tlačítko se překlopí mezi dvěma scénami, které Android animuje s výchozími hodnotami přechodu:

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

    TransitionManager.Go (scene1);
};

Následující snímek obrazovky znázorňuje scénu před animací:

Následující snímek obrazovky znázorňuje scénu po animaci:

Poznámka:

V knihovně Android Transitions existuje známá chyba , která způsobuje přerušení scén vytvořených pomocí GetSceneForLayout při druhém procházení aktivit uživatelem.

Vlastní přechody na scénách

Vlastní přechod lze definovat v souboru prostředků XML v adresáři v transition části Resources, jak je znázorněno na následujícím snímku obrazovky:

Následující ukázka kódu definuje přechod, který se animuje po dobu 5 sekund. Další informace o animaci najdete na adrese.

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

Přechod se vytvoří v aktivitě pomocí transitionInflateru, jak je znázorněno následujícím kódem:

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

Nový přechod se pak přidá do Go volání, které zahájí animaci:

TransitionManager.Go (scene1, transition);

Průsvitné uživatelské rozhraní

KitKat vám dává větší kontrolu nad motivy aplikace s volitelným průsvitným stavem a navigačními panely. Průsvitnost prvků systémového uživatelského rozhraní můžete změnit ve stejném souboru XML, který používáte k definování motivu Androidu. KitKat zavádí následující vlastnosti:

• windowTranslucentStatus - Když nastavíte hodnotu true, zobrazí se horní stavový řádek jako průsvitný.

• windowTranslucentNavigation - Když je nastavená hodnota true, zvýrazní dolní navigační panel.

• fitsSystemWindows - Nastavení horního nebo dolního panelu pro transkluent posune obsah pod průhlednými prvky uživatelského rozhraní ve výchozím nastavení. Nastavení této vlastnosti true je jednoduchý způsob, jak zabránit překrývání obsahu s průsvitnými prvky uživatelského rozhraní systému.

Následující kód definuje motiv s průsvitným stavem a navigačními panely:

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

Následující snímek obrazovky znázorňuje výše uvedený motiv s průsvitným stavem a navigačními panely:

Uživatelský obsah

Architektura úložiště a přístupu

SAF (Storage Access Framework) je nový způsob, jak uživatelé pracovat s uloženým obsahem, jako jsou obrázky, videa a dokumenty. Místo prezentování uživatelů pomocí dialogového okna pro výběr aplikace pro zpracování obsahu otevře KitKat nové uživatelské rozhraní, které uživatelům umožňuje přístup k datům v jednom agregovaném umístění. Po zvolení obsahu se uživatel vrátí do aplikace, která požadovala obsah, a prostředí aplikace bude pokračovat v normálním stavu.

Tato změna vyžaduje dvě akce na straně vývojáře: nejprve aplikace, které vyžadují obsah od poskytovatelů, musí být aktualizovány na nový způsob vyžádání obsahu. Za druhé, aplikace, které zapisuje data do ContentProvider potřeby upravit, aby používaly novou architekturu. Oba scénáře závisí na novém DocumentsProvider Rozhraní api.

DocumentsProvider

V KitKat, interakce s ContentProviders jsou abstrahovány s DocumentsProvider třídou. To znamená, že SAF nezajímá, kde jsou data fyzicky, pokud jsou přístupná prostřednictvím DocumentsProvider rozhraní API. Místní poskytovatelé, cloudové služby a externí úložiště používají stejné rozhraní a zachází se stejným způsobem, aby uživatelé a vývojáři mohli pracovat s obsahem uživatele na jednom místě.

Tato část popisuje, jak načíst a uložit obsah pomocí architektury Storage Access Framework.

Vyžádání obsahu od zprostředkovatele

Můžeme říct KitKat, že chceme vybrat obsah pomocí uživatelského rozhraní SAF se ActionOpenDocument záměrem, což znamená, že se chceme připojit ke všem poskytovatelům obsahu dostupným pro zařízení. Do tohoto záměru můžete přidat filtrování zadáním CategoryOpenable, což znamená, že se vrátí pouze obsah, který lze otevřít (tj. přístupný, použitelný obsah). KitKat také umožňuje filtrování obsahu pomocí MimeType. Například následující kód filtruje výsledky obrázků zadáním obrázku MimeType:

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

Volání StartActivityForResult spustí uživatelské rozhraní SAF, které uživatel pak může procházet a zvolit obrázek:

Jakmile uživatel vybere obrázek, OnActivityResult vrátí Android.Net.Uri vybraný soubor. Následující ukázka kódu zobrazí výběr obrázku uživatele:

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

Zápis obsahu do zprostředkovatele

Kromě načítání obsahu z uživatelského rozhraní SAF vám KitKat také umožňuje ukládat obsah do libovolného ContentProvider rozhraní API, který implementuje DocumentProvider rozhraní API. Ukládání obsahu používá:IntentActionCreateDocument

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

Výše uvedený vzorový kód načte uživatelské rozhraní SAF, které uživateli umožní změnit název souboru a vybrat adresář pro umístění nového souboru:

Když uživatel stiskne klávesu Uložit, OnActivityResult předá Android.Net.Uri se nově vytvořený soubor, ke kterému lze získat přístup.data.Data Identifikátor URI se dá použít k streamování dat do nového souboru:

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

Všimněte si, že ContentResolver.OpenOutputStream(Android.Net.Uri) vrátí hodnotu System.IO.Stream, takže celý proces streamování může být napsán v .NET.

Další informace o načítání, vytváření a úpravách obsahu pomocí architektury Storage Access Framework najdete v dokumentaci k Androidu pro architekturu Storage Access Framework.

Tisk

Tisk obsahu je zjednodušen v KitKat se zavedením tiskových služeb a PrintManager. KitKat je také první verze rozhraní API, která plně využívá rozhraní API služby Cloud Print společnosti Google pomocí aplikací Google Cloud Print. Většina zařízení, která jsou dodávána s KitKat automaticky stáhnout aplikaci Google Cloud Print a modul plug-intiskové služby HP při prvním připojení k WiFi. Uživatel může zkontrolovat nastavení tisku zařízení tak, že přejde na Nastavení > systémový > tisk:

Poznámka:

I když jsou rozhraní API pro tisk nastavená tak, aby ve výchozím nastavení fungovala se službou Google Cloud Print, Android stále umožňuje vývojářům připravit tiskový obsah pomocí nových rozhraní API a odeslat ho do jiných aplikací, aby mohli zpracovávat tisk.

Tisk obsahu HTML

KitKat automaticky vytvoří PrintDocumentAdapter pro webové zobrazení s WebView.CreatePrintDocumentAdapter. Tisk webového obsahu je koordinované úsilí mezi WebViewClient tím, že čeká na načtení obsahu HTML a informuje aktivitu, aby byla možnost tisku dostupná v nabídce možností, a aktivita, která čeká, až uživatel vybere možnost Tisk a zavolá Printna PrintManagertlačítko . Tato část popisuje základní nastavení potřebné k tisku obsahu HTML na obrazovce.

Upozorňujeme, že načítání a tisk webového obsahu vyžaduje oprávnění k internetu:

Vytisknout položku nabídky

Možnost tisku se obvykle zobrazí v nabídce možností aktivity. Nabídka možností umožňuje uživatelům provádět akce s aktivitou. Je v pravém horním rohu obrazovky a vypadá takto:

Další položky nabídky lze definovat v adresáři nabídkyv části Prostředky. Následující kód definuje ukázkovou položku nabídky s názvem Tisk:

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

Interakce s nabídkou možností v aktivitě probíhá prostřednictvím OnCreateOptionsMenu metod a OnOptionsItemSelected metod. OnCreateOptionsMenu je místo pro přidání nových položek nabídky, například možnosti Tisk, z adresáře prostředků nabídky . OnOptionsItemSelected naslouchá uživateli, který vybere možnost Tisk z nabídky, a začne tisknout:

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

Výše uvedený kód také definuje proměnnou, dataLoaded která bude sledovat stav obsahu HTML. Tato WebViewClient proměnná se nastaví na true, když se načte veškerý obsah, takže aktivita ví, že přidá položku nabídky Tisk do nabídky možností.

WebViewClient

Úkolem je WebViewClient zajistit, aby se data v plně načtených WebView datech před zobrazením možnosti tisku v nabídce, kterou provádí s metodou OnPageFinished . OnPageFinished naslouchá webovému obsahu, aby se dokončil načítání, a řekne aktivitě, aby znovu vytvořit nabídku možností pomocí 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 také nastaví dataLoaded hodnotu na true, aby OnCreateOptionsMenu bylo možné znovu vytvořit nabídku s možností Tisk na místě.

PrintManager

Následující příklad kódu vytiskne obsah WebView:

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

Print přebírá jako argumenty: název tiskové úlohy ("MyWebPage" v tomto příkladu), a PrintDocumentAdapter který vygeneruje tiskový dokument z obsahu a PrintAttributes (null v příkladu výše). Můžete určit PrintAttributes , aby se obsah na vytištěné stránce rozložil, i když výchozí atributy by měly zpracovávat většinu scénářů.

Volání Print načte uživatelské rozhraní tisku, ve kterém jsou uvedeny možnosti tiskové úlohy. Uživatelské rozhraní umožňuje uživatelům tisknout nebo ukládat obsah HTML do PDF, jak je znázorněno na následujících snímcích obrazovky:

Hardware

KitKat přidává několik rozhraní API pro přizpůsobení nových funkcí zařízení. Nejdůležitější z nich jsou emulace karet na základě hostitele a nové SensorManager.

Emulace karet založená na hostiteli v NFC

Emulace karet založená na hostiteli (HCE) umožňuje aplikacím chovat se jako karty NFC nebo čtečky karet NFC, aniž by se museli spoléhat na proprietární zabezpečený prvek operátora. Před nastavením HCE se ujistěte, že je HCE k dispozici na zařízení s PackageManager.HasSystemFeature:

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

HCE vyžaduje, aby byla funkce HCE i Nfc oprávnění registrována v aplikaci AndroidManifest.xml:

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

Aby to fungovalo, musí HCE běžet na pozadí a musí se spustit, když uživatel provede transakci NFC, i když aplikace používající HCE není spuštěná. Toho můžeme dosáhnout napsáním kódu HCE jako znaku Service. Služba HCE implementuje HostApduService rozhraní, které implementuje následující metody:

• ProcessCommandApdu – aplikační datová jednotka (APDU) je to, co se odesílá mezi čtečkou NFC a službou HCE. Tato metoda využívá ADPU od čtenáře a vrací datovou jednotku v odpovědi.

• OnDeactivated – Deaktivuje se HostAdpuService , když služba HCE už nekomunikuje se čtečkou NFC.

Služba HCE musí být také zaregistrovaná v manifestu aplikace a musí být opatřena správnými oprávněními, filtrem záměru a metadaty. Následující kód je příkladem registrovaného HostApduService v manifestu Androidu pomocí atributu Service (další informace o atributech najdete v průvodci manifestem 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)
    {
        ...
    }
}

Výše uvedená služba poskytuje způsob, jak čtečka NFC pracovat s aplikací, ale čtečka NFC stále nemá žádný způsob, jak zjistit, jestli tato služba emuluje kartu NFC, která potřebuje naskenovat. Abychom čtečkě NFC pomohli identifikovat službu, můžeme službě přiřadit jedinečné ID aplikace (AID). Společně s dalšími metadaty o službě HCE zadáme aid v souboru prostředků XML zaregistrovaného pomocí atributu MetaData (viz příklad kódu výše). Tento soubor prostředků určuje jeden nebo více filtrů AID – řetězce jedinečného identifikátoru v šestnáctkovém formátu, které odpovídají identifikátorům AID jednoho nebo více zařízení čtečky 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>

Kromě filtrů AID poskytuje soubor prostředků XML také popis služby HCE pro uživatele, určuje skupinu AID (platební aplikace versus "jiné") a v případě platební aplikace 260x96 dp banner, který se zobrazí uživateli.

Výše uvedené nastavení poskytuje základní stavební bloky pro aplikaci emulující kartu NFC. Technologie NFC sama vyžaduje několik dalších kroků a další testování konfigurace. Další informace o emulaci karet založeném na hostiteli najdete na portálu dokumentace pro Android. Další informace o používání NFC s Xamarinem najdete v ukázkách Xamarin NFC.

Senzory

KitKat poskytuje přístup k senzorům zařízení prostřednictvím SensorManagerzařízení . Umožňuje SensorManager operačnímu systému naplánovat doručování informací ze snímačů do aplikace v dávkách a zachovat životnost baterie.

KitKat se také dodává se dvěma novými typy snímačů pro sledování kroků uživatele. Jsou založeny na akcelerometru a zahrnují:

• StepDetector – Aplikace se upozorní nebo vzbudí, když uživatel provede krok, a detektor poskytuje časovou hodnotu pro čas, kdy došlo k kroku.

• StepCounter – sleduje počet kroků, které uživatel od registrace senzoru provedl , až do dalšího restartování zařízení.

Následující snímek obrazovky znázorňuje čítač kroku v akci:

Můžete vytvořit SensorManager voláním GetSystemService(SensorService) a přetypováním výsledku SensorManagerjako . Chcete-li použít čítač kroku, zavolejte GetDefaultSensor na SensorManagertlačítko . Senzor můžete zaregistrovat a poslouchat změny v počtu kroků pomocí funkce ISensorEventListener jak je znázorněno v ukázce kódu níže:

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 je volána, pokud se počet kroků aktualizuje v době, kdy je aplikace v popředí. Pokud aplikace přejde na pozadí nebo zařízení spí, nebude volána. OnSensorChanged Kroky se ale budou dál počítat, dokud UnregisterListener se nevolá.

Mějte na paměti, že hodnota počtu kroků je kumulativní ve všech aplikacích, které senzor registrují. To znamená, že i když odinstalujete a znovu nainstalujete aplikaci a inicializujete count proměnnou při spuštění aplikace na 0, zůstane hodnota hlášená senzorem celkový počet kroků provedených během registrace senzoru, ať už vaší aplikací nebo jinou. Aplikaci můžete zabránit v přidání do čítače kroku voláním UnregisterListener kódu SensorManager, jak je znázorněno níže v kódu:

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

Restartováním zařízení se obnoví počet kroků na 0. Vaše aplikace bude vyžadovat další kód, který zajistí, že hlásí přesný počet aplikací bez ohledu na jiné aplikace používající senzor nebo stav zařízení.

Poznámka:

I když rozhraní API pro detekci a počítání kroků dodává kitKat, nejsou všechny telefony vybaveny senzorem. Pokud chcete zkontrolovat, jestli je senzor dostupný, spusťte PackageManager.HasSystemFeature(PackageManager.FeatureSensorStepCounter);nebo zkontrolujte, jestli vrácená hodnota GetDefaultSensor není null.

Vývojářské nástroje

Záznam obrazovky

KitKat obsahuje nové možnosti nahrávání obrazovky, aby vývojáři mohli zaznamenávat aplikace v akci. Záznam obrazovky je k dispozici prostřednictvím klienta ADB (Android Debug Bridge), který lze stáhnout jako součást sady Android SDK.

Pokud chcete zaznamenat obrazovku, připojte zařízení; pak vyhledejte instalaci sady Android SDK, přejděte do adresáře nástrojů platformy a spusťte klienta adb :

adb shell screenrecord /sdcard/screencast.mp4

Výše uvedený příkaz zaznamená výchozí 3minutové video ve výchozím rozlišení 4 Mb/s. Pokud chcete upravit délku, přidejte příznak --time-limit . Pokud chcete změnit rozlišení, přidejte příznak --bit-rate . Následující příkaz zaznamená minutové video na 8 Mb/s:

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

Video najdete na svém zařízení – po dokončení nahrávání se zobrazí v Galerii.

Další doplňky KitKat

Kromě výše popsaných změn vám KitKat umožňuje:

• Použití zobrazení na celé obrazovce – KitKat zavádí nový asistivní režim pro procházení obsahu, hraní her a spouštění dalších aplikací, které by mohly těžit z prostředí na celé obrazovce.

• Přizpůsobení oznámení – Získání dalších podrobností o systémových oznámeních pomocí NotificationListenerService . Díky tomu můžete informace v aplikaci prezentovat jiným způsobem.

• Zrcadlení nakreslených zdrojů – nakreslené zdroje mají novou autoMirrored atribut, který systému říká vytvoření zrcadlené verze pro obrázky, které vyžadují překlopení pro rozložení zleva doprava.

• Pozastavení animací – Pozastavení a obnovení animací vytvořených pomocí Animator Třída.

• Číst dynamicky měnit text – označují části uživatelského rozhraní, které se dynamicky aktualizují novým textem jako "živé oblasti" s novým accessibilityLiveRegion atributu, takže nový text se bude číst automaticky v režimu přístupnosti.

• Vylepšení zvukového prostředí - hlasitější stopy pomocí LoudnessEnhancer , najděte špičku a RMS zvukového streamu pomocí Visualizera získejte informace z časového razítka zvuku, které vám pomůžou se synchronizací zvukových videí.

• Synchronizace ContentResolver ve vlastním intervalu – KitKat přidává určitou variabilitu času provedení žádosti o synchronizaci. ContentResolver Synchronizujte vlastní čas nebo interval voláním ContentResolver.RequestSync a předáním .SyncRequest

• Rozlišovat mezi kontrolery – V KitKat jsou kontrolery přiřazeny jedinečné celočíselné identifikátory, ke kterým lze přistupovat prostřednictvím vlastnosti zařízení ControllerNumber . To usnadňuje rozlišování hráčů ve hře.

• Vzdálené řízení - s několika změnami na straně hardwaru i softwaru, KitKat umožňuje převést zařízení vybavené vysílačem IR na dálkové ovládání pomocí ConsumerIrServicea pracovat s periferními zařízeními s novým RemoteController Rozhraní api.

Další informace o výše uvedených změnách rozhraní API najdete v přehledu rozhraní API pro Google Android 4.4.

Shrnutí

Tento článek představil některá nová rozhraní API dostupná v Androidu 4.4 (úroveň rozhraní API 19) a probírala osvědčené postupy při přechodu aplikace na KitKat. Nastínil změny rozhraní API ovlivňující uživatelské prostředí, včetně architektury přechodu a nových možností pro motivy. Dále představil rozhraní Storage-Access Framework a DocumentsProvider třídu a také nová rozhraní API pro tisk. Prozkoumala emulaci karet založenou na hostiteli NFC a způsob práce se snímači s nízkým výkonem, včetně dvou nových senzorů pro sledování kroků uživatele. Nakonec ukázal zachycení ukázek aplikací v reálném čase s nahráváním obrazovky a poskytl podrobný seznam změn a doplňků rozhraní API KitKat.

Související odkazy

• Rozhraní API androidu 4.4
• Android KitKat