Tổng quan về Wi-Fi Direct (ngang hàng hoặc P2P)

Wi-Fi Direct (P2P) cho phép các thiết bị có phần cứng phù hợp kết nối trực tiếp với nhau qua Wi-Fi mà không cần điểm truy cập trung gian. Khi sử dụng các API này, bạn có thể phát hiện và kết nối với các thiết bị khác khi mỗi thiết bị hỗ trợ Wi-Fi P2P, sau đó giao tiếp qua kết nối nhanh chóng ở khoảng cách dài hơn nhiều so với kết nối Bluetooth. Điều này hữu ích cho các ứng dụng chia sẻ dữ liệu giữa người dùng, chẳng hạn như trò chơi nhiều người chơi hoặc ứng dụng chia sẻ ảnh.

Các API Wi-Fi P2P bao gồm các phần chính sau:

  • Các phương thức cho phép bạn phát hiện, yêu cầu và kết nối với các ứng dụng ngang hàng được xác định trong lớp WifiP2pManager.
  • Trình nghe cho phép bạn nhận thông báo về việc gọi phương thức WifiP2pManager thành công hay không. Khi gọi các phương thức WifiP2pManager, mỗi phương thức có thể nhận một trình nghe cụ thể được truyền dưới dạng tham số.
  • Ý định thông báo cho bạn về các sự kiện cụ thể do khung Wi-Fi P2P phát hiện, chẳng hạn như kết nối bị gián đoạn hoặc ứng dụng ngang hàng mới được phát hiện.

Bạn thường sẽ sử dụng cùng nhau 3 thành phần chính này của API. Ví dụ: bạn có thể cung cấp WifiP2pManager.ActionListener cho lệnh gọi đến discoverPeers() để các phương thức ActionListener.onSuccess() và ActionListener.onFailure() có thể thông báo cho bạn. Ý định WIFI_P2P_PEERS_CHANGED_ACTION cũng được truyền tin nếu phương thức discoverPeers() phát hiện thấy danh sách các ứng dụng ngang hàng đã thay đổi.

Tổng quan về API

Lớp WifiP2pManager cung cấp các phương thức cho phép bạn tương tác với phần cứng Wi-Fi trên thiết bị để thực hiện những việc như phát hiện và kết nối với các ứng dụng ngang hàng. Bạn có thể thực hiện các thao tác sau:

Bảng 1. Phương thức Wi-Fi P2P

Phương thức Nội dung mô tả
initialize() Đăng ký ứng dụng với khung Wi-Fi. Gọi phương thức này trước khi gọi bất kỳ phương thức Wi-Fi P2P nào khác.
connect() Bắt đầu kết nối ngang hàng với một thiết bị có cấu hình được chỉ định.
cancelConnect() Huỷ mọi hoạt động thương lượng nhóm ngang hàng đang diễn ra.
requestConnectInfo() Yêu cầu thông tin kết nối của thiết bị.
createGroup() Tạo một nhóm ngang hàng với thiết bị hiện tại là chủ sở hữu nhóm.
removeGroup() Xoá nhóm ngang hàng hiện tại.
requestGroupInfo() Yêu cầu thông tin nhóm ngang hàng.
discoverPeers() Bắt đầu phát hiện ứng dụng ngang hàng.
requestPeers() Yêu cầu danh sách hiện tại gồm các ứng dụng ngang hàng đã phát hiện.

Các phương thức WifiP2pManager cho phép bạn truyền một trình nghe để khung Wi-Fi P2P có thể thông báo cho hoạt động của bạn về trạng thái của lệnh gọi. Các giao diện trình nghe có sẵn và các lệnh gọi phương thức WifiP2pManager tương ứng sử dụng trình nghe được mô tả trong bảng 2.

Bảng 2. Trình nghe Wi-Fi P2P

Giao diện trình nghe Các thao tác được liên kết
WifiP2pManager.ActionListener connect(), cancelConnect(), createGroup(), removeGroup(), và discoverPeers()
WifiP2pManager.ChannelListener initialize()
WifiP2pManager.ConnectionInfoListener requestConnectInfo()
WifiP2pManager.GroupInfoListener requestGroupInfo()
WifiP2pManager.PeerListListener requestPeers()

Các API Wi-Fi P2P xác định các ý định được truyền tin khi một số sự kiện Wi-Fi P2P xảy ra, chẳng hạn như khi một ứng dụng ngang hàng mới được phát hiện hoặc khi trạng thái Wi-Fi của thiết bị thay đổi. Bạn có thể đăng ký nhận các ý định này trong ứng dụng bằng cách tạo một bộ nhận tín hiệu truyền tin xử lý các ý định này:

Bảng 3. Ý định Wi-Fi P2P

Intent Nội dung mô tả
WIFI_P2P_CONNECTION_CHANGED_ACTION Truyền tin khi trạng thái kết nối Wi-Fi của thiết bị thay đổi.
WIFI_P2P_PEERS_CHANGED_ACTION Truyền tin khi bạn gọi discoverPeers(). Bạn thường sẽ gọi requestPeers() để lấy danh sách các ứng dụng ngang hàng được cập nhật nếu bạn xử lý ý định này trong ứng dụng.
WIFI_P2P_STATE_CHANGED_ACTION Truyền tin khi Wi-Fi P2P được bật hoặc tắt trên thiết bị.
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION Truyền tin khi thông tin chi tiết của thiết bị đã thay đổi, chẳng hạn như tên thiết bị.

Tạo bộ nhận tín hiệu truyền tin cho ý định Wi-Fi P2P

Bộ nhận tín hiệu truyền tin cho phép bạn nhận các ý định do hệ thống Android truyền tin để ứng dụng có thể phản hồi các sự kiện mà bạn quan tâm. Các bước cơ bản để tạo bộ nhận tín hiệu truyền tin nhằm xử lý ý định Wi-Fi P2P như sau:

  1. Tạo một lớp mở rộng lớp BroadcastReceiver. Đối với hàm khởi tạo của lớp, bạn sẽ sử dụng các tham số cho WifiP2pManager, WifiP2pManager.Channel và hoạt động mà bộ nhận tín hiệu truyền tin này sẽ được đăng ký. Điều này cho phép bộ nhận tín hiệu truyền tin gửi thông tin cập nhật đến hoạt động cũng như có quyền truy cập vào phần cứng Wi-Fi và kênh giao tiếp nếu cần.

  2. Trong bộ nhận tín hiệu truyền tin, hãy kiểm tra các ý định mà bạn quan tâm trong onReceive() phương thức. Thực hiện mọi thao tác cần thiết tuỳ thuộc vào ý định nhận được. Ví dụ: nếu bộ nhận tín hiệu truyền tin nhận được ý định WIFI_P2P_PEERS_CHANGED_ACTION, bạn có thể gọi phương thức requestPeers() để lấy danh sách các ứng dụng ngang hàng hiện được phát hiện.

Mã sau đây cho biết cách tạo bộ nhận tín hiệu truyền tin thông thường. Bộ nhận tín hiệu truyền tin lấy đối tượng WifiP2pManager và một hoạt động làm đối số, đồng thời sử dụng 2 lớp này để thực hiện các thao tác cần thiết một cách thích hợp khi bộ nhận tín hiệu truyền tin nhận được một ý định:

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

Trên các thiết bị chạy Android 10 trở lên, các ý định truyền tin sau đây không phải là ý định cố định:

WIFI_P2P_CONNECTION_CHANGED_ACTION
Ứng dụng có thể sử dụng requestConnectionInfo(), requestNetworkInfo(), hoặc requestGroupInfo() để truy xuất thông tin kết nối hiện tại.
WIFI_P2P_THIS_DEVICE_CHANGED_ACTION
Ứng dụng có thể sử dụng requestDeviceInfo() để truy xuất thông tin kết nối hiện tại.

Tạo ứng dụng Wi-Fi P2P

Việc tạo ứng dụng Wi-Fi P2P bao gồm việc tạo và đăng ký trình nhận tin truyền tin cho ứng dụng, phát hiện các ứng dụng ngang hàng, kết nối với một ứng dụng ngang hàng và chuyển dữ liệu đến một ứng dụng ngang hàng. Các phần sau đây mô tả cách thực hiện việc này.

Thiết lập ban đầu

Trước khi sử dụng các API Wi-Fi P2P, bạn phải đảm bảo rằng ứng dụng có thể truy cập vào phần cứng và thiết bị hỗ trợ giao thức Wi-Fi P2P. Nếu Wi-Fi P2P được hỗ trợ, bạn có thể lấy một thực thể của WifiP2pManager, tạo và đăng ký bộ nhận tín hiệu truyền tin, đồng thời bắt đầu sử dụng các API Wi-Fi P2P.

  1. Yêu cầu quyền sử dụng phần cứng Wi-Fi trên thiết bị và khai báo ứng dụng của bạn có phiên bản SDK tối thiểu chính xác trong tệp kê khai 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" />

    Ngoài các quyền nêu trên, các API sau đây cũng yêu cầu bật Chế độ vị trí:

  2. Kiểm tra xem Wi-Fi P2P có bật và được hỗ trợ hay không. Một vị trí tốt để kiểm tra điều này là trong bộ nhận tín hiệu truyền tin khi bộ nhận này nhận được ý định WIFI_P2P_STATE_CHANGED_ACTION. Thông báo cho hoạt động của bạn về trạng thái Wi-Fi P2P và phản ứng cho phù hợp:

    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. Trong phương thức onCreate() của hoạt động, hãy lấy một thực thể của WifiP2pManager và đăng ký ứng dụng của bạn với khung Wi-Fi P2P bằng cách gọi initialize(). Phương thức này trả về một WifiP2pManager.Channel dùng để kết nối ứng dụng của bạn với khung Wi-Fi P2P. Bạn cũng nên tạo một thực thể của trình nhận tin truyền tin bằng các đối tượng WifiP2pManager và WifiP2pManager.Channel cùng với tham chiếu đến hoạt động của bạn. Điều này cho phép bộ nhận tín hiệu truyền tin của bạn thông báo cho hoạt động của bạn về các sự kiện thú vị và cập nhật cho phù hợp. Bạn cũng có thể thao tác với trạng thái Wi-Fi của thiết bị nếu cần:

    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. Tạo bộ lọc ý định và thêm các ý định tương tự mà bộ nhận tín hiệu truyền tin của bạn kiểm tra:

    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. Đăng ký bộ nhận tín hiệu truyền tin trong phương thức onResume() của hoạt động và huỷ đăng ký trong phương thức onPause() của hoạt động:

    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. Khi bạn đã nhận được WifiP2pManager.Channel và thiết lập trình nhận tin truyền tin, ứng dụng của bạn có thể thực hiện các lệnh gọi phương thức Wi-Fi P2P và nhận ý định Wi-Fi P2P.

  7. Triển khai ứng dụng của bạn bằng các tính năng Wi-Fi P2P bằng cách gọi các phương thức trong WifiP2pManager.

Các phần tiếp theo mô tả cách thực hiện các thao tác thông thường như phát hiện và kết nối với các ứng dụng ngang hàng.

Khám phá các ứng dụng ngang hàng

Gọi discoverPeers() để phát hiện các ứng dụng ngang hàng có sẵn trong phạm vi và có thể kết nối. Lệnh gọi đến hàm này là không đồng bộ và thông báo thành công hoặc không thành công cho ứng dụng của bạn bằng onSuccess() và onFailure() nếu bạn đã tạo WifiP2pManager.ActionListener. Phương thức onSuccess() chỉ thông báo cho bạn rằng quá trình phát hiện đã thành công và không cung cấp bất kỳ thông tin nào về các ứng dụng ngang hàng thực tế mà phương thức này đã phát hiện (nếu có). Mã mẫu sau đây cho biết cách thiết lập.

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

Nếu quá trình phát hiện thành công và phát hiện các ứng dụng ngang hàng, hệ thống sẽ truyền tin ý định WIFI_P2P_PEERS_CHANGED_ACTION. Bạn có thể theo dõi ý định này trong bộ nhận tín hiệu truyền tin để lấy danh sách các ứng dụng ngang hàng. Khi ứng dụng của bạn nhận được ý định WIFI_P2P_PEERS_CHANGED_ACTION, bạn có thể yêu cầu danh sách các ứng dụng ngang hàng đã phát hiện bằng requestPeers(). Mã sau đây cho biết cách thiết lập.

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

Phương thức requestPeers() cũng là phương thức không đồng bộ và có thể thông báo cho hoạt động của bạn khi có danh sách các ứng dụng ngang hàng bằng onPeersAvailable(), được xác định trong giao diện WifiP2pManager.PeerListListener. Phương thức onPeersAvailable() cung cấp cho bạn một WifiP2pDeviceList, mà bạn có thể lặp lại để tìm ứng dụng ngang hàng cần kết nối.

Kết nối với các ứng dụng ngang hàng

Sau khi bạn nhận được danh sách các ứng dụng ngang hàng có thể và chọn một thiết bị để kết nối, hãy gọi phương thức connect() để kết nối với thiết bị đó. Lệnh gọi phương thức này yêu cầu đối tượng WifiP2pConfig chứa thông tin về thiết bị cần kết nối. WifiP2pManager.ActionListener có thể thông báo cho bạn về việc kết nối thành công hay không. Mã sau đây cho biết cách tạo kết nối với một thiết bị.

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

Chuyển dữ liệu

Sau khi thiết lập kết nối, bạn có thể chuyển dữ liệu giữa các thiết bị bằng ổ cắm. Các bước cơ bản để chuyển dữ liệu như sau:

  1. Tạo một ServerSocket. Ổ cắm này chờ kết nối từ một ứng dụng trên một cổng được chỉ định và chặn cho đến khi kết nối xảy ra, vì vậy, hãy thực hiện việc này trong một luồng nền.
  2. Tạo ứng dụng Socket. Ứng dụng sử dụng địa chỉ IP và cổng của ổ cắm máy chủ để kết nối với thiết bị máy chủ.
  3. Gửi dữ liệu từ ứng dụng đến máy chủ. Khi điểm cuối máy khách kết nối thành công với điểm cuối máy chủ, bạn có thể gửi dữ liệu từ ứng dụng đến máy chủ bằng luồng byte.
  4. Điểm cuối máy chủ chờ kết nối ứng dụng (bằng phương thức accept()). Lệnh gọi này chặn cho đến khi một ứng dụng kết nối, vì vậy, hãy gọi lệnh này trong một luồng khác. Khi kết nối xảy ra, thiết bị máy chủ có thể nhận dữ liệu từ ứng dụng.

Ví dụ sau đây, được sửa đổi từ Bản minh hoạ Wi-Fi P2P, cho biết cách tạo giao tiếp ổ cắm ứng dụng-máy chủ này và chuyển hình ảnh JPEG từ ứng dụng đến máy chủ bằng một dịch vụ. Để xem ví dụ đầy đủ về cách thức hoạt động, hãy biên dịch và chạy bản minh hoạ.

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

Trên ứng dụng, hãy kết nối với điểm cuối máy chủ bằng điểm cuối máy khách và chuyển dữ liệu. Ví dụ này chuyển một tệp JPEG trên hệ thống tệp của thiết bị ứng dụng.

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