La prima lezione di questo corso, Utilizzo di Network Service Discovery, ha mostrato come rilevare i servizi connessi a una rete locale. Tuttavia, l'utilizzo di Wi-Fi Direct (P2P) Service Discovery ti consente di rilevare i servizi dei dispositivi nelle vicinanze direttamente, senza doverti connettere a una rete. Puoi anche pubblicizzare i servizi in esecuzione sul tuo dispositivo. Queste funzionalità aiutano a comunicare tra le app, anche quando non sono disponibili hotspot o reti locali.
Questo insieme di API è simile alle API Network Service Discovery descritte in una lezione precedente, ma l'implementazione nel codice è molto diversa. Questa lezione mostra come scoprire i servizi disponibili da altri dispositivi utilizzando Wi-Fi Direct. Nella lezione si presume che tu abbia già familiarità con l'API Wi-Fi Direct.
Configurare il manifest
Per utilizzare il Wi-Fi P2P, aggiungi le autorizzazioni CHANGE_WIFI_STATE, ACCESS_WIFI_STATE, ACCESS_FINE_LOCATION e INTERNET al manifest. Se la tua app ha come target Android 13 (livello API 33) o versioni successive, aggiungi anche l'autorizzazione
NEARBY_WIFI_DEVICES
al file manifest. Anche se Wi-Fi Direct non richiede una connessione a internet, utilizza socket Java standard e il loro utilizzo in Android richiede le autorizzazioni richieste.
<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" />
...
Oltre alle autorizzazioni precedenti, è necessario attivare anche le API seguenti per attivare la modalità di geolocalizzazione:
Aggiungi un servizio locale
Se offri un servizio locale, devi registrarlo per il rilevamento dei servizi. Una volta registrato il servizio locale, il framework risponde automaticamente alle richieste di rilevamento dei servizi dei peer.
Per creare un servizio locale:
- Crea un oggetto
WifiP2pServiceInfo. - Inseriscilo con informazioni sul tuo servizio.
- Chiama
addLocalService()per registrare il servizio locale per il rilevamento dei servizi.
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
}
});
}
Scopri i servizi nelle vicinanze
Android utilizza metodi di callback per informare l'applicazione dei servizi disponibili, pertanto la prima cosa da fare è configurarli. Crea un WifiP2pManager.DnsSdTxtRecordListener per ascoltare
i record in arrivo. Facoltativamente, questo record può essere trasmesso da altri dispositivi. Quando ne ricevi uno, copia l'indirizzo del dispositivo e tutte le altre informazioni pertinenti che vuoi in una struttura di dati esterna al metodo attuale, in modo da potervi accedere in un secondo momento. L'esempio seguente presuppone che il record contenga un campo "buddyname", completato con l'identità dell'utente.
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"));
}
};
}
Per ottenere le informazioni sul servizio, crea un WifiP2pManager.DnsSdServiceResponseListener. In questo modo verranno ricevute la descrizione effettiva e le informazioni sulla connessione. Lo snippet di codice precedente ha implementato un oggetto Map per accoppiare l'indirizzo di un dispositivo al nome dell'amico. Il listener di risposte del servizio utilizza questa opzione per collegare il record DNS alle informazioni sul servizio corrispondente. Una volta implementati entrambi gli ascoltatori, aggiungili a WifiP2pManager utilizzando il metodo setDnsSdResponseListeners().
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);
...
}
Ora crea una richiesta di servizio e chiama addServiceRequest().
Questo metodo richiede anche un listener per segnalare l'esito positivo o negativo.
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
}
});
Infine, chiama discoverServices().
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(...)
...
}
});
Se tutto va bene, evviva, hai finito! In caso di problemi, ricorda che le chiamate asincrone che hai effettuato prendono come argomento un WifiP2pManager.ActionListener e questo ti fornisce callback che indicano l'esito positivo o negativo. Per diagnosticare i problemi, inserisci il codice di debug in onFailure(). Il codice di errore fornito dal metodo suggerisce il problema. Ecco i possibili valori di errore
e il loro significato
-
P2P_UNSUPPORTED - Wi-Fi Direct non è supportato sul dispositivo su cui è in esecuzione l'app.
-
BUSY - Il sistema è troppo occupato per elaborare la richiesta.
-
ERROR - L'operazione non è riuscita a causa di un errore interno.