phantomknight287/Portfolio

public

translated :D39da910a year ago193 lines · 6.8 KB

1	---
2	title: "Erstellen Sie Wear OS-Apps und verbinden sie mit Android"
3	summary: "Erstellen Sie Wear OS-Apps und verbinden sie mit Android. Behandelt Einrichtung, Erlaubnis und Informationen Mitnahme."
4	---
5
6	## Ersteinrichtung
7
8	Beginnen Sie mit dem Erstellung einer Android-App mit Ihrem bevorzugten Framework und öffnen Sie Ihr Projekt in Android Studio(öffnen Sie den ordnen „Android“, wenn Sie plattformübergreifende Frameworks verwenden).
9
10	## Einrichtung der Telefon-App
11
12	Erste wir müssen einen Listener binden, damit wir die von unserer Uhr gesendenten Nachrichten auch dann abhören können, wenn unsere App geschlossen/beendet ist. Dazu müssen Berechtigungen hinzufügen und das Paket implementiert werden. Machen Sie sich keine Gedanken darüber, Benutzer nach Berechtigungen zu fragen – das ist nicht nötig, da es sich um eine [normale](https://developer.android.com/guide/topics/permissions/overview#normal) Berechtigung handelt.
13
14	### Hinzufügen von Berechtigungen
15
16	Fügen Sie Ihrer Gradle-Datei auf App-Ebene Folgendes hinzu(`app/build.gradle`):
17
18	```kotlin
19	implementation("com.google.android.gms:play-services-wearable:19.0.0")
20	```
21
22	Vergessen Sie nicht, auf `Sync Now` zu drücken.
23
24	### Berechtigungseinrichtung
25
26	Fügen Sie den folgenden Code in den `Manifest`-Block von `AndroidManifest.xml` ein:
27
28	```xml
29	<uses-permission android:name
30	```
31
32
33	### Nachrichtenempfänger Receiver
34
35	Jetzt schreiben wir einen Dienst namens `android:exported`. Erstellen Sie eine neue Datei `WearMessageReceiver.kt` im selben Ordner wie
36
37
38	```kotlin
39	package com.your.package
40
41	import android.content.Intent
42	import com.google.android.gms.wearable.MessageEvent
43	import com.google.android.gms.wearable.WearableListenerService
44
45	class WearMessageReceiver : WearableListenerService
46	override fun onMessageReceived(event:
47	when (event.path) {
48	"/open" -> {
49	val intent = packageManager.getLaunchIntentForPackage(packageName)?.apply
50	addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
51	addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
52	}
53	startActivity(intent)
54	}
55	}
56	}
57	}
58	```
59
60	Der obige Code wartet auf die Nachrichten `/open` und öffnet die App, wenn er empfangen wird.
61
62	### Registrieren des Dienstes
63
64	Wir müssen unserem Telefon von diesem Dienst erzählen. Fügen Sie den folgenden Code in den `application`-block von `AndroidManifest.xml` ein:
65
66	```xml
67	<service
68	android:name="
69	android:exported="
70	<intent-filter>
71	<action android:name
72	<category android:name
73	<data
74	android:host="
75	android:pathPattern="
76	android:scheme="
77	</intent-filter>
78	</service>
79	```
80
81	### Nachrichtensendefunktion
82
83	Diese Funktion sendet Nachrichten von unserem Telefon an die Uhr. Fügen Sie es zu `MainActivity.kt` hinzu:
84
85	```kotlin
86	suspend fun sendMessageToWatch(
87	context: Context,
88	path: String,
89	data: ByteArray
90	) {
91	withContext(Dispatchers.IO) {
92	try {
93	val nodes = Tasks.await(Wearable.getNodeClient
94	// it is recommended to filter out nodes with `isNearby = false`
95	nodes.forEach { node ->
96	Tasks.await(
97	Wearable.getMessageClient(context).sendMessage(
98	node.id,
99	path,
100	data,
101	)
102	)
103	}
104	} catch (e: Exception) {
105	e.printStackTrace()
106	}
107	}
108	}
109	```
110
111	Weitere Informationen zu Suspend-Funktionen finden Sie [hier](https://kotlinlang.org/docs/composing-suspending-functions.html).
112
113
114	## Einrichtung der Watch-App
115
116	Hierfür benötigen Sie ein Wear OS-Gerät, das mit Ihrem Telefon und per Wireless-Debugging mit Ihrem PC verbunden ist. Sie haben kein Wear OS-Gerät? Kein Problem! Erstellen Sie einen neuen Emulator und führen Sie ihn gemäß den Einrichtungsanweisungen aus. Im Gegensatz zum Apple Watch-Simulator wird er mit Ihrem physischen Telefon oder Emulator verbunden.
117
118	### Erstellen des Watch-Projekt
119
120	1. Gehen Sie zu `Android Studio > File > New > New Project > Wear OS > Empty Wear App`
121	2. Behalten Sie die Bundle-ID bei, die mit der Ihrer Telefon-App identisch ist.
122	3. Verbinden Sie ein Wear OS-Gerät oder erstellen Sie einen Emulator.
123
124	### Hinzufügen von Berechtigungen
125
126	Genau wie bei der Telefon-App müssen wir einen Listener binden und Berechtigungen hinzufügen. Fügen Sie dem Block `manifest` in `AndroidManifest.xml` Folgendes hinzu:
127
128	```xml
129	<uses-permission android:name
130	```
131
132	### Erstellen des Nachrichtenempfänger
133
134	Erstellen Sie `MessageListenerService.kt`:
135
136	```kotlin
137
138	class MessageListenerService : WearableListenerService
139	override fun onMessageReceived(event:
140	super.onMessageReceived(event)
141	when (event.path) {
142	"/boot" -> {
143	val intent = Intent(this
144	addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
145	}
146	startActivity(intent)
147	}
148	}
149	}
150	}
151	```
152
153	### Registrieren des Dienstes
154
155	Fügen Sie dem Block `application` in `AndroidManifest.xml` hinzu:
156
157	```xml
158	<service
159	android:name="
160	android:exported="
161	<intent-filter>
162	<action android:name
163	<data
164	android:host="
165	android:pathPattern=
166	android:scheme="
167	</intent-filter>
168	</service>
169	```
170
171	### Nachrichtensendefunktion
172
173	Fügen Sie den folgenden Code in `MainActivity.kt` hinzu:
174
175	```kotlin
176	private suspend fun sendMessageToPhone
177	val connectedNodes = Wearable.getNodeClient(this
178
179	for (node in connectedNodes) {
180	try {
181	messageClient.sendMessage(node.id, path, data).await
182	} catch (e: Exception) {
183	println("Failed to send message to node ${node.id}:
184	}
185	}
186	}
187	```
188
189	## Abschließende Anmerkungen
190
191	- Nachrichten zwischen Geräten werden in `ByteArray`-Format übertragen - denken Sie daran, Daten im Sender-Gerät zu kodieren und im Empfänger-Gerät zu dekodieren
192	- Für plattformübergreifende Frameworks können Sie `sendMessageToWatch` mit [MethodChannel
193	- Der Name der Dienste muss mit dem in `AndroidManifest.xml` angegebenen Namen übereinstimmen