Visão geral do Wi-Fi Direct (ponto a ponto ou P2P)

O Wi-Fi Direct (P2P) permite que dispositivos Android 4.0 (API de nível 14) ou posterior, com o hardware apropriado, conectem-se diretamente via Wi-Fi sem um ponto de acesso intermediário. Usando essas APIs, você pode encontrar e se conectar a outros dispositivos compatíveis com o Wi-Fi P2P e depois se comunicar por meio de uma conexão rápida por distâncias muito mais longas que uma conexão Bluetooth. Isso é útil para aplicativos que compartilham dados entre usuários, como um jogo multijogador, ou para aplicativos de compartilhamento de fotos.

As APIs de Wi-Fi P2P são constituídas das seguintes partes principais:

• Os métodos que permitem descobrir, solicitar e conectar-se aos pontos são definidos na classe WifiP2pManager.

• Os listeners que permitem que você seja notificado sobre a conclusão ou a falha dos métodos de chamada WifiP2pManager. Ao chamar os métodos WifiP2pManager, cada um deles poderá receber um listener específico transmitido como um parâmetro.

• Os intents que notificam você sobre eventos específicos detectados pela biblioteca Wi-Fi P2P, como uma conexão interrompida ou um ponto recém-descoberto.

Normalmente, esses três componentes principais das APIs são usados juntos. Por exemplo, você pode fornecer WifiP2pManager.ActionListener para chamar discoverPeers(). Assim, você será notificado com os métodos ActionListener.onSuccess() e ActionListener.onFailure(). Um intent WIFI_P2P_PEERS_CHANGED_ACTION também será transmitido se o método discoverPeers() descobrir que a lista de pontos foi alterada.

Visão geral da API

A classe WifiP2pManager fornece métodos para permitir que você interaja com o hardware Wi-Fi do seu dispositivo e realize tarefas como encontrar e se conectar a pontos. As seguintes ações estão disponíveis:

Tabela 1.Métodos Wi-Fi P2P

Os métodosWifiP2pManager permitem que você transmita um listener para que a biblioteca Wi-Fi P2P possa notificar sua atividade sobre o status de uma chamada. As interfaces disponíveis do listener e as chamadas do método WifiP2pManager correspondentes que usam os listeners são descritas na tabela a seguir:

Tabela 2. Listeners Wi-Fi P2P

As APIs de Wi-Fi P2P definem intents transmitidos quando certos eventos de Wi-Fi P2P acontecem, como a descoberta de um novo ponto ou quando o estado do Wi-Fi de um dispositivo é alterado. Você pode fazer registro para receber esses intents no seu aplicativo criando um broadcast receiver que gerencia estes intents:

Tabela 3. Intents de Wi-Fi P2P

Criar um broadcast receiver para intents de Wi-Fi P2P

Um broadcast receiver permite que você receba intents transmitidos pelo sistema Android para que o aplicativo possa responder aos eventos do seu interesse. Siga estas etapas básicas para criar um broadcast receiver e gerenciar intents de Wi-Fi P2P:

1. Crie uma classe que estende BroadcastReceiver. No criador da classe, tenha os parâmetros para WifiP2pManager, WifiP2pManager.Channel e a atividade em que este broadcast receiver será registrado. Assim, o broadcast receiver enviará atualizações para a atividade e terá acesso ao hardware Wi-Fi e a um canal de comunicação, se necessário.

2. No broadcast receiver, verifique os intents em que você está interessado em onReceive(). Realize as ações necessárias, dependendo do intent recebido. Por exemplo, se o broadcast receiver receber um intent WIFI_P2P_PEERS_CHANGED_ACTION, você poderá chamar o método requestPeers() para ver uma lista de pontos descobertos recentemente.

O código a seguir mostra como criar um broadcast receiver típico. O broadcast receiver aciona um objeto WifiP2pManager e uma atividade como argumentos e usa essas duas classes para executar adequadamente as ações necessárias ao receber um intent:

/**
 * A BroadcastReceiver that notifies of important Wi-Fi p2p events.
 */
class WiFiDirectBroadcastReceiver(
        private val manager: WifiP2pManager,
        private val channel: WifiP2pManager.Channel,
        private val activity: MyWifiActivity
) : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        val action: String = intent.action
        when (action) {
            WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> {
                // Check to see if Wi-Fi is enabled and notify appropriate activity
            }
            WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {
                // Call WifiP2pManager.requestPeers() to get a list of current peers
            }
            WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> {
                // Respond to new connection or disconnections
            }
            WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION -> {
                // Respond to this device's wifi state changing
            }
        }
    }
}

/**
 * A BroadcastReceiver that notifies of important Wi-Fi p2p events.
 */
public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {

    private WifiP2pManager mManager;
    private Channel mChannel;
    private MyWiFiActivity mActivity;

    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
            MyWifiActivity activity) {
        super();
        this.mManager = manager;
        this.mChannel = channel;
        this.mActivity = activity;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();

        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
            // Check to see if Wi-Fi is enabled and notify appropriate activity
        } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
            // Call WifiP2pManager.requestPeers() to get a list of current peers
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
            // Respond to new connection or disconnections
        } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
            // Respond to this device's wifi state changing
        }
    }
}

Com o Android Q, os seguintes intents de transmissão foram alterados de fixos para não fixos:

WIFI_P2P_CONNECTION_CHANGED_ACTION

Os aplicativos podem usar requestConnectionInfo(), requestNetworkInfo() ou requestGroupInfo() para recuperar as informações de conexão atuais.

WIFI_P2P_THIS_DEVICE_CHANGED_ACTION

Os aplicativos podem usar requestDeviceInfo() para recuperar as informações de conexão atuais.

Criar um aplicativo Wi-Fi P2P

O desenvolvimento de um aplicativo Wi-Fi P2P envolve a criação e o registro de um broadcast receiver, a descoberta de pontos, além da conexão e transferência de dados para um ponto. As seções a seguir descrevem como fazer isso.

Configuração inicial

Antes de usar as APIs de Wi-Fi P2P, verifique se o aplicativo pode acessar o hardware e se o dispositivo é compatível com o protocolo Wi-Fi P2P. Se houver compatibilidade com Wi-Fi P2P, você poderá ter uma instância de WifiP2pManager, criar e fazer registro do seu broadcast receiver e começar a usar as APIs de Wi-Fi P2P.

1. Solicite permissão para usar o hardware Wi-Fi no dispositivo e também declare que seu aplicativo tem a versão mínima correta do SDK no manifest do Android:

   <uses-sdk android:minSdkVersion="14" />
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
   <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
   

   Além das permissões anteriores, as seguintes APIs também exigem que o Modo de localização esteja ativado:

   • discoverPeers
   • discoverServices
   • requestPeers

2. Verifique se o Wi-Fi P2P está ativado e é compatível. Um bom lugar para verificar isso é no seu broadcast receiver quando ele receber o intent WIFI_P2P_STATE_CHANGED_ACTION. Notifique sua atividade do estado do Wi-Fi P2P e defina as reações necessárias:

   Kotlin

   override fun onReceive(context: Context, intent: Intent) {
   ...
   val action: String = intent.action
   when (action) {
       WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> {
           val state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1)
           when (state) {
               WifiP2pManager.WIFI_P2P_STATE_ENABLED -> {
                   // Wifi P2P is enabled
               }
               else -> {
                   // Wi-Fi P2P is not enabled
               }
           }
       }
   }
   ...
   }
   

   Java

   @Override
   public void onReceive(Context context, Intent intent) {
   ...
   String action = intent.getAction();
   if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
       int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
       if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
           // Wifi P2P is enabled
       } else {
           // Wi-Fi P2P is not enabled
       }
   }
   ...
   }
   

3. No método da sua atividade onCreate(), acesse a instância WifiP2pManager e faça registro do seu aplicativo com a biblioteca Wi-Fi P2P chamando initialize(). Esse método retornará WifiP2pManager.Channel, que é usado para conectar seu aplicativo à biblioteca Wi-Fi P2P. Você também deve criar uma instância do seu broadcast receiver com os objetos WifiP2pManager e WifiP2pManager.Channel junto com uma referência à sua atividade. Isso permite que o broadcast receiver notifique sua atividade de eventos interessantes e faça as atualizações correspondentes. Assim, também é possível gerenciar o estado do Wi-Fi do dispositivo, se necessário:

   Kotlin

   val manager: WifiP2pManager? by lazy(LazyThreadSafetyMode.NONE) {
       getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager?
   }
   
   var mChannel: WifiP2pManager.Channel? = null
   var receiver: BroadcastReceiver? = null
   
   override fun onCreate(savedInstanceState: Bundle?) {
       ...
   
       mChannel = manager?.initialize(this, mainLooper, null)
       mChannel?.also { channel ->
           receiver = WiFiDirectBroadcastReceiver(manager, channel, this)
       }
   
   }
   

   Java

   WifiP2pManager manager;
   Channel channel;
   BroadcastReceiver receiver;
   ...
   @Override
   protected void onCreate(Bundle savedInstanceState){
       ...
       manager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
       channel = manager.initialize(this, getMainLooper(), null);
       receiver = new WiFiDirectBroadcastReceiver(manager, mChannel, this);
       ...
   }
   

4. Crie um filtro e adicione os mesmos intents verificados pelo seu broadcast receiver:

   Kotlin

   val intentFilter = IntentFilter().apply {
       addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)
       addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION)
       addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)
       addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION)
   }
   

   Java

   IntentFilter intentFilter;
   ...
   @Override
   protected void onCreate(Bundle savedInstanceState){
       ...
       intentFilter = new IntentFilter();
       intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
       intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
       intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
       intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
       ...
   }
   

5. Faça registro do broadcast receiver no método onResume() da sua atividade e cancele o método onPause():

   Kotlin

   /* register the broadcast receiver with the intent values to be matched */
   override fun onResume() {
       super.onResume()
       mReceiver?.also { receiver ->
           registerReceiver(receiver, intentFilter)
       }
   }
   
   /* unregister the broadcast receiver */
   override fun onPause() {
       super.onPause()
       mReceiver?.also { receiver ->
           unregisterReceiver(receiver)
       }
   }
   

   Java

   /* register the broadcast receiver with the intent values to be matched */
   @Override
   protected void onResume() {
       super.onResume();
       registerReceiver(mReceiver, intentFilter);
   }
   /* unregister the broadcast receiver */
   @Override
   protected void onPause() {
       super.onPause();
       unregisterReceiver(mReceiver);
   }
   

   Quando você tiver WifiP2pManager.Channel e configurar um broadcast receiver, seu aplicativo poderá fazer chamadas de método Wi-Fi P2P e receber os intents relacionados.

   Agora você pode implementar seu aplicativo e usar os recursos Wi-Fi P2P chamando os métodos em WifiP2pManager. As próximas seções descrevem como executar ações comuns, como encontrar e se conectar a pontos.

Descobrir pontos

Para descobrir pontos disponíveis para conexão, chame discoverPeers() para detectá-los. A chamada para esta função é assíncrona e uma conclusão ou falha é comunicada ao seu aplicativo com onSuccess() e onFailure() se você tiver criado um WifiP2pManager.ActionListener. O método onSuccess() só avisará que o processo de descoberta foi bem-sucedido e não fornecerá nenhuma informação sobre os pontos encontrados:

manager?.discoverPeers(channel, object : WifiP2pManager.ActionListener {

    override fun onSuccess() {
        ...
    }

    override fun onFailure(reasonCode: Int) {
        ...
    }
})

manager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
    @Override
    public void onSuccess() {
        ...
    }

    @Override
    public void onFailure(int reasonCode) {
        ...
    }
});

Se o processo de descoberta for bem-sucedido e detectar novos pontos, o sistema transmitirá o intent WIFI_P2P_PEERS_CHANGED_ACTION, que você poderá interceptar em um broadcast receiver para acessar uma lista de pontos. Quando um aplicativo recebe o intent WIFI_P2P_PEERS_CHANGED_ACTION, você pode solicitar uma lista dos pontos descobertos com requestPeers(). O código a seguir mostra como configurar isso:

override fun onReceive(context: Context, intent: Intent) {
    val action: String = intent.action
    when (action) {
        ...
        WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> {
            manager?.requestPeers(channel) { peers: WifiP2pDeviceList? ->
                // Handle peers list
            }
        }
        ...
    }
}

PeerListListener myPeerListListener;
...
if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {

    // request available peers from the wifi p2p manager. This is an
    // asynchronous call and the calling activity is notified with a
    // callback on PeerListListener.onPeersAvailable()
    if (manager != null) {
        manager.requestPeers(channel, myPeerListListener);
    }
}

O método requestPeers() também é assíncrono e pode notificar sua atividade quando uma lista de pontos estiver disponível usando onPeersAvailable(), que é definido na interface WifiP2pManager.PeerListListener. O método onPeersAvailable() fornece uma WifiP2pDeviceList, que você pode analisar para encontrar o ponto usado para conexão.

Conectar pontos

Ao encontrar o dispositivo com que você quer fazer a conexão após acessar uma lista de possíveis pontos, chame o método connect(). Esse método exige um objeto WifiP2pConfig, que tem informações do dispositivo para conexão. Você pode ser notificado sobre um sucesso ou falha na conexão por meio do WifiP2pManager.ActionListener. O código a seguir mostra como criar uma conexão com um dispositivo:

val device: WifiP2pDevice = ...
val config = WifiP2pConfig()
config.deviceAddress = device.deviceAddress
mChannel?.also { channel ->
    manager?.connect(channel, config, object : WifiP2pManager.ActionListener {

        override fun onSuccess() {
            //success logic
        }

        override fun onFailure(reason: Int) {
            //failure logic
        }
}
})

//obtain a peer from the WifiP2pDeviceList
WifiP2pDevice device;
WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = device.deviceAddress;
manager.connect(channel, config, new ActionListener() {

    @Override
    public void onSuccess() {
        //success logic
    }

    @Override
    public void onFailure(int reason) {
        //failure logic
    }
});

Transferir dados

Depois que uma conexão é estabelecida, você pode transferir dados entre os dispositivos com soquetes. Veja as etapas básicas da transferência de dados:

1. Crie um ServerSocket. Esse soquete aguarda uma conexão de um cliente em uma porta especificada e a bloqueia até que isso aconteça. Por isso, realize essa ação em um thread em segundo plano.

2. Crie um cliente Socket. O cliente usa o endereço IP e a porta do soquete do servidor para se conectar ao dispositivo do servidor.

3. Envie os dados do cliente para o servidor. Quando o soquete do cliente estiver conectado ao do servidor, você poderá enviar dados do cliente para o servidor com streams de bytes.

4. O soquete do servidor aguarda uma conexão do cliente com o método accept(). Essa chamada é bloqueada até que um cliente se conecte. Por isso, faça essa chamada de outro thread. Quando uma conexão acontecer, o dispositivo do servidor poderá receber os dados do cliente. Realize qualquer ação com esses dados, como salvá-los em um arquivo ou apresentá-los ao usuário.

O exemplo a seguir, uma atualização da amostra Demonstração de Wi-Fi P2P, mostra como criar essa comunicação de soquete cliente-servidor e transferir imagens JPEG de um cliente para um servidor com um serviço. Para um exemplo completo, compile e execute a amostra Demonstração de Wi-Fi P2P.

class FileServerAsyncTask(
        private val context: Context,
        private var statusText: TextView
) : AsyncTask<Void, Void, String?>() {

    override fun doInBackground(vararg params: Void): String? {
        /**
         * Create a server socket.
         */
        val serverSocket = ServerSocket(8888)
        return serverSocket.use {
            /**
             * Wait for client connections. This call blocks until a
             * connection is accepted from a client.
             */
            val client = serverSocket.accept()
            /**
             * If this code is reached, a client has connected and transferred data
             * Save the input stream from the client as a JPEG file
             */
            val f = File(Environment.getExternalStorageDirectory().absolutePath +
                    "/${context.packageName}/wifip2pshared-${System.currentTimeMillis()}.jpg")
            val dirs = File(f.parent)

            dirs.takeIf { it.doesNotExist() }?.apply {
                mkdirs()
            }
            f.createNewFile()
            val inputstream = client.getInputStream()
            copyFile(inputstream, FileOutputStream(f))
            serverSocket.close()
            f.absolutePath
        }
    }

    private fun File.doesNotExist(): Boolean = !exists()

    /**
     * Start activity that can handle the JPEG image
     */
    override fun onPostExecute(result: String?) {
        result?.run {
            statusText.text = "File copied - $result"
            val intent = Intent(android.content.Intent.ACTION_VIEW).apply {
                setDataAndType(Uri.parse("file://$result"), "image/*")
            }
            context.startActivity(intent)
        }
    }
}

public static class FileServerAsyncTask extends AsyncTask {

    private Context context;
    private TextView statusText;

    public FileServerAsyncTask(Context context, View statusText) {
        this.context = context;
        this.statusText = (TextView) statusText;
    }

    @Override
    protected String doInBackground(Void... params) {
        try {

            /**
             * Create a server socket and wait for client connections. This
             * call blocks until a connection is accepted from a client
             */
            ServerSocket serverSocket = new ServerSocket(8888);
            Socket client = serverSocket.accept();

            /**
             * If this code is reached, a client has connected and transferred data
             * Save the input stream from the client as a JPEG file
             */
            final File f = new File(Environment.getExternalStorageDirectory() + "/"
                    + context.getPackageName() + "/wifip2pshared-" + System.currentTimeMillis()
                    + ".jpg");

            File dirs = new File(f.getParent());
            if (!dirs.exists())
                dirs.mkdirs();
            f.createNewFile();
            InputStream inputstream = client.getInputStream();
            copyFile(inputstream, new FileOutputStream(f));
            serverSocket.close();
            return f.getAbsolutePath();
        } catch (IOException e) {
            Log.e(WiFiDirectActivity.TAG, e.getMessage());
            return null;
        }
    }

    /**
     * Start activity that can handle the JPEG image
     */
    @Override
    protected void onPostExecute(String result) {
        if (result != null) {
            statusText.setText("File copied - " + result);
            Intent intent = new Intent();
            intent.setAction(android.content.Intent.ACTION_VIEW);
            intent.setDataAndType(Uri.parse("file://" + result), "image/*");
            context.startActivity(intent);
        }
    }
}

No cliente, conecte-se ao soquete do servidor com um soquete do cliente e transfira os dados. Este exemplo mostra como transferir um arquivo JPEG no sistema de arquivos do dispositivo cliente.

val context = applicationContext
val host: String
val port: Int
val len: Int
val socket = Socket()
val buf = ByteArray(1024)
...
try {
    /**
     * Create a client socket with the host,
     * port, and timeout information.
     */
    socket.bind(null)
    socket.connect((InetSocketAddress(host, port)), 500)

    /**
     * Create a byte stream from a JPEG file and pipe it to the output stream
     * of the socket. This data is retrieved by the server device.
     */
    val outputStream = socket.getOutputStream()
    val cr = context.contentResolver
    val inputStream: InputStream = cr.openInputStream(Uri.parse("path/to/picture.jpg"))
    while (inputStream.read(buf).also { len = it } != -1) {
        outputStream.write(buf, 0, len)
    }
    outputStream.close()
    inputStream.close()
} catch (e: FileNotFoundException) {
    //catch logic
} catch (e: IOException) {
    //catch logic
} finally {
    /**
     * Clean up any open sockets when done
     * transferring or if an exception occurred.
     */
    socket.takeIf { it.isConnected }?.apply {
        close()
    }
}

Context context = this.getApplicationContext();
String host;
int port;
int len;
Socket socket = new Socket();
byte buf[]  = new byte[1024];
...
try {
    /**
     * Create a client socket with the host,
     * port, and timeout information.
     */
    socket.bind(null);
    socket.connect((new InetSocketAddress(host, port)), 500);

    /**
     * Create a byte stream from a JPEG file and pipe it to the output stream
     * of the socket. This data is retrieved by the server device.
     */
    OutputStream outputStream = socket.getOutputStream();
    ContentResolver cr = context.getContentResolver();
    InputStream inputStream = null;
    inputStream = cr.openInputStream(Uri.parse("path/to/picture.jpg"));
    while ((len = inputStream.read(buf)) != -1) {
        outputStream.write(buf, 0, len);
    }
    outputStream.close();
    inputStream.close();
} catch (FileNotFoundException e) {
    //catch logic
} catch (IOException e) {
    //catch logic
}

/**
 * Clean up any open sockets when done
 * transferring or if an exception occurred.
 */
finally {
    if (socket != null) {
        if (socket.isConnected()) {
            try {
                socket.close();
            } catch (IOException e) {
                //catch logic
            }
        }
    }
}