Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Wi-Fi Direct (Peer-to-Peer oder P2P)

Mit Wi-Fi Direct (P2P) können Geräte mit der entsprechenden Hardware direkt über WLAN miteinander verbunden werden, ohne dass ein Zwischenzugriffspunkt erforderlich ist. Mit diesen APIs kannst du andere Geräte finden und dich mit ihnen verbinden, wenn jedes Gerät Wi-Fi P2P unterstützt. Anschließend kannst du über eine schnelle Verbindung über Entfernungen kommunizieren, die viel größer sind als bei einer Bluetooth-Verbindung. Dies ist nützlich für Anwendungen, die Daten zwischen Nutzern teilen, z. B. ein Mehrspieler-Spiel oder eine Anwendung zum Teilen von Fotos.

Die Wi-Fi P2P APIs bestehen aus den folgenden Hauptteilen:

Methoden, mit denen Sie Peers finden, anfordern und eine Verbindung zu ihnen herstellen können, die in der Klasse WifiP2pManager definiert sind.
Listener, die Sie über den Erfolg oder das Fehlschlagen von WifiP2pManager-Methodenaufrufen informieren. Beim Aufrufen von WifiP2pManager-Methoden kann jede Methode einen bestimmten Listener als Parameter erhalten.
Intents, die Sie über bestimmte Ereignisse benachrichtigen, die vom Wi-Fi P2P-Framework erkannt werden, z. B. eine unterbrochene Verbindung oder ein neu entdeckter Peer.

Diese drei Hauptkomponenten der APIs werden häufig zusammen verwendet. Sie können beispielsweise einen WifiP2pManager.ActionListener für einen Aufruf von discoverPeers() angeben, damit Sie von den Methoden ActionListener.onSuccess() und ActionListener.onFailure() benachrichtigt werden können. Ein WIFI_P2P_PEERS_CHANGED_ACTION-Intent wird auch gesendet, wenn die Methode discoverPeers() feststellt, dass sich die Liste der Peers geändert hat.

API-Übersicht

Die Klasse WifiP2pManager bietet Methoden, mit denen du mit der WLAN-Hardware auf deinem Gerät interagieren kannst, um beispielsweise andere Geräte zu finden und dich mit ihnen zu verbinden. Folgende Aktionen sind möglich:

Tabelle 1. WLAN-P2P-Methoden

Methode	Beschreibung
`initialize()`	Registriert die Anwendung beim WLAN-Framework. Rufen Sie diese Methode auf, bevor Sie eine andere Wi-Fi P2P-Methode aufrufen.
`connect()`	Startet eine Peer-to-Peer-Verbindung mit einem Gerät mit der angegebenen Konfiguration.
`cancelConnect()`	Bricht alle laufenden Peer-to-Peer-Gruppenverhandlungen ab.
`requestConnectInfo()`	Fordert die Verbindungsinformationen eines Geräts an.
`createGroup()`	Erstellt eine Peer-to-Peer-Gruppe mit dem aktuellen Gerät als Gruppeninhaber.
`removeGroup()`	Entfernt die aktuelle Peer-to-Peer-Gruppe.
`requestGroupInfo()`	Fordert Informationen zur Peer-to-Peer-Gruppe an.
`discoverPeers()`	Initiiert die Peer-Erkennung.
`requestPeers()`	Fordert die aktuelle Liste der erkannten Peers an.

Mit WifiP2pManager-Methoden kannst du einen Listener übergeben, damit das Wi-Fi P2P-Framework deine Aktivität über den Status eines Aufrufs benachrichtigen kann. Die verfügbaren Listener-Schnittstellen und die entsprechenden WifiP2pManager-Methodenaufrufe, die die Listener verwenden, sind in Tabelle 2 beschrieben.

Tabelle 2. Wi-Fi-P2P-Listener

Listener-Schnittstelle	Verknüpfte Aktionen
`WifiP2pManager.ActionListener`	`connect()`, `cancelConnect()`, `createGroup()`, `removeGroup()` und `discoverPeers()`
`WifiP2pManager.ChannelListener`	`initialize()`
`WifiP2pManager.ConnectionInfoListener`	`requestConnectInfo()`
`WifiP2pManager.GroupInfoListener`	`requestGroupInfo()`
`WifiP2pManager.PeerListListener`	`requestPeers()`

Die Wi-Fi P2P APIs definieren Intents, die übertragen werden, wenn bestimmte Wi-Fi P2P-Ereignisse auftreten, z. B. wenn ein neuer Peer erkannt wird oder sich der WLAN-Status eines Geräts ändert. Du kannst dich für den Empfang dieser Intents in deiner Anwendung registrieren, indem du einen Übertragungsempfänger erstellst, der diese Intents verarbeitet:

Tabelle 3 Wi-Fi P2P Intents

Intent	Beschreibung
`WIFI_P2P_CONNECTION_CHANGED_ACTION`	Wird gesendet, wenn sich der Status der WLAN-Verbindung des Geräts ändert.
`WIFI_P2P_PEERS_CHANGED_ACTION`	Übertragen, wenn Sie `discoverPeers()` aufrufen. In der Regel rufen Sie `requestPeers()` auf, um eine aktualisierte Liste der Peers zu erhalten, wenn Sie diesen Intent in Ihrer Anwendung verarbeiten.
`WIFI_P2P_STATE_CHANGED_ACTION`	Broadcast, wenn Wi-Fi P2P auf dem Gerät aktiviert oder deaktiviert wird.
`WIFI_P2P_THIS_DEVICE_CHANGED_ACTION`	Wird gesendet, wenn sich die Details eines Geräts geändert haben, z. B. der Name des Geräts.

Übertragungsempfänger für Wi-Fi P2P-Intents erstellen

Mit einem Übertragungsempfänger können Sie Intents empfangen, die vom Android-System übertragen werden, sodass Ihre Anwendung auf Ereignisse reagieren kann, die für Sie relevant sind. Die grundlegenden Schritte zum Erstellen eines Übertragungsempfängers für die Verarbeitung von Wi-Fi P2P-Intents sind:

Erstellen Sie eine Klasse, die die Klasse BroadcastReceiver erweitert. Für den Konstruktor der Klasse verwenden Sie Parameter für WifiP2pManager, WifiP2pManager.Channel und die Aktivität, in der dieser Übertragungsempfänger registriert wird. So kann der Übertragungsempfänger Updates an die Aktivität senden und bei Bedarf auf die WLAN-Hardware und einen Kommunikationskanal zugreifen.
Prüfe im Übertragungsempfänger in der Methode onReceive(), ob die gewünschten Intents vorhanden sind. Führen Sie je nach empfangenem Intent die erforderlichen Aktionen aus. Wenn der Übertragungsempfänger beispielsweise einen WIFI_P2P_PEERS_CHANGED_ACTION-Intent empfängt, können Sie die Methode requestPeers() aufrufen, um eine Liste der aktuell erkannten Peers abzurufen.

Der folgende Code zeigt, wie Sie einen typischen Übertragungsempfänger erstellen. Der Übertragungsempfänger verwendet ein WifiP2pManager-Objekt und eine Aktivität als Argumente und nutzt diese beiden Klassen, um die erforderlichen Aktionen auszuführen, wenn der Übertragungsempfänger einen Intent empfängt:

Kotlin

/**
* 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 Wi-Fi state changing
           }
       }
   }
}

Java

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

   private WifiP2pManager manager;
   private Channel channel;
   private MyWiFiActivity activity;

   public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
           MyWifiActivity activity) {
       super();
       this.manager = manager;
       this.channel = channel;
       this.activity = 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 Wi-Fi state changing
       }
   }
}

Auf Geräten mit Android 10 und höher sind die folgenden Broadcast-Intents nicht-sticky:

WIFI_P2P_CONNECTION_CHANGED_ACTION: Anwendungen können requestConnectionInfo(), requestNetworkInfo() oder requestGroupInfo() verwenden, um die aktuellen Verbindungsinformationen abzurufen.
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: Anwendungen können requestDeviceInfo() verwenden, um die aktuellen Verbindungsinformationen abzurufen.

Wi-Fi P2P-Anwendung erstellen

Wenn Sie eine Wi-Fi P2P-Anwendung erstellen möchten, müssen Sie einen Übertragungsempfänger für Ihre Anwendung erstellen und registrieren, Peers finden, eine Verbindung zu einem Peer herstellen und Daten an einen Peer übertragen. In den folgenden Abschnitten wird beschrieben, wie Sie dabei vorgehen.

Ersteinrichtung

Bevor Sie die Wi-Fi P2P APIs verwenden, müssen Sie sicherstellen, dass Ihre Anwendung auf die Hardware zugreifen kann und dass das Gerät das Wi-Fi P2P-Protokoll unterstützt. Wenn Wi-Fi P2P unterstützt wird, können Sie eine Instanz von WifiP2pManager abrufen, Ihren Broadcast-Empfänger erstellen und registrieren und die Wi-Fi P2P APIs verwenden.

Fordern Sie die Berechtigung zur Verwendung der WLAN-Hardware auf dem Gerät an und deklarieren Sie im Android-Manifest, dass Ihre Anwendung die richtige SDK-Mindestversion hat:

<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.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!-- 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: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 sein:

Prüfen Sie, ob Wi-Fi P2P aktiviert ist und unterstützt wird. Eine gute Stelle, um dies zu prüfen, ist der Übertragungsempfänger, wenn er den Intent WIFI_P2P_STATE_CHANGED_ACTION empfängt. Benachrichtigen Sie Ihre Aktivität über den Wi-Fi P2P-Status und reagieren Sie entsprechend:

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 -> {
               // Wi-Fi 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) {
       // Wi-Fi P2P is enabled
   } else {
       // Wi-Fi P2P is not enabled
   }
}
...
}

Rufen Sie in der Methode onCreate() Ihrer Aktivität eine Instanz von WifiP2pManager ab und registrieren Sie Ihre Anwendung beim Wi-Fi P2P-Framework, indem Sie initialize() aufrufen. Diese Methode gibt einen WifiP2pManager.Channel zurück, der verwendet wird, um deine Anwendung mit dem Wi-Fi P2P-Framework zu verbinden. Außerdem sollten Sie eine Instanz Ihres Übertragungsempfängers mit den Objekten WifiP2pManager und WifiP2pManager.Channel sowie einen Verweis auf Ihre Aktivität erstellen. Mit dieser Konfiguration kann der Übertragungsempfänger die Aktivität über interessante Ereignisse benachrichtigen und sie entsprechend aktualisieren. Außerdem können Sie bei Bedarf den WLAN-Status des Geräts ändern:

Kotlin

val manager: WifiP2pManager? by lazy(LazyThreadSafetyMode.NONE) {
   getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager?
}

var channel: WifiP2pManager.Channel? = null
var receiver: BroadcastReceiver? = null

override fun onCreate(savedInstanceState: Bundle?) {
   ...

   channel = manager?.initialize(this, mainLooper, null)
   channel?.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, channel, this);
   ...
}

Erstelle einen Intent-Filter und füge dieselben Intents hinzu, die dein Übertragungsempfänger prüft:

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);
   ...
}

Registrieren Sie den Übertragungsempfänger in der Methode onResume() Ihrer Aktivität und melden Sie ihn in der Methode onPause() Ihrer Aktivität ab:

Kotlin

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

/* unregister the broadcast receiver */
override fun onPause() {
   super.onPause()
   receiver?.also { receiver ->
       unregisterReceiver(receiver)
   }
}

Java

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

Wenn du einen WifiP2pManager.Channel erhalten und einen Übertragungsempfänger eingerichtet hast, kann deine Anwendung Wi-Fi P2P-Methodenaufrufe ausführen und Wi-Fi P2P-Intents empfangen.
Implementiere deine Anwendung mit den Wi-Fi P2P-Funktionen, indem du die Methoden in WifiP2pManager aufrufst.

In den folgenden Abschnitten wird beschrieben, wie Sie gängige Aktionen ausführen, z. B. Peers finden und eine Verbindung zu ihnen herstellen.

Peers entdecken

Rufen Sie discoverPeers() auf, um verfügbare Peers zu erkennen, die sich in Reichweite befinden und für eine Verbindung verfügbar sind. Der Aufruf dieser Funktion ist asynchron. Der Erfolg oder Misserfolg wird Ihrer Anwendung mit onSuccess() und onFailure() mitgeteilt, wenn Sie ein WifiP2pManager.ActionListener erstellt haben. Die Methode onSuccess() benachrichtigt Sie nur darüber, dass der Erkennungsprozess erfolgreich war. Sie liefert keine Informationen zu den tatsächlich erkannten Peers, falls vorhanden. Das folgende Codebeispiel zeigt, wie Sie dies einrichten.

Kotlin

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

   override fun onSuccess() {
       ...
   }

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

Java

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

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

Wenn der Erkennungsprozess erfolgreich ist und Peers erkannt werden, sendet das System den Intent WIFI_P2P_PEERS_CHANGED_ACTION, den Sie in einem Übertragungsempfänger abhören können, um eine Liste der Peers zu erhalten. Wenn Ihre Anwendung den Intent WIFI_P2P_PEERS_CHANGED_ACTION empfängt, können Sie mit requestPeers() eine Liste der gefundenen Peers anfordern. Der folgende Code zeigt, wie Sie dies einrichten.

Kotlin

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
           }
       }
       ...
   }
}

Java

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

   // request available peers from the Wi-Fi 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);
   }
}

Die Methode requestPeers() ist ebenfalls asynchron und kann deine Aktivität mit onPeersAvailable() benachrichtigen, wenn eine Liste von Peers verfügbar ist. Dies wird in der Schnittstelle WifiP2pManager.PeerListListener definiert. Die Methode onPeersAvailable() stellt ein WifiP2pDeviceList bereit, das Sie durchlaufen können, um den Peer zu finden, mit dem Sie eine Verbindung herstellen möchten.

Verbindung zu Peers herstellen

Nachdem du eine Liste möglicher Peers erhalten und ein Gerät ausgewählt hast, mit dem du eine Verbindung herstellen möchtest, rufe die Methode connect() auf, um eine Verbindung zum Gerät herzustellen. Für diesen Methodenaufruf ist ein WifiP2pConfig-Objekt erforderlich, das Informationen zum Gerät enthält, mit dem eine Verbindung hergestellt werden soll. WifiP2pManager.ActionListener kann Sie über den Erfolg oder das Fehlschlagen einer Verbindung informieren. Der folgende Code zeigt, wie Sie eine Verbindung zu einem Gerät herstellen.

Kotlin

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

       override fun onSuccess() {
           //success logic
       }

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

Java

//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
   }
});

Daten übertragen

Nachdem eine Verbindung hergestellt wurde, können Sie Daten zwischen den Geräten mit Sockets übertragen. Die grundlegenden Schritte der Datenübertragung sind:

Erstellen Sie einen ServerSocket. Dieser Socket wartet auf eine Verbindung von einem Client an einem bestimmten Port und blockiert, bis dies geschieht. Führe dies also in einem Hintergrundthread aus.
Erstellen Sie einen Client Socket. Der Client verwendet die IP-Adresse und den Port des Server-Sockets, um eine Verbindung zum Servergerät herzustellen.
Daten vom Client an den Server senden Wenn der Client-Socket erfolgreich eine Verbindung zum Server-Socket herstellt, können Sie Daten vom Client über Byte-Streams an den Server senden.
Der Server-Socket wartet auf eine Clientverbindung (mit der Methode accept()). Dieser Aufruf wird blockiert, bis ein Client eine Verbindung herstellt. Rufen Sie ihn daher in einem anderen Thread auf. Wenn eine Verbindung hergestellt wird, kann das Servergerät die Daten vom Client empfangen.

Das folgende Beispiel, das aus der Wi-Fi P2P-Demo stammt, zeigt, wie Sie diese Client-Server-Socket-Kommunikation erstellen und JPEG-Bilder von einem Client zu einem Server mit einem Dienst übertragen. Ein vollständiges Arbeitsbeispiel finden Sie in der Demo. Kompilieren Sie sie und führen Sie sie aus.

Kotlin

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)
       }
   }
}

Java

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);
       }
   }
}

Stellen Sie auf dem Client eine Verbindung zum Server-Socket mit einem Client-Socket her und übertragen Sie Daten. In diesem Beispiel wird eine JPEG-Datei im Dateisystem des Clientgeräts übertragen.

Kotlin

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()
   }
}

Java

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
           }
       }
   }
}

Wi-Fi Direct (Peer-to-Peer oder P2P) Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

API-Übersicht

Übertragungsempfänger für Wi-Fi P2P-Intents erstellen

Kotlin

Java

Wi-Fi P2P-Anwendung erstellen

Ersteinrichtung

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Peers entdecken

Kotlin

Java

Kotlin

Java

Verbindung zu Peers herstellen

Kotlin

Java

Daten übertragen

Kotlin

Java

Kotlin

Java

Wi-Fi Direct (Peer-to-Peer oder P2P)