android - poner - ¿Cómo obtener la dirección IP de cada dispositivo en el escenario de Wi-Fi Direct?

mi celular no tiene direccion ip

Question

A partir de ICS, se introduce Wi-Fi Direct. Normalmente, usamos la clase WifiP2pManager para operar con Wi-Fi Direct, pero parece que solo puede recuperar la dirección IP de GroupOwner después de la conexión. Pero, en realidad, cualquier dispositivo llegó a negociar para convertirse en el GroupOwner. En la Aplicación Superior, necesitamos obtener la dirección IP del igual o la dirección IP de cada uno en un grupo para que podamos enviar / comunicarnos con ellos.

¿Cómo obtener cada dirección IP en Wi-Fi Direct? ¿Incluir la propia dirección IP y cada compañero en el grupo?

Answer 1

He podido conectar y enviar en ambos sentidos en una red WiFi directa. Todos los dispositivos conocen la dirección IP del propietario del grupo. Obtenemos la IP del par desde un socket creado para la comunicación. De alguna manera, obtener la IP del socket en el lado del servidor (en el propietario del grupo) no funcionó para mí. Por lo tanto, le envío al propietario del grupo la IP del dispositivo individual desde ese dispositivo. Para obtener la IP, simplemente cree un socket y conéctelo a cualquier puerto local, obtenga la dirección de este socket y envíela al propietario. He usado un socket UDP pero funciona bastante bien con sockets TCP.

DatagramSocket socket=null;
     try {
        socket=new DatagramSocket();
        socket.connect((new InetSocketAddress(host, port)));
        String address=socket.getLocalAddress().getHostAddress();
        ByteBuffer bb=ByteBuffer.allocate(2+address.length());
        bb.putChar(''I'');
        bb.put(address.getBytes());
        DatagramPacket pkt=new DatagramPacket(bb.array(),2+address.length());
        socket.send(pkt);
        Log.d(WiFiDirectActivity.TAG,"address"+address+"dest"+host);
        Log.d(WiFiDirectActivity.TAG,"send");
    } catch (SocketException e) {
        Log.e(WiFiDirectActivity.TAG,"error socketException");
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if (socket != null) {
            if (socket.isConnected()) {
                socket.close();
            }
    }

host es la dirección del propietario del grupo que obtenemos de la información de conexión.

Answer 2

He realizado un proyecto de demostración que es capaz de obtener cada ip de dispositivo y enviar datos de un dispositivo a otro (sea el propietario del grupo o no). La url es:

https://github.com/ahmontero/wifi-direct-demo

¡Espero que te ayude!

EDIT: Básicamente, busque la dirección IP en el caché ARP de esta manera:

public static String getIPFromMac(String MAC) {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader("/proc/net/arp"));
        String line;
        while ((line = br.readLine()) != null) {

            String[] splitted = line.split(" +");
            if (splitted != null && splitted.length >= 4) {
                // Basic sanity check
                String device = splitted[5];
                if (device.matches(".*p2p-p2p0.*")){
                    String mac = splitted[3];
                    if (mac.matches(MAC)) {
                        return splitted[0];
                    }
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return null;
}

Answer 3

La mejor respuesta que puedes obtener es posiblemente la de Mano:

Me encontré con el mismo problema. Dado que ambos dispositivos conocen la ip del propietario del grupo, ya es posible enviar un mensaje al propietario del grupo. El primer mensaje que envíe puede contener la dirección IP del otro dispositivo; A partir de entonces, la comunicación bidireccional es posible.

Así es como lo implementé. Cuando conecto un cliente al propietario del grupo a través de WiFi Direct, obtengo la dirección IP del propietario del grupo y le envío un mensaje al propietario del grupo a través de un socket. Algo como:

Socket socket = new Socket();
socket.setReuseAddress(true);
socket.connect((new InetSocketAddress(mIP, mPort)), SOCKET_TIMEOUT);
OutputStream os = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(new String("BROFIST");
oos.close();
os.close();
socket.close();

Ya conoce mIP (la dirección IP del propietario del grupo), y solo tiene que decidir un mPort y recibir la conexión del propietario del grupo de esta manera:

Socket serverSocket = new ServerSocket(mPort);
serverSocket.setReuseAddress(true);
Socket client = serverSocket.accept();
ObjectInputStream objectInputStream = new ObjectInputStream(client.getInputStream());
Object object = objectInputStream.readObject();
if (object.getClass().equals(String.class) && ((String) object).equals("BROFIST")) {
  Log.d(TAG, "Client IP address: "+client.getInetAddress());
}

Este es el código real que estoy usando. Voy a reemplazar este mensaje con información útil, como un objeto de mensaje que contiene el MAC del remitente, que puede usarse para conocer las relaciones MAC-IP, ya que WifiP2pDevice solo proporciona MAC e InetAddress la IP (¿Alguien sabe si? hay una manera de obtener el MAC de un objeto InetAddress ?)

Answer 4

Me encontré con el mismo problema. Dado que ambos dispositivos conocen la ip del propietario del grupo, ya es posible enviar un mensaje al propietario del grupo. El primer mensaje que envíe puede contener la dirección IP del otro dispositivo; A partir de entonces, la comunicación bidireccional es posible.

Aquí hay una posibilidad para recuperar tu ip en java:

private byte[] getLocalIPAddress() {
    try { 
        for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) { 
            NetworkInterface intf = en.nextElement(); 
            for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) { 
                InetAddress inetAddress = enumIpAddr.nextElement(); 
                if (!inetAddress.isLoopbackAddress()) { 
                    if (inetAddress instanceof Inet4Address) { // fix for Galaxy Nexus. IPv4 is easy to use :-) 
                        return inetAddress.getAddress(); 
                    } 
                    //return inetAddress.getHostAddress().toString(); // Galaxy Nexus returns IPv6 
                } 
            } 
        } 
    } catch (SocketException ex) { 
        //Log.e("AndroidNetworkAddressFactory", "getLocalIPAddress()", ex); 
    } catch (NullPointerException ex) { 
        //Log.e("AndroidNetworkAddressFactory", "getLocalIPAddress()", ex); 
    } 
    return null; 
}

private String getDottedDecimalIP(byte[] ipAddr) {
    //convert to dotted decimal notation:
    String ipAddrStr = "";
    for (int i=0; i<ipAddr.length; i++) {
        if (i > 0) {
            ipAddrStr += ".";
        }
        ipAddrStr += ipAddr[i]&0xFF;
    }
    return ipAddrStr;
}

ip = getDottedDecimalIP(getLocalIPAddress());

Envuelva esta ip en un objeto Serializable y envíelo al propietario del grupo como si fuera a enviar cualquier otro objeto. Considere este primer paso en su protocolo wifi directo ... Ahora, el propietario del grupo también tiene una IP para enviar las respuestas.

Esto me funciona, aunque creo que es extraño que tuve que implementarlo yo mismo y solo pude encontrar el IP del propietario del grupo fácilmente (info.groupOwnerAddress.getHostAddress (); // con info una instancia de WifiP2pInfo). Tal vez haya una forma comparable de recuperar la ip de los otros compañeros, pero no pude encontrarla. Por favor, póngase en contacto conmigo si lo hace.

Buena suerte...

Answer 5

Por favor, utilice este método para obtener la dirección IP.

  public static String getIpAddress() {
    try {
        List<NetworkInterface> interfaces = Collections
                .list(NetworkInterface.getNetworkInterfaces());
        /*
         * for (NetworkInterface networkInterface : interfaces) { Log.v(TAG,
         * "interface name " + networkInterface.getName() + "mac = " +
         * getMACAddress(networkInterface.getName())); }
         */

        for (NetworkInterface intf : interfaces) {
            if (!getMACAddress(intf.getName()).equalsIgnoreCase(
                    Globals.thisDeviceAddress)) {
                // Log.v(TAG, "ignore the interface " + intf.getName());
                // continue;
            }
            if (!intf.getName().contains("p2p"))
                continue;

            Log.v(TAG,
                    intf.getName() + "   " + getMACAddress(intf.getName()));

            List<InetAddress> addrs = Collections.list(intf
                    .getInetAddresses());

            for (InetAddress addr : addrs) {
                // Log.v(TAG, "inside");

                if (!addr.isLoopbackAddress()) {
                    // Log.v(TAG, "isnt loopback");
                    String sAddr = addr.getHostAddress().toUpperCase();
                    Log.v(TAG, "ip=" + sAddr);

                    boolean isIPv4 = InetAddressUtils.isIPv4Address(sAddr);

                    if (isIPv4) {
                        if (sAddr.contains("192.168.49.")) {
                            Log.v(TAG, "ip = " + sAddr);
                            return sAddr;
                        }
                    }

                }

            }
        }

    } catch (Exception ex) {
        Log.v(TAG, "error in parsing");
    } // for now eat exceptions
    Log.v(TAG, "returning empty ip address");
    return "";
}

public static String getMACAddress(String interfaceName) {
        try {
            List<NetworkInterface> interfaces = Collections
                    .list(NetworkInterface.getNetworkInterfaces());

            for (NetworkInterface intf : interfaces) {
                if (interfaceName != null) {
                    if (!intf.getName().equalsIgnoreCase(interfaceName))
                        continue;
                }
                byte[] mac = intf.getHardwareAddress();
                if (mac == null)
                    return "";
                StringBuilder buf = new StringBuilder();
                for (int idx = 0; idx < mac.length; idx++)
                    buf.append(String.format("%02X:", mac[idx]));
                if (buf.length() > 0)
                    buf.deleteCharAt(buf.length() - 1);
                return buf.toString();
            }
        } catch (Exception ex) {
        } // for now eat exceptions
        return "";
        /*
         * try { // this is so Linux hack return
         * loadFileAsString("/sys/class/net/" +interfaceName +
         * "/address").toUpperCase().trim(); } catch (IOException ex) { return
         * null; }
         */
    }

Answer 6

Tengo otro enfoque!

Cuando crea la conexión entre los 2 (o más) dispositivos, no puede establecer quién es el propietario y quiénes son los clientes.

La única información que tiene sobre esto es cuando el receptor BroadCast está conectado, recibe un objeto "WifiP2pInfo". Este objeto contiene 2 informaciones interesantes:

• La dirección IP del propietario (mWifiP2PInfo.groupOwnerAddress). Esta cadena comienza por "/". No te olvides de quitarlo! ;)
• si eres el propietario o no (mWifiP2PInfo.isGroupOwner)

De eso tienes todo lo que necesitas!

Si eres el groupOwner => Escucha una conexión

De lo contrario, cree una conexión con el propietario con la dirección IP.

if (mWifiP2PInfo.isGroupOwner) {
    serverSocket = new ServerSocket(port);
    socket = serverSocket.accept();
} else {
    // If the client is not listening when the server create the connection, the connection is not established => Try again
    int retry = 10;

    socket = new Socket();
    socket.bind(null);
    do {
        socket.connect((new InetSocketAddress(mWifiP2PInfo.groupOwnerAddress, port)), 500);
        retry--;
    } while (!socket.isConnected() && retry > 0);
}

Hop te puede ayudar !!!