Google は、黒人コミュニティに対する人種平等の促進に取り組んでいます。取り組みを見る

Wi-Fi Direct(ピアツーピアまたは P2P)の概要

適切なハードウェアを備えた Android 4.0(API レベル 14)以降の端末であれば、Wi-Fi Direct(P2P)を使用することで、中間アクセス ポイントなしに Wi-Fi を介して相互に直接接続することができます。これらの API を使用すると、Wi-Fi P2P をサポートする端末を検出して接続することができ、Bluetooth 接続で可能な距離よりもはるかに長い距離でも高速に通信できます。マルチプレーヤー型ゲームや写真共有アプリケーションといった、ユーザー間でデータを共有するアプリケーションにとって、これは便利な機能です。

Wi-Fi P2P API は、次の主要な部分で構成されています。

  • 各種メソッド。ピアの検出、ピアのリクエスト、ピアへの接続などを可能にし、WifiP2pManager クラスに定義されています。

  • リスナー。WifiP2pManager メソッドの呼び出しが成功したかまたは失敗したかを通知します。WifiP2pManager メソッドを呼び出すと、各メソッドはパラメータとして渡された特定のリスナーを受信できます。

  • インテント。接続が切断されたことやピアが新たに検出されたことなど、Wi-Fi P2P フレームワークによって検出された特定のイベントを通知します。

API を構成するこれら 3 つの主要コンポーネントを一緒に使用することがよくあります。たとえば、WifiP2pManager.ActionListenerdiscoverPeers() への呼び出しに使用すると、ActionListener.onSuccess() メソッドと ActionListener.onFailure() メソッドによって通知が行われます。また、ピアリストが変更されたことを discoverPeers() メソッドが検出すると、WIFI_P2P_PEERS_CHANGED_ACTION インテントもブロードキャストされます。

API の概要

WifiP2pManager クラスは、端末上の Wi-Fi ハードウェアと対話してピアの検出や接続などを行うメソッドを提供します。次のアクションを実行できます。

表 1. Wi-Fi P2P メソッド

メソッド 説明
initialize() アプリケーションを Wi-Fi フレームワークに登録します。このメソッドは、どの Wi-Fi P2P メソッドよりも先に呼び出す必要があります。
connect() 指定した設定で端末とのピアツーピア接続を開始します。
cancelConnect() 進行中のピアツーピアでのグループ ネゴシエーションをキャンセルします。
requestConnectInfo() 端末の接続情報をリクエストします。
createGroup() 現在の端末をグループ所有者とするピアツーピア グループを作成します。
removeGroup() 現在のピアツーピア グループを削除します。
requestGroupInfo() ピアツーピア グループ情報をリクエストします。
discoverPeers() ピア検出を開始します。
requestPeers() 検出されたピアの現在のリストをリクエストします。

WifiP2pManager メソッドを使用するとリスナーに渡すことが可能となるため、Wi-Fi P2P フレームワークは呼び出しのステータスをユーザーのアクティビティに通知することができます。使用可能なリスナー インターフェースとそれに対応してリスナーを使用する WifiP2pManager メソッド呼び出しを、次の表に示します。

表 2. Wi-Fi P2P リスナー

リスナー インターフェース 関連アクション
WifiP2pManager.ActionListener connect()cancelConnect()createGroup()removeGroup()、および discoverPeers()
WifiP2pManager.ChannelListener initialize()
WifiP2pManager.ConnectionInfoListener requestConnectInfo()
WifiP2pManager.GroupInfoListener requestGroupInfo()
WifiP2pManager.PeerListListener requestPeers()

Wi-Fi P2P API は、新しいピアが検出されたときや端末の Wi-Fi 状態が変更になったときなど、特定の Wi-Fi P2P イベントが発生したときにブロードキャストされるインテントを定義します。これらのインテントを処理するブロードキャスト レシーバを作成することで、アプリケーションにこれらのインテントを受け取るよう登録することができます。

表 3. Wi-Fi P2P インテント

インテント 説明
WIFI_P2P_CONNECTION_CHANGED_ACTION 端末の Wi-Fi 接続の状態が変更になったときにブロードキャストします。
WIFI_P2P_PEERS_CHANGED_ACTION discoverPeers() を呼び出したときにブロードキャストします。アプリケーションでこのインテントを処理する場合、通常は requestPeers() を呼び出して、更新されたピアのリストを取得します。
WIFI_P2P_STATE_CHANGED_ACTION 端末で Wi-Fi P2P が有効または無効になったときにブロードキャストします。
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION 端末の名前など、端末の詳細が変更されたときにブロードキャストされます。

Wi-Fi P2P インテント用のブロードキャスト レシーバの作成

ブロードキャスト レシーバを使用することで Android システムからブロードキャストされたインテントを受信することが可能になり、関心のあるイベントに対してアプリケーションで応答することができます。Wi-Fi P2P インテントを処理するブロードキャスト レシーバを作成する基本的な手順は、次のとおりです。

  1. BroadcastReceiver クラスを拡張するクラスを作成します。このクラスのコンストラクタには、WifiP2pManagerWifiP2pManager.Channel、およびこのブロードキャスト レシーバが登録されるアクティビティのパラメータが必要になります。このようにすることにより、ブロードキャスト レシーバは更新をアクティビティに送信するだけでなく、必要に応じて Wi-Fi ハードウェアや通信チャンネルにもアクセスできるようになります。

  2. ブロードキャスト レシーバで、関心のあるインテントが onReceive() 内にあるかどうかを確認します。受信したインテントに応じて、必要なアクションを実行します。たとえば、ブロードキャスト レシーバが WIFI_P2P_PEERS_CHANGED_ACTION インテントを受信した場合、requestPeers() メソッドを呼び出して、現在検出されているピアのリストを取得できます。

次のコードは、一般的なブロードキャスト レシーバを作成する方法を示しています。ブロードキャスト レシーバは、WifiP2pManager オブジェクトとアクティビティを引数として取り、次の 2 つのクラスを使用して、ブロードキャスト レシーバがインテントを受信したときに必要なアクションを実行します。

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 mManager;
    private Channel mChannel;
    private MyWiFiActivity mActivity;

    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel,
            MyWifiActivity activity) {
        super();
        this.mManager = manager;
        this.mChannel = channel;
        this.mActivity = 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 Q では、次のブロードキャスト インテントが固定から非固定に変更されました。

WIFI_P2P_CONNECTION_CHANGED_ACTION
アプリケーションは、requestConnectionInfo()requestNetworkInfo()、または requestGroupInfo() を使用して、現在の接続情報を取得できます。
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
アプリケーションは、requestDeviceInfo() を使用して現在の接続情報を取得できます。

Wi-Fi P2P アプリケーションの作成

Wi-Fi P2P アプリケーションの作成には、アプリケーション用のブロードキャスト レシーバの作成と登録、ピアの検出、ピアへの接続、ピアへのデータの転送が含まれます。次のセクションでは、その方法について説明します。

初期セットアップ

Wi-Fi P2P API を使用する前に、アプリケーションがハードウェアにアクセスできることと、端末が Wi-Fi P2P プロトコルをサポートしていることを確認する必要があります。Wi-Fi P2P をサポートしている場合は、WifiP2pManager のインスタンスを取得し、ブロードキャスト レシーバを作成および登録すると Wi-Fi P2P API の使用を開始できます。

  1. 端末上で Wi-Fi ハードウェアを使用するためのパーミッションをリクエストし、アプリケーションが正しい最小の SDK バージョンを持っていることを Android マニフェストに宣言します。

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

    上述のパーミッション以外にも、次の API で位置情報モードが有効になっている必要があります。

  2. Wi-Fi P2P がオンになっているかどうか、およびサポートされているかどうかを確認します。この確認はブロードキャスト レシーバで、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 のインスタンスを取得し、initialize() を呼び出して、アプリケーションを Wi-Fi P2P フレームワークに登録します。このメソッドによって返される 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 mChannel: WifiP2pManager.Channel? = null
    var receiver: BroadcastReceiver? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
    
        mChannel = manager?.initialize(this, mainLooper, null)
        mChannel?.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, mChannel, this);
        ...
    }
    
  4. インテント フィルタを作成し、ブロードキャスト レシーバが確認する対象と同じインテントを追加します。

    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. ブロードキャスト レシーバをユーザー アクティビティの onResume() メソッドに登録し、ユーザー アクティビティの onPause() メソッドから登録を解除します。

    Kotlin

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

    Java

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

    WifiP2pManager.Channel を取得してブロードキャスト レシーバをセットアップすると、アプリケーションで Wi-Fi P2P メソッド呼び出しを作成して、Wi-Fi P2P インテントを受信できるようになります。

    これでアプリケーションを実装でき、WifiP2pManager のメソッドを呼び出して Wi-Fi P2P の各機能を使用できるようになります。次のセクションでは、ピアの検出や接続などの一般的なアクションの実行方法について説明します。

ピアの検出

接続可能なピアを検出するには、discoverPeers() を呼び出して、接続範囲内にある利用可能なピアを検出します。この関数の呼び出しは非同期であり、WifiP2pManager.ActionListener を作成済みである場合は、onSuccess()onFailure() を使用して成功したかまたは失敗したかがアプリケーションに伝達されます。onSuccess() メソッドは、検出プロセスが成功したことを通知するだけで、検出された実際のピアに関する情報があっても何も提供しません。

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

検出プロセスが成功し、ピアを検出すると、システムは WIFI_P2P_PEERS_CHANGED_ACTION インテントをブロードキャストします。ブロードキャスト レシーバでこのインテントをリッスンして、ピアのリストを取得できます。アプリケーションが WIFI_P2P_PEERS_CHANGED_ACTION インテントを受信したら、検出されたピアのリストを requestPeers() を使用して要求することができます。次のコードは、その設定方法を示しています。

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

requestPeers() メソッドも非同期であり、WifiP2pManager.PeerListListener インターフェースで定義されている onPeersAvailable() でピアのリストが使用可能になったときに、ユーザーのアクティビティに通知することができます。onPeersAvailable() メソッドは WifiP2pDeviceList を提供しますが、これを繰り返して接続するピアを見つけることができます。

ピアへの接続

接続可能なピアのリストを取得した後、接続する端末が決まったら、connect() メソッドを呼び出してその端末に接続します。このメソッド呼び出しでは、接続する端末の情報を持つ WifiP2pConfig オブジェクトが必要です。接続が成功したか失敗したかは、WifiP2pManager.ActionListener によって通知されます。次のコードは、目的の端末への接続を作成する方法を示しています。

Kotlin

val device: WifiP2pDevice = ...
val config = WifiP2pConfig()
config.deviceAddress = device.deviceAddress
mChannel?.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
    }
});

データの転送

接続が確立されたら、ソケットを使用した端末間のデータ転送が可能になります。データ転送の基本手順は次のとおりです。

  1. ServerSocket を作成します。このソケットは、指定されたポートでクライアントからの接続を待機し、それまでは他の接続をブロックします。そのため、この処理はバックグラウンド スレッドで実行します。

  2. クライアント Socket を作成します。クライアントはサーバー ソケットの IP アドレスとポートを使用して、サーバー端末に接続します。

  3. クライアントからサーバーにデータを送信します。クライアント ソケットがサーバー ソケットに正常に接続されたら、クライアントからサーバーにバイト ストリームでデータを送信することができます。

  4. サーバー ソケットは(accept() メソッドを使用して)クライアント接続を待機します。この呼び出しはクライアントが接続するまでブロックされた状態なので、別のスレッドとみなすことができます。接続が開始すると、サーバー端末はクライアントからデータを受信することができます。このデータに対して、ファイルに保存するまたはユーザーに提示するなど、任意のアクションを実行します。

次の例は、Wi-Fi P2P デモ サンプルを変更したもので、このクライアント サーバー間のソケット通信を作成し、サービスを使用してクライアントからサーバーに JPEG イメージを転送する方法を示しています。完全な実働サンプルについては、Wi-Fi P2P デモ サンプルをコンパイルして実行してください。

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

クライアント上で、クライアント ソケットを使用してサーバー ソケットに接続し、データを転送します。次の例では、クライアント端末のファイル システム上の JPEG ファイルを転送します。

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