Le Wi-Fi Direct (P2P) permet aux appareils disposant du matériel approprié de se connecter directement les uns aux autres via le Wi-Fi sans point d'accès intermédiaire. À l'aide de ces API, vous pouvez détecter d'autres appareils et vous y connecter lorsque chacun d'eux est compatible avec le Wi-Fi P2P, puis communiquer sur une connexion rapide sur des distances beaucoup plus longues qu'une connexion Bluetooth. Cela est utile pour les applications qui partagent des données entre les utilisateurs, telles qu'un jeu multijoueur ou une application de partage de photos.
Les API Wi-Fi P2P se composent des éléments principaux suivants:
- Les méthodes vous permettant de découvrir des pairs, de les interroger et de s'y connecter, définis dans la classe
WifiP2pManager
- Des écouteurs qui vous permettent d'être averti de la réussite ou de l'échec des appels de méthode
WifiP2pManager
. Lorsque vous appelez des méthodesWifiP2pManager
, chaque méthode peut recevoir un écouteur spécifique transmis en tant que paramètre. - Intents qui vous informent des événements spécifiques détectés par le framework Wi-Fi P2P, tels qu'une perte de connexion ou la découverte d'un pair
Vous utiliserez souvent ces trois composants principaux des API ensemble. Par exemple, vous pouvez fournir un WifiP2pManager.ActionListener
à un appel à discoverPeers()
afin que les méthodes ActionListener.onSuccess()
et ActionListener.onFailure()
puissent vous en informer. Un intent WIFI_P2P_PEERS_CHANGED_ACTION
est également diffusé si la méthode discoverPeers()
découvre que la liste des pairs a changé.
Présentation de l'API
La classe WifiP2pManager
fournit des méthodes vous permettant d'interagir avec le matériel Wi-Fi de votre appareil pour effectuer des opérations telles que la découverte de pairs et vous y connecter.
Les actions suivantes sont disponibles:
Tableau 1. Méthodes Wi-Fi P2P
Méthode | Description |
initialize()
|
Enregistre l'application auprès du framework Wi-Fi. Appelez-la avant toute autre méthode Wi-Fi P2P. |
connect()
|
Démarre une connexion peer-to-peer avec un appareil disposant de la configuration spécifiée. |
cancelConnect()
|
Annule toute négociation de groupe peer-to-peer en cours. |
requestConnectInfo()
|
Demande les informations de connexion d'un appareil. |
createGroup()
|
Crée un groupe peer-to-peer où l'appareil actuel est défini comme propriétaire du groupe. |
removeGroup()
|
Supprime le groupe peer-to-peer actuel. |
requestGroupInfo()
|
Demande des informations de groupe peer-to-peer. |
discoverPeers()
|
Lance la découverte de pairs. |
requestPeers()
|
Demande la liste actuelle des pairs découverts. |
Les méthodes WifiP2pManager
vous permettent de transmettre un écouteur, afin que le framework Wi-Fi P2P puisse avertir votre activité de l'état d'un appel. Les interfaces d'écouteur disponibles et les appels de méthode WifiP2pManager
correspondants qui utilisent les écouteurs sont décrits dans le tableau 2.
Tableau 2. Écouteurs Wi-Fi P2P
Interface de l'écouteur | Actions associées |
WifiP2pManager.ActionListener
|
connect() , cancelConnect() , createGroup() , removeGroup() et discoverPeers()
|
WifiP2pManager.ChannelListener
|
initialize()
|
WifiP2pManager.ConnectionInfoListener
|
requestConnectInfo()
|
WifiP2pManager.GroupInfoListener
|
requestGroupInfo()
|
WifiP2pManager.PeerListListener
|
requestPeers()
|
Les API Wi-Fi P2P définissent des intents qui sont diffusés lorsque certains événements Wi-Fi P2P se produisent, par exemple lorsqu'un nouveau pair est détecté ou lorsque l'état Wi-Fi d'un appareil change. Vous pouvez vous inscrire pour recevoir ces intents dans votre application en créant un broadcast receiver qui gère ces intents:
Tableau 3 : Intents P2P Wi-Fi
Intention | Description |
WIFI_P2P_CONNECTION_CHANGED_ACTION
|
Annoncer lorsque l'état de la connexion Wi-Fi de l'appareil change. |
WIFI_P2P_PEERS_CHANGED_ACTION
|
Faites une annonce lorsque vous appelez discoverPeers() . Si vous gérez cet intent dans votre application, vous appelez généralement requestPeers() pour obtenir une liste à jour des pairs.
|
WIFI_P2P_STATE_CHANGED_ACTION
|
Annoncer lorsque le Wi-Fi P2P est activé ou désactivé sur l'appareil |
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
|
Annoncer lorsque les caractéristiques d'un appareil (son nom, par exemple) ont changé |
Créer un broadcast receiver pour les intents Wi-Fi P2P
Un broadcast receiver vous permet de recevoir des intents diffusés par le système Android, afin que votre application puisse répondre aux événements qui vous intéressent. Les étapes de base pour créer un broadcast receiver afin de gérer les intents Wi-Fi P2P sont les suivantes:
Créez une classe qui étend la classe
BroadcastReceiver
. Pour le constructeur de la classe, vous utiliserez des paramètres pourWifiP2pManager
,WifiP2pManager.Channel
et l'activité dans laquelle ce broadcast receiver sera enregistré. Cela permet au broadcast receiver d'envoyer des mises à jour de l'activité et d'avoir accès au matériel Wi-Fi et à un canal de communication si nécessaire.Dans le broadcast receiver, recherchez les intents qui vous intéressent dans la méthode
onReceive()
. Effectuez toutes les actions nécessaires en fonction de l'intent reçu. Par exemple, si le broadcast receiver reçoit un intentWIFI_P2P_PEERS_CHANGED_ACTION
, vous pouvez appeler la méthoderequestPeers()
pour obtenir la liste des pairs actuellement détectés.
Le code suivant vous montre comment créer un broadcast receiver classique. Le broadcast receiver utilise un objet WifiP2pManager
et une activité comme arguments et utilise ces deux classes pour effectuer de manière appropriée les actions nécessaires lorsqu'il reçoit un intent:
Kotlin
/** * A BroadcastReceiver that notifies of important Wi-Fi p2p events. */ class WiFiDirectBroadcastReceiver( private val manager: WifiP2pManager, private val channel: WifiP2pManager.Channel, private val activity: MyWifiActivity ) : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent) { val action: String = intent.action when (action) { WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION -> { // Check to see if Wi-Fi is enabled and notify appropriate activity } WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION -> { // Call WifiP2pManager.requestPeers() to get a list of current peers } WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> { // Respond to new connection or disconnections } WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION -> { // Respond to this device's wifi state changing } } } }
Java
/** * A BroadcastReceiver that notifies of important Wi-Fi p2p events. */ public class WiFiDirectBroadcastReceiver extends BroadcastReceiver { private WifiP2pManager manager; private Channel channel; private MyWiFiActivity activity; public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel, MyWifiActivity activity) { super(); this.manager = manager; this.channel = channel; this.activity = activity; } @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) { // Check to see if Wi-Fi is enabled and notify appropriate activity } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) { // Call WifiP2pManager.requestPeers() to get a list of current peers } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) { // Respond to new connection or disconnections } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) { // Respond to this device's wifi state changing } } }
Sur les appareils équipés d'Android 10 ou version ultérieure, les intents de diffusion suivants ne sont pas persistants:
WIFI_P2P_CONNECTION_CHANGED_ACTION
- Les applications peuvent utiliser
requestConnectionInfo()
,requestNetworkInfo()
ourequestGroupInfo()
pour récupérer les informations de connexion actuelles. WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
- Les applications peuvent utiliser
requestDeviceInfo()
pour récupérer les informations de connexion actuelles.
Créer une application Wi-Fi P2P
La création d'une application Wi-Fi P2P implique la création et l'enregistrement d'un broadcast receiver pour votre application, la découverte de pairs, la connexion à un pair et le transfert de données vers un pair. Pour ce faire, reportez-vous aux sections suivantes.
Configuration initiale
Avant d'utiliser les API Wi-Fi P2P, vous devez vous assurer que votre application peut accéder au matériel et que l'appareil est compatible avec le protocole Wi-Fi P2P. Si le Wi-Fi P2P est compatible, vous pouvez obtenir une instance de WifiP2pManager
, créer et enregistrer votre broadcast receiver et commencer à utiliser les API Wi-Fi P2P.
Demandez l'autorisation d'utiliser le matériel Wi-Fi sur l'appareil et déclarez que votre application dispose de la bonne version minimale du SDK dans le fichier manifeste 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.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" />
Outre les autorisations précédentes, les API suivantes nécessitent également l'activation du mode de localisation:
Vérifiez si le Wi-Fi P2P est activé et compatible. Pour vérifier cela, nous vous conseillons de le faire dans votre broadcast receiver lorsqu'il reçoit l'intent
WIFI_P2P_STATE_CHANGED_ACTION
. Prévenez votre activité de l'état du Wi-Fi P2P et réagissez en conséquence: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 } } ... }
Dans la méthode
onCreate()
de votre activité, obtenez une instance deWifiP2pManager
et enregistrez votre application avec le framework Wi-Fi P2P en appelantinitialize()
. Cette méthode renvoie unWifiP2pManager.Channel
permettant de connecter votre application au framework Wi-Fi P2P. Vous devez également créer une instance de votre broadcast receiver avec les objetsWifiP2pManager
etWifiP2pManager.Channel
, et faire référence à votre activité. Cela permet au broadcast receiver d'avertir votre activité des événements intéressants et de la mettre à jour en conséquence. Il vous permet également de manipuler l'état du Wi-Fi de l'appareil si nécessaire: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); ... }
Créez un filtre d'intent et ajoutez les mêmes intents que ceux recherchés par votre broadcast receiver:
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); ... }
Enregistrez le broadcast receiver dans la méthode
onResume()
de votre activité et annulez son enregistrement dans la méthodeonPause()
de votre activité: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); }
Lorsque vous avez obtenu un
WifiP2pManager.Channel
et configuré un broadcast receiver, votre application peut effectuer des appels de méthode Wi-Fi P2P et recevoir des intents Wi-Fi P2P.Implémentez votre application à l'aide des fonctionnalités Wi-Fi P2P en appelant les méthodes dans
WifiP2pManager
.
Les sections suivantes décrivent comment effectuer des actions courantes, comme découvrir des pairs et s'y connecter.
Découvrir des applications similaires
Appelez discoverPeers()
pour détecter les pairs disponibles à portée et disponibles pour la connexion. L'appel de cette fonction est asynchrone, et une réussite ou un échec est communiqué à votre application avec onSuccess()
et onFailure()
si vous avez créé un WifiP2pManager.ActionListener
. La méthode onSuccess()
vous informe uniquement que le processus de découverte a réussi et ne fournit aucune information sur les pairs réels détectés, le cas échéant. L'exemple de code suivant montre comment procéder.
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) { ... } });
Si le processus de découverte réussit et détecte les pairs, le système diffuse l'intent WIFI_P2P_PEERS_CHANGED_ACTION
, que vous pouvez écouter dans un broadcast receiver pour obtenir une liste de pairs. Lorsque votre application reçoit l'intent WIFI_P2P_PEERS_CHANGED_ACTION
, vous pouvez demander la liste des pairs détectés avec requestPeers()
. Le code suivant montre comment configurer cela.
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); } }
La méthode requestPeers()
est également asynchrone et peut notifier votre activité lorsqu'une liste de pairs est disponible avec onPeersAvailable()
, qui est défini dans l'interface WifiP2pManager.PeerListListener
. La méthode onPeersAvailable()
fournit un WifiP2pDeviceList
, que vous pouvez itérer pour trouver le pair auquel vous connecter.
Se connecter à des applications similaires
Une fois que vous avez obtenu la liste des pairs possibles et sélectionné un appareil auquel vous connecter, appelez la méthode connect()
pour vous connecter à l'appareil. Cet appel de méthode nécessite un objet WifiP2pConfig
contenant des informations sur l'appareil auquel se connecter.
WifiP2pManager.ActionListener
peut vous informer du succès ou de l'échec d'une connexion. Le code suivant vous montre comment créer une connexion à un appareil.
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 } });
Transférer des données
Une fois la connexion établie, vous pouvez transférer des données entre les appareils dotés de sockets. Les étapes de base du transfert de données sont les suivantes:
- Créez un
ServerSocket
. Ce socket attend une connexion d'un client sur un port spécifié et se bloque jusqu'à ce que cela se produise. Faites-le donc dans un thread d'arrière-plan. - Créez un client
Socket
. Le client utilise l'adresse IP et le port du socket serveur pour se connecter à l'appareil du serveur. - Envoyer des données du client au serveur. Lorsque le socket client se connecte correctement au socket du serveur, vous pouvez envoyer des données du client au serveur à l'aide de flux d'octets.
- Le socket serveur attend une connexion client (avec la méthode
accept()
). Cet appel se bloque jusqu'à ce qu'un client se connecte. Vous devez donc l'appeler dans un autre thread. Lorsqu'une connexion se produit, l'appareil serveur peut recevoir les données du client.
L'exemple suivant, modifié à partir de la démonstration Wi-Fi P2P, vous montre comment créer cette communication socket client-serveur et transférer des images JPEG d'un client vers un serveur avec un service. Pour obtenir un exemple fonctionnel complet, compilez et exécutez la démonstration.
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); } } }
Sur le client, connectez-vous au socket serveur avec un socket client et transférez les données. Dans cet exemple, un fichier JPEG est transféré sur le système de fichiers de l'appareil client.
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 } } } }