private InetAddress getAdresseBroadcast()
{
    WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
    DhcpInfo dhcp = wifiManager.getDhcpInfo();

    int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
    byte[] quads = new byte[4];
    for (int k = 0; k < 4; k++)
      quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
    return InetAddress.getByAddress(quads);
}

private DatagramPacket envoyerTrameUDP(String requete, int port) throws Exception
{
	DatagralSocket socket = new DatagramSocket(mPort);
	socket.setBroadcast(true);
	InetAddress broadcastAdress = getAdresseBroadcast();
	DatagramPacket packet = new DatagramPacket(requete.getBytes(), requete.length(), broadcastAdress, port);
	socket.send(packet);

	byte[] buf = new byte[1024];
	packet = new DatagramPacket(buf, buf.length);
	socket.setSoTimeout(TIMEOUT_RECEPTION_REPONSE);
	
	String monAdresse = getMonAdresseIP();		
	socket.receive(packet);
	while (packet.getAddress().getHostAddress().contains(monAdresse))
	{
		socket.receive(packet);
	}
	
	socket.close();
	
	return packet;
}

public String getMonAdresseIP()
{
    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()) 
                	return inetAddress.getHostAddress();
            }
        }
    } 
    catch (SocketException e) 
    {
        e.printStackTrace();
    }
    return null;
}

public void attendreRequete(int port)
{
	socket = null;
	try 
	{
		// On essaye de créer notre socket serveur UDP
		socket = new DatagramSocket(port);
		socket.setSoTimeout(TIMEOUT_RECEPTION_REPONSE);
	} 
	catch (SocketException se) 
	{
		se.printStackTrace();
	}
	
	// On initialise les trames qui vont servir à recevoir et envoyer les paquets
	byte[] receiveData = new byte[1024];
	byte[] sendData = new byte[1024];
    
	// Tant qu'on est connecté, on attend une requête et on y répond
	while (socket != null && !socket.isClosed())
	{
		try
		{
			DatagramPacket paquetRecu = new DatagramPacket(receiveData, receiveData.length);
			socket.receive(paquetRecu);
			String requete = new String(paquetRecu.getData());
			InetAddress IPAddress = paquetRecu.getAddress();
			int port = paquetRecu.getPort();
			// Si on reçoit un "ping", on répond "pong" à celui qui nous l'a envoyé
			if (requete.contains("Ping"))
			{
				sendData = "Pong".getBytes();
				DatagramPacket paquetRetour = new DatagramPacket(sendData, sendData.length, IPAddress, port);
				socket.send(paquetRetour);
				socket.close();
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

import java.io.InterruptedIOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

import android.content.Context;
import android.net.DhcpInfo;
import android.net.wifi.WifiManager;
import android.util.Log;

public class Discovery 
{
	public static final int RECEIVING_TIMEOUT = 10000;
	public static final int RECEIVING_TIMEOUT_SERVER = 30000;
	private DatagramSocket socket;
	private Context mContext;
	private int mPort;
	
	public Discovery(Context c, int p)
	{
		mContext = c;
		mPort = p;
	}
	
	public void stop()
	{
		udpNeeded = false;
		try
		{
			socket.close();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
	public String getServerIp()
	{
		try 
		{
			DatagramPacket packet = sendBroadcast("Ping");
			return packet.getAddress().getHostAddress();
		} 
		catch (InterruptedIOException ie)
		{
			Log.d("ERROR", "No server found");
			try
			{
				socket.close();
			}
			catch (Exception e2) {}
			ie.printStackTrace();
		}
		catch (Exception e) 
		{
			Log.d("ERROR", "Verify your Wifi connection");
			try
			{
				socket.close();
			}
			catch (Exception e2) {}
			e.printStackTrace();
		}
		
		stop();		
		return null;
	}
	
	public void waitingForDiscover()
	{
		socket = null;
		try 
		{
			socket = new DatagramSocket(mPort);
			socket.setSoTimeout(RECEIVING_TIMEOUT_SERVER);
		} 
		catch (SocketException se) 
		{
			Log.d("ERROR", "Verify your Wifi connection");
			se.printStackTrace();
		}
		
		byte[] receiveData = new byte[1024];
		byte[] sendData = new byte[1024];
        
		int i = 0;
		while (socket != null && !socket.isClosed())
		{
			try
			{
				DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
				socket.receive(receivePacket);
				String sentence = new String(receivePacket.getData());
				InetAddress IPAddress = receivePacket.getAddress();
				int port = receivePacket.getPort();
				if (sentence.contains("Ping"))
				{
					sendData = "Pong".getBytes();
					DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port);
					socket.send(sendPacket);
				}
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
			i++;
		}
		stop();
	}
	
	private InetAddress getBroadcastAddress() throws Exception 
	{
	    WifiManager wifi = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
	    DhcpInfo dhcp = wifi.getDhcpInfo();

	    int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
	    byte[] quads = new byte[4];
	    for (int k = 0; k < 4; k++)
	      quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
	    return InetAddress.getByAddress(quads);
	}
	
	private DatagramPacket sendBroadcast(String data) throws Exception
	{
		socket = new DatagramSocket(mPort);
		socket.setBroadcast(true);
		InetAddress broadcastAdress = getBroadcastAddress();
		DatagramPacket packet = new DatagramPacket(data.getBytes(), data.length(), broadcastAdress, mPort);
		socket.send(packet);

		byte[] buf = new byte[1024];
		packet = new DatagramPacket(buf, buf.length);
		socket.setSoTimeout(RECEIVING_TIMEOUT);
		
		String myAdress = Engine.getIpAddress();
		
		socket.receive(packet);
		while (packet.getAddress().getHostAddress().contains(myAdress))
			socket.receive(packet);
		
		stop();		
		return packet;
	}
}