Diese Seite wurde von der Cloud Translation API übersetzt.

NFC – Grundlagen

In diesem Dokument werden die grundlegenden NFC-Aufgaben beschrieben, die Sie in Android ausführen. Es wird erläutert, wie Sie NFC-Daten in Form von NDEF-Nachrichten empfangen und die Android-Framework-APIs beschreiben, die diese Funktionen. Fortgeschrittenere Themen, einschließlich einer Diskussion über die Arbeit mit Nicht-NDEF-Daten, Siehe Erweiterte NFC.

Es gibt zwei Hauptanwendungsfälle bei der Arbeit mit NDEF-Daten und Android:

NDEF-Daten aus einem NFC-Tag lesen
Übertragung von NDEF-Nachrichten von einem Gerät auf ein anderes mit Android BeamTM

Das Lesen von NDEF-Daten aus einem NFC-Tag erfolgt über die Tag-Weiterleitung erkannte NFC-Tags analysiert, die Daten entsprechend kategorisiert und eine Anwendung ist, die an den kategorisierten Daten interessiert ist. Eine Anwendung, die den kann das gescannte NFC-Tag einen Intent-Filter deklarieren und um die Daten zu verarbeiten.

Mit der Android BeamTM-Funktion kann ein Gerät eine NDEF-Nachricht auf eine indem Sie die Geräte aneinander halten. Diese Interaktion bietet eine einfachere Möglichkeit, als bei anderen drahtlosen Technologien wie Bluetooth, da bei NFC kein manuelles Erkennung oder Kopplung ist erforderlich. Die Verbindung wird automatisch hergestellt, sobald zwei Geräte auf einmal liegen. Android Beam ist über eine Reihe von NFC-APIs verfügbar, sodass jede App zwischen den verschiedenen Geräten. Die Kontakte, der Browser und die YouTube-Anwendungen nutzen beispielsweise Android Beam zum Teilen von Kontakten, Webseiten und Videos mit anderen Geräten

Tag-Weiterleitungssystem

Android-Geräte suchen in der Regel nach NFC-Tags, wenn der Bildschirm ist entsperrt, es sei denn, NFC ist im Menü "Einstellungen" des Geräts deaktiviert. Wenn ein Android-Gerät ein NFC-Tag erkennt, ist das gewünschte Verhalten ist die geeignetste Aktivität, den Intent zu verarbeiten, ohne den Nutzer zu fragen, welche Anwendung zu verwenden. Da die Geräte NFC-Tags in sehr kurzer Reichweite scannen, ist es wahrscheinlich, dass Nutzer manuell Eine Aktivität würde sie dazu zwingen, das Gerät vom Tag wegzubewegen und die Verbindung zu unterbrechen. Sie sollten Ihre Aktivitäten so entwickeln, dass nur NFC-Tags verarbeitet werden, die für Ihre Aktivität relevant sind. verhindern, dass die Aktivitätsauswahl angezeigt wird.

Um Sie bei diesem Ziel zu unterstützen, bietet Android ein spezielles Tag-Versandsystem, das gescannte NFC-Tags, parst sie und versucht, Anwendungen zu finden, die an den gescannten Daten interessiert sind. Es geht dazu folgendermaßen vor:

NFC-Tag parsen und MIME-Typ oder URI ermitteln, der die Datennutzlast identifiziert im Tag.
Kapselung des MIME-Typs oder URI und der Nutzlast in einem Intent. Die ersten beiden Eine Anleitung dazu finden Sie unter Zuordnung von NFC-Tags zu MIME-Typen und URIs.
Startet eine Aktivität basierend auf dem Intent. Dies wird in Informationen zum Senden von NFC-Tags an Anwendungen

Zuordnung von NFC-Tags zu MIME-Typen und URIs

Bevor Sie mit dem Schreiben Ihrer NFC-Anwendungen beginnen, ist es wichtig, dass Sie die verschiedenen Arten von NFC-Tags, wie das Tag-Weiterleitungssystem NFC-Tags parst und welche besonderen Aufgaben weitergeleitet, wenn es eine NDEF-Nachricht erkennt. NFC-Tags werden in einer und Daten auf viele verschiedene Arten in sie schreiben. Android bietet die größte Unterstützung für den NDEF-Standard, der vom NFC-Forum definiert wird.

NDEF-Daten werden in einer Nachricht (NdefMessage) gekapselt, die Folgendes enthält: oder mehr Datensätze (NdefRecord). Jeder NDEF-Eintrag muss nach den ist die Spezifikation des zu erstellenden Datensatztyps. Android-Geräte unterstützt auch andere Tag-Typen, die keine NDEF-Daten enthalten, mit denen Sie arbeiten können, indem Sie die Klassen im android.nfc.tech-Paket. Weitere Informationen Weitere Informationen zu diesen Technologien finden Sie unter Erweiterte NFC. Wenn Sie mit diesen anderen Tag-Typen arbeiten, Ihren eigenen Protokollstack schreiben, um mit den Tags zu kommunizieren. Wir empfehlen daher, NDEF zu verwenden, für eine einfachere Entwicklung und einen maximalen Support für Android-Geräte.

Hinweis: Die vollständigen NDEF-Spezifikationen finden Sie in den NFC-Forumsspezifikationen und Website mit Anwendungsdokumenten und Gängige Arten von NDEF-Einträgen erstellen mit Beispielen dafür, wie Sie NDEF-Einträge zu erstellen.

Nachdem Sie nun einige Hintergrundinformationen zu NFC-Tags haben, wird in den folgenden Abschnitten ausführlicher beschrieben, Android verarbeitet NDEF-formatierte Tags. Wenn ein Android-Gerät ein NFC-Tag scannt, das NDEF enthält formatierten Daten enthält, parst es die Nachricht und versucht, den MIME-Typ der Daten URI. Dazu liest das System die ersten NdefRecord innerhalb der NdefMessage, um zu bestimmen, wie die gesamte NDEF-Nachricht interpretiert werden soll (eine NDEF-Nachricht kann mehrere NDEF-Einträge haben). In einer korrekt formatierten NDEF-Nachricht: die erste NdefRecord enthält die folgenden Felder:

3-Bit-TNF (Typnamensformat): Gibt an, wie das Feld für den Variablenlängentyp zu interpretieren ist. Gültige Werte: wie in Tabelle 1 beschrieben.
Variable Länge: Hier wird der Eintragstyp beschrieben. Wenn Sie TNF_WELL_KNOWN verwenden, verwenden Sie in dieses Feld, um die Datensatztypdefinition (RTD) anzugeben. Die gültigen RTD-Werte sind in Tabelle 2 beschrieben.
ID der Variablenlänge: Eine eindeutige Kennung für den Eintrag. Dieses Feld wird nicht oft verwendet, Wenn Sie ein Tag eindeutig identifizieren müssen, können Sie eine ID für das Tag erstellen.
Nutzlast variabler Länge: Die tatsächliche Datennutzlast, die Sie lesen oder schreiben möchten. Ein NDEF Nachricht kann mehrere NDEF-Einträge enthalten. Gehen Sie also nicht davon aus, dass sich die vollständige Nutzlast in der ersten NDEF befindet. Eintrag der NDEF-Nachricht.

Das Tag-Weiterleitungssystem versucht mithilfe der Felder TNF und Typ, einen MIME-Typ oder eine URI dem NDEF-Nachricht. Im Erfolgsfall werden diese Informationen zusammen mit der eigentlichen Nutzlast in einen ACTION_NDEF_DISCOVERED-Intent gekapselt. Es gibt jedoch Fälle, in denen das Tag-Weiterleitungssystem den Datentyp nicht anhand der ersten NDEF Datensatz. Das passiert, wenn die NDEF-Daten keinem MIME-Typ oder URI zugeordnet werden können, oder wenn der Das NFC-Tag enthält von vornherein keine NDEF-Daten. In solchen Fällen wird ein Tag-Objekt mit Informationen zu den Technologien des Tags und der Nutzlast in einen ACTION_TECH_DISCOVERED-Intent gekapselt.

In Tabelle 1 wird beschrieben, wie das Tag-Weiterleitungssystem TNF und Typ zuordnet. auf MIME-Typen oder URIs. Außerdem wird beschrieben, welche TNFs keinem MIME-Typ oder URI zugeordnet werden können. In diesen Fällen greift das Tag-Weiterleitungssystem auf ACTION_TECH_DISCOVERED

Wenn das Tag-Weiterleitungssystem beispielsweise auf einen Datensatz vom Typ TNF_ABSOLUTE_URI stößt, ordnet es das Feld für den Variablenlängentyp dieses Eintrags zu in einen URI. Das Tag-Weiterleitungssystem kapselt diesen URI zusammen mit anderen Informationen zum Tag im Datenfeld eines ACTION_NDEF_DISCOVERED-Intents ein. wie z. B. die Nutzlast. Wenn sie jedoch auf einen Datensatz vom Typ TNF_UNKNOWN stößt, wird ein Intent erstellt, der die Technologien des Tags kapselt. .

Tabelle 1 Unterstützte TNFs und ihre Zuordnungen

Format des Typnamens (TNF)	Zuordnung
`TNF_ABSOLUTE_URI`	URI basierend auf dem Feld „type“.
`TNF_EMPTY`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`TNF_EXTERNAL_TYPE`	URI basierend auf der URN im Feld „type“. Die URN ist im Feld NDEF-Typ in gekürzten Form: `<domain_name>:<service_name>`. Android ordnet dies einem URI im folgenden Format zu: `vnd.android.nfc://ext/<domain_name>:<service_name>`
`TNF_MIME_MEDIA`	MIME-Typ basierend auf dem Feld „type“.
`TNF_UNCHANGED`	Ungültig im ersten Eintrag, daher wird auf Folgendes zurückgegriffen: `ACTION_TECH_DISCOVERED`
`TNF_UNKNOWN`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`TNF_WELL_KNOWN`	MIME-Typ oder URI abhängig von der Datensatztypdefinition (RTD), die Sie in den type ein. Weitere Informationen finden Sie in Tabelle 2. der verfügbaren Echtzeitdaten und deren Zuordnungen.

Tabelle 2: Unterstützte Echtzeitdaten für TNF_WELL_KNOWN und ihre Zuordnungen

Datensatztypdefinition (RTD)	Zuordnung
`RTD_ALTERNATIVE_CARRIER`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`RTD_HANDOVER_CARRIER`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`RTD_HANDOVER_REQUEST`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`RTD_HANDOVER_SELECT`	Gilt wieder für `ACTION_TECH_DISCOVERED`.
`RTD_SMART_POSTER`	URI basierend auf dem Parsen der Nutzlast.
`RTD_TEXT`	MIME-Typ von `text/plain`.
`RTD_URI`	URI basierend auf Nutzlast.

So werden NFC-Tags an Anwendungen gesendet

Wenn das Tag-Weiterleitungssystem einen Intent erstellt hat, der das NFC-Tag und seine zur Identifizierung von Informationen, wird der Intent an eine interessierte Anwendung gesendet, für den Intent. Wenn mehrere Anwendungen den Intent verarbeiten können, gibt die Aktivitätsauswahl wird angezeigt, damit der Nutzer die Aktivität auswählen kann. Das Tag-Weiterleitungssystem definiert drei Intents: Sie sind von der höchsten zur niedrigsten Priorität geordnet:

ACTION_NDEF_DISCOVERED: Mit diesem Intent wird ein Aktivität, wenn ein Tag, das eine NDEF-Nutzlast enthält, gescannt wird und einen erkannten Typ hat. Dies ist Intent mit der höchsten Priorität haben und das Tag-Weiterleitungssystem versucht, eine Aktivität mit dieser vor jedem anderen Intent.
ACTION_TECH_DISCOVERED: Wenn sich keine Aktivitäten registrieren, Umgang mit der ACTION_NDEF_DISCOVERED Intent versucht, versucht das Tag-Weiterleitungssystem, eine Anwendung mit diesem Intent zu starten. Dieses Intent wird auch direkt gestartet (ohne zuerst ACTION_NDEF_DISCOVERED zu starten), wenn das gescannte Tag NDEF-Daten enthält, die keinem MIME-Typ oder URI zugeordnet werden können, oder wenn das Tag keine NDEF-Daten enthält aber eine bekannte Tag-Technologie ist.
ACTION_TAG_DISCOVERED: Dieser Intent wird gestartet ACTION_NDEF_DISCOVERED oder ACTION_TECH_DISCOVERED werden von keinen Aktivitäten verarbeitet Intents.

Die grundlegende Funktionsweise des Tag-Weiterleitungssystems sieht so aus:

Versuchen, eine Aktivität mit dem Intent zu starten, der vom Tag-Weiterleitungssystem erstellt wurde beim Parsen des NFC-Tags (entweder ACTION_NDEF_DISCOVERED oder ACTION_TECH_DISCOVERED).
Wenn für diesen Intent keine Aktivitäten gefiltert werden, starten Sie eine Aktivität mit der nächsten Intent mit der niedrigsten Priorität (entweder ACTION_TECH_DISCOVERED oder ACTION_TAG_DISCOVERED), bis eine Anwendung nach dem oder bis das Tag-Weiterleitungssystem alle möglichen Intents ausprobiert.
Wenn keine Anwendungen nach einem der Intents filtern, tun Sie nichts.

Arbeiten Sie nach Möglichkeit mit NDEF-Nachrichten und dem Intent ACTION_NDEF_DISCOVERED, da dies die spezifischste von die drei. Mit diesem Intent können Sie Ihre Anwendung zu einem geeigneten Zeitpunkt starten als der zwei anderen Intents, um die User Experience zu verbessern.

NFC-Zugriff im Android-Manifest anfordern

Deklarieren Sie Folgendes, bevor Sie auf die NFC-Hardware eines Geräts zugreifen und NFC-Intents richtig verarbeiten können. Elemente in Ihrer AndroidManifest.xml-Datei:

Das NFC-<uses-permission>-Element für den Zugriff auf die NFC-Hardware:
```
<uses-permission android:name="android.permission.NFC" />
```
Die SDK-Mindestversion, die Ihre App unterstützt. API Level 9 unterstützt nur begrenzte Tag-Weiterleitung über ACTION_TAG_DISCOVERED und nur Zugriff auf NDEF-Nachrichten über das Extra EXTRA_NDEF_MESSAGES. Nein andere Tag-Eigenschaften oder E/A-Vorgänge zugänglich sind. API-Level 10 umfasst umfassende Unterstützung für Leser/Autoren, NDEF-Übertragung im Vordergrund und API-Level Version 14 bietet eine einfachere Möglichkeit, NDEF-Nachrichten mit Android Beam und zusätzlichen Geräten an andere Geräte zu senden um NDEF-Einträge zu erstellen.
```
<uses-sdk android:minSdkVersion="10"/>
```
Das uses-feature-Element, damit deine App bei Google Play angezeigt wird Nur für Geräte mit NFC-Hardware:
```
<uses-feature android:name="android.hardware.nfc" android:required="true" />
```
Wenn Ihre Anwendung NFC-Funktionen verwendet, diese aber für Ihre Anwendung finden, können Sie das Element uses-feature weglassen und die NFC-Verfügbarkeit unter folgendem Link prüfen: indem Sie prüfen, ob getDefaultAdapter() ist null.

Nach NFC-Intents filtern

Um Ihre Anwendung zu starten, wenn ein zu verarbeitendes NFC-Tag gescannt wird, muss Ihre Anwendung kann nach einem, zwei oder allen drei NFC-Intents im Android-Manifest filtern. Sie haben jedoch möchten in der Regel nach dem Intent ACTION_NDEF_DISCOVERED für die wann Ihre Anwendung gestartet wird. Der Intent ACTION_TECH_DISCOVERED ist ein Fallback für ACTION_NDEF_DISCOVERED, wenn kein Anwendungsfilter vorhanden ist ACTION_NDEF_DISCOVERED oder wenn die Nutzlast nicht NDEF Das Filtern nach ACTION_TAG_DISCOVERED ist normalerweise zu allgemein Kategorie, nach der gefiltert werden soll. Viele Anwendungen filtern vor dem ACTION_TAG_DISCOVERED nach ACTION_NDEF_DISCOVERED oder ACTION_TECH_DISCOVERED. Ihre Anwendung hat daher eine geringe Wahrscheinlichkeit, beginnt. ACTION_TAG_DISCOVERED ist nur als letzte Option verfügbar für Anwendungen zum Filtern in Fällen, in denen keine anderen Anwendungen installiert sind, um den ACTION_NDEF_DISCOVERED- oder ACTION_TECH_DISCOVERED-Intent.

Da NFC-Tag-Bereitstellungen variieren und häufig nicht Ihrer Kontrolle unterliegen, ist dies nicht immer Deshalb können Sie bei Bedarf auf die anderen beiden Intents zurückgreifen. Wenn Sie die Art der geschriebenen Tags und Daten zu steuern, sollten Sie NDEF verwenden, um Ihre Tags. In den folgenden Abschnitten wird beschrieben, wie Sie nach Intent-Typen filtern.

ACTION_NDEF_DISCOVERED (Aktion_NDEF_DISCOVERED)

Deklarieren Sie die Methode, um nach ACTION_NDEF_DISCOVERED-Intents zu filtern Intent-Filter zusammen mit dem Datentyp, nach dem Sie filtern möchten. Die folgende Beispielfilter für ACTION_NDEF_DISCOVERED Intents mit dem MIME-Typ text/plain:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
    <category android:name="android.intent.category.DEFAULT"/>
    <data android:mimeType="text/plain" />
</intent-filter>

Im folgenden Beispiel wird nach einem URI in der Form von https://developer.android.com/index.html

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
    <category android:name="android.intent.category.DEFAULT"/>
   <data android:scheme="https"
              android:host="developer.android.com"
              android:pathPrefix="/index.html" />
</intent-filter>

ACTION_TECH_DISCOVERED

Wenn Ihre Aktivitäten nach dem Intent ACTION_TECH_DISCOVERED filtern, Sie müssen eine XML-Ressourcendatei erstellen, in der die Technologien angegeben sind, die Ihre Aktivität unterstützt innerhalb eines tech-list-Satzes. Deine Aktivität: wenn ein tech-list-Satz eine Teilmenge der Technologien ist, das vom Tag unterstützt wird. Dieses erhalten Sie durch Aufrufen von getTechList().

Wenn das gescannte Tag beispielsweise MifareClassic, NdefFormatable und NfcA unterstützt, werden die Attribute Das tech-list-Set muss alle drei, zwei oder eine der Technologien angeben. Es darf nichts angegeben werden. damit Ihre Aktivitäten abgeglichen werden können.

Im folgenden Beispiel werden alle Technologien definiert. Sie müssen diejenigen entfernen, die nicht die von Ihrem NFC-Tag unterstützt werden. Speichern Sie diese Datei im Ordner „<project-root>/res/xml“.

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <tech-list>
        <tech>android.nfc.tech.IsoDep</tech>
        <tech>android.nfc.tech.NfcA</tech>
        <tech>android.nfc.tech.NfcB</tech>
        <tech>android.nfc.tech.NfcF</tech>
        <tech>android.nfc.tech.NfcV</tech>
        <tech>android.nfc.tech.Ndef</tech>
        <tech>android.nfc.tech.NdefFormatable</tech>
        <tech>android.nfc.tech.MifareClassic</tech>
        <tech>android.nfc.tech.MifareUltralight</tech>
    </tech-list>
</resources>

Sie können auch mehrere tech-list-Sätze angeben. Alle tech-list wird als unabhängig betrachtet und Ihre Aktivität gilt als Übereinstimmung, Das tech-list-Set ist eine Teilmenge der Technologien, die von getTechList() zurückgegeben werden. Dies bietet AND und OR Semantik für Abgleichtechnologien. Im folgenden Beispiel werden Tags zugeordnet, die den Parameter NfcA- und Ndef-Technologien oder unterstützen die NfcB- und Ndef-Technologien:

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <tech-list>
        <tech>android.nfc.tech.NfcA</tech>
        <tech>android.nfc.tech.Ndef</tech>
    </tech-list>
    <tech-list>
        <tech>android.nfc.tech.NfcB</tech>
        <tech>android.nfc.tech.Ndef</tech>
    </tech-list>
</resources>

Geben Sie in der Datei AndroidManifest.xml die Ressourcendatei an, die Sie gerade erstellt haben. im <meta-data>-Element innerhalb von <activity> wie im folgenden Beispiel dargestellt:

<activity>
...
<intent-filter>
    <action android:name="android.nfc.action.TECH_DISCOVERED"/>
</intent-filter>

<meta-data android:name="android.nfc.action.TECH_DISCOVERED"
    android:resource="@xml/nfc_tech_filter" />
...
</activity>

Weitere Informationen zur Verwendung von Tag-Technologien und dem Intent ACTION_TECH_DISCOVERED finden Sie unter Mit unterstützten Tags arbeiten. Technologien im Dokument „Erweiterte NFC“.

ACTION_TAG_DISCOVERED

Verwenden Sie den folgenden Intent, um nach ACTION_TAG_DISCOVERED zu filtern Filter:

<intent-filter>
    <action android:name="android.nfc.action.TAG_DISCOVERED"/>
</intent-filter>

Informationen aus Intents abrufen

Wenn eine Aktivität aufgrund eines NFC-Intents startet, können Sie Informationen über die gescannte NFC-Funktion abrufen. aus dem Intent. Intents können je nach gescanntem Tag die folgenden Extras enthalten:

EXTRA_TAG (erforderlich): Ein Tag-Objekt. das das gescannte Tag darstellt.
EXTRA_NDEF_MESSAGES (optional): Ein Array von NDEF-Nachrichten aus dem Tag geparst werden. Diese Ergänzung ist bei ACTION_NDEF_DISCOVERED Intents.
EXTRA_ID (optional): Die Low-Level-ID des Tags.

Um diese Extras zu erhalten, prüfen Sie, ob Ihre Aktivität mit einer der folgenden Funktionen gestartet wurde: die NFC-Intents, um sicherzustellen, dass ein Tag gescannt wurde, und erhalten dann die Extras aus dem die Nutzerabsicht verstehen. Im folgenden Beispiel wird geprüft, ob ACTION_NDEF_DISCOVERED Intent und ruft die NDEF-Nachrichten von einem Intent zusätzlich ab.

Kotlin

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    ...
    if (NfcAdapter.ACTION_NDEF_DISCOVERED == intent.action) {
        intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES)?.also { rawMessages ->
            val messages: List<NdefMessage> = rawMessages.map { it as NdefMessage }
            // Process the messages array.
            ...
        }
    }
}

Java

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    ...
    if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(intent.getAction())) {
        Parcelable[] rawMessages =
            intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
        if (rawMessages != null) {
            NdefMessage[] messages = new NdefMessage[rawMessages.length];
            for (int i = 0; i < rawMessages.length; i++) {
                messages[i] = (NdefMessage) rawMessages[i];
            }
            // Process the messages array.
            ...
        }
    }
}

Alternativ können Sie ein Tag-Objekt aus dem Intent abrufen, mit dem enthalten die Nutzlast und ermöglichen die Aufzählung der Technologien des Tags:

Kotlin

val tag: Tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG)

Java

Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);

Allgemeine Arten von NDEF-Einträgen erstellen

In diesem Abschnitt wird beschrieben, wie Sie gängige Arten von NDEF-Einträgen erstellen, die Ihnen beim Schreiben in NFC-Tags oder Senden von Daten mit Android Beam Ab Android 4.0 (API-Level 14) Die Methode createUri() hilft Ihnen beim Erstellen URI-Einträge werden automatisch erfasst. Ab Android 4.1 (API-Level 16) createExternal() und createMime() helfen Ihnen beim Erstellen MIME- und NDEF-Einträge für externe Typen. Verwenden Sie nach Möglichkeit diese Hilfsmethoden, um Fehler zu vermeiden. wenn Sie NDEF-Einträge manuell erstellen.

In diesem Abschnitt wird auch beschrieben, wie die entsprechende Intent-Filter für den Datensatz. Alle Beispiele für NDEF-Einträge müssen in der ersten NDEF-Datei enthalten sein der NDEF-Nachricht, die Sie in ein Tag oder ein Beaming schreiben.

TNF_ABSOLUTE_URI

Hinweis: Wir empfehlen die Verwendung des Stattdessen RTD_URI eingeben von TNF_ABSOLUTE_URI, weil es effizienter ist.

So erstellen Sie einen NDEF-Eintrag für TNF_ABSOLUTE_URI: :

Kotlin

val uriRecord = ByteArray(0).let { emptyByteArray ->
    NdefRecord(
            TNF_ABSOLUTE_URI,
            "https://developer.android.com/index.html".toByteArray(Charset.forName("US-ASCII")),
            emptyByteArray,
            emptyByteArray
    )
}

Java

NdefRecord uriRecord = new NdefRecord(
    NdefRecord.TNF_ABSOLUTE_URI ,
    "https://developer.android.com/index.html".getBytes(Charset.forName("US-ASCII")),
    new byte[0], new byte[0]);

Der Intent-Filter für den vorherigen NDEF-Eintrag würde so aussehen:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:scheme="https"
        android:host="developer.android.com"
        android:pathPrefix="/index.html" />
</intent-filter>

TNF_MIME_MEDIA

So erstellen Sie einen NDEF-Eintrag für TNF_MIME_MEDIA:

Mithilfe der Methode createMime():

Kotlin

val mimeRecord = NdefRecord.createMime(
        "application/vnd.com.example.android.beam",
        "Beam me up, Android".toByteArray(Charset.forName("US-ASCII"))
)

Java

NdefRecord mimeRecord = NdefRecord.createMime("application/vnd.com.example.android.beam",
    "Beam me up, Android".getBytes(Charset.forName("US-ASCII")));

Erstellen Sie NdefRecord manuell:

Kotlin

val mimeRecord = Charset.forName("US-ASCII").let { usAscii ->
    NdefRecord(
            NdefRecord.TNF_MIME_MEDIA,
            "application/vnd.com.example.android.beam".toByteArray(usAscii),
            ByteArray(0),
            "Beam me up, Android!".toByteArray(usAscii)
    )
}

Java

NdefRecord mimeRecord = new NdefRecord(
    NdefRecord.TNF_MIME_MEDIA ,
    "application/vnd.com.example.android.beam".getBytes(Charset.forName("US-ASCII")),
    new byte[0], "Beam me up, Android!".getBytes(Charset.forName("US-ASCII")));

Der Intent-Filter für den vorherigen NDEF-Eintrag würde so aussehen:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:mimeType="application/vnd.com.example.android.beam" />
</intent-filter>

TNF_WELL_KNOWN mit RTD_TEXT

So erstellen Sie einen NDEF-Eintrag für TNF_WELL_KNOWN:

Kotlin

fun createTextRecord(payload: String, locale: Locale, encodeInUtf8: Boolean): NdefRecord {
    val langBytes = locale.language.toByteArray(Charset.forName("US-ASCII"))
    val utfEncoding = if (encodeInUtf8) Charset.forName("UTF-8") else Charset.forName("UTF-16")
    val textBytes = payload.toByteArray(utfEncoding)
    val utfBit: Int = if (encodeInUtf8) 0 else 1 shl 7
    val status = (utfBit + langBytes.size).toChar()
    val data = ByteArray(1 + langBytes.size + textBytes.size)
    data[0] = status.toByte()
    System.arraycopy(langBytes, 0, data, 1, langBytes.size)
    System.arraycopy(textBytes, 0, data, 1 + langBytes.size, textBytes.size)
    return NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT, ByteArray(0), data)
}

Java

public NdefRecord createTextRecord(String payload, Locale locale, boolean encodeInUtf8) {
    byte[] langBytes = locale.getLanguage().getBytes(Charset.forName("US-ASCII"));
    Charset utfEncoding = encodeInUtf8 ? Charset.forName("UTF-8") : Charset.forName("UTF-16");
    byte[] textBytes = payload.getBytes(utfEncoding);
    int utfBit = encodeInUtf8 ? 0 : (1 << 7);
    char status = (char) (utfBit + langBytes.length);
    byte[] data = new byte[1 + langBytes.length + textBytes.length];
    data[0] = (byte) status;
    System.arraycopy(langBytes, 0, data, 1, langBytes.length);
    System.arraycopy(textBytes, 0, data, 1 + langBytes.length, textBytes.length);
    NdefRecord record = new NdefRecord(NdefRecord.TNF_WELL_KNOWN,
    NdefRecord.RTD_TEXT, new byte[0], data);
    return record;
}

Der Intent-Filter für den vorherigen NDEF-Eintrag würde so aussehen:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:mimeType="text/plain" />
</intent-filter>

TNF_WELL_KNOWN mit RTD_URI

So erstellen Sie einen NDEF-Eintrag für TNF_WELL_KNOWN:

Mithilfe der Methode createUri(String):

Kotlin

val rtdUriRecord1 = NdefRecord.createUri("https://example.com")

Java

NdefRecord rtdUriRecord1 = NdefRecord.createUri("https://example.com");

Mithilfe der Methode createUri(Uri):

Kotlin

val rtdUriRecord2 = Uri.parse("https://example.com").let { uri ->
    NdefRecord.createUri(uri)
}

Java

Uri uri = Uri.parse("https://example.com");
NdefRecord rtdUriRecord2 = NdefRecord.createUri(uri);

Erstellen Sie NdefRecord manuell:

Kotlin

val uriField = "example.com".toByteArray(Charset.forName("US-ASCII"))
val payload = ByteArray(uriField.size + 1)                   //add 1 for the URI Prefix
payload [0] = 0x01                                           //prefixes https://www. to the URI
System.arraycopy(uriField, 0, payload, 1, uriField.size)     //appends URI to payload
val rtdUriRecord = NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_URI, ByteArray(0), payload)

Java

byte[] uriField = "example.com".getBytes(Charset.forName("US-ASCII"));
byte[] payload = new byte[uriField.length + 1];              //add 1 for the URI Prefix
payload[0] = 0x01;                                           //prefixes https://www. to the URI
System.arraycopy(uriField, 0, payload, 1, uriField.length);  //appends URI to payload
NdefRecord rtdUriRecord = new NdefRecord(
    NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_URI, new byte[0], payload);

Der Intent-Filter für den vorherigen NDEF-Eintrag würde so aussehen:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:scheme="https"
        android:host="example.com"
        android:pathPrefix="" />
</intent-filter>

TNF_EXTERNER_TYP

Hier können Sie einen NDEF-Eintrag für TNF_EXTERNAL_TYPE erstellen: Möglichkeiten:

Mithilfe der Methode createExternal():

Kotlin

var payload: ByteArray //assign to your data
val domain = "com.example" //usually your app's package name
val type = "externalType"
val extRecord = NdefRecord.createExternal(domain, type, payload)

Java

byte[] payload; //assign to your data
String domain = "com.example"; //usually your app's package name
String type = "externalType";
NdefRecord extRecord = NdefRecord.createExternal(domain, type, payload);

Erstellen Sie NdefRecord manuell:

Kotlin

var payload: ByteArray
...
val extRecord = NdefRecord(
        NdefRecord.TNF_EXTERNAL_TYPE,
        "com.example:externalType".toByteArray(Charset.forName("US-ASCII")),
        ByteArray(0),
        payload
)

Java

byte[] payload;
...
NdefRecord extRecord = new NdefRecord(
    NdefRecord.TNF_EXTERNAL_TYPE, "com.example:externalType".getBytes(Charset.forName("US-ASCII")),
    new byte[0], payload);

Der Intent-Filter für den vorherigen NDEF-Eintrag würde so aussehen:

<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED" />
    <category android:name="android.intent.category.DEFAULT" />
    <data android:scheme="vnd.android.nfc"
        android:host="ext"
        android:pathPrefix="/com.example:externalType"/>
</intent-filter>

Verwenden Sie TNF_EXTERNAL_TYPE für allgemeinere NFC-Tag-Bereitstellungen, um beides besser zu unterstützen Geräte mit und ohne Android.

Hinweis: URNs für TNF_EXTERNAL_TYPE haben folgendes kanonisches Format: urn:nfc:ext:example.com:externalType, aber die RTD-Spezifikation des NFC-Forums deklariert, dass der urn:nfc:ext:-Teil der URN im NDEF-Eintrag. Sie müssen also nur die Domain angeben (im Beispiel example.com). und geben Sie (im Beispiel externalType) getrennt durch einen Doppelpunkt ein. Beim Senden von TNF_EXTERNAL_TYPE konvertiert Android die urn:nfc:ext:example.com:externalType-URN in einen vnd.android.nfc://ext/example.com:externalType-URI. Intent-Filter in den Beispieldeklarationen.

Einträge für Android-Apps

Seit der Einführung in Android 4.0 (API-Level 14) bietet der AAE (Android Application Record) eine bessere Sicherheit, dass Ihre Anwendung gestartet wird, wenn ein NFC-Tag gescannt wird. AAE hat den Paketnamen einer Anwendung, die in einen NDEF-Eintrag eingebettet ist. Sie können jedem NDEF-Eintrag Ihrer NDEF einen AAR hinzufügen weil Android die gesamte NDEF-Nachricht nach AAE durchsucht. Wenn automatisch angewendete Empfehlungen gefunden werden, basierend auf dem Paketnamen in den automatisch angewendeten Empfehlungen. Wenn die Anwendung nicht auf der wird Google Play gestartet, damit die App heruntergeladen werden kann.

AAE sind nützlich, wenn Sie verhindern möchten, dass andere Anwendungen nach demselben Intent die möglicherweise von Ihnen bereitgestellten Tags verarbeitet werden. AAE werden nur in der aufgrund der Beschränkung des Paketnamens und nicht wie bei Intent-Filterung. Wenn Sie einen Intent auf Aktivitätsebene verarbeiten möchten, verwenden Sie Intent-Filter.

Wenn ein Tag einen AAE enthält, erfolgt die Weiterleitung durch das Tag-Weiterleitungssystem auf folgende Weise:

Versuchen Sie, eine Aktivität wie gewohnt mit einem Intent-Filter zu starten. Wenn die mit der der Intent auch mit AAE übereinstimmt, starten Sie die Aktivität.
Wenn die Aktivität, die nach dem Intent gefiltert wird, nicht mit dem AAE: Wenn der Intent von mehreren Aktivitäten verarbeitet werden kann, oder wenn keine Aktivität den Intent verarbeitet, starten Sie AAE angegeben wird.
Wenn keine App mit automatisch angewendeten Empfehlungen beginnen kann, laden Sie die basierend auf den automatisch angewendeten Empfehlungen.

Hinweis:Sie können AAE und das Intent-Weiterleitungssystem mit dem Parameter Vordergrund Weiterleitungssystem, mit dem eine Vordergrundaktivität priorisiert werden kann, wenn ein NFC-Tag gefunden. Bei dieser Methode muss die Aktivität im Vordergrund ausgeführt werden, damit automatisch angewendete Empfehlungen und das Attribut Intent-Weiterleitungssystem erstellt.

Wenn Sie trotzdem nach gescannten Tags filtern möchten, die keine AAE enthalten, können Sie Intent-Filter wie gewohnt. Dies ist nützlich, wenn Ihre Anwendung an anderen Tags interessiert ist. die keinen AAE enthalten. Vielleicht möchten Sie z. B. sicherstellen, dass Ihre Anwendung proprietäre Tags, die Sie bereitstellen, sowie allgemeine Tags, die von Drittanbietern eingesetzt werden. Wichtige Hinweise AAE sind spezifisch für Android 4.0-Geräte oder höher. Wenn Sie also Tags bereitstellen, , um eine Kombination aus AAE und MIME-Typen/URIs zu verwenden, um eine Vielzahl von Geräten zu unterstützen. In Überlegen Sie bei der Bereitstellung von NFC-Tags, wie Sie Ihre NFC-Tags schreiben möchten, um auf den meisten Geräten (Android- und andere Geräte) unterstützt. Dazu können Sie relativ eindeutigen MIME-Typ oder URI definieren, damit Anwendungen leichter unterschieden werden können.

Android bietet eine einfache API zum Erstellen von automatisch angewendeten Empfehlungen, createApplicationRecord() Alles, was Sie brauchen, um die automatisch angewendeten Empfehlungen an einer beliebigen Stelle in NdefMessage einbetten. Sie möchten nicht, um den ersten Eintrag von NdefMessage zu verwenden, es sei denn, AAE ist der einzige in NdefMessage aufnehmen. Das liegt daran, dass die Android- prüft das System den ersten Eintrag eines NdefMessage, um den MIME-Typ oder URI des Tags, mit dem ein Intent erstellt wird, den Anwendungen filtern können. Der folgende Code erfahren Sie, wie Sie automatisch angewendete Empfehlungen erstellen:

Kotlin

val msg = NdefMessage(
        arrayOf(
                ...,
                NdefRecord.createApplicationRecord("com.example.android.beam")
        )
)

Java

NdefMessage msg = new NdefMessage(
        new NdefRecord[] {
            ...,
            NdefRecord.createApplicationRecord("com.example.android.beam")}
        );
)

NDEF-Nachrichten an andere Geräte übertragen

Android Beam ermöglicht einen einfachen Peer-to-Peer-Datenaustausch zwischen zwei Android-Geräten. Die App, die Daten auf ein anderes Gerät übertragen möchte, im Vordergrund muss darf nicht gesperrt sein. Wenn das Strahlgerät eng genug Kontakt mit einer empfangen, zeigt das Beaming-Gerät die Meldung "Zum Beamen berühren" an UI. Der Nutzer kann dann ob die Nachricht auf das empfangende Gerät beamen soll oder nicht.

Hinweis:Das NDEF-Push-Verfahren im Vordergrund war auf API-Ebene 10 verfügbar. Es bietet ähnliche Funktionen wie Android Beam. Diese APIs wurden inzwischen eingestellt, sind für ältere Geräte verfügbar. Weitere Informationen findest du in den enableForegroundNdefPush().

Sie können Android Beam für Ihre App aktivieren, indem Sie eine der beiden folgenden Methoden aufrufen:

setNdefPushMessage(): Akzeptiert ein NdefMessage, um sie als zu beamende Nachricht festzulegen. Die Nachricht wird automatisch übertragen. wenn sich zwei Geräte nah genug in der Nähe befinden.
setNdefPushMessageCallback(): Nimmt einen Callback an, der einen createNdefMessage() Er wird aufgerufen, wenn sich ein Gerät in Reichweite befindet, um Daten zu übertragen. Mit dem Callback können Sie NDEF-Nachricht nur, wenn nötig.

Für eine Aktivität kann immer nur eine NDEF-Nachricht gleichzeitig gesendet werden, daher hat setNdefPushMessageCallback() Vorrang über setNdefPushMessage(), wenn beide festgelegt sind. Zur Verwendung Android Beam müssen die folgenden allgemeinen Richtlinien erfüllt sein:

Die Aktivität, die die Daten überträgt, muss im Vordergrund stehen. Beide Geräte müssen ihre Bildschirme entsperrt sind.
Die Daten, die Sie per Beaming übertragen, müssen in einem NdefMessage gekapselt werden. -Objekt enthält.
Das NFC-Gerät, das die übertragenen Daten empfängt, muss den com.android.npp NDEF-Push-Protokoll oder SNEP des NFC-Forums (einfacher NDEF-Austausch Protokoll). Das Protokoll com.android.npp ist für Geräte mit API-Level 9 (Android) erforderlich 2.3) auf API-Level 13 (Android 3.2). com.android.npp und SNEP sind beide erforderlich auf API-Level 14 (Android 4.0) und höher.

Hinweis:Wenn Ihre Aktivität Android Beam ermöglicht und im Vordergrund ausgeführt wird, ist das Standard-Intent-Weiterleitungssystem deaktiviert. Wenn sich Ihre Aktivitäten jedoch auch aktiviert die Weiterleitung im Vordergrund aktiviert, können weiterhin Tags gescannt werden, die mit den Intent-Filtern übereinstimmen, die im Weiterleitung im Vordergrund.

So aktivieren Sie Android Beam:

NdefMessage erstellen, die die NdefRecords enthält die Sie auf dem anderen Gerät platzieren möchten.
Rufen Sie setNdefPushMessage() mit einem NdefMessage auf oder rufen Sie setNdefPushMessageCallback auf und übergeben Sie ein NfcAdapter.CreateNdefMessageCallback-Objekt in der Methode onCreate() von Ihre Aktivitäten. Für diese Methoden ist mindestens eine Aktivität erforderlich, die Sie mit Android aktivieren möchten Beam, zusammen mit einer optionalen Liste weiterer zu aktivierender Aktivitäten.
Im Allgemeinen verwenden Sie setNdefPushMessage(), wenn Ihre Aktivitäten nur Folgendes erfordern: immer dieselbe NDEF-Nachricht senden, wenn sich zwei Geräte in Reichweite für die Kommunikation befinden. Sie verwenden setNdefPushMessageCallback, wenn Ihr Der aktuelle Kontext der Anwendung ist wichtig und sie möchte eine NDEF-Nachricht senden je nachdem, was der Nutzer in der Anwendung tut.

Das folgende Beispiel zeigt, wie eine einfache Aktivität NfcAdapter.CreateNdefMessageCallback in der onCreate()-Methode eines Aktivität (siehe AndroidBeamDemo) für das gesamte Beispiel). Dieses Beispiel enthält auch Methoden, mit denen Sie einen MIME-Eintrag erstellen können:

Kotlin

package com.example.android.beam

import android.app.Activity
import android.content.Intent
import android.nfc.NdefMessage
import android.nfc.NdefRecord
import android.nfc.NfcAdapter
import android.nfc.NfcAdapter.CreateNdefMessageCallback
import android.nfc.NfcEvent
import android.os.Bundle
import android.os.Parcelable
import android.widget.TextView
import android.widget.Toast
import java.nio.charset.Charset

class Beam : Activity(), NfcAdapter.CreateNdefMessageCallback {
    
    private var nfcAdapter: NfcAdapter? = null
    private lateinit var textView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        textView = findViewById(R.id.textView)
        // Check for available NFC Adapter
        nfcAdapter = NfcAdapter.getDefaultAdapter(this)
        if (nfcAdapter == null) {
            Toast.makeText(this, "NFC is not available", Toast.LENGTH_LONG).show()
            finish()
            return
        }
        // Register callback
        nfcAdapter?.setNdefPushMessageCallback(this, this)
    }

    override fun createNdefMessage(event: NfcEvent): NdefMessage {
        val text = "Beam me up, Android!\n\n" +
                "Beam Time: " + System.currentTimeMillis()
        return NdefMessage(
                arrayOf(
                        createMime("application/vnd.com.example.android.beam", text.toByteArray())
                )
                /**
                 * The Android Application Record (AAR) is commented out. When a device
                 * receives a push with an AAR in it, the application specified in the AAR
                 * is guaranteed to run. The AAR overrides the tag dispatch system.
                 * You can add it back in to guarantee that this
                 * activity starts when receiving a beamed message. For now, this code
                 * uses the tag dispatch system.
                 *///,NdefRecord.createApplicationRecord("com.example.android.beam")
        )
    }

    override fun onResume() {
        super.onResume()
        // Check to see that the Activity started due to an Android Beam
        if (NfcAdapter.ACTION_NDEF_DISCOVERED == intent.action) {
            processIntent(intent)
        }
    }

    override fun onNewIntent(intent: Intent) {
        // onResume gets called after this to handle the intent
        setIntent(intent)
    }

    /**
     * Parses the NDEF Message from the intent and prints to the TextView
     */
    private fun processIntent(intent: Intent) {
        textView = findViewById(R.id.textView)
        // only one message sent during the beam
        intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES)?.also { rawMsgs ->
            (rawMsgs[0] as NdefMessage).apply {
                // record 0 contains the MIME type, record 1 is the AAR, if present
                textView.text = String(records[0].payload)
            }
        }
    }
}

Java

package com.example.android.beam;

import android.app.Activity;
import android.content.Intent;
import android.nfc.NdefMessage;
import android.nfc.NdefRecord;
import android.nfc.NfcAdapter;
import android.nfc.NfcAdapter.CreateNdefMessageCallback;
import android.nfc.NfcEvent;
import android.os.Bundle;
import android.os.Parcelable;
import android.widget.TextView;
import android.widget.Toast;
import java.nio.charset.Charset;


public class Beam extends Activity implements CreateNdefMessageCallback {
    NfcAdapter nfcAdapter;
    TextView textView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        TextView textView = (TextView) findViewById(R.id.textView);
        // Check for available NFC Adapter
        nfcAdapter = NfcAdapter.getDefaultAdapter(this);
        if (nfcAdapter == null) {
            Toast.makeText(this, "NFC is not available", Toast.LENGTH_LONG).show();
            finish();
            return;
        }
        // Register callback
        nfcAdapter.setNdefPushMessageCallback(this, this);
    }

    @Override
    public NdefMessage createNdefMessage(NfcEvent event) {
        String text = ("Beam me up, Android!\n\n" +
                "Beam Time: " + System.currentTimeMillis());
        NdefMessage msg = new NdefMessage(
                new NdefRecord[] { createMime(
                        "application/vnd.com.example.android.beam", text.getBytes())
         /**
          * The Android Application Record (AAR) is commented out. When a device
          * receives a push with an AAR in it, the application specified in the AAR
          * is guaranteed to run. The AAR overrides the tag dispatch system.
          * You can add it back in to guarantee that this
          * activity starts when receiving a beamed message. For now, this code
          * uses the tag dispatch system.
          */
          //,NdefRecord.createApplicationRecord("com.example.android.beam")
        });
        return msg;
    }

    @Override
    public void onResume() {
        super.onResume();
        // Check to see that the Activity started due to an Android Beam
        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(getIntent().getAction())) {
            processIntent(getIntent());
        }
    }

    @Override
    public void onNewIntent(Intent intent) {
        // onResume gets called after this to handle the intent
        setIntent(intent);
    }

    /**
     * Parses the NDEF Message from the intent and prints to the TextView
     */
    void processIntent(Intent intent) {
        textView = (TextView) findViewById(R.id.textView);
        Parcelable[] rawMsgs = intent.getParcelableArrayExtra(
                NfcAdapter.EXTRA_NDEF_MESSAGES);
        // only one message sent during the beam
        NdefMessage msg = (NdefMessage) rawMsgs[0];
        // record 0 contains the MIME type, record 1 is the AAR, if present
        textView.setText(new String(msg.getRecords()[0].getPayload()));
    }
}

Dieser Code kommentiert automatisch angewendete Empfehlungen, die Sie entfernen können. Wenn Sie automatisch angewendete Empfehlungen aktivieren, App, die im AAE angegeben ist, empfängt immer die Android Beam-Nachricht. Wenn die Anwendung nicht angezeigt wird, wird Google Play gestartet, um die App herunterzuladen. Daher wird der folgende Intent für Geräte mit Android 4.0 oder höher aus technischer Sicht nicht erforderlich, wenn AAE verwendet wird:

<intent-filter>
  <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <data android:mimeType="application/vnd.com.example.android.beam"/>
</intent-filter>

Mit diesem Intent-Filter kann die com.example.android.beam-Anwendung jetzt gestartet werden wenn ein NFC-Tag gescannt oder ein Android Beam mit einem AAE von Typ com.example.android.beam oder wenn eine Nachricht im NDEF-Format einen MIME-Eintrag enthält vom Typ application/vnd.com.example.android.beam.

AAE garantieren zwar, dass eine App gestartet oder heruntergeladen wird, Intent-Filter sind jedoch empfohlen, da Sie damit eine Aktivität Ihrer Wahl in Ihrem statt immer die Hauptaktivität innerhalb des durch ein AAE angegebenen Pakets zu starten. AAE haben keinen Detaillierungsgrad auf Aktivitätsebene. Da einige Android-Mobilgeräte AAE unterstützen, sollten Sie außerdem identifizierende Informationen in den ersten NDEF-Eintrag Ihrer NDEF und filtern Sie sicherheitshalber auch danach. Siehe Erstellen von Common Arten von NDEF-Einträgen für weitere Informationen zum Erstellen von Einträgen.