Wi-Fi Direct (P2P) ermöglicht es Geräten mit der passenden Hardware, eine direkte Verbindung über WLAN ohne Zugangspunkt. Mit diesen APIs können Sie andere Geräte finden und eine Verbindung herstellen, wenn jedes Gerät Wi‑Fi P2P unterstützt. Anschließend können Sie über eine schnelle Verbindung über größere Entfernungen als bei einer Bluetooth-Verbindung kommunizieren. 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 den Erfolg oder das Fehlschlagen von
WifiP2pManager
-Methodenaufrufen informiert werden. Beim Aufrufen vonWifiP2pManager
-Methoden kann jeder Methode ein bestimmter Listener als Parameter übergeben werden. - Intents, die dich über bestimmte Ereignisse benachrichtigen, die vom WLAN-P2P erkannt wurden z. B. eine unterbrochene Verbindung oder einen neu erkannten Peer.
Häufig verwenden Sie diese drei Hauptkomponenten der APIs zusammen. Sie können beispielsweise einen Wert für WifiP2pManager.ActionListener
für einen Aufruf von discoverPeers()
angeben, damit Sie über die Methoden ActionListener.onSuccess()
und ActionListener.onFailure()
benachrichtigt werden. A
WIFI_P2P_PEERS_CHANGED_ACTION
Intent wird auch gesendet, wenn die Methode discoverPeers()
erkennt,
Die Liste der Peers hat sich geändert.
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 verfügbar:
Tabelle 1 WLAN-P2P-Methoden
Methode | Beschreibung |
initialize()
|
Registriert die Anwendung beim WLAN-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()
|
Hier werden die Verbindungsinformationen eines Geräts angefordert. |
createGroup()
|
Es wird eine Peer-to-Peer-Gruppe mit dem aktuellen Gerät als Gruppeninhaber erstellt. |
removeGroup()
|
Entfernt die aktuelle Peer-to-Peer-Gruppe. |
requestGroupInfo()
|
Fordert Peer-to-Peer-Gruppeninformationen an. |
discoverPeers()
|
Initiiert die Peer-Erkennung. |
requestPeers()
|
Fordert die aktuelle Liste der erkannten Peers an. |
WifiP2pManager
Methoden erlauben
Sie übergeben einen Zuhörer, damit das Wi-Fi-P2P-Framework Ihre Aktivitäten benachrichtigen kann.
zum Status eines Anrufs. Die verfügbaren Listener-Schnittstellen und die entsprechenden WifiP2pManager
-Methodenaufrufe, die die Listener verwenden, werden 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 gesendet 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. 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
Intent | 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 Broadcast-Empfänger können Sie vom Android-System gesendete Intents empfangen, damit Ihre Anwendung auf Ereignisse reagieren kann, die Sie interessieren. So erstellen Sie einen Broadcast-Empfänger zum Verarbeiten von Wi‑Fi P2P-Intents:
Erstellen Sie eine Klasse, die die Klasse
BroadcastReceiver
erweitert. Für den Kurs“ -Konstruktor verwenden, verwenden Sie Parameter fürWifiP2pManager
,WifiP2pManager.Channel
und die Aktivität, die dieser Übertragungsempfänger ausführt für die Sie sich registriert haben. 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ühren Sie je nach Intent alle erforderlichen Aktionen aus. erhalten haben. Wenn der Übertragungsempfänger eineWIFI_P2P_PEERS_CHANGED_ACTION
-Intent können Sie denrequestPeers()
, um eine Liste der aktuell erkannten Peers abzurufen.
Der folgende Code zeigt, wie Sie einen typischen Übertragungsempfänger erstellen. Der Broadcast-Empfänger nimmt ein WifiP2pManager
-Objekt und eine Aktivität als Argumente an und führt mithilfe dieser beiden Klassen die erforderlichen Aktionen aus, wenn der Broadcast-Empfänger eine 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 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 „sticky“:
WIFI_P2P_CONNECTION_CHANGED_ACTION
- Anwendungen können
requestConnectionInfo()
,requestNetworkInfo()
oderrequestGroupInfo()
verwenden, um die aktuellen Verbindungsinformationen abzurufen. WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
- Anwendungen können
requestDeviceInfo()
verwenden, um die aktuellen Verbindungsinformationen abzurufen.
WLAN-P2P-Anwendung erstellen
Wenn Sie eine WLAN-P2P-Anwendung erstellen, müssen Sie einen Broadcastempfä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 das tun.
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 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.
Berechtigung zur Verwendung der WLAN-Hardware auf dem Gerät anfordern und erklären dass Ihre App über die korrekte SDK-Mindestversion im Android- manifest:
<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 oben genannten Berechtigungen muss für die folgenden APIs auch der Standortmodus aktiviert sein:
Prüfen Sie, ob WLAN-P2P aktiviert ist 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 } } ... }
Rufen Sie in der Methode
onCreate()
Ihrer Aktivität eine Instanz vonWifiP2pManager
ab und registrieren Sie Ihre Anwendung im Wi‑Fi P2P-Framework, indem Sieinitialize()
aufrufen. Diese Methode gibt eineWifiP2pManager.Channel
, über das die Anwendung mit dem Wi-Fi-P2P-Framework. Außerdem solltest du eine Instanz deines Broadcast-Empfängers mit denWifiP2pManager
- undWifiP2pManager.Channel
-Objekten sowie einem Verweis auf deine Aktivität erstellen. So kann Ihr Broadcast-Empfänger Ihre Aktivität über interessante Ereignisse informieren 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); ... }
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 imonPause()
-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 du eine
WifiP2pManager.Channel
erhalten und eine Übertragung eingerichtet hast -Empfänger kann Ihre Anwendung Anrufe über WLAN-P2P-Methoden tätigen und WLANs empfangen. P2P-Intents.Implementieren Sie Ihre Anwendung mit den WLAN-P2P-Funktionen, indem Sie die Methoden in
WifiP2pManager
aufrufen.
In den folgenden Abschnitten wird beschrieben, wie Sie häufige Aktionen ausführen, z. B. das Auffinden und Verbinden mit Peers.
Ähnliche Apps finden
discoverPeers()
aufrufen, um verfügbare Peers zu finden, die sich in Reichweite befinden und verfügbar sind
um eine Verbindung herzustellen. Der Aufruf dieser Funktion ist asynchron. Wenn Sie eine WifiP2pManager.ActionListener
erstellt haben, wird der Erfolg oder Fehler mit onSuccess()
und onFailure()
an Ihre Anwendung gesendet. Die onSuccess()
-Methode benachrichtigt Sie nur darüber, dass der Discovery-Vorgang erfolgreich war, und enthält keine Informationen zu den tatsächlich gefundenen Peers, falls vorhanden. Die folgenden
wie dies eingerichtet wird.
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 erkennt, sendet das System die
Intent WIFI_P2P_PEERS_CHANGED_ACTION
, den du in einer Übertragung beobachten kannst
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()
. 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 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
Die Methode onPeersAvailable()
stellt ein
WifiP2pDeviceList
,
die Sie iterieren können, um den Peer zu finden, zu 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. 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
Sobald eine Verbindung hergestellt ist, können Sie Daten zwischen den Geräten mit Sockets. 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 dies geschieht. Führen Sie dies daher in einem Hintergrund-Thread 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. - Senden Sie Daten vom Client an den Server. 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 mit der Methode
accept()
auf eine Clientverbindung. Dieser Aufruf 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 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 } } } }