एंड्रॉइड

Question

का उपयोग कर वाईफ़ाई कनेक्टिविटी के लिए वाईफ़ाई मैं एंड्रॉइड डिवाइस से संदेशों को डेस्कटॉप एप्लिकेशन में स्थानांतरित करना चाहता हूं। मेरा सवाल यह है कि क्या मैं एंड्रॉइड वाईफाई डिवाइस को डेस्कटॉप कनेक्शन के बिना डेस्कटॉप वाईफाई डिवाइस से कनेक्ट कर सकता हूं। मैं इसे ब्लूटूथ की तरह इस्तेमाल करना चाहता हूं। क्या यह संभव है या नहीं? यदि यह संभव है तो मैं इसे कैसे कार्यान्वित कर सकता हूं?

धन्यवाद और सादर अमित Thaper

Answer 1

यहां मैरिकेल के सुझाव का कार्यान्वयन है। मैंने इसे देखा जब मुझे एक ही समस्या थी और मैंने सोचा कि मैं सिर्फ समाधान के कार्यान्वयन को पोस्ट करूंगा। यह वास्तव में सरल है। मैंने एक जावा सर्वर भी बनाया जो एंड्रॉइड डिवाइस से आने वाले अनुरोधों के लिए सुनता है (ज्यादातर डिबगिंग उद्देश्यों के लिए)। वायरलेस पर सामान भेजने के लिए कोड यहां दिया गया है:

import java.net.*; 
import java.io.*; 
import java.util.*; 

import android.app.Activity; 
import android.content.Context; 
import android.content.ContentValues; 
import android.content.SharedPreferences; 
import android.content.SharedPreferences.Editor; 
import android.os.Bundle; 
import android.util.Log; 


public class SMSConnection { 
     /* The socket to the server */ 
    private Socket connection; 

    /* Streams for reading and writing the socket */ 
    private BufferedReader fromServer; 
    private DataOutputStream toServer; 

    /* application context */ 
    Context mCtx; 

    private static final String CRLF = "\r\n"; 

    /* Create an SMSConnection object. Create the socket and the 
     associated streams. Initialize SMS connection. */ 
    public SMSConnection(Context ctx) throws IOException { 
     mCtx=ctx; 
     this.open(); 
     /* may anticipate problems with readers being initialized before connection is opened? */ 
     fromServer = new BufferedReader(new InputStreamReader(connection.getInputStream())); 
     toServer = new DataOutputStream(connection.getOutputStream()); 
    } 

    public boolean open(String host, int port) { 
     try { 
      connection = new Socket(host, port); 
      return true; 
     } catch(IOException e) { 
      Log.v("smswifi", "cannot open connection: " + e.toString()); 
     } 
     return false; 
    } 

    /* Close the connection. */ 
    public void close() { 
     try { 
      connection.close(); 
     } catch (IOException e) { 
      Log.v("smswifi","Unable to close connection: " + e.toString()); 
     } 
    } 

    /* Send an SMS command to the server. Check that the reply code 
     is what is is supposed to be according to RFC 821. */ 
    public void sendCommand(String command) throws IOException { 

     /* Write command to server. */ 
     this.toServer.writeBytes(command+this.CRLF); 

     /* read reply */ 
     String reply = this.fromServer.readLine(); 
    } 
} 

जो कनेक्शन क्लास के लिए मूल कंकाल है। आप बस क्लास को तुरंत चालू करते हैं, और मेजबान और बंदरगाह के साथ बनाए गए इंस्टेंस पर खुलते हैं (जब आप पूरा कर लें तो कनेक्शन बंद करना न भूलें) और आप अपनी पसंद के अनुसार भेजने के शरीर को बदल सकते हैं। मैंने फ़ंक्शन बॉडी में एक उदाहरण के रूप में एक पठन/लेखन ऑपरेशन शामिल किया है।

यहां एक दूरस्थ मशीन पर सर्वर चलाने के लिए कोड है जो कनेक्शन के लिए सुनता है और प्रत्येक अनुरोध को संभालने के लिए थ्रेड को स्पैन करता है। यह डिबगिंग (या किसी भी उपयोग) के लिए उपरोक्त कोड से आसानी से बातचीत कर सकता है।

import java.io.*; 
import java.net.*; 
import java.util.*; 

public final class smsd { 
    ///////MEMBER VARIABLES 
    ServerSocket server=null; 
    Socket client=null; 

    ///////MEMBER FUNCTIONS 
    public boolean createSocket(int port) { 
     try{ 
      server = new ServerSocket(port); 
      } catch (IOException e) { 
      System.out.println("Could not listen on port "+port); 
      System.exit(-1); 
     } 
     return true; 
    } 

    public boolean listenSocket(){ 
     try{ 
      client = server.accept(); 
     } catch (IOException e) { 
      System.out.println("Accept failed: "); 
      System.exit(-1); 
     } 
     return true; 
    } 

    public static void main(String argv[]) throws Exception { 
     // 
     smsd mySock=new smsd(); 

     //establish the listen socket 
     mySock.createSocket(3005); 
     while(true) { 
      if(mySock.listenSocket()) { 
       //make new thread 
       // Construct an object to process the SMS request message. 
       SMSRequest request = new SMSRequest(mySock.client); 

       // Create a new thread to process the request. 
       Thread thread = new Thread(request); 

       // Start the thread. 
       thread.start(); 
      } 
     } 

     //process SMS service requests in an infinite loop 

    } 
///////////end class smsd///////// 
} 


final class SMSRequest implements Runnable { 
    // 
    final static String CRLF = "\r\n"; 
    Socket socket; 

    // Constructor 
    public SMSRequest(Socket socket) throws Exception 
    { 
     this.socket = socket; 
    } 

    // Implement the run() method of the Runnable interface. 
    public void run() 
    { 
     try { 
      processRequest(); 
     } catch (Exception e) { 
      System.out.println(e); 
     } 
    } 

    private static void sendBytes(FileInputStream fis, OutputStream os) throws Exception 
     { 
      // Construct a 1K buffer to hold bytes on their way to the socket. 
      byte[] buffer = new byte[1024]; 
      int bytes = 0; 

      // Copy requested file into the socket's output stream. 
      while((bytes = fis.read(buffer)) != -1) { 
       os.write(buffer, 0, bytes); 
      } 
     } 

    private void processRequest() throws Exception 
    { 
     // Get a reference to the socket's input and output streams. 
     InputStream is = this.socket.getInputStream(); 
     DataOutputStream os = new DataOutputStream(this.socket.getOutputStream()); 

     // Set up input stream filters. 
     InputStreamReader isr = new InputStreamReader(is); 
     BufferedReader br = new BufferedReader(isr); 

     // Get the request line of the SMS request message. 
     String requestLine = br.readLine(); 

     //print message to screen 
     System.out.println(requestLine); 

     //send a reply 
     os.writeBytes("200"); 

     // Close streams and socket. 
     os.close(); 
     br.close(); 
     socket.close(); 
    } 
} 

nb4namingconventions।

लगभग भूल गया। वायरलेस का उपयोग करने के लिए आपको इन AndroidManifest.xml में टैग के अंदर इन अनुमतियों को सेट करने की आवश्यकता होगी।

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> 
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" /> 

Answer 2

यह आसानी से संभव है अगर दोनों उपकरणों एक ही वाईफाई नेटवर्क का उपयोग कर रहे हैं और एक दूसरे पिंग कर सकते हैं। आप बस अपने डेस्कटॉप पर जावा एप्लिकेशन बना सकते हैं जो ServerSocket बनाता है। फिर आप डेस्कटॉप के आईपी पते का उपयोग करके अपने एंड्रॉइड ऐप में Socket खोल सकते हैं और OutputStream के माध्यम से डेटा भेज सकते हैं।

Answer 3

मेरा मानना ​​है कि अमित वायरलेस मशीनों का उपयोग करके मशीनों को सीधे एक-दूसरे से कनेक्ट करने का जिक्र कर रहा है।

वर्तमान में वाईफ़ाई-प्रत्यक्ष विनिर्देश का विकास है जो एक्सेस पॉइंट्स के प्लग-इन-प्ले सेटअप की अनुमति देता है। वर्तमान में यह मुद्दा यह सुनिश्चित कर रहा है कि मशीनों में से एक एक एपी है जो अन्य मशीनें कनेक्शन स्थापित कर सकती हैं।

मुझे दिलचस्पी है कि यह विज्ञापन-हाॉक नेटवर्क से कैसे संबंधित है। मेरे पास कोई समाधान नहीं है, हालांकि मुझे इस प्रश्न में भी काफी दिलचस्पी है! (मान लीजिए यह आपका प्रश्न अमित है)।