סקירה כללית על Wi-Fi ישיר (מקצה לקצה (P2P) או P2P)

Wi-Fi ישיר (P2P) מאפשר למכשירים עם החומרה המתאימה להתחבר ישירות זה לזה באמצעות Wi-Fi ללא נקודת גישה ביניים. באמצעות ממשקי ה-API האלה, אפשר לגלות מכשירים אחרים ולהתחבר אליהם כשכל מכשיר תומך ב-Wi-Fi P2P, ואז לתקשר באמצעות חיבור מהיר למרחקים ארוכים בהרבה מחיבור Bluetooth. האפשרות הזו שימושית לאפליקציות שמשתפות נתונים בין משתמשים, כמו משחק מרובה משתתפים או אפליקציה לשיתוף תמונות.

ממשקי ה-API של Wi-Fi P2P מורכבים מהחלקים העיקריים הבאים:

• שיטות שמאפשרות לכם לגלות עמיתים, לשלוח להם בקשות ולהתחבר אליהם, שמוגדרות במחלקה WifiP2pManager.
• מאזינים שמאפשרים לקבל הודעה על הצלחה או כישלון של קריאות ל-method‏ WifiP2pManager. כשמתקשרים לשיטות WifiP2pManager, כל שיטה יכולה לקבל מאזין ספציפי שמועבר כפרמטר.
• ‫Intents שמודיעים לכם על אירועים ספציפיים שזוהו על ידי מסגרת ה-Wi-Fi P2P, כמו ניתוק או גילוי של מכשיר עמית חדש.

לרוב משתמשים בשלושת הרכיבים העיקריים האלה של ממשקי ה-API יחד. לדוגמה, אפשר לספק את WifiP2pManager.ActionListener לשיחה אל discoverPeers() כדי שהשיטות ActionListener.onSuccess() ו-ActionListener.onFailure() יוכלו לשלוח לכם התראות. ה-intent‏ WIFI_P2P_PEERS_CHANGED_ACTION משודר גם אם השיטה discoverPeers() מגלה שרשימת העמיתים השתנתה.

סקירה כללית על ממשקי API

הסיווג WifiP2pManager מספק שיטות שמאפשרות לכם ליצור אינטראקציה עם חומרת ה-Wi-Fi במכשיר, כדי לבצע פעולות כמו גילוי של עמיתים וחיבור אליהם. אלה הפעולות שאפשר לבצע:

טבלה 1. שיטות P2P ב-Wi-Fi

בשיטות WifiP2pManager אפשר להעביר מאזין, כדי שמסגרת ה-Wi-Fi P2P תוכל להודיע על הפעילות שלכם לגבי סטטוס השיחה. בטבלה 2 מתוארים ממשקי המאזינים הזמינים וקריאות השיטה התואמות WifiP2pManager שמשתמשות במאזינים.

טבלה 2. מאזינים ל-Wi-Fi P2P

ממשקי ה-API של Wi-Fi P2P מגדירים כוונות שמשודרות כשמתרחשים אירועים מסוימים של Wi-Fi P2P, כמו גילוי של עמית חדש או שינוי במצב ה-Wi-Fi של מכשיר. כדי להירשם לקבלת הכוונות האלה באפליקציה, צריך ליצור מקלט שידור שמטפל בכוונות האלה:

טבלה 3. Wi-Fi P2P Intents

יצירת broadcast receiver ל-Wi-Fi P2P intents

מקלט שידורים מאפשר לכם לקבל שידורי Intent ממערכת Android, כדי שהאפליקציה שלכם תוכל להגיב לאירועים שמעניינים אתכם. אלה השלבים הבסיסיים ליצירת מקלט שידור לטיפול ב-intent של Wi-Fi P2P:

1. יוצרים כיתה שמרחיבה את הכיתה BroadcastReceiver. במקרה של בנאי המחלקה, תשתמשו בפרמטרים של WifiP2pManager, WifiP2pManager.Channel והפעילות שבה יירשם מקלט השידור הזה. כך מקלט השידור יכול לשלוח עדכונים לפעילות וגם לקבל גישה לחומרת ה-Wi-Fi ולערוץ תקשורת אם צריך.

2. ב-broadcast receiver, בודקים את הכוונות שמעניינות אתכם בשיטה onReceive(). מבצעים את הפעולות הנדרשות בהתאם לכוונה שהתקבלה. לדוגמה, אם מקלט השידור מקבל intent של WIFI_P2P_PEERS_CHANGED_ACTION, אפשר לקרוא ל-method ‏requestPeers() כדי לקבל רשימה של עמיתים שהתגלו כרגע.

בדוגמה הבאה מוצג קוד ליצירת מקלט שידורים טיפוסי. ה-broadcast receiver מקבל אובייקט WifiP2pManager ופעילות כארגומנטים, ומשתמש בשתי המחלקות האלה כדי לבצע את הפעולות הנדרשות בצורה מתאימה כשה-broadcast receiver מקבל intent:

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

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

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

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

במכשירים שמותקנת בהם מערכת Android מגרסה 10 ומעלה, כוונות השידור הבאות לא נשארות במערכת:

WIFI_P2P_CONNECTION_CHANGED_ACTION

אפליקציות יכולות להשתמש ב-requestConnectionInfo(), ב-requestNetworkInfo() או ב-requestGroupInfo() כדי לאחזר את פרטי החיבור הנוכחיים.

WIFI_P2P_THIS_DEVICE_CHANGED_ACTION

אפליקציות יכולות להשתמש ב-requestDeviceInfo() כדי לאחזר את פרטי החיבור הנוכחיים.

יצירת אפליקציית Wi-Fi P2P

כדי ליצור אפליקציית Wi-Fi P2P, צריך ליצור ולרשום מקלט שידור לאפליקציה, לגלות עמיתים, להתחבר לעמית ולהעביר נתונים לעמית. בקטעים הבאים מוסבר איך עושים את זה.

הגדרה ראשונית

לפני שמשתמשים בממשקי ה-API של Wi-Fi P2P, צריך לוודא שהאפליקציה יכולה לגשת לחומרה ושהמכשיר תומך בפרוטוקול Wi-Fi P2P. אם יש תמיכה ב-Wi-Fi P2P, אפשר לקבל מופע של WifiP2pManager, ליצור ולרשום את מקלט השידור ולהתחיל להשתמש ב-Wi-Fi P2P APIs.

1. צריך לבקש הרשאה להשתמש בחומרת ה-Wi-Fi במכשיר ולהצהיר בקובץ המניפסט של Android שהאפליקציה כוללת את גרסת ה-SDK המינימלית הנכונה:

   <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" />
   

   בנוסף להרשאות שצוינו למעלה, ממשקי ה-API הבאים דורשים גם הפעלה של LocationMode:

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

2. בודקים אם Wi-Fi P2P מופעל ונתמך. מקום טוב לבדוק את זה הוא ב-broadcast receiver כשמתקבלת כוונת WIFI_P2P_STATE_CHANGED_ACTION. קבלת התראות על הפעילות של מצב Wi-Fi P2P ותגובה בהתאם:

   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. בשיטה onCreate() של הפעילות, מקבלים מופע של WifiP2pManager ורושמים את האפליקציה באמצעות מסגרת Wi-Fi P2P על ידי קריאה ל-initialize(). השיטה הזו מחזירה WifiP2pManager.Channel, שמשמשת לחיבור האפליקציה למסגרת Wi-Fi P2P. צריך גם ליצור מופע של מקלט השידור עם האובייקטים WifiP2pManager ו-WifiP2pManager.Channel, וגם הפניה לפעילות. כך מקלט השידורים יכול להודיע על אירועים מעניינים ולעדכן את הפעילות בהתאם. בנוסף, אפשר לשנות את מצב ה-Wi-Fi של המכשיר אם צריך:

   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. יוצרים מסנן Intent ומוסיפים את אותם ה-Intents שבודק מקלט השידור:

   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. רושמים את broadcast receiver בשיטה onResume() של הפעילות ומבטלים את הרישום בשיטה onPause() של הפעילות:

   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. אחרי שמקבלים WifiP2pManager.Channel ומגדירים מקלט שידורים, האפליקציה יכולה לבצע קריאות לשיטות Wi-Fi P2P ולקבל כוונות Wi-Fi P2P.

7. מטמיעים את האפליקציה באמצעות התכונות של Wi-Fi P2P על ידי קריאה לשיטות ב-WifiP2pManager.

בקטעים הבאים מוסבר איך לבצע פעולות נפוצות כמו גילוי של עמיתים וחיבור אליהם.

גילוי אפליקציות דומות

מתקשרים אל discoverPeers() כדי לזהות עמיתים זמינים שנמצאים בטווח וזמינים לחיבור. הקריאה לפונקציה הזו היא אסינכרונית, והצלחה או כישלון מועברים לאפליקציה באמצעות onSuccess() ו-onFailure() אם יצרתם WifiP2pManager.ActionListener. ה-method onSuccess() רק מודיעה לכם שתהליך הגילוי הצליח, ולא מספקת מידע על העמיתים בפועל שהיא גילתה, אם יש כאלה. בדוגמת הקוד הבאה אפשר לראות איך מגדירים את זה.

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

אם תהליך הגילוי מצליח ומזהה עמיתים, המערכת משדרת את הכוונה WIFI_P2P_PEERS_CHANGED_ACTION, שאפשר להאזין לה ב-broadcast receiver כדי לקבל רשימה של עמיתים. כשהאפליקציה מקבלת את כוונת WIFI_P2P_PEERS_CHANGED_ACTION, אפשר לבקש רשימה של עמיתים שנמצאו באמצעות requestPeers(). בדוגמה הבאה מוצג קוד להגדרת התכונה.

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

השיטה requestPeers() היא גם אסינכרונית ויכולה לשלוח הודעה על הפעילות כשזמינה רשימה של עמיתים עם onPeersAvailable(), שמוגדר בממשק WifiP2pManager.PeerListListener. השיטה onPeersAvailable() מספקת לכם את WifiP2pDeviceList, שאפשר לחזור עליה כדי למצוא את העמית שאליו רוצים להתחבר.

התחברות לעמיתים

אחרי שמקבלים רשימה של מכשירים אפשריים ובוחרים מכשיר להתחבר אליו, קוראים לשיטה connect() כדי להתחבר למכשיר. הקריאה הזו לשיטה דורשת אובייקט WifiP2pConfig שמכיל מידע על המכשיר שאליו רוצים להתחבר. WifiP2pManager.ActionListener יכול להודיע לכם על חיבור מוצלח או על חיבור שנכשל. בדוגמה הבאה מוצג קוד ליצירת חיבור למכשיר.

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

העברת נתונים

אחרי שנוצר חיבור, אפשר להעביר נתונים בין המכשירים באמצעות sockets. אלה השלבים הבסיסיים להעברת נתונים:

1. ליצור ServerSocket. הסוקט הזה מחכה לחיבור מלקוח ביציאה שצוינה, ונחסם עד שזה קורה, לכן צריך לעשות את זה בשרשור ברקע.
2. יוצרים לקוח Socket. הלקוח משתמש בכתובת ה-IP וביציאה של שקע השרת כדי להתחבר למכשיר השרת.
3. שליחת נתונים מהלקוח לשרת. כשהשקע של הלקוח מתחבר בהצלחה לשקע של השרת, אפשר לשלוח נתונים מהלקוח לשרת באמצעות זרמי בייטים.
4. שקע השרת ממתין לחיבור של לקוח (עם השיטה accept()). השיחה הזו נחסמת עד שלקוח מתחבר, לכן צריך להפעיל אותה בשרשור אחר. כשמתבצע חיבור, מכשיר השרת יכול לקבל את הנתונים מהלקוח.

בדוגמה הבאה, ששונתה מתוך הדגמה של Wi-Fi P2P, אפשר לראות איך ליצור תקשורת שקעים בין לקוח לשרת ולהעביר תמונות JPEG מלקוח לשרת באמצעות שירות. כדי לראות דוגמה מלאה, צריך לקמפל ולהריץ את ההדגמה.

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

בצד הלקוח, מתחברים לשקע השרת באמצעות שקע לקוח ומעבירים נתונים. בדוגמה הזו מועבר קובץ JPEG במערכת הקבצים של מכשיר הלקוח.

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