Funkce KitKat

Android 4.4 (KitKat) má nabitou sadu funkcí pro uživatele a vývojáře. Tato příručka uvádí několik z těchto funkcí a poskytuje příklady kódu a podrobnosti implementace, které vám pomůžou na co nejvíce z KitKatu.

Přehled

Android 4.4 (api úroveň 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í – snadné animace s přechodovou architekturou, průsvitným stavem a navigačními pruhy a imerzivním režimem na celou obrazovku pomáhají vytvořit lepší prostředí pro uživatele.

• Uživatelský obsah – zjednodušená správa uživatelských souborů s architekturou přístupu k úložišti Tisk obrázků, webů a jiného obsahu je díky vylepšeným rozhraním API pro tisk jednodušší.

• Hardware – převedou libovolnou aplikaci na kartu NFC s emulací Host-Based NFC. spusťte senzory s nízkou spotřebou energie pomocí .

• Vývojářské nástroje – Aplikace směrového vysílání v akci s Android Debug Bridge, které jsou k dispozici jako součást Android SDK.

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

Požadavky

K vývoji aplikací Xamarin.Android pomocí KitKatu potřebujete nainstalovaný Xamarin.Android 4.11.0 nebo novější a Android 4.4 (api úrovně 19) 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 s první odpovědí, které vám pomůžou s přechodem existujících aplikací na Android 4.4.

Kontrola verze systému

Pokud aplikace musí být kompatibilní se staršími verzemi Androidu, nezapomeňte do kontroly verze systému zabalit jakýkoli kód specifický pro KitKat, 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á alarmové služby k probuzení aplikace na pozadí v zadaný čas. KitKat to posouvá o krok dál dávkováním alarmů, aby se zachoval výkon. To znamená, že místo toho, aby kitKat každou aplikaci v přesný čas bdíl, dává přednost seskupení několika aplikací, které jsou zaregistrované k probuzení ve stejném časovém intervalu, a probuzení ve stejnou dobu. Pokud chcete Androidu říct, aby v zadaném časovém intervalu probouzí aplikaci, zavolejte funkci , která předá minimální a maximální dobu (v milisekundách), která může uplynout před probouzením aplikace, a operaci, která se má provést při SetWindowAlarmManager probuzení. Následující kód obsahuje příklad aplikace, kterou je potřeba probou zbudit mezi půlhodinou a hodinou od nastavení okna:

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

Pokud chcete aplikaci v přesném čase probouzít, použijte , předáte přesně ten čas, kdy se má aplikace SetExact probouzí, a operaci, která se má provést:

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

KitKat už vám nemůže nastavit přesné opakování alarmu. Aplikace, které používajíSetRepeating a vyžadovat, aby přesně fungovala alarmy, bude teď muset aktivovat jednotlivá upozornění ručně.

Externí úložiště

Externí úložiště je teď rozdělené do dvou typů – úložiště je 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í WRITE_EXTERNAL_STORAGE nebo . Tyto dva typy lze klasifikovat takto:

• Pokud se vám zobrazuje cesta k souboru nebo adresáři voláním metody pro Context , napříkladGetExternalFilesDir nebo GetExternalCacheDirs

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

• Pokud přistupujete k vlastnosti nebo voláte metodu v souboru nebo adresáři, například EnvironmentGetExternalStorageDirectory neboGetExternalStoragePublicDirectory – vaše aplikace vyžaduje READ_EXTERNAL_STORAGE oprávnění WRITE_EXTERNAL_STORAGE nebo .

Konsolidace SMS

KitKat zjednodušuje uživateli zasílání zpráv tím, že agreguje veškerý obsah SMS v jedné výchozí aplikaci vybrané uživatelem. Vývojář zodpovídá za výběr aplikace jako výchozí aplikace zasílání zpráv a odpovídající chování v kódu a v životě, pokud 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.

Aplikace WebView

WebView se v KitKatu přehodí. Největší změnou je přidané zabezpečení pro načítání obsahu do WebView . I když by většina aplikací, které cílí na starší verze rozhraní API, měla fungovat podle očekávání, důrazně doporučujeme testovací WebView aplikace, které používají třídu . Další informace o ovlivněných rozhraních API WebView najdete v dokumentaci Android Migrating to WebView in Android 4.4 (Migrace Androidu na WebView v Androidu 4.4).

Zkušenosti uživatele

KitKat se dodává s několika novými rozhraními API pro vylepšení uživatelského prostředí, včetně nové architektury přechodu pro zpracování animací vlastností a možnosti průsvitné uživatelského rozhraní pro theming. Tyto změny jsou uvedená níže.

Transition Framework

Přechodová rozhraní usnadňuje implementaci animací. KitKat umožňuje provést jednoduchou animaci vlastností pouze s jedním řádem kódu nebo přizpůsobit přechody pomocí scenes.

Animace jednoduché vlastnosti

Nová knihovna Přechody pro Android zjednodušuje kód animace vlastností. Tato rozhraní 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 zpracovává jeden řádek kódu, můžete to snadno provést kompatibilní se staršími verzemi Androidu tím, že volání zabalíte do BeginDelayedTransition 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:

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

Android Scenes

Scény byly představeny jako součást přechodové architektury, aby vývojáři měli větší kontrolu nad animacemi. Scény vytvoří dynamickou oblast v uživatelském rozhraní: pro obsah XML uvnitř kontejneru zadáte kontejner a několik verzí (nebo také "scény") a Android udělá zbytek práce a animace přechodů mezi scénymi. Scény Androidu umožňují vytvářet složité animace s minimálním úsilím na straně vývoje.

Statický prvek uživatelského rozhraní, který se nachází v dynamickém obsahu, se nazývá kontejner nebo základ scény. Následující příklad používá následující Android Designer k vytvoření s RelativeLayout názvem container :

Rozložení ukázky 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í pro Android. Tato rozložení určují pouze kód uvnitř kontejneru. Následující příklad kódu definuje rozložení s názvem Scene1, které obsahuje dvě textová pole pro čtení "Kit" a "Kat" v uvedeném pořadí, a druhé rozložení s názvem Scene2, které obsahuje stejná textová pole obráceně. Kód 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á ke zkrácení kódu zobrazení a merge zjednodušení hierarchie zobrazení. Další informace o merge rozloženích najdete merge

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

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ě scény, které Android animacemi 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:

Vlastní přechody na scénách

Vlastní přechod lze definovat v souboru prostředků XML v adresáři pod , jak je transitionResources 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 a používá interpolátor pro řešení potíží:

<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í TransitionInflater, jak znázorňuje následující kód:

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

Translucentní uživatelské rozhraní

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

• windowTranslucentStatus - Pokud je nastavená hodnota true, zvýrazní se horní stavový řádek.

• windowTranslucentNavigation - Pokud je nastavená hodnota true, dolní navigační panel se zkrátí.

• fitsSystemWindows – Nastavením horního nebo dolního pruhu na transcluent se ve výchozím nastavení posune obsah pod prvky transparentního uživatelského rozhraní. Nastavení této vlastnosti na je jednoduchý způsob, jak zabránit překrývání obsahu s prvky true průsvitných systémových uživatelského rozhraní.

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 ukazuje výše uvedený motiv s průsvitnou úrovní stavu a navigačními panely:

Obsah uživatele

Storage-Access Framework

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

Tato změna vyžaduje dvě akce na straně vývojáře: nejprve je potřeba aktualizovat aplikace, které vyžadují obsah od poskytovatelů, na nový způsob žádosti o obsah. Za druhé, aplikace, které zapisovat data do , je potřeba ContentProvider upravit tak, aby nové rozhraní bylo možné používat. Oba scénáře závisejí na novémDocumentsProvider ROZHRANÍ API.

Objekt DocumentsProvider

V KitKatu jsou interakce s ContentProviders třídou abstrahovány. DocumentsProvider To znamená, že SAF je jedno, kde jsou data fyzicky přístupná, pokud jsou přístupná prostřednictvím rozhraní DocumentsProvider API. Místní poskytovatelé, cloudové služby a externí úložná zařízení používají stejné rozhraní a jsou zacházeno stejným způsobem, takže uživatelé a vývojáři mají jedno místo pro interakci s obsahem uživatele.

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

Vyžádání obsahu od poskytovatele

KitKatu můžeme říct, že chceme vybrat obsah pomocí uživatelského rozhraní SAF se záměrem , což znamená, že se chceme připojit ke všem poskytovatelům obsahu dostupným ActionOpenDocument pro zařízení. Do tohoto záměru můžete přidat filtrování zadáním , což znamená, že se vrátí pouze obsah, který je možné otevřít CategoryOpenable (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ím StartActivityForResult se spustí uživatelské rozhraní SAF, které pak uživatel může procházet a zvolit image:

Jakmile uživatel vybere obrázek, OnActivityResult vrátí hodnotu Android.Net.Uri zvoleného souboru. 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 jakéhokoli, ContentProvider který implementuje DocumentProvider rozhraní API. Při ukládání obsahu se používá Intent s 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);

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

Když uživatel stiskne Uložit, předá se nově vytvořený soubor, ke kterému se dostanete pomocí Android.Net.Uridata.Data . Identifikátor URI lze použít ke 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, žeContentResolver.OpenOutputStream(Android.Net.Uri) vrací 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í rozhraní Storage Access Framework najdete v dokumentaci k Androidu pro Storage Access Framework.

Tisk

Tisk obsahu je v KitKatu zjednodušený díky zavedení tiskových služeb a . KitKat je také první verzí rozhraní API, která plně využívá rozhraní API služby Cloud Print od Googlu pomocí aplikace Google Cloud Print. Většina zařízení, která se dodá spolu s KitKatem, si při prvním připojení k Wi-Fi automaticky stáhne aplikaci Google Cloud Print a modul plug-in HP PrintService. Uživatel může zkontrolovat nastavení Tisk na svém zařízení tak, že přejde na Nastavení tisk > systému:

Tisk obsahu HTML

KitKat automaticky vytvoří PrintDocumentAdapter pro webové zobrazení pomocí WebView.CreatePrintDocumentAdapter . Tisk webového obsahu je koordinovaný pokus mezi objektem , který čeká na načtení obsahu HTML, a dá aktivitě vědět, aby v nabídce možností byla dostupná možnost tisku, a aktivitou, která čeká, až uživatel vybere možnost Tisk a zavolá metodu WebViewClientPrintPrintManager . Tato část popisuje základní nastavení potřebné k tisku obsahu HTML na obrazovce.

Všimněte si, že načítání a tisk webového obsahu vyžaduje oprávnění k internetu:

Tisk položky 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á asi takhle:

Další položky nabídky je možné definovat v adresáři nabídekv čá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 metod OnCreateOptionsMenuOnOptionsItemSelected a . OnCreateOptionsMenu je místo, kam můžete přidat nové položky nabídky, jako je možnost Tisk, z OnCreateOptionsMenu nabídky. OnOptionsItemSelected naslouchá uživateli, když v nabídce vybere možnost Tisk 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 s názvem , která bude sledovat dataLoaded stav obsahu HTML. Proměnná nastaví při načtení veškerého obsahu na hodnotu true, takže aktivita ví, že má přidat položku nabídky WebViewClient Tisk do nabídky možností.

WebViewClient

Úkolem je zajistit úplné načtení dat v , než se v nabídce zobrazí možnost tisku, což WebViewClient dělá pomocí metody WebViewOnPageFinished . OnPageFinished naslouchá dokončení načítání webového obsahu a říká aktivitě, aby znovu vytvořila nabídku možností pomocí InvalidateOptionsMenu příkazu :

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 , takže můžete znovu vytvořit trueOnCreateOptionsMenu nabídku s nastavenou možností Tisk.

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 (v tomto příkladu "MyWebPage"),PrintDocumentAdapter , která generuje tisk dokumentu z obsahu, aPrintAttributes ( null v příkladu výše). Můžete určit, aby vám pomohl rozložení obsahu na vytištěné stránce, i když výchozí atributy PrintAttributes by měly zpracovávat většinu scénářů.

Volání Print načte uživatelské rozhraní tisku, které vypíše možnosti pro tiskovou úlohu. Uživatelské rozhraní dává uživatelům možnost vytisknout nebo uložit 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 Host-Based emulace karet a nové SensorManager .

Host-Based emulace karty v NFC

Host-Based emulace karet (HCE) umožňuje aplikacím chovat se jako karty NFC nebo čtečky karet NFC, aniž by se spoléhaly na speciální zabezpečený prvek dopravce. Před nastavením HCE se ujistěte, že je na zařízení dostupná služba HCE pomocí PackageManager.HasSystemFeature :

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

HCE vyžaduje, aby funkce HCE i oprávnění byly zaregistrované v souboru NfcAndroidManifest.xml aplikace :

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

Aby to fungovalo, musí být HCE schopné běžet na pozadí a musí začít, když uživatel provede transakci NFC, i když aplikace, která HCE používá, není spuštěná. Toho dosáhneme tak, že napíšeme kód HCE jako Service . Služba HCE implementuje rozhraní HostApduService , které implementuje následující metody:

• ProcessCommandApdu – Datová jednotka aplikačního protokolu (APDU) se odesílá mezi čtečkou NFC a službou HCE. Tato metoda spotřebovává ADPU z čtecího zařízení a vrátí datovou jednotku v reakci.

• Deaktivováno – deaktivuje se, když už služba HCE nekomunikuje s čtečkou NFC.

Služba HCE musí být také zaregistrovaná v manifestu aplikace a upravena pomocí správných oprávnění, filtru záměrů a metadat. Následující kód je příkladem HostApduService registrovaného s manifestem Android s použitím Service atributu (Další informace o atributech najdete v tématu věnovaném průvodci HostApduService ):

[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 může čtečka NFC pracovat s aplikací, ale čtečka NFC ještě nemá žádný způsob, jak zjistit, jestli tato služba emuluje kartu NFC, kterou potřebuje vyhledat. Aby mohl čtečka NFC identifikovat službu, můžeme službě přiřadit jedinečné ID aplikace (podpora). Společně s dalšími metadaty týkajícími se služby HCE určíme pomoc v souboru prostředků XML zaregistrovaném s MetaData atributem (viz příklad kódu výše). Tento soubor prostředků Určuje jeden nebo více filtrů podpory – jedinečné řetězce identifikátorů v šestnáctkovém formátu, které odpovídají pomůckám 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ů podpory poskytuje soubor prostředků XML také uživatelsky orientovaný popis služby HCE, určuje skupinu podpory (platební aplikace vs.) a v případě platební aplikace se zobrazí banner 260x96 DP, 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í, které je potřeba nakonfigurovat. Další informace o emulaci karet na hostiteli najdete na portálu dokumentace pro Android. Další informace o použití NFC s Xamarin najdete v ukázkách pro XAMARIN NFC.

Čidl

KitKat poskytuje přístup k senzorům zařízení přes SensorManager . SensorManagerUmožňuje operačnímu systému naplánovat doručování informací snímačů do aplikace v dávkách, čímž se zachovává výdrž baterie.

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

• StepDetector -aplikace se oznamuje/probuzený, 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 provedl od registrace snímače, až do dalšího restartování zařízení.

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

Můžete vytvořit SensorManager voláním GetSystemService(SensorService) a přetypováním výsledku jako SensorManager . Chcete-li použít čítač krok, zavolejte GetDefaultSensor na SensorManager . Můžete zaregistrovat senzor a naslouchat změnám v počtu kroků s využitímISensorEventListener rozhraní, jak je znázorněno v následujícím příkladu kódu:

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 se zavolá, pokud se počet kroků aktualizuje, zatímco je aplikace v popředí. Pokud aplikace přejde do pozadí nebo je zařízení v režimu spánku, nebude OnSensorChanged volána. postup bude však nadále počítán, dokud UnregisterListener nebude volán.

Pamatujte, že hodnota počet kroků je kumulativní pro všechny aplikace, které zaregistrují senzor. To znamená, že i když odinstalujete a znovu nainstalujete aplikaci a při count spuštění aplikace inicializujete proměnnou na 0, hodnota uvedená senzorem zůstane celkový počet kroků provedených během registrace senzoru, ať už je to vaše aplikace, nebo jiná. Aplikaci můžete zabránit v přidávání do čítače kroku voláním UnregisterListener na SensorManager , jak je znázorněno v následujícím kódu:

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

Po restartování zařízení se obnoví počet kroků na 0. Vaše aplikace bude potřebovat dodatečný kód, aby bylo zajištěno, že bude hlásit přesný počet pro aplikaci bez ohledu na ostatní aplikace používající senzor nebo stav zařízení.

Vývojářské nástroje

Záznam obrazovky

KitKat zahrnuje nové funkce záznamu obrazovky, aby mohli vývojáři nahrávat aplikace v akci. Záznam obrazovky je k dispozici prostřednictvím klienta Android Debug Bridge (ADB) , který lze stáhnout jako součást Android SDK.

Pokud chcete zaznamenat obrazovku, připojte své zařízení. pak vyhledejte instalaci 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í 3 minutové video s výchozím rozlišením 4Mbps. Chcete-li upravit délku, přidejte příznak --time-limit . Chcete-li změnit rozlišení, přidejte příznak --bit-rate . Následující příkaz zaznamená minutové video na 8Mbps:

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

Video můžete na svém zařízení najít – po dokončení nahrávání se zobrazí v galerii.

Další doplňky KitKat

Kromě výše uvedených změn vám KitKat umožní:

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

• Přizpůsobení oznámení – další podrobnosti o systémových oznámeních získáte pomocíNotificationListenerService . Díky tomu můžete v rámci aplikace prezentovat informace jiným způsobem.

• Zrcadlově vykreslené prostředky – vykreslitelné prostředky mají novouautoMirrored atribut, který oznamuje systému vytvoření zrcadlené verze pro obrázky, které vyžadují překlopení pro rozložení zleva doprava.

• Pozastavit animace – pozastavit a obnovit animace vytvořené pomocíAnimator Deník.

• Přečtěte si dynamicky se měnící text – části uživatelského rozhraní, které se dynamicky aktualizují s novým textem jako "živé oblasti" s novýmaccessibilityLiveRegion Vytvoří atribut tak, aby se nový text automaticky četl v režimu usnadnění.

• Vylepšení zvukového prostředí – sledování hlasitého nahlasování pomocíLoudnessEnhancer , najděte špičku a RMS zvukového datového proudu pomocíVisualizer a získejte informace ze Visualizer , které vám pomůžou při synchronizaci zvukového videa.

• Synchronizace ContentResolver ve vlastním intervalu – KitKat přidá určitou variabilitu do doby, kdy je provedena žádost o synchronizaci. Synchronizuje se ve ContentResolver vlastním čase nebo intervalu voláním ContentResolver.RequestSync a předáním do SyncRequest .

• Mezi řadiči v KitKat se přiřazují jedinečné celočíselné identifikátory, ke kterým se dá dostat prostřednictvím vlastnosti zařízení. To usnadňuje seznámení hráčů při hře.

• Vzdálené řízení – při několika změnách na straně hardwaru i softwaru vám KitKat umožní zapnout zařízení, které je vybavené VYSÍLAČem IR, na vzdálené řízení pomocí nástroje a komunikovat s periferními zařízeními s novýmRemoteController Třídy.

Další informace o změnách rozhraní API najdete v tématu Přehled rozhraní API pro Google Android 4,4 .

Souhrn

Tento článek představil některá z nových rozhraní API dostupných v Androidu 4,4 (rozhraní API úrovně 19) a zahrnuté osvědčené postupy při přechodu aplikace na KitKat. Naznačeny se změny rozhraní API, které ovlivňují uživatelské prostředí, včetně rozhraní pro přechod a nové možnosti pro ně. dále zavedl rozhraní a třídu Storage-Access a také nová tisková rozhraní api. Prozkoumala emulaci karty založené na hostiteli NFC a jak pracovat s senzory s nízkým výkonem, včetně dvou nových senzorů pro sledování kroků uživatele. Nakonec ukázala zachycení ukázek aplikací v reálném čase se záznamem obrazovkya poskytuje podrobný seznam změn rozhraní API KitKat a jejich přidání.

Související odkazy

• Ukázka KitKat
• Rozhraní API pro Android 4,4
• Android KitKat