इस पेज का अनुवाद Cloud Translation API से किया गया है.

वाई-फ़ाई अवेयर की खास जानकारी

Wi-Fi Aware की सुविधाओं की मदद से, Android 8.0 (एपीआई लेवल 26) और इसके बाद के वर्शन वाले डिवाइसों को एक-दूसरे का पता लगाने और सीधे तौर पर कनेक्ट करने में मदद मिलती है. इसके लिए, किसी अन्य तरह के कनेक्शन की ज़रूरत नहीं होती. वाई-फ़ाई अवेयर को नेबर अवेयरनेस नेटवर्किंग (एनएएन) भी कहा जाता है.

वाई-फ़ाई अवेयर नेटवर्किंग, आस-पास मौजूद डिवाइसों के साथ क्लस्टर बनाकर काम करती है. अगर कोई डिवाइस किसी इलाके में मौजूद पहला डिवाइस है, तो वह नया क्लस्टर बनाती है. क्लस्टर करने का यह तरीका, पूरे डिवाइस पर लागू होता है. इसे Wi-Fi Aware सिस्टम सेवा मैनेज करती है. ऐप्लिकेशन, क्लस्टर करने के तरीके को कंट्रोल नहीं कर सकते. ऐप्लिकेशन, वाई-फ़ाई अवेयर सिस्टम सेवा से बात करने के लिए, वाई-फ़ाई अवेयर एपीआई का इस्तेमाल करते हैं. यह सेवा, डिवाइस पर वाई-फ़ाई अवेयर हार्डवेयर को मैनेज करती है.

वाई-फ़ाई अवेयर एपीआई की मदद से, ऐप्लिकेशन ये काम कर सकते हैं:

दूसरे डिवाइसों को ढूंढना: इस एपीआई में, आस-पास मौजूद दूसरे डिवाइसों को ढूंढने का एक तरीका है. यह प्रोसेस तब शुरू होती है, जब कोई डिवाइस एक या उससे ज़्यादा ऐसी सेवाएं पब्लिश करता है जिन्हें खोजा जा सकता है. इसके बाद, जब कोई डिवाइस एक या उससे ज़्यादा सेवाओं की सदस्यता लेता है और पब्लिशर के वाई-फ़ाई नेटवर्क की रेंज में आता है, तो सदस्य को सूचना मिलती है कि उससे मिलता-जुलता पब्लिशर मिल गया है. जब सदस्य को कोई पब्लिशर मिल जाता है, तो वह उस डिवाइस पर छोटा मैसेज भेज सकता है या नेटवर्क कनेक्शन सेट अप कर सकता है. डिवाइस, पब्लिशर और सदस्य, दोनों के तौर पर काम कर सकते हैं.
नेटवर्क कनेक्शन बनाना: दो डिवाइसों के एक-दूसरे को ढूंढने के बाद, वे ऐक्सेस पॉइंट के बिना, दोनों तरफ़ से काम करने वाला Wi-Fi Aware नेटवर्क कनेक्शन बना सकते हैं.

ब्लूटूथ कनेक्शन के मुकाबले, वाई-फ़ाई अवेयर नेटवर्क कनेक्शन की मदद से, लंबी दूरी पर ज़्यादा डेटा ट्रांसफ़र किया जा सकता है. इस तरह के कनेक्शन, उन ऐप्लिकेशन के लिए काम के होते हैं जो उपयोगकर्ताओं के बीच काफ़ी ज़्यादा डेटा शेयर करते हैं. जैसे, फ़ोटो शेयर करने वाले ऐप्लिकेशन.

Android 13 (एपीआई लेवल 33) में किए गए सुधार

Android 13 (एपीआई लेवल 33) और उसके बाद के वर्शन वाले डिवाइसों पर, ऐप्लिकेशन PublishConfig.Builder.setInstantCommunicationModeEnabled() और SubscribeConfig.Builder.setInstantCommunicationModeEnabled() तरीकों का इस्तेमाल करके, पब्लिशर या सदस्य के डिस्कवरी सेशन के लिए, इंस्टैंट कम्यूनिकेशन मोड को चालू या बंद कर सकते हैं. इंस्टैंट कम्यूनिकेशन मोड की मदद से, मैसेज एक्सचेंज करने, सेवा खोजने, और पब्लिशर या सदस्य के डिस्कवरी सेशन के हिस्से के तौर पर सेट अप किए गए किसी भी डेटा-पाथ की स्पीड बढ़ जाती है. यह पता लगाने के लिए कि किसी डिवाइस पर इंस्टैंट कम्यूनिकेशन मोड काम करता है या नहीं, isInstantCommunicationModeSupported() तरीके का इस्तेमाल करें.

Android 12 (एपीआई लेवल 31) में किए गए सुधार

Android 12 (एपीआई लेवल 31) में, वाई-फ़ाई अवेयर सुविधा को बेहतर बनाया गया है:

Android 12 (एपीआई लेवल 31) या इसके बाद के वर्शन वाले डिवाइसों पर, onServiceLost() कॉलबैक का इस्तेमाल करके सूचनाएं पाएं. इससे, आपको यह पता चलेगा कि आपके ऐप्लिकेशन को सेवा बंद होने या दायरे से बाहर जाने की वजह से, खोजी गई सेवा नहीं मिली है.
वाई-फ़ाई अवेयर डेटा पाथ को सेटअप करना आसान हो गया है. पिछले वर्शन में, शुरू करने वाले व्यक्ति का MAC पता देने के लिए, L2 मैसेजिंग का इस्तेमाल किया जाता था. इससे इंतज़ार का समय बढ़ जाता था. Android 12 और उसके बाद के वर्शन वाले डिवाइसों पर, रिस्पॉन्स देने वाले डिवाइस (सर्वर) को किसी भी पीयर को स्वीकार करने के लिए कॉन्फ़िगर किया जा सकता है. इसका मतलब है कि उसे शुरू करने वाले डिवाइस का एमएसी पता पहले से जानने की ज़रूरत नहीं है. इससे डेटापाथ को शुरू करने की प्रोसेस तेज़ हो जाती है. साथ ही, एक ही नेटवर्क अनुरोध से कई पॉइंट-टू-पॉइंट लिंक चालू हो जाते हैं.
Android 12 या उसके बाद के वर्शन पर काम करने वाले ऐप्लिकेशन, फ़िलहाल उपलब्ध डेटा पाथ की संख्या जानने, सेशन पब्लिश करने, और सेशन की सदस्यता लेने के लिए, WifiAwareManager.getAvailableAwareResources() के तरीके का इस्तेमाल कर सकते हैं. इससे ऐप्लिकेशन यह तय कर सकता है कि उसके पसंदीदा फ़ंक्शन को लागू करने के लिए, ज़रूरत के मुताबिक संसाधन उपलब्ध हैं या नहीं.

शुरुआती सेट अप

वाई-फ़ाई अवेयर डिस्कवरी और नेटवर्किंग का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन को सेट अप करने के लिए यह तरीका अपनाएं:

अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, इन अनुमतियों का अनुरोध करें:

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

देखें कि डिवाइस पर PackageManager API की मदद से, वाई-फ़ाई अवेयर की सुविधा काम करती है या नहीं. इसके लिए, यहां दिया गया तरीका अपनाएं:
Kotlin
```
context.packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI_AWARE)
```
Java
```
context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI_AWARE);
```
देखें कि फ़िलहाल Wi-Fi Aware की सुविधा उपलब्ध है या नहीं. हो सकता है कि डिवाइस में Wi-Fi Aware की सुविधा मौजूद हो, लेकिन फ़िलहाल यह उपलब्ध न हो. ऐसा इसलिए हो सकता है, क्योंकि उपयोगकर्ता ने Wi-Fi या जगह की जानकारी की सुविधा बंद कर दी हो. हार्डवेयर और फ़र्मवेयर की क्षमताओं के आधार पर, हो सकता है कि कुछ डिवाइसों पर Wi-Fi Direct, SoftAP या tethering का इस्तेमाल करने पर, Wi-Fi Aware की सुविधा काम न करे. यह देखने के लिए कि फ़िलहाल वाई-फ़ाई अवेयर की सुविधा उपलब्ध है या नहीं, isAvailable() पर कॉल करें.

Wi-Fi Aware की उपलब्धता कभी भी बदल सकती है. आपके ऐप्लिकेशन को ACTION_WIFI_AWARE_STATE_CHANGED पाने के लिए, BroadcastReceiver रजिस्टर करना चाहिए. यह सूचना, खरीदारी के लिए उपलब्धता में बदलाव होने पर भेजी जाती है. जब आपके ऐप्लिकेशन को ब्रॉडकास्ट इंटेंट मिलता है, तो उसे सभी मौजूदा सेशन को खारिज कर देना चाहिए. ऐसा मान लें कि Wi-Fi Aware सेवा में रुकावट आई थी. इसके बाद, उपलब्धता की मौजूदा स्थिति की जांच करें और उसके हिसाब से ऐप्लिकेशन के काम करने के तरीके में बदलाव करें. उदाहरण के लिए:
Kotlin
```
val wifiAwareManager = context.getSystemService(Context.WIFI_AWARE_SERVICE) as WifiAwareManager?
val filter = IntentFilter(WifiAwareManager.ACTION_WIFI_AWARE_STATE_CHANGED)
val myReceiver = object : BroadcastReceiver() {

    override fun onReceive(context: Context, intent: Intent) {
        // discard current sessions
        if (wifiAwareManager?.isAvailable) {
            ...
        } else {
            ...
        }
    }
}
context.registerReceiver(myReceiver, filter)
```
Java
```
WifiAwareManager wifiAwareManager = 
        (WifiAwareManager)context.getSystemService(Context.WIFI_AWARE_SERVICE)
IntentFilter filter =
        new IntentFilter(WifiAwareManager.ACTION_WIFI_AWARE_STATE_CHANGED);
BroadcastReceiver myReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        // discard current sessions
        if (wifiAwareManager.isAvailable()) {
            ...
        } else {
            ...
        }
    }
};
context.registerReceiver(myReceiver, filter);
```

ज़्यादा जानकारी के लिए, ब्रॉडकास्ट लेख पढ़ें.

सेशन पाना

Wi-Fi Aware का इस्तेमाल शुरू करने के लिए, आपके ऐप्लिकेशन को attach() को कॉल करके WifiAwareSession पाना होगा. यह तरीका, ये काम करता है:

Wi-Fi Aware हार्डवेयर को चालू करता है.
वाई-फ़ाई अवेयर क्लस्टर में शामिल होता है या बनाता है.
यह एक यूनीक नेमस्पेस के साथ वाई-फ़ाई अवेयर सेशन बनाता है. यह नेमस्पेस, उसमें बनाए गए सभी डिस्कवरी सेशन के लिए कंटेनर के तौर पर काम करता है.

अगर ऐप्लिकेशन अटैच हो जाता है, तो सिस्टम onAttached() कॉलबैक को लागू करता है. यह कॉलबैक एक WifiAwareSession ऑब्जेक्ट उपलब्ध कराता है, जिसका इस्तेमाल आपके ऐप्लिकेशन को सेशन के सभी आगे के ऑपरेशन के लिए करना चाहिए. कोई ऐप्लिकेशन, सेवा पब्लिश करने या सेवा की सदस्यता लेने के लिए सेशन का इस्तेमाल कर सकता है.

आपके ऐप्लिकेशन को attach() को सिर्फ़ एक बार कॉल करना चाहिए. अगर आपका ऐप्लिकेशन attach() को कई बार कॉल करता है, तो हर कॉल के लिए ऐप्लिकेशन को एक अलग सेशन मिलता है. हर सेशन का अपना नेमस्पेस होता है. यह मुश्किल स्थितियों में मददगार हो सकता है, लेकिन आम तौर पर इसका इस्तेमाल नहीं किया जाना चाहिए.

सेवा पब्लिश करना

किसी सेवा को खोजे जा सकने लायक बनाने के लिए, publish() तरीके को कॉल करें. यह तरीका इन पैरामीटर का इस्तेमाल करता है:

PublishConfig, सेवा का नाम और मैच फ़िल्टर जैसी अन्य कॉन्फ़िगरेशन प्रॉपर्टी बताता है.
DiscoverySessionCallback से यह तय होता है कि इवेंट होने पर कौनसी कार्रवाइयां की जाएंगी. जैसे, जब सदस्य को कोई मैसेज मिलता है.

यहां एक उदाहरण दिया गया है:

Kotlin

val config: PublishConfig = PublishConfig.Builder()
        .setServiceName(AWARE_FILE_SHARE_SERVICE_NAME)
        .build()
awareSession.publish(config, object : DiscoverySessionCallback() {

    override fun onPublishStarted(session: PublishDiscoverySession) {
        ...
    }

    override fun onMessageReceived(peerHandle: PeerHandle, message: ByteArray) {
        ...
    }
})

Java

PublishConfig config = new PublishConfig.Builder()
    .setServiceName(“Aware_File_Share_Service_Name”)
    .build();

awareSession.publish(config, new DiscoverySessionCallback() {
    @Override
    public void onPublishStarted(PublishDiscoverySession session) {
        ...
    }
    @Override
    public void onMessageReceived(PeerHandle peerHandle, byte[] message) {
        ...
    }
}, null);

पब्लिकेशन पूरा होने पर, onPublishStarted() कॉलबैक वाला तरीका इस्तेमाल किया जाता है.

पब्लिश करने के बाद, जब सदस्यों के ऐप्लिकेशन चलाने वाले डिवाइस, पब्लिश करने वाले डिवाइस की Wi-Fi रेंज में आ जाते हैं, तो सदस्यों को यह सेवा दिखती है. जब कोई सदस्य किसी पब्लिशर को खोजता है, तो पब्लिशर को कोई सूचना नहीं मिलती. हालांकि, अगर सदस्य पब्लिशर को मैसेज भेजता है, तो पब्लिशर को सूचना मिलती है. ऐसा होने पर, onMessageReceived() कॉलबैक मेथड को कॉल किया जाता है. इस तरीके में दिए गए PeerHandle आर्ग्युमेंट का इस्तेमाल करके, सदस्य को मैसेज भेजा जा सकता है या उससे कनेक्शन बनाया जा सकता है.

सेवा को पब्लिश होने से रोकने के लिए, DiscoverySession.close() को कॉल करें. डिस्कवरी सेशन, उनके पैरंट WifiAwareSession से जुड़े होते हैं. अगर पैरंट सेशन बंद हो जाता है, तो उससे जुड़े डिस्कवरी सेशन भी बंद हो जाते हैं. हालांकि, खारिज किए गए ऑब्जेक्ट भी बंद हो जाते हैं, लेकिन सिस्टम यह गारंटी नहीं देता कि दायरे से बाहर के सेशन कब बंद हो जाएंगे. इसलिए, हमारा सुझाव है कि आप close() तरीकों को साफ़ तौर पर कॉल करें.

किसी सेवा की सदस्यता लेना

किसी सेवा की सदस्यता लेने के लिए, subscribe() का इस्तेमाल करें. यह तरीका इन पैरामीटर का इस्तेमाल करता है:

SubscribeConfig, सदस्यता लेने के लिए सेवा का नाम और मैच फ़िल्टर जैसी अन्य कॉन्फ़िगरेशन प्रॉपर्टी बताता है.
DiscoverySessionCallback, इवेंट होने पर की जाने वाली कार्रवाइयों के बारे में बताता है. जैसे, पब्लिशर का पता चलने पर.

यहां एक उदाहरण दिया गया है:

Kotlin

val config: SubscribeConfig = SubscribeConfig.Builder()
        .setServiceName(AWARE_FILE_SHARE_SERVICE_NAME)
        .build()
awareSession.subscribe(config, object : DiscoverySessionCallback() {

    override fun onSubscribeStarted(session: SubscribeDiscoverySession) {
        ...
    }

    override fun onServiceDiscovered(
            peerHandle: PeerHandle,
            serviceSpecificInfo: ByteArray,
            matchFilter: List<ByteArray>
    ) {
        ...
    }
}, null)

Java

SubscribeConfig config = new SubscribeConfig.Builder()
    .setServiceName("Aware_File_Share_Service_Name")
    .build();

awareSession.subscribe(config, new DiscoverySessionCallback() {
    @Override
    public void onSubscribeStarted(SubscribeDiscoverySession session) {
        ...
    }

    @Override
    public void onServiceDiscovered(PeerHandle peerHandle,
            byte[] serviceSpecificInfo, List<byte[]> matchFilter) {
        ...
    }
}, null);

अगर सदस्यता लेने की प्रोसेस पूरी हो जाती है, तो सिस्टम आपके ऐप्लिकेशन में onSubscribeStarted() कॉलबैक को कॉल करता है. आपके ऐप्लिकेशन को पब्लिशर मिल जाने के बाद, आपके पास कॉलबैक में SubscribeDiscoverySession आर्ग्युमेंट का इस्तेमाल करके पब्लिशर से संपर्क करने का विकल्प होता है. इसलिए, आपको यह रेफ़रंस सेव करना चाहिए. डिस्कवरी सेशन में updateSubscribe() को कॉल करके, सदस्यता लेने वाले सेशन को किसी भी समय अपडेट किया जा सकता है.

इस दौरान, आपकी सदस्यता, मैच होने वाले पब्लिशर के वाई-फ़ाई की रेंज में आने का इंतज़ार करती है. ऐसा होने पर, सिस्टम onServiceDiscovered() कॉलबैक वाला तरीका लागू करता है. इस कॉलबैक के PeerHandle आर्ग्युमेंट का इस्तेमाल करके, उस पब्लिशर को मैसेज भेजा जा सकता है या कनेक्शन बनाया जा सकता है.

किसी सेवा की सदस्यता छोड़ने के लिए, DiscoverySession.close() पर कॉल करें. डिस्कवरी सेशन, उनके पैरंट WifiAwareSession से जुड़े होते हैं. अगर पैरंट सेशन बंद हो जाता है, तो उससे जुड़े डिस्कवरी सेशन भी बंद हो जाते हैं. हालांकि, खारिज किए गए ऑब्जेक्ट भी बंद हो जाते हैं, लेकिन सिस्टम यह गारंटी नहीं देता कि दायरे से बाहर के सेशन कब बंद होंगे. इसलिए, हमारा सुझाव है कि आप साफ़ तौर पर close() तरीकों को कॉल करें.

मैसेज भेजें

किसी दूसरे डिवाइस पर मैसेज भेजने के लिए, आपके पास ये ऑब्जेक्ट होने चाहिए:

DiscoverySession. इस ऑब्जेक्ट की मदद से, sendMessage() को कॉल किया जा सकता है. आपके ऐप्लिकेशन को DiscoverySession तब मिलता है, जब वह कोई सेवा पब्लिश करता है या किसी सेवा की सदस्यता लेता है.
मैसेज को रूट करने के लिए, दूसरे डिवाइस का PeerHandle. आपके ऐप्लिकेशन को किसी दूसरे डिवाइस का PeerHandle इनमें से किसी एक तरीके से मिलता है:
- आपका ऐप्लिकेशन कोई सेवा पब्लिश करता है और उसे किसी सदस्य से मैसेज मिलता है. आपके ऐप्लिकेशन को onMessageReceived() callback से सदस्य का PeerHandle मिलता है.
- आपका ऐप्लिकेशन किसी सेवा की सदस्यता लेता है. इसके बाद, जब उसे मैच करने वाला पब्लिशर मिलता है, तो आपके ऐप्लिकेशन को onServiceDiscovered() कॉलबैक से पब्लिशर का PeerHandle मिलता है.

मैसेज भेजने के लिए, sendMessage() पर कॉल करें. इसके बाद, ये कॉलबैक हो सकते हैं:

जब पीयर को मैसेज मिल जाता है, तो सिस्टम मैसेज भेजने वाले ऐप्लिकेशन में onMessageSendSucceeded() कॉलबैक को कॉल करता है.
जब पीयर को कोई मैसेज मिलता है, तो सिस्टम मैसेज पाने वाले ऐप्लिकेशन में onMessageReceived() कॉलबैक को कॉल करता है.

ध्यान दें: मैसेज का इस्तेमाल आम तौर पर कम साइज़ वाले मैसेज भेजने के लिए किया जाता है. ऐसा इसलिए, क्योंकि हो सकता है कि वे डिलीवर न हों (या क्रम से या एक से ज़्यादा बार डिलीवर हों) और उनकी लंबाई करीब 255 बाइट तक सीमित हो. वीडियो की लंबाई की सटीक सीमा जानने के लिए, getMaxServiceSpecificInfoLength() को कॉल करें. तेज़ी से और दोनों तरफ़ से होने वाले कम्यूनिकेशन के लिए, आपके ऐप्लिकेशन को इसके बजाय कनेक्शन बनाना चाहिए.

हालांकि, PeerHandle की ज़रूरत, पीयर के साथ बातचीत करने के लिए होती है, लेकिन आपको इस पर पूरी तरह से भरोसा नहीं करना चाहिए. ऐप्लिकेशन, बेहतर लेवल के आइडेंटिफ़ायर का इस्तेमाल कर सकता है. ये आइडेंटिफ़ायर, डिस्कवरी सेवा में या बाद में भेजे जाने वाले मैसेज में एम्बेड किए जाते हैं. डिस्कवरी सेवा में आइडेंटिफ़ायर को एम्बेड करने के लिए, PublishConfig या SubscribeConfig के setMatchFilter() या setServiceSpecificInfo() तरीके का इस्तेमाल किया जा सकता है. setMatchFilter() तरीके से, वीडियो के सुझावों पर असर पड़ता है. वहीं, setServiceSpecificInfo() तरीके से, वीडियो के सुझावों पर कोई असर नहीं पड़ता.

किसी मैसेज में आइडेंटिफ़ायर जोड़ने का मतलब है कि मैसेज के बाइट कलेक्शन में बदलाव करके, उसमें आइडेंटिफ़ायर शामिल करना. उदाहरण के लिए, पहले कुछ बाइट के तौर पर.

कनेक्शन बनाना

Wi-Fi Aware, दो Wi-Fi Aware डिवाइसों के बीच क्लाइंट-सर्वर नेटवर्किंग की सुविधा देता है.

क्लाइंट-सर्वर कनेक्शन सेट अप करने के लिए:

सेवा पब्लिश करने (सर्वर पर) और सेवा की सदस्यता लेने (क्लाइंट पर) के लिए, वाई-फ़ाई अवेयर डिस्कवरी का इस्तेमाल करें.
जब सदस्य को पब्लिशर मिल जाता है, तो सदस्य से पब्लिशर को मैसेज भेजें.
पब्लिशर डिवाइस पर ServerSocket शुरू करें और उसका पोर्ट सेट करें या पाएं:
Kotlin
```
val ss = ServerSocket(0)
val port = ss.localPort
```
Java
```
ServerSocket ss = new ServerSocket(0);
int port = ss.getLocalPort();
```

ConnectivityManager का इस्तेमाल करके, WifiAwareNetworkSpecifier का इस्तेमाल करके पब्लिशर पर वाई-फ़ाई अवेयर नेटवर्क का अनुरोध करें. साथ ही, सदस्य के डिस्कवरी सेशन और PeerHandle की जानकारी दें. यह जानकारी, सदस्य से मिले मैसेज से मिली है:

Kotlin

val networkSpecifier = WifiAwareNetworkSpecifier.Builder(discoverySession, peerHandle)
    .setPskPassphrase("somePassword")
    .setPort(port)
    .build()
val myNetworkRequest = NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI_AWARE)
    .setNetworkSpecifier(networkSpecifier)
    .build()
val callback = object : ConnectivityManager.NetworkCallback() {
    override fun onAvailable(network: Network) {
        ...
    }

    override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
        ...
    }

    override fun onLost(network: Network) {
        ...
    }
}

connMgr.requestNetwork(myNetworkRequest, callback);

Java

NetworkSpecifier networkSpecifier = new WifiAwareNetworkSpecifier.Builder(discoverySession, peerHandle)
    .setPskPassphrase("somePassword")
    .setPort(port)
    .build();
NetworkRequest myNetworkRequest = new NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI_AWARE)
    .setNetworkSpecifier(networkSpecifier)
    .build();
ConnectivityManager.NetworkCallback callback = new ConnectivityManager.NetworkCallback() {
    @Override
    public void onAvailable(Network network) {
        ...
    }

    @Override
    public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
        ...
    }

    @Override
    public void onLost(Network network) {
        ...
    }
};

ConnectivityManager connMgr.requestNetwork(myNetworkRequest, callback);

पब्लिशर के किसी नेटवर्क से अनुरोध करने के बाद, उसे सदस्य को मैसेज भेजना चाहिए.
जब सदस्य को पब्लिशर से मैसेज मिल जाता है, तो पब्लिशर के तौर पर इस्तेमाल किए गए तरीके का इस्तेमाल करके, सदस्य के लिए वाई-फ़ाई Aware नेटवर्क का अनुरोध करें. NetworkSpecifier बनाते समय, कोई पोर्ट न डालें. नेटवर्क कनेक्शन उपलब्ध होने, बदलने या बंद होने पर, सही कॉलबैक तरीके को कॉल किया जाता है.
जब सदस्य पर onAvailable() तरीका लागू किया जाता है, तो एक Network ऑब्जेक्ट उपलब्ध होता है. इसकी मदद से, पब्लिशर पर ServerSocket के साथ बातचीत करने के लिए, Socket खोला जा सकता है. हालांकि, इसके लिए आपको ServerSocket का IPv6 पता और पोर्ट पता पता होना चाहिए. ये आपको onCapabilitiesChanged() कॉलबैक में दिए गए NetworkCapabilities ऑब्जेक्ट से मिलते हैं:
Kotlin
```
val peerAwareInfo = networkCapabilities.transportInfo as WifiAwareNetworkInfo
val peerIpv6 = peerAwareInfo.peerIpv6Addr
val peerPort = peerAwareInfo.port
...
val socket = network.getSocketFactory().createSocket(peerIpv6, peerPort)
```
Java
```
WifiAwareNetworkInfo peerAwareInfo = (WifiAwareNetworkInfo) networkCapabilities.getTransportInfo();
Inet6Address peerIpv6 = peerAwareInfo.getPeerIpv6Addr();
int peerPort = peerAwareInfo.getPort();
...
Socket socket = network.getSocketFactory().createSocket(peerIpv6, peerPort);
```
नेटवर्क कनेक्शन पूरा होने के बाद, unregisterNetworkCallback() को कॉल करें.

ध्यान दें: नेटवर्क अनुरोध बनाना और नेटवर्क की ज़रूरी सुविधाओं के बारे में बताना, सिर्फ़ Wi-Fi Aware API के लिए नहीं है. नेटवर्क अनुरोधों के साथ काम करने के बारे में ज़्यादा जानकारी के लिए, ConnectivityManager देखें.

रेंजिंग पीयर और जगह की जानकारी के हिसाब से डिस्कवरी

वाई-फ़ाई आरटीटी की जगह की जानकारी की सुविधाओं वाला डिवाइस, आस-पास मौजूद डिवाइसों से सीधे तौर पर अपनी दूरी का पता लगा सकता है. साथ ही, इस जानकारी का इस्तेमाल करके वाई-फ़ाई अवेयर सेवा की खोज को सीमित कर सकता है.

Wi-Fi RTT API, Wi-Fi Aware पीयर के PeerHandle या MAC पते का इस्तेमाल करके, सीधे तौर पर रेंजिंग की सुविधा देता है.

वाई-फ़ाई अवेयर डिस्कवरी की सुविधा को सिर्फ़ किसी खास जियोफ़ेंस में मौजूद सेवाओं को खोजने के लिए सीमित किया जा सकता है. उदाहरण के लिए, आपके पास ऐसी जियोफ़ेंस सेट अप करने का विकल्प है जिससे "Aware_File_Share_Service_Name" सेवा पब्लिश करने वाले ऐसे डिवाइस का पता लगाया जा सके जो 3 मीटर (3,000 मिमी) से ज़्यादा और 10 मीटर (10,000 मिमी) से कम दूरी पर हो.

जियोफ़ेंसिंग की सुविधा चालू करने के लिए, पब्लिशर और सदस्य, दोनों को कार्रवाई करनी होगी:

पब्लिशर को setRangingEnabled(true) का इस्तेमाल करके, पब्लिश की गई सेवा पर रेंजिंग की सुविधा चालू करनी होगी.

अगर पब्लिशर, रेंजिंग की सुविधा चालू नहीं करता है, तो सदस्य की बताई गई किसी भी जियोफ़ेंस की पाबंदियों को अनदेखा कर दिया जाता है. साथ ही, दूरी को अनदेखा करके सामान्य डिस्कवरी की जाती है.
सदस्य को setMinDistanceMm और setMaxDistanceMm के कॉम्बिनेशन का इस्तेमाल करके, कोई जियोफ़ेंस तय करनी होगी.

दोनों वैल्यू के लिए, तय की गई दूरी का मतलब है कि कोई सीमा नहीं है. सिर्फ़ ज़्यादा से ज़्यादा दूरी तय करने का मतलब है कि कम से कम दूरी 0 है. सिर्फ़ कम से कम दूरी तय करने का मतलब है कि ज़्यादा से ज़्यादा दूरी तय नहीं की गई है.

जब किसी पीयर सेवा को जियोफ़ेंस के अंदर खोजा जाता है, तो onServiceDiscoveredWithinRange कॉलबैक ट्रिगर होता है. इससे, पीयर की मेज़र की गई दूरी का पता चलता है. इसके बाद, ज़रूरत पड़ने पर, सीधे वाई-फ़ाई आरटीटी एपीआई को कॉल करके, बाद में दूरी को मापा जा सकता है.