In der ersten Lektion dieses Kurses, Netzwerkdiensterkennung verwenden, wurde gezeigt, wie Sie Dienste finden, die mit einem lokalen Netzwerk verbunden sind. Mit Wi-Fi Direct (P2P) Service Discovery können Sie jedoch die Dienste von Geräten in der Nähe direkt erkennen, ohne mit einem Netzwerk verbunden zu sein. Sie können auch die auf Ihrem Gerät ausgeführten Dienste anbieten. Diese Funktionen helfen Ihnen bei der Kommunikation zwischen Anwendungen, auch wenn kein lokales Netzwerk oder kein lokaler Hotspot verfügbar ist.
Diese APIs haben einen ähnlichen Zweck wie die APIs zur Erkennung von Netzwerkdiensten, die in einer vorherigen Lektion beschrieben wurden. Die Implementierung im Code unterscheidet sich jedoch stark. In dieser Lektion erfahren Sie, wie Sie mit Wi-Fi Direct Dienste finden, die auf anderen Geräten verfügbar sind. In dieser Lektion wird davon ausgegangen, dass Sie mit der Wi-Fi Direct API vertraut sind.
Manifest einrichten
Fügen Sie Ihrem Manifest die Berechtigungen CHANGE_WIFI_STATE
, ACCESS_WIFI_STATE
, ACCESS_FINE_LOCATION
und INTERNET
hinzu, um WLAN-P2P zu verwenden. Wenn deine App auf Android 13 (API-Level 33) oder höher ausgerichtet ist, füge deinem Manifest auch die Berechtigung NEARBY_WIFI_DEVICES
hinzu. Für Wi-Fi Direct ist zwar keine Internetverbindung erforderlich, dafür werden aber standardmäßige Java-Sockets verwendet, und die Verwendung dieser in Android erfordert die angeforderten Berechtigungen.
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.android.nsdchat" ... <uses-permission android:required="true" android:name="android.permission.ACCESS_WIFI_STATE"/> <uses-permission android:required="true" android:name="android.permission.CHANGE_WIFI_STATE"/> <uses-permission android:required="true" android:name="android.permission.INTERNET"/> <!-- If your app targets Android 13 (API level 33) or higher, you must declare the NEARBY_WIFI_DEVICES permission. --> <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" <!-- If your app derives location information from Wi-Fi APIs, don't include the "usesPermissionFlags" attribute. --> android:usesPermissionFlags="neverForLocation" /> <uses-permission android:required="true" android:name="android.permission.ACCESS_FINE_LOCATION" <!-- If any feature in your app relies on precise location information, don't include the "maxSdkVersion" attribute. --> android:maxSdkVersion="32" /> ...
Zusätzlich zu den oben genannten Berechtigungen muss für die folgenden APIs auch der Standortmodus aktiviert werden:
Lokale Dienstleistung hinzufügen
Wenn Sie einen lokalen Dienst bereitstellen, müssen Sie ihn für die Diensterkennung registrieren. Sobald Ihr lokaler Dienst registriert ist, antwortet das Framework automatisch auf Diensterkennungsanfragen von Peers.
So erstellen Sie einen lokalen Dienst:
- Erstellen Sie ein
WifiP2pServiceInfo
-Objekt. - Geben Sie Informationen zu Ihrer Dienstleistung ein.
- Rufen Sie
addLocalService()
auf, um den lokalen Dienst für die Diensterkennung zu registrieren.
Kotlin
private fun startRegistration() { // Create a string map containing information about your service. val record: Map<String, String> = mapOf( "listenport" to SERVER_PORT.toString(), "buddyname" to "John Doe${(Math.random() * 1000).toInt()}", "available" to "visible" ) // Service information. Pass it an instance name, service type // _protocol._transportlayer , and the map containing // information other devices will want once they connect to this one. val serviceInfo = WifiP2pDnsSdServiceInfo.newInstance("_test", "_presence._tcp", record) // Add the local service, sending the service info, network channel, // and listener that will be used to indicate success or failure of // the request. manager.addLocalService(channel, serviceInfo, object : WifiP2pManager.ActionListener { override fun onSuccess() { // Command successful! Code isn't necessarily needed here, // Unless you want to update the UI or add logging statements. } override fun onFailure(arg0: Int) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY } }) }
Java
private void startRegistration() { // Create a string map containing information about your service. Map record = new HashMap(); record.put("listenport", String.valueOf(SERVER_PORT)); record.put("buddyname", "John Doe" + (int) (Math.random() * 1000)); record.put("available", "visible"); // Service information. Pass it an instance name, service type // _protocol._transportlayer , and the map containing // information other devices will want once they connect to this one. WifiP2pDnsSdServiceInfo serviceInfo = WifiP2pDnsSdServiceInfo.newInstance("_test", "_presence._tcp", record); // Add the local service, sending the service info, network channel, // and listener that will be used to indicate success or failure of // the request. manager.addLocalService(channel, serviceInfo, new ActionListener() { @Override public void onSuccess() { // Command successful! Code isn't necessarily needed here, // Unless you want to update the UI or add logging statements. } @Override public void onFailure(int arg0) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY } }); }
Dienstleistungen in der Nähe finden
Android verwendet Callback-Methoden, um Ihre App über verfügbare Dienste zu informieren. Daher müssen Sie diese zuerst einrichten. Erstellen Sie einen WifiP2pManager.DnsSdTxtRecordListener
, der auf eingehende Datensätze wartet. Dieser Eintrag kann optional von anderen Geräten übertragen werden. Wenn eine Person eingeht, kopieren Sie die Geräteadresse und alle anderen relevanten Informationen, die Sie benötigen, in eine Datenstruktur außerhalb der aktuellen Methode, damit Sie später darauf zugreifen können. Im folgenden Beispiel wird davon ausgegangen, dass der Eintrag das Feld „buddyname“ mit der Identität des Nutzers enthält.
Kotlin
private val buddies = mutableMapOf<String, String>() ... private fun discoverService() { /* Callback includes: * fullDomain: full domain name: e.g. "printer._ipp._tcp.local." * record: TXT record dta as a map of key/value pairs. * device: The device running the advertised service. */ val txtListener = DnsSdTxtRecordListener { fullDomain, record, device -> Log.d(TAG, "DnsSdTxtRecord available -$record") record["buddyname"]?.also { buddies[device.deviceAddress] = it } } }
Java
final HashMap<String, String> buddies = new HashMap<String, String>(); ... private void discoverService() { DnsSdTxtRecordListener txtListener = new DnsSdTxtRecordListener() { @Override /* Callback includes: * fullDomain: full domain name: e.g. "printer._ipp._tcp.local." * record: TXT record dta as a map of key/value pairs. * device: The device running the advertised service. */ public void onDnsSdTxtRecordAvailable( String fullDomain, Map record, WifiP2pDevice device) { Log.d(TAG, "DnsSdTxtRecord available -" + record.toString()); buddies.put(device.deviceAddress, record.get("buddyname")); } }; }
Erstellen Sie einen WifiP2pManager.DnsSdServiceResponseListener
, um die Dienstinformationen abzurufen. Diese empfängt die tatsächliche Beschreibung und Verbindungsinformationen. Im vorherigen Code-Snippet wurde ein Map
-Objekt zum Koppeln einer Geräteadresse mit dem Buddy-Namen implementiert. Der Dienstantwort-Listener verknüpft damit den DNS-Eintrag mit den entsprechenden Dienstinformationen. Sobald beide Listener implementiert sind, fügen Sie sie mit der Methode setDnsSdResponseListeners()
zu WifiP2pManager
hinzu.
Kotlin
private fun discoverService() { ... val servListener = DnsSdServiceResponseListener { instanceName, registrationType, resourceType -> // Update the device name with the human-friendly version from // the DnsTxtRecord, assuming one arrived. resourceType.deviceName = buddies[resourceType.deviceAddress] ?: resourceType.deviceName // Add to the custom adapter defined specifically for showing // wifi devices. val fragment = fragmentManager .findFragmentById(R.id.frag_peerlist) as WiFiDirectServicesList (fragment.listAdapter as WiFiDevicesAdapter).apply { add(resourceType) notifyDataSetChanged() } Log.d(TAG, "onBonjourServiceAvailable $instanceName") } manager.setDnsSdResponseListeners(channel, servListener, txtListener) ... }
Java
private void discoverService() { ... DnsSdServiceResponseListener servListener = new DnsSdServiceResponseListener() { @Override public void onDnsSdServiceAvailable(String instanceName, String registrationType, WifiP2pDevice resourceType) { // Update the device name with the human-friendly version from // the DnsTxtRecord, assuming one arrived. resourceType.deviceName = buddies .containsKey(resourceType.deviceAddress) ? buddies .get(resourceType.deviceAddress) : resourceType.deviceName; // Add to the custom adapter defined specifically for showing // wifi devices. WiFiDirectServicesList fragment = (WiFiDirectServicesList) getFragmentManager() .findFragmentById(R.id.frag_peerlist); WiFiDevicesAdapter adapter = ((WiFiDevicesAdapter) fragment .getListAdapter()); adapter.add(resourceType); adapter.notifyDataSetChanged(); Log.d(TAG, "onBonjourServiceAvailable " + instanceName); } }; manager.setDnsSdResponseListeners(channel, servListener, txtListener); ... }
Erstellen Sie jetzt eine Dienstanfrage und rufen Sie addServiceRequest()
auf.
Bei dieser Methode wird auch ein Listener benötigt, um den Erfolg oder Fehler zu melden.
Kotlin
serviceRequest = WifiP2pDnsSdServiceRequest.newInstance() manager.addServiceRequest( channel, serviceRequest, object : WifiP2pManager.ActionListener { override fun onSuccess() { // Success! } override fun onFailure(code: Int) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY } } )
Java
serviceRequest = WifiP2pDnsSdServiceRequest.newInstance(); manager.addServiceRequest(channel, serviceRequest, new ActionListener() { @Override public void onSuccess() { // Success! } @Override public void onFailure(int code) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY } });
Rufen Sie abschließend discoverServices()
auf.
Kotlin
manager.discoverServices( channel, object : WifiP2pManager.ActionListener { override fun onSuccess() { // Success! } override fun onFailure(code: Int) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY when (code) { WifiP2pManager.P2P_UNSUPPORTED -> { Log.d(TAG, "Wi-Fi Direct isn't supported on this device.") } } } } )
Java
manager.discoverServices(channel, new ActionListener() { @Override public void onSuccess() { // Success! } @Override public void onFailure(int code) { // Command failed. Check for P2P_UNSUPPORTED, ERROR, or BUSY if (code == WifiP2pManager.P2P_UNSUPPORTED) { Log.d(TAG, "Wi-Fi Direct isn't supported on this device."); else if(...) ... } });
Wenn alles gut läuft, haben Sie es geschafft! Wenn Probleme auftreten, denken Sie daran, dass die von Ihnen durchgeführten asynchronen Aufrufe ein WifiP2pManager.ActionListener
als Argument verwenden. Dadurch erhalten Sie Callbacks, die Erfolg oder Misserfolg anzeigen. Fügen Sie Debugging-Code in onFailure()
ein, um Probleme zu diagnostizieren. Der von der Methode bereitgestellte Fehlercode weist auf das Problem hin. Hier sind die möglichen Fehlerwerte
und ihre Bedeutung
-
P2P_UNSUPPORTED
- Wi-Fi Direct wird auf dem Gerät, auf dem die App läuft, nicht unterstützt.
-
BUSY
- Das System ist zu ausgelastet, um die Anfrage zu verarbeiten.
-
ERROR
- Der Vorgang ist aufgrund eines internen Fehlers fehlgeschlagen.