Diese Seite wurde von der Cloud Translation API übersetzt.

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

Mit Wi‑Fi Direct (P2P) können Geräte mit der entsprechenden Hardware sich direkt über WLAN ohne Zwischenzugangspunkt miteinander verbinden. Mit diesen APIs können Sie andere Geräte erkennen und sich mit ihnen verbinden, wenn jedes Gerät Wi-Fi P2P unterstützt, dann über eine schnelle Verbindung und über Entfernungen, die wesentlich länger sind als Bluetooth-Verbindung. Dies ist nützlich für Anwendungen, die Daten zwischen z. B. ein Spiel im Mehrspielermodus oder eine App zum Teilen von Fotos.

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

Methoden, mit denen Sie Peers erkennen, anfordern und mit ihnen verbinden können. definiert in den Klasse WifiP2pManager.
Listener, mit denen Sie über Erfolg oder Misserfolg eines WifiP2pManager-Methodenaufrufe. Beim Aufrufen von WifiP2pManager-Methoden -Methode einen bestimmten Listener empfangen, der als Parameter übergeben wird.
Intents, die dich über bestimmte Ereignisse benachrichtigen, die vom WLAN-P2P erkannt wurden z. B. eine unterbrochene Verbindung oder einen neu erkannten Peer.

Diese drei Hauptkomponenten der APIs werden häufig zusammen verwendet. Für können Sie beispielsweise eine WifiP2pManager.ActionListener zu einem Anruf bei discoverPeers() damit ActionListener.onSuccess() und ActionListener.onFailure(). können Sie benachrichtigt werden. Ein WIFI_P2P_PEERS_CHANGED_ACTION-Intent wird auch gesendet, wenn die discoverPeers()-Methode feststellt, dass sich die Peer-Liste geändert hat.

API-Übersicht

Die Klasse WifiP2pManager bietet Methoden zur Interaktion mit dem WLAN-Hardware auf Ihrem Gerät, um ähnliche Geräte zu finden und sich mit ihnen zu verbinden Folgende Aktionen sind möglich:

Tabelle 1 WLAN-P2P-Methoden

Methode	Beschreibung
`initialize()`	Registriert die Anwendung im Wi-Fi-Framework. Anruf vor dem anderen WLAN-P2P-Methoden anrufen.
`connect()`	Startet eine Peer-to-Peer-Verbindung mit einem Gerät mit der angegebenen Konfiguration.
`cancelConnect()`	Bricht alle laufenden Verhandlungen mit Peer-to-Peer-Gruppen 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()`	Es werden Informationen zu Peer-to-Peer-Gruppen angefordert.
`discoverPeers()`	Initiiert die Peer-Erkennung.
`requestPeers()`	Fordert die aktuelle Liste der erkannten Peers an.

Mit WifiP2pManager-Methoden können Sie einen Listener übergeben, damit das Wi‑Fi P2P-Framework Ihre Aktivität über den Status eines Anrufs benachrichtigen kann. Die verfügbaren Listener-Oberflächen und die entsprechenden WifiP2pManager-Methodenaufrufe die die Listener verwenden, sind in Tabelle 2 beschrieben.

Tabelle 2: WLAN-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 z. B. wenn ein neuer Peer entdeckt wird oder die WLAN-Verbindung eines Geräts Statusänderungen. Sie können sich registrieren, um diese Intents in Ihrer Anwendung zu empfangen, indem Sie einen Broadcast-Empfänger erstellen, der diese Intents verarbeitet:

Tabelle 3 WLAN-P2P-Intents

Absicht	Beschreibung
`WIFI_P2P_CONNECTION_CHANGED_ACTION`	Nachricht an alle senden, wenn sich der Status der WLAN-Verbindung des Geräts ändert.
`WIFI_P2P_PEERS_CHANGED_ACTION`	Nachricht an alle, wenn du `discoverPeers()` anrufst. Wenn Sie diese Absicht in Ihrer Anwendung verarbeiten, rufen Sie in der Regel `requestPeers()` auf, um eine aktuelle Liste der Peers zu erhalten.
`WIFI_P2P_STATE_CHANGED_ACTION`	Nachricht an alle senden, wenn WLAN-P2P aktiviert oder deaktiviert ist
`WIFI_P2P_THIS_DEVICE_CHANGED_ACTION`	Nachricht an alle, wenn sich Gerätedetails geändert haben, z. B. der Name des Geräts.

Broadcast-Empfänger für WLAN-P2P-Intents erstellen

Mit einem Übertragungsempfänger können Sie Intents empfangen, die vom Android-Gerät übertragen werden. damit Ihre Anwendung auf Ereignisse reagieren kann, . Grundlegende Schritte zur Erstellung eines Übertragungsempfängers für WLAN-P2P Intents sind:

Erstellen Sie eine Klasse, die die Klasse BroadcastReceiver. Für den Konstruktor der Klasse verwenden Sie Parameter für die WifiP2pManager, WifiP2pManager.Channel und die Aktivität, in der dieser Broadcast-Empfänger registriert wird. Dadurch kann der Übertragungsempfänger Updates an die sowie Zugriff auf die WLAN-Hardware und den Kanal hinzu.
Prüfen Sie im Broadcast-Empfänger in der Methode onReceive(), ob die gewünschten Intents vorhanden sind. Führe je nach empfangenem Intent alle erforderlichen Aktionen aus. Wenn der Übertragungsempfänger eine WIFI_P2P_PEERS_CHANGED_ACTION-Intent können Sie den requestPeers() , um eine Liste der aktuell erkannten Peers abzurufen.

Der folgende Code zeigt, wie ein typischer Broadcast-Empfänger erstellt wird. Die Der Übertragungsempfänger verwendet ein WifiP2pManager-Objekt und eine Aktivität als Argumente. und verwendet diese beiden Klassen, um die erforderlichen Aktionen erhält der Übertragungsempfänger einen Intent:

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 wifi 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 wifi state changing
       }
   }
}

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

WIFI_P2P_CONNECTION_CHANGED_ACTION: Anwendungen dürfen requestConnectionInfo(), requestNetworkInfo(), oder requestGroupInfo(), um die aktuellen Verbindungsinformationen abzurufen.
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION: Anwendungen dürfen requestDeviceInfo() um die aktuellen Verbindungsinformationen abzurufen.

WLAN-P2P-Anwendung erstellen

Die Erstellung einer Wi-Fi-P2P-Anwendung beinhaltet die Erstellung und Registrierung einer Übertragung Empfänger für Ihre Anwendung, die Erkennung von Peers, das Herstellen einer Verbindung zu einem Peer und Daten an einen Peer übertragen. In den folgenden Abschnitten wird dies beschrieben.

Ersteinrichtung

Bevor Sie die Wi-Fi P2P APIs verwenden, müssen Sie sicherstellen, dass Ihre Anwendung auf die Hardware zugreifen und dass das Gerät das Wi-Fi-P2P-Protokoll unterstützt. Wenn WLAN P2P wird unterstützt. Sie können eine Instanz von WifiP2pManager abrufen, und registrieren Sie Ihren Übertragungsempfänger und beginnen Sie mit der Verwendung der Wi-Fi P2P APIs.

Fordern Sie die Berechtigung zur Verwendung der WLAN-Hardware auf dem Gerät an und erklären Sie in Ihrem 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" />

Neben den vorherigen Berechtigungen ist für die folgenden APIs auch die Standortermittlung erforderlich Zu aktivierender Modus:

Prüfen Sie, ob WLAN-P2P aktiviert und unterstützt wird. Sie können dies in Ihrem Broadcast-Empfänger prüfen, wenn er die WIFI_P2P_STATE_CHANGED_ACTION-Intent empfängt. Sie werden über den P2P-Status des WLANs informiert und können entsprechend reagieren:

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

In der onCreate() , rufen Sie eine WifiP2pManager-Instanz ab und registrieren Sie Ihre Anwendung mit dem Wi-Fi-P2P-Framework durch Aufrufen von initialize(). Diese Methode gibt eine WifiP2pManager.Channel zurück, die zum Verbinden Ihrer Anwendung mit dem Wi‑Fi P2P-Framework verwendet wird. Sie sollten auch eine Instanz Ihrer Übertragung erstellen. Empfänger mit den Objekten WifiP2pManager und WifiP2pManager.Channel in Bezug auf Ihre Aktivität. Dadurch kann der Übertragungsempfänger über interessante Ereignisse informieren und sie entsprechend aktualisieren. Außerdem ermöglicht es Ihnen, bei Bedarf den WLAN-Status des Geräts zu ä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);
   ...
}

Erstellen Sie einen Intent-Filter und fügen Sie dieselben Intents wie Ihr Übertragungsempfänger hinzu überprüft Folgendes:

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 onResume()-Methode Ihres und melden Sie sie im onPause()-Methode Ihres Aktivität:

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 Sie einen WifiP2pManager.Channel erhalten und einen Broadcast-Empfänger eingerichtet haben, kann Ihre Anwendung Wi‑Fi P2P-Methodenaufrufe starten und Wi‑Fi P2P-Intents empfangen.
Implementieren Sie Ihre Anwendung mit den WLAN-P2P-Funktionen, indem Sie die Methoden in WifiP2pManager aufrufen.

In den nächsten Abschnitten wird beschrieben, wie Sie gängige Aktionen wie das Entdecken und mit Gleichgesinnten vernetzen.

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 gefunden werden, sendet das System die WIFI_P2P_PEERS_CHANGED_ACTION-Intent, auf die Sie in einem Broadcast-Empfänger warten können, um eine Liste der Peers zu erhalten. Wenn Ihre Anwendung die WIFI_P2P_PEERS_CHANGED_ACTION haben, können Sie eine Liste der erkannten Peering mit requestPeers(). Im folgenden Code wird gezeigt, 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 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);
   }
}

Die requestPeers()-Methode ist auch asynchron und kann Sie über Ihre Aktivitäten benachrichtigen, wenn eine Liste von Peers mit onPeersAvailable() verfügbar ist, die in der WifiP2pManager.PeerListListener-Benutzeroberfläche definiert ist. Die Methode onPeersAvailable() gibt eine WifiP2pDeviceList zurück, die Sie durchlaufen können, um den Peer zu finden, mit dem Sie eine Verbindung herstellen möchten.

Kontakte knüpfen

Sobald Sie eine Liste der möglichen Peers erhalten und ein Gerät für die Verbindung ausgewählt haben Rufen Sie die Methode connect() auf, um eine Verbindung mit dem Gerät herzustellen. Dieser Methodenaufruf erfordert ein WifiP2pConfig Objekt, das Informationen über das Gerät enthält, zu dem eine Verbindung hergestellt werden soll. WifiP2pManager.ActionListener kann Sie über den Erfolg oder das Fehlschlagen einer Verbindung informieren. Der folgende Code zeigt, wie eine Verbindung zu einem Gerät hergestellt wird.

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

Sobald eine Verbindung hergestellt wurde, können Sie Daten über die Sockets zwischen den Geräten übertragen. Die grundlegenden Schritte zur Datenübertragung sind:

Erstellen Sie einen ServerSocket. Dieser Socket wartet auf eine Verbindung von einem Client an einem bestimmten Port und blockiert, bis also in einem Hintergrundthread.
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 ausgeführt wurde eine Verbindung zum Server-Socket herstellt, können Sie Daten vom Client an den mit Bytestreams.
Der Server-Socket wartet auf eine Client-Verbindung (mit dem accept()-Methode). Dieser Aufruf blockiert, bis ein Client eine Verbindung herstellt. Rufen Sie ihn daher in einem anderen Thread auf. Wenn ein Verbindung erfolgt, kann das Servergerät die Daten vom Client empfangen.

Das folgende Beispiel geändert vom Wi-Fi P2P Demo zeigt Ihnen, wie Sie diese Client-Server-Socket-Kommunikation und JPEG-Bilder von einem Client zu einem Server mit einem Dienst. Für eine vollständige Beispiel, kompiliere die Demo und führe 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 über einen Client-Socket her und übertragen Sie Daten. In diesem Beispiel wird eine JPEG-Datei in das 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)

API-Übersicht

Broadcast-Empfänger für WLAN-P2P-Intents erstellen

Kotlin

Java

WLAN-P2P-Anwendung erstellen

Ersteinrichtung

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

Ähnliche Apps finden

Kotlin

Java

Kotlin

Java

Kontakte knüpfen

Kotlin

Java

Daten übertragen

Kotlin

Java

Kotlin

Java