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

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

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

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

Wi-Fi Aware API की मदद से, ऐप्लिकेशन ये काम कर सकते हैं:

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

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

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 या जगह की जानकारी की सुविधा बंद कर दी हो. हार्डवेयर और फ़र्मवेयर की क्षमताओं के आधार पर, हो सकता है कि कुछ डिवाइसों पर Wi-Fi Direct, SoftAP या tethering का इस्तेमाल करने पर, Wi-Fi Aware की सुविधा काम न करे. कॉल करें और देखें कि फ़िलहाल वाई-फ़ाई अवेयर उपलब्ध है या नहीं isAvailable().

वाई-फ़ाई अवेयर की उपलब्धता में किसी भी समय बदलाव किया जा सकता है. आपके ऐप्लिकेशन को ACTION_WIFI_AWARE_STATE_CHANGED पाने के लिए, BroadcastReceiver रजिस्टर करना चाहिए. यह सूचना, खरीदारी के लिए उपलब्धता में बदलाव होने पर भेजी जाती है. जब आपका ऐप्लिकेशन ब्रॉडकास्ट इंटेंट के तौर पर अपलोड किया जाता है, तो इसे सभी मौजूदा सेशन को खारिज कर देना चाहिए. वाई-फ़ाई अवेयर सेवा बाधित हुई है), फिर उपलब्धता की मौजूदा स्थिति और उसके हिसाब से इसके काम करने के तरीके में बदलाव करे. उदाहरण के लिए:
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);

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

सेशन पाना

वाई-फ़ाई अवेयर का इस्तेमाल शुरू करने के लिए, आपके ऐप्लिकेशन को कॉल करके WifiAwareSession attach(). यह तरीका, ये काम करता है:

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() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है कॉलबैक का तरीका इस्तेमाल किया जाता है.

पब्लिकेशन के बाद, सदस्यता की सुविधा देने वाले ऐप्लिकेशन से मिलते-जुलते ऐप्लिकेशन इस्तेमाल करने वाले डिवाइसों में, पब्लिश करने वाले डिवाइस की वाई-फ़ाई रेंज, सदस्यों को सेवा खोजने की सुविधा मिलती है. टास्क कब शुरू होगा जब कोई सदस्य किसी पब्लिशर के साथ जुड़ता है, तब पब्लिशर को सूचना; अगर सदस्य पब्लिशर को मैसेज भेजता है, तो तो पब्लिशर को एक सूचना मिलती है. ऐसा होने पर, 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() में दिखाए गए PeerHandle कॉलबैक.
- आपका ऐप्लिकेशन किसी सेवा की सदस्यता लेता है. इसके बाद, जब इसे मिलते-जुलते वीडियो का पता चलता है पब्लिशर, आपके ऐप्लिकेशन को पब्लिशर के PeerHandle onServiceDiscovered() कॉलबैक.

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

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

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

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

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

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

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

पब्लिशर के नेटवर्क का अनुरोध करने के बाद, उसे यह करना चाहिए सदस्य को मैसेज भेजें.
जब सदस्य को पब्लिशर से मैसेज मिल जाता है, तो पब्लिशर के लिए इस्तेमाल किए गए तरीके का इस्तेमाल करके, सदस्य के लिए वाई-फ़ाई ऐवेयर नेटवर्क का अनुरोध करें. ये काम करें बनाते समय कोई पोर्ट तय नहीं करते NetworkSpecifier. कॉन्टेंट बनाने नेटवर्क कनेक्शन के होने पर उचित कॉलबैक विधियों को कॉल किया जाता है उपलब्ध, बदला या खो गया है.
सदस्य को onAvailable() तरीका कॉल करने के बाद, Network ऑब्जेक्ट, इसके साथ उपलब्ध है जिसे आप Socket खोलकर बातचीत कर सकते हैं ServerSocket के साथ दिखाया है, लेकिन आपको यह जानने की ज़रूरत है ServerSocket का आईपीवी6 पता और पोर्ट. आपको ये 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.

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

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

वाई-फ़ाई RTT API, इसकी मदद से सीधे तौर पर वाई-फ़ाई अवेयर पीयर की मदद से मैक पता या उसका PeerHandle.

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

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

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

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

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

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