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

Wi-Fi Direct (P2P) ermöglicht es Geräten mit der entsprechenden Hardware, sich ohne Zwischenzugangspunkt direkt über WLAN direkt miteinander zu verbinden. Mit diesen APIs können Sie andere Geräte erkennen und eine Verbindung zu ihnen herstellen, wenn jedes Gerät Wi-Fi-P2P unterstützt. Anschließend können Sie über eine schnelle Verbindung über eine viel größere Entfernung als eine Bluetooth-Verbindung kommunizieren. Dies ist nützlich für Anwendungen, die Daten unter Nutzern teilen, wie z. B. ein Mehrspielerspiel oder eine Anwendung zum Teilen von Fotos.

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

• Methoden, mit denen Sie Peers, die in der Klasse WifiP2pManager definiert sind, erkennen, anfordern und eine Verbindung zu ihnen herstellen können.
• Listener, mit denen Sie über Erfolg oder Misserfolg von WifiP2pManager-Methodenaufrufen benachrichtigt werden können. Beim Aufrufen von WifiP2pManager-Methoden kann jede Methode einen bestimmten Listener empfangen, der als Parameter übergeben wird.
• Intents, die Sie über bestimmte Ereignisse benachrichtigen, die vom Wi-Fi-P2P-Framework erkannt wurden, z. B. eine unterbrochene Verbindung oder ein neu erkannter Peer.

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

API-Übersicht

Die Klasse WifiP2pManager bietet Methoden, mit denen Sie mit der WLAN-Hardware Ihres Geräts interagieren können, z. B. Peers erkennen und eine Verbindung zu ihnen herstellen. Folgende Aktionen sind verfügbar:

Tabelle 1 Wi-Fi-P2P-Methoden

Mit WifiP2pManager-Methoden können Sie einen Listener übergeben, sodass das Wi-Fi-P2P-Framework Ihre Aktivität über den Status eines Aufrufs informieren kann. Die verfügbaren Listener-Schnittstellen und die entsprechenden WifiP2pManager-Methodenaufrufe, die diese Listener verwenden, sind in Tabelle 2 beschrieben.

Tabelle 2 WLAN-P2P-Listener

Die Wi-Fi-P2P-APIs definieren Intents, die gesendet werden, wenn bestimmte WLAN-P2P-Ereignisse eintreten, z. B. wenn ein neuer Peer erkannt wird oder sich der WLAN-Status eines Geräts ändert. Sie können sich für den Empfang dieser Intents in Ihrer Anwendung registrieren. Dazu erstellen Sie einen Broadcast-Empfänger, der diese Intents verarbeitet:

Tabelle 3 WLAN-P2P-Intents

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

Mit einem Broadcast-Empfänger können Sie Intents empfangen, die vom Android-System gesendet werden, sodass Ihre App auf Ereignisse reagieren kann, die Sie interessieren. Zum Erstellen eines Broadcast-Empfängers für die Verarbeitung von Wi-Fi-P2P-Intents sind folgende grundlegende Schritte erforderlich:

1. 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 Broadcast-Empfänger registriert wird. Dadurch kann der Broadcast-Empfänger Aktualisierungen der Aktivität senden und bei Bedarf Zugriff auf die WLAN-Hardware und einen Kommunikationskanal haben.

2. Prüfen Sie im Broadcast-Empfänger, ob die Intents, die Sie interessieren, in der Methode onReceive() enthalten sind. Führen Sie je nach empfangenem Intent alle erforderlichen Aktionen aus. Wenn der Broadcastempfänger beispielsweise den Intent WIFI_P2P_PEERS_CHANGED_ACTION 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 Broadcast-Empfänger verwendet ein WifiP2pManager-Objekt und eine Aktivität als Argumente und verwendet diese beiden Klassen, um die erforderlichen Aktionen entsprechend auszuführen, wenn der Broadcast-Empfänger einen Intent empfängt:

/**
* 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 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 fixiert:

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 über requestDeviceInfo() die aktuellen Verbindungsinformationen abrufen.

WLAN-P2P-Anwendung erstellen

Zum Erstellen einer Wi-Fi-P2P-Anwendung wird ein Broadcast-Empfänger für Ihre Anwendung erstellt und registriert, Peers ermittelt, eine Verbindung zu einem Peer hergestellt und Daten an einen Peer übertragen. In den folgenden Abschnitten wird beschrieben, wie Sie dies tun.

Ersteinrichtung

Bevor Sie die Wi-Fi P2P APIs verwenden, müssen Sie dafür sorgen, dass Ihre Anwendung auf die Hardware zugreifen kann und das Gerät das Wi-Fi P2P-Protokoll unterstützt. Wenn Wi-Fi P2P unterstützt wird, kannst du eine Instanz von WifiP2pManager abrufen, deinen Broadcast-Empfänger erstellen und registrieren und die Wi-Fi P2P APIs verwenden.

1. Fordern Sie im Android-Manifest die Berechtigung zur Nutzung der WLAN-Hardware auf dem Gerät an und legen Sie fest, dass Ihre App 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 vorherigen Berechtigungen muss für die folgenden APIs der Standortmodus aktiviert sein:

   • discoverPeers()
   • discoverServices()
   • requestPeers()

2. Prüfen Sie, ob Wi-Fi P2P aktiviert ist und unterstützt wird. Sie können dies im Broadcast-Empfänger prüfen, wenn er den Intent WIFI_P2P_STATE_CHANGED_ACTION empfängt. Benachrichtigen Sie Aktivitäten über den WLAN-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 -> {
                  // 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. Rufen Sie in der Methode onCreate() Ihrer Aktivität eine Instanz von WifiP2pManager ab und registrieren Sie Ihre Anwendung mit dem Wi-Fi-P2P-Framework, indem Sie initialize() aufrufen. Diese Methode gibt ein WifiP2pManager.Channel zurück, mit dem Ihre Anwendung mit dem Wi-Fi-P2P-Framework verbunden wird. Sie sollten außerdem eine Instanz Ihres Übertragungsempfängers mit den Objekten WifiP2pManager und WifiP2pManager.Channel sowie einem Verweis auf Ihre Aktivität erstellen. Dadurch kann der Empfangsempfänger Ihre Aktivitäten über interessante Ereignisse benachrichtigen und 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);
      ...
   }
   

4. Erstellen Sie einen Intent-Filter und fügen Sie dieselben Intents hinzu, nach denen der Empfänger sucht:

   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. Registrieren Sie den Übertragungsempfänger mit der Methode onResume() Ihrer Aktivitäten und heben Sie die Registrierung in der Methode onPause() Ihrer Aktivitäten auf:

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

6. Wenn Sie ein WifiP2pManager.Channel erhalten und einen Übertragungsempfänger eingerichtet haben, kann Ihre Anwendung WLAN-P2P-Methodenaufrufe senden und WLAN-P2P-Intents empfangen.

7. Implementieren Sie Ihre Anwendung mithilfe der Wi-Fi-P2P-Funktionen. Rufen Sie dazu die Methoden in WifiP2pManager auf.

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

Kollegen entdecken

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

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

Wenn der Erkennungsprozess erfolgreich ist und Peers erkennt, sendet das System den Intent WIFI_P2P_PEERS_CHANGED_ACTION, auf den Sie bei einem Übertragungsempfänger warten können, um eine Liste der Peers zu erhalten. Wenn die Anwendung den Intent WIFI_P2P_PEERS_CHANGED_ACTION empfängt, können Sie mit requestPeers() eine Liste der erkannten Peers anfordern. Der folgende Code zeigt, wie dies eingerichtet wird.

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

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

Mit ähnlichen Apps verbinden

Nachdem Sie eine Liste möglicher Peers abgerufen und ein Gerät für die Verbindung ausgewählt haben, rufen Sie die Methode connect() auf, um eine Verbindung zu dem Gerät herzustellen. Für diesen Methodenaufruf ist ein WifiP2pConfig-Objekt erforderlich, das Informationen zu dem Gerät enthält, mit dem eine Verbindung hergestellt werden soll. WifiP2pManager.ActionListener kann Sie über eine erfolgreiche oder fehlgeschlagene Verbindung informieren. Der folgende Code zeigt, wie Sie eine Verbindung zu einem Gerät herstellen.

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

//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 zwischen den Geräten mit Steckdosen übertragen. Im Folgenden sind die grundlegenden Schritte für die Datenübertragung aufgeführt:

1. Erstellen Sie ein ServerSocket. Dieser Socket wartet auf eine Verbindung von einem Client an einem bestimmten Port und blockiert, bis dies erfolgt. Dies sollte in einem Hintergrundthread geschehen.
2. Erstellen Sie einen Client Socket. Der Client verwendet die IP-Adresse und den Port des Server-Sockets, um eine Verbindung zum Servergerät herzustellen.
3. Daten vom Client an den Server senden Wenn der Client-Socket erfolgreich eine Verbindung zum Server-Socket herstellt, können Sie mit Bytestreams Daten vom Client an den Server senden.
4. Der ServerSocket wartet auf eine Clientverbindung (mit der Methode accept()). Dieser Aufruf wird blockiert, bis ein Client eine Verbindung herstellt. Rufen Sie ihn also 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 geändert wurde, zeigt, wie Sie diese Client-Server-Socket-Kommunikation erstellen und JPEG-Bilder von einem Client an einen Server mit einem Dienst übertragen. Wenn Sie ein vollständiges Arbeitsbeispiel erhalten möchten, kompilieren Sie die Demo und führen Sie sie aus.

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

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.

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