Android में Wi-Fi Peer-to-Peer का उपयोग करके फाइल ट्रांसफर कैसे करें

यह ट्यूटोरियल Android के Wi-Fi Direct (Wi-Fi P2P) API का उपयोग करके दो डिवाइस के बीच फाइल ट्रांसफर करने का प्रदर्शन करता है। पारंपरिक Wi-Fi के विपरीत, Wi-Fi Direct को एक्सेस पॉइंट की आवश्यकता नहीं होती - डिवाइस सीधे एक उच्च-गति स्थानीय लिंक बनाते हैं।

क्यों Wi-Fi Direct फाइल ट्रांसफर के लिए?

• उच्च गति: 250 Mbps+ तक (Wi-Fi Direct मानक)
• कोई इंटरनेट/राउटर आवश्यक नहीं: ऑफलाइन काम करता है
• देशी Android समर्थन: WifiP2pManager API के माध्यम से
• सुरक्षित: WPA2 एन्क्रिप्शन अंतर्निहित

आवश्यक अनुमतियाँ (AndroidManifest.xml)

<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_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" /> <!-- Android 13+ -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" /> <!-- सॉकेट के लिए -->

उच्च-स्तरीय फाइल ट्रांसफर फ्लो

1. दोनों डिवाइस: Wi-Fi Direct सक्षम करें, खोज प्रारंभ करें
2. Sender: Receiver डिवाइस खोजें → कनेक्शन अनुरोध करें
3. Receiver: कनेक्शन स्वीकार करें → Group Owner बनें या क्लाइंट बनें
4. दोनों: कनेक्शन जानकारी प्राप्त करें (Group Owner IP)
5. Sender: Group Owner IP/पोर्ट पर Socket कनेक्ट करें
6. Sender: फाइल मेटाडेटा (नाम, आकार) भेजें → फाइल डेटा स्ट्रीम करें
7. Receiver: फाइल प्राप्त करें → संग्रहण में सहेजें
8. दोनों: सॉकेट बंद करें, सफाई करें

मुख्य घटक

1. WifiP2pManager सेटअप

WifiP2pManager manager = (WifiP2pManager) getSystemService(WIFI_P2P_SERVICE);
Channel channel = manager.initialize(this, getMainLooper(), null);

2. BroadcastReceiver P2P घटनाओं के लिए

public class P2pReceiver extends BroadcastReceiver {
    // WIFI_P2P_STATE_CHANGED_ACTION - P2P चालू/बंद
    // WIFI_P2P_PEERS_CHANGED_ACTION - पीयर सूची अपडेट
    // WIFI_P2P_CONNECTION_CHANGED_ACTION - कनेक्शन स्थिति
    // WIFI_P2P_THIS_DEVICE_CHANGED_ACTION - स्थानीय डिवाइस जानकारी
}

3. पीयर खोजें

manager.discoverPeers(channel, new WifiP2pManager.ActionListener() {
    @Override public void onSuccess() { /* खोज प्रारंभ */ }
    @Override public void onFailure(int reason) { /* त्रुटि संभालें */ }
});

4. पीयर सूची प्राप्त करें

manager.requestPeers(channel, peerList -> {
    for (WifiP2pDevice device : peerList.getDeviceList()) {
        // UI में डिवाइस दिखाएं, उपयोगकर्ता चयन करता है
    }
});

5. चयनित पीयर से कनेक्ट करें

WifiP2pConfig config = new WifiP2pConfig();
config.deviceAddress = selectedDevice.deviceAddress;
config.wps.setup = WpsInfo.PBC; // पुश-बटन कॉन्फ़िगरेशन

manager.connect(channel, config, new WifiP2pManager.ActionListener() {
    @Override public void onSuccess() { /* कनेक्शन आरंभ */ }
    @Override public void onFailure(int reason) { /* त्रुटि */ }
});

6. कनेक्शन जानकारी प्राप्त करें (Group Owner IP)

manager.requestConnectionInfo(channel, info -> {
    if (info.groupFormed) {
        String groupOwnerIp = info.groupOwnerAddress.getHostAddress();
        boolean isGroupOwner = info.isGroupOwner;
        // अब फाइल ट्रांसफर के लिए सॉकेट का उपयोग करें
        startFileTransfer(groupOwnerIp, isGroupOwner);
    }
});

फाइल ट्रांसफर कार्यान्वयन (Socket-आधारित)

Sender पक्ष (Group Owner से कनेक्ट होता है)

private void sendFile(String hostIp, File file) {
    new Thread(() -> {
        try (Socket socket = new Socket()) {
            socket.connect(new InetSocketAddress(hostIp, 8888), 10000);
            
            // मेटाडेटा भेजें: फाइलनाम\nफाइलसाइज\n
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.writeUTF(file.getName());
            dos.writeLong(file.length());
            dos.flush();

            // फाइल सामग्री स्ट्रीम करें
            try (FileInputStream fis = new FileInputStream(file)) {
                byte[] buffer = new byte[8192];
                int read;
                long total = 0;
                while ((read = fis.read(buffer)) != -1) {
                    dos.write(buffer, 0, read);
                    total += read;
                    // प्रगति अपडेट: publishProgress(total, file.length())
                }
                dos.flush();
            }
        } catch (IOException e) { e.printStackTrace(); }
    }).start();
}

Receiver पक्ष (Group Owner - ServerSocket सुनता है)

private void receiveFile() {
    new Thread(() -> {
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            serverSocket.setSoTimeout(30000);
            Socket socket = serverSocket.accept();
            
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            
            // मेटाडेटा पढ़ें
            String fileName = dis.readUTF();
            long fileSize = dis.readLong();
            
            // फाइल सहेजें
            File outputFile = new File(getExternalFilesDir(null), fileName);
            try (FileOutputStream fos = new FileOutputStream(outputFile)) {
                byte[] buffer = new byte[8192];
                int read;
                long total = 0;
                while (total < fileSize && (read = dis.read(buffer)) != -1) {
                    fos.write(buffer, 0, read);
                    total += read;
                    // प्रगति अपडेट
                }
            }
        } catch (IOException e) { e.printStackTrace(); }
    }).start();
}

पूर्ण Activity संरचना

public class FileTransferActivity extends AppCompatActivity {
    // UI: RecyclerView पीयर के लिए, प्रगति बार, स्थिति टेक्स्ट, फाइल चुनें बटन
    
    // P2P घटक
    WifiP2pManager manager;
    Channel channel;
    P2pReceiver receiver;
    IntentFilter filter;
    
    // स्थिति
    List peers = new ArrayList<>();
    WifiP2pDevice selectedPeer;
    boolean isGroupOwner = false;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // UI सेटअप, P2P प्रारंभ, रिसीवर पंजीकृत करें
    }
    
    // खोज, कनेक्ट, फाइल चुनें, ट्रांसफर प्रारंभ करने के तरीके
    
    @Override
    protected void onResume() { super.onResume(); registerReceiver(receiver, filter); }
    @Override
    protected void onPause() { super.onPause(); unregisterReceiver(receiver); }
}

Android संस्करण-विशिष्ट विचार

सर्वोत्तम अभ्यास

1. ExecutorService का उपयोग करें कच्चे Threads के बजाय
2. प्रगति रिपोर्टिंग लागू करें ProgressDialog या नोटिफिकेशन के साथ
3. बड़ी फाइलों को संभालें: चंक्ड ट्रांसफर, रिज्यूम क्षमता
4. अखंडता जांच: ट्रांसफर के बाद CRC32/MD5 सत्यापित करें
5. कई फाइलें: ZIP में पैक करें या क्रमिक रूप से भेजें
6. पृष्ठभूमि ट्रांसफर: लंबी फाइलों के लिए Foreground Service + नोटिफिकेशन
7. त्रुटि प्रबंधन: टाइमआउट, पुनः प्रयास, उपयोगकर्ता रद्दीकरण

उपयोग के लिए तैयार लाइब्रेरी (अनुशंसित)

कच्चे सॉकेट लागू करने के बजाय, इन पर विचार करें:

• Nearby Connections API (Google Play Services) - उच्च-स्तरीय, क्रॉस-प्लेटफ़ॉर्म
• Wi-Fi Direct Library (GitHub पर कई ओपन-सोर्स रैपर)
• ShareSheet / Nearby Share - सिस्टम-स्तरीय शेयरिंग (Android 10+)

निष्कर्ष

Wi-Fi Direct इंटरनेट इंफ्रास्ट्रक्चर के बिना Android डिवाइस के बीच तेज़, सुरक्षित फाइल ट्रांसफर को सक्षम करता है। मुख्य चरण हैं: खोज → कनेक्शन → Group Owner IP निर्धारण → Socket-आधारित फाइल स्ट्रीमिंग। यह आधार फोटो शेयरिंग, ऑफलाइन सहयोग, IoT प्रोविजनिंग, और मल्टीप्लेयर गेमिंग जैसे ऐप्स को शक्ति प्रदान करता है।