La primera lección de esta clase, Cómo usar el servicio de red Discovery, mostró cómo detectar servicios que están conectados a una red local. Sin embargo, El descubrimiento de servicios de Wi-Fi directo (P2P) te permite descubrir los servicios de dispositivos cercanos. directamente, sin conectarse a una red. También puedes publicitar servicios que se ejecuta en tu dispositivo. Estas funciones te ayudan a comunicarte entre apps, incluso cuando no hay una red local o un hotspot disponibles.
Si bien este conjunto de APIs tiene un propósito similar al de descubrimiento de servicios de red APIs descritas en una lección anterior, implementarlas en código es muy diferente. Esta lección te muestra cómo descubrir servicios disponibles desde otros dispositivos, a través de Wi-Fi directo. Se da por sentado que ya conoces la API de Wi-Fi directo.
Cómo configurar el manifiesto
Para usar Wi-Fi P2P, agrega CHANGE_WIFI_STATE, ACCESS_WIFI_STATE,
ACCESS_FINE_LOCATION,
y INTERNET
permisos a tu manifiesto. Si tu app se orienta a Android 13 (nivel de API 33) o versiones posteriores, también agrega el atributo
NEARBY_WIFI_DEVICES,
permiso en tu manifiesto. Aunque Wi-Fi Direct no requiere un
una conexión a Internet, usa sockets de Java estándar, y su uso en Android
requiere los permisos solicitados.
<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" />
...
Además de los permisos anteriores, las siguientes API también requieren que se habilite el Modo de ubicación:
Cómo agregar un servicio local
Si ofreces un servicio local, debes registrarlo en descubrimiento de servicios. Una vez que se registra tu servicio local, el framework responde automáticamente a las solicitudes de descubrimiento de servicios de intercambios de tráfico.
Para crear un servicio local, sigue estos pasos:
- Crea un
WifiP2pServiceInfo. - Llénalo con información sobre tu servicio.
- Llama a
addLocalService()para registrar la ubicación para el descubrimiento de servicios.
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
}
});
}
Cómo descubrir servicios cercanos
Android usa métodos de devolución de llamada para notificar a tu aplicación sobre los servicios disponibles, de modo que
lo primero que hay que hacer es configurarlos. Crea un WifiP2pManager.DnsSdTxtRecordListener para escuchar
registros entrantes. Este registro puede ser transmitido opcionalmente por otros
dispositivos. Cuando llegue uno, copia la dirección del dispositivo y cualquier otra
información relevante que desees en una estructura de datos externa a la
para poder acceder a ella más tarde. En el siguiente ejemplo, se supone que
el registro contiene un "nombredelbuddy" completado con la identidad del usuario.
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"));
}
};
}
Para obtener la información del servicio, crea un WifiP2pManager.DnsSdServiceResponseListener. Esta
recibe la descripción real y la información de conexión. El código anterior
el fragmento implementó un objeto Map para vincular la dirección de un dispositivo con el amigo.
de la fuente de datos. El objeto de escucha de respuestas del servicio lo usa para vincular el registro DNS con el
la información del servicio correspondiente. Cuando ambos
de objetos de escucha, agrégalos a WifiP2pManager con el método 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);
...
}
Ahora crea una solicitud de servicio y llama a addServiceRequest().
Este método también requiere que un objeto de escucha informe si la solicitud se realizó correctamente o no.
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
}
});
Por último, realiza la llamada a 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(...)
...
}
});
Si todo sale bien, ¡listo! Si tienes problemas, recuerda
que las llamadas asíncronas que realizaste toman un
WifiP2pManager.ActionListener como argumento
Esto te proporciona devoluciones de llamadas que indican el éxito o el fracaso. Para diagnosticar
problemas, coloca el código de depuración en onFailure(). El código de error
proporcionadas por las sugerencias del método sobre el problema. Estos son los posibles valores de error
y lo que significan
-
P2P_UNSUPPORTED - Wi-Fi directo no es compatible con el dispositivo en el que se ejecuta la app.
-
BUSY - El sistema está demasiado ocupado para procesar la solicitud.
-
ERROR - La operación falló debido a un error interno.