Nachrichten über Wear senden und empfangen

Sie senden Nachrichten über die MessageClient API an und hängen Sie die folgenden Elemente an die Nachricht an:

• Optionale beliebige Nutzlast
• Ein Pfad, der die Aktion der Nachricht eindeutig identifiziert

Anders als bei Datenelementen findet keine Synchronisierung zwischen den Handheld- und Wearable-Apps. Nachrichten sind ein einseitiger Kommunikationsmechanismus, der für Remoteprozeduraufrufe (Remote Procedure Calls, RPCs) nützlich ist. zum Beispiel das Senden einer Nachricht an das Wearable, um eine Aktivität zu starten.

Es können mehrere am Körper tragbare Geräte mit dem Handheld-Gerät eines Nutzers verbunden werden. Jedes verbundene Gerät in wird das Netzwerk als Knoten betrachtet.

Bei mehreren verbundenen Geräten müssen Sie überlegen, -Knoten die Nachrichten empfangen. In einer Sprachtranskriptions-App, die Sprachdaten auf die Nachricht an einen Knoten mit Prozessorleistung und Akku Kapazität zur Verarbeitung der Anfrage, z. B. auf einem Handheld-Gerät.

Hinweis: Wenn Sie die Details Ihrer Nachricht festlegen, denken Sie daran, dass möglicherweise mehrere verbundenen Knoten. Achten Sie darauf, dass die Nachricht an die gewünschten Geräte oder Knoten zugestellt wird.

Eine Nachricht posten

Eine Wearable-App kann Nutzern Funktionen wie Sprachfunktionen bieten Transkription. Nutzer können in das Mikrofon ihres Wearables sprechen und sich ein Transkript anzeigen lassen in einer Notiz gespeichert. Da ein Wearable normalerweise keine Rechenleistung und keinen Akku hat Kapazität, die für die Sprachtranskription erforderlich ist, muss die App diese Arbeit leistungsstärkeren verbundenen Geräten.

In den folgenden Abschnitten wird beschrieben, wie Sie Geräteknoten bewerben, die Aktivitäten verarbeiten können. -Anfragen, ermitteln die Knoten, die einen angeforderten Bedarf erfüllen können, und senden Nachrichten an diese Knoten.

Werbefunktionen

Um von einem Wearable aus eine Aktivität auf einem Handheld-Gerät zu starten, verwende die MessageClient zum Senden der Anfrage. Da mehrere Wearables kann mit der muss die Wearable-App feststellen, ob ein verbundener Knoten die Aktivität starten kann. Bieten Sie in Ihrer Handheld-App an, dass der Knoten auf denen sie ausgeführt wird, bietet spezifische Funktionen.

So bewerben Sie die Funktionen Ihrer Handheld-App:

1. Erstellen Sie im Verzeichnis res/values/ Ihres Projekts eine XML-Konfigurationsdatei und und nennen Sie sie wear.xml.
2. Fügen Sie wear.xml eine Ressource mit dem Namen android_wear_capabilities hinzu.
3. Definieren Sie die Funktionen, die das Gerät bietet.

Hinweis: Funktionen sind benutzerdefinierte Strings, die Sie definieren und innerhalb Ihrer App eindeutig sein müssen.

Das folgende Beispiel zeigt, wie Sie eine Funktion mit dem Namen voice_transcription zu wear.xml:

<resources xmlns:tools="http://schemas.android.com/tools"
           tools:keep="@array/android_wear_capabilities">
    <string-array name="android_wear_capabilities">
        <item>voice_transcription</item>
    </string-array>
</resources>

Knoten mit den erforderlichen Funktionen abrufen

Zu Beginn können Sie die leistungsfähigen Knoten ermitteln, indem Sie die Methode getCapability-Methode des Klasse CapabilityClient. Wenn du diese Methode verwenden möchtest, müssen deine Wear OS-App und deine Smartphone-App muss dieselbe Anwendungs-ID haben. Im folgenden Beispiel zeigt, wie Sie die Ergebnisse erreichbarer Knoten mit der voice_transcription-Funktion:

private const val VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription"
...
private fun setupVoiceTranscription() {
    val capabilityInfo: CapabilityInfo = Tasks.await(
            Wearable.getCapabilityClient(context)
                    .getCapability(
                            VOICE_TRANSCRIPTION_CAPABILITY_NAME,
                            CapabilityClient.FILTER_REACHABLE
                    )
    )
    // capabilityInfo has the reachable nodes with the transcription capability
    updateTranscriptionCapability(capabilityInfo)
}

private static final String
    VOICE_TRANSCRIPTION_CAPABILITY_NAME = "voice_transcription";
    ...
private void setupVoiceTranscription() {
    CapabilityInfo capabilityInfo = Tasks.await(
        Wearable.getCapabilityClient(context).getCapability(
            VOICE_TRANSCRIPTION_CAPABILITY_NAME, CapabilityClient.FILTER_REACHABLE));
    // capabilityInfo has the reachable nodes with the transcription capability
    updateTranscriptionCapability(capabilityInfo);
}

Registrieren Sie einen Knoten, um bei der Verbindung mit dem Wearable-Gerät geeignete Knoten zu erkennen Instanz eines Listeners, genauer gesagt ein OnCapabilityChangedListener eines CapabilityClient-Objekts. Das folgende Beispiel zeigt, wie Sie Registrieren Sie den Listener und rufen Sie ein Ergebnis mit erreichbaren Knoten ab, die den voice_transcription-Funktion:

private fun setupVoiceTranscription() {
    updateTranscriptionCapability(capabilityInfo).also { capabilityListener ->
        Wearable.getCapabilityClient(context).addListener(
                capabilityListener,
                VOICE_TRANSCRIPTION_CAPABILITY_NAME
        )
    }
}

private void setupVoiceTranscription() {
    ...
    // This example uses a Java 8 Lambda. You can use named or anonymous classes.
    CapabilityClient.OnCapabilityChangedListener capabilityListener =
        capabilityInfo -> { updateTranscriptionCapability(capabilityInfo); };
    Wearable.getCapabilityClient(context).addListener(
        capabilityListener,
        VOICE_TRANSCRIPTION_CAPABILITY_NAME);
}

Bestimmen Sie nach der Erkennung der fähigen Knoten, wohin die Nachricht gesendet werden soll. Knoten auswählen sich in der Nähe deines Wearables befindet, das Routing von Nachrichten über mehrere Knoten. Ein nahe gelegener Knoten ist definiert als ein Knoten, der direkt verbunden ist auf das Gerät übertragen. Um zu ermitteln, ob ein Knoten in der Nähe ist, z. B. über Bluetooth verbunden ist, rufen Sie den <ph type="x-smartling-placeholder"></ph> Node.isNearby()-Methode. Wenn sich mehr als ein Knoten in der Nähe befindet, wählen Sie willkürlich einen aus. Wenn sich kein fähiger Knoten in der Nähe befindet, kann beliebig ein fähiger Knoten ausgewählt werden.

Das folgende Beispiel zeigt, wie Sie den besten Knoten ermitteln können:

private var transcriptionNodeId: String? = null

private fun updateTranscriptionCapability(capabilityInfo: CapabilityInfo) {
    transcriptionNodeId = pickBestNodeId(capabilityInfo.nodes)
}

private fun pickBestNodeId(nodes: Set<Node>): String? {
    // Find a nearby node or pick one arbitrarily.
    return nodes.firstOrNull { it.isNearby }?.id ?: nodes.firstOrNull()?.id
}

private String transcriptionNodeId = null;

private void updateTranscriptionCapability(CapabilityInfo capabilityInfo) {
    Set<Node> connectedNodes = capabilityInfo.getNodes();

    transcriptionNodeId = pickBestNodeId(connectedNodes);
}

private String pickBestNodeId(Set<Node> nodes) {
    String bestNodeId = null;
    // Find a nearby node or pick one arbitrarily.
    for (Node node : nodes) {
        if (node.isNearby()) {
            return node.getId();
         }
         bestNodeId = node.getId();
    }
    return bestNodeId;
}

Die Nachricht übermitteln

Wenn Sie einen zu verwendenden Knoten identifiziert haben, senden Sie die Nachricht mithilfe der Klasse MessageClient.

Das folgende Beispiel zeigt, wie eine Nachricht an den transkribierbaren Knoten gesendet wird die von einem Wearable-Gerät stammen. Dieser Aufruf ist synchron und blockiert die Verarbeitung, bis das System die Nachricht zur Zustellung in die Warteschlange stellt.

Hinweis:Ein erfolgreicher Ergebniscode garantiert nicht, dass in der Nachricht. Wenn für deine App Datenzuverlässigkeit erforderlich ist, solltest du DataItem verwenden -Objekte oder die ChannelClient -Klasse verwendet, um Daten zwischen Geräten zu senden.

const val VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription"
...
private fun requestTranscription(voiceData: ByteArray) {
    transcriptionNodeId?.also { nodeId ->
        val sendTask: Task<*> = Wearable.getMessageClient(context).sendMessage(
                nodeId,
                VOICE_TRANSCRIPTION_MESSAGE_PATH,
                voiceData
        ).apply {
            addOnSuccessListener { ... }
            addOnFailureListener { ... }
        }
    }
}

public static final String VOICE_TRANSCRIPTION_MESSAGE_PATH = "/voice_transcription";
private void requestTranscription(byte[] voiceData) {
    if (transcriptionNodeId != null) {
        Task<Integer> sendTask =
            Wearable.getMessageClient(context).sendMessage(
              transcriptionNodeId, VOICE_TRANSCRIPTION_MESSAGE_PATH, voiceData);
         // You can add success and/or failure listeners,
         // Or you can call Tasks.await() and catch ExecutionException
         sendTask.addOnSuccessListener(...);
         sendTask.addOnFailureListener(...);
    } else {
        // Unable to retrieve node with transcription capability
    }
}

Hinweis: Wenn Sie mehr über asynchrone und synchrone Aufrufe von Informationen zu den jeweiligen Google Play-Diensten und ihrer Verwendung finden Sie in der Tasks API.

Sie können auch Nachrichten an alle verbundenen Knoten senden. Um alle Verbundene Knoten, an die Sie Nachrichten senden können, implementieren Sie den folgenden Code:

private fun getNodes(): Collection<String> {
    return Tasks.await(Wearable.getNodeClient(context).connectedNodes).map { it.id }
}

private Collection<String> getNodes() {
    HashSet <String>results = new HashSet<String>();
    List<Node> nodes =
        Tasks.await(Wearable.getNodeClient(context).getConnectedNodes());
    for (Node node : nodes.getNodes()) {
        results.add(node.getId());
    }
    return results;
}

Nachrichten empfangen

Um über empfangene Nachrichten informiert zu werden, implementieren Sie den MessageClient.OnMessageReceivedListener -Schnittstelle zur Bereitstellung eines Listeners für Nachrichtenereignisse. Registrieren Sie dann den Listener. mit dem addListener . Das folgende Beispiel zeigt, wie Sie den Listener implementieren können, um die VOICE_TRANSCRIPTION_MESSAGE_PATH Wenn diese Bedingung true, starte eine Aktivität zur Verarbeitung der Sprachdaten.

fun onMessageReceived(messageEvent: MessageEvent) {
    if (messageEvent.path == VOICE_TRANSCRIPTION_MESSAGE_PATH) {
        val startIntent = Intent(this, MainActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            putExtra("VOICE_DATA", messageEvent.data)
        }
        startActivity(this, startIntent)
    }
}

@Override
public void onMessageReceived(MessageEvent messageEvent) {
    if (messageEvent.getPath().equals(VOICE_TRANSCRIPTION_MESSAGE_PATH)) {
        Intent startIntent = new Intent(this, MainActivity.class);
        startIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        startIntent.putExtra("VOICE_DATA", messageEvent.getData());
        startActivity(this, startIntent);
    }
}

Für diesen Code sind weitere Implementierungsdetails erforderlich. Weitere Informationen wie Sie einen vollständigen Listener-Dienst oder eine Listener-Aktivität in <ph type="x-smartling-placeholder"></ph> Datenschichtereignisse beobachten