<!-- language: c# -->

   /**
     * 周りのデバイスが、自分を検索できるようにする
     */
    public void wifiAdvertisement()
    {
        publisher = new WiFiDirectAdvertisementPublisher();
        listener = new WiFiDirectConnectionListener();

        try
        {
            listener.ConnectionRequested += OnConnectionRequest;
        }
        catch(Exception e)
        {
            NotifyUser("Wifi Directがサポートされてません。" + e.Message);
            return;
        }

        publisher.Advertisement.IsAutonomousGroupOwnerEnabled = false;
        publisher.Advertisement.ListenStateDiscoverability = WiFiDirectAdvertisementListenStateDiscoverability.Normal;
        publisher.Start();
    }

    /**
     * 周りのデバイスから接続要求が来た場合、
     * 応答する
     */
    private async void OnConnectionRequest(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs connEventArgs)
    {
        WiFiDirectConnectionRequest connReq = connEventArgs.GetConnectionRequest();
        NotifyUser($"Connection request from {connReq.DeviceInformation.Name}");

        bool result = await Dispatcher.RunTaskAsync(async () =>
        {
            return await HandlerConnectionRequest(connReq);
        });

        if (!result)
        {
            // 接続要求を拒否する
            NotifyUser($"Connection request from {connReq.DeviceInformation.Name} was declined");
            connReq.Dispose();
        }
    }

    HostName hostname;
    HostName client;
    StreamSocket clientsocket;
    /**
     * 要求してきた相手の端末と接続する。
     */
    private async Task<bool> HandlerConnectionRequest(WiFiDirectConnectionRequest connReq)
    {
        string deviceName = connReq.DeviceInformation.Name;

        NotifyUser($"Connecting to {deviceName}...");
        NotifyUser($"Connecting to {connReq.DeviceInformation.Id}...");

        try
        {
            wfdDevice = await WiFiDirectDevice.FromIdAsync(connReq.DeviceInformation.Id);
        }
        catch (Exception e)
        {
            listener.ConnectionRequested -= OnConnectionRequest;
            publisher.Stop();
            NotifyUser($"Exception in FromIdAsync : {e.Message}");
            return false;
        }

        publisher.Stop();
        NotifyUser("deviceInfo " + wfdDevice.ConnectionStatus);

        wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;

        var EndpointPairs = wfdDevice.GetConnectionEndpointPairs();
        hostname = EndpointPairs[0].RemoteHostName;
        client = EndpointPairs[0].LocalHostName;
        NotifyUser("LocalHostName " + EndpointPairs[0].LocalHostName);
        NotifyUser("RemoteHostName " + EndpointPairs[0].RemoteHostName);
        NotifyUser("LocalServiceName " + EndpointPairs[0].LocalServiceName);
        NotifyUser("RemoteServiceName " + EndpointPairs[0].RemoteServiceName);

        //listenerSocket = new StreamSocketListener();

        //// Save this (listenerSocket, wfdDevice) pair so we can hook it up when the socket connection is made.
        //_pendingConnections[listenerSocket] = wfdDevice;

        await Task.Delay(2000);

        //clientsocket = new StreamSocket();
        //await clientsocket.ConnectAsync(hostname, "8988");

        //Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //serverSocket.Bind(new IPEndPoint(IPAddress.Any, 8988));

        //Stream streamOut = clientsocket.OutputStream.AsStreamForWrite();
        //StreamWriter writer = new StreamWriter(streamOut);
        //string ss = "a";
        //await writer.WriteLineAsync(ss);
        //await writer.FlushAsync();
        //NotifyUser("Stream a");

        //DataWriter dw = new DataWriter(clientsocket.OutputStream);
        //dw.WriteUInt32(dw.MeasureString("A"));
        //await dw.StoreAsync();
        //await dw.FlushAsync();
        //NotifyUser("Stream A");


        //socketRw = new SocketReaderWriter(clientsocket, this);

        //try
        //{
        //    await socketRw.WriteMessageAsync(sessionId);

        //}
        //catch (Exception e)
        //{
        //    NotifyUser("socketRw.WriteMessageAsync" + e.Message);
        //}

        //socketSend = new SocketSend(EndpointPairs[0].RemoteHostName+"", this);
        //socketSend.send(new byte[] { 0,0,0,0 });

        listenerSocket.ConnectionReceived += OnSocketConnectionReceived;
        try
        {
            await listenerSocket.BindServiceNameAsync("8988");
        }
        catch (Exception ex)
        {
            NotifyUser($"connect operation threw an exception: {ex.Message}");
            return false;
        }

        //NotifyUser($"Devices connected on L2, listening on IP Address: {EndpointPairs[0].LocalHostName}" + $" Port: {strServerPort}");

        //await connDevice.SocketRW.WriteMessageAsync(new byte[] { 0,0,0,0});
        return true;
    }

    private void OnConnectionStatusChanged(WiFiDirectDevice sender, object arg)
    {
        NotifyUser($"Connection status changed: {sender.ConnectionStatus}");

        if (sender.ConnectionStatus == WiFiDirectConnectionStatus.Disconnected)
        {
            try
            {
                listener.ConnectionRequested -= OnConnectionRequest;
                wfdDevice.ConnectionStatusChanged -= OnConnectionStatusChanged;
                wfdDevice.Dispose();
                publisher.Stop();
            }
            catch (Exception e)
            {
                NotifyUser($"connDevice Closeing Error: {e.Message}");
            }

        }
    }

    private async void OnSocketConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
    {

        Stream inStream = args.Socket.InputStream.AsStreamForRead();
        StreamReader reader = new StreamReader(inStream);
        string request = await reader.ReadLineAsync();
        //var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
        //{
        //    NotifyUser("Connecting to remote side on L4 layer...");
        //    StreamSocket serverSocket = args.Socket;

        //    SocketReaderWriter socketRW = new SocketReaderWriter(serverSocket, rootPage);
        //    // The first message sent is the name of the connection.
        //    string message = await socketRW.ReadMessageAsync();

        //    while (message != null)
        //    {
        //        message = await socketRW.ReadMessageAsync();
        //    }
        //});
    }

    protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
    {
        if (wfdDevice.ConnectionStatus == WiFiDirectConnectionStatus.Connected)
        {
            //ConnectedDevices.Remove(connDevice);
            //connDevice.Dispose();
        }
        listener.ConnectionRequested -= OnConnectionRequest;
        publisher.Stop();
    }

    private async void SendBinaryTODO_Click(object sender, RoutedEventArgs e)
    {
        string text = "B";

        try
        {
            await socketRw.WriteMessageAsync(text);

        }
        catch (Exception ex)
        {
            NotifyUser("socketRw.WriteMessageAsync" + ex.Message);
        }
    }

    private void SendBinaryTODO2_Click(object sender, RoutedEventArgs e)
    {

    }

<!-- language: java -->
public class FileReciverService extends IntentService {
    private boolean serviceEnabled;
    private int port;
    private ResultReceiver serverResult;
    private ServerSocket serverSocket = null;

    public FileReciverService() {
        super("FileReciverService");
        serviceEnabled = true;
    }

    @Override
    protected void onHandleIntent(Intent intent) {

        port = ((Integer) intent.getExtras().get("port")).intValue();
        serverResult = (ResultReceiver) intent.getExtras().get(Const.EXTRAS_SERVER_RESULT);

        ByteArrayOutputStream bout;

        InputStream inputstream;
        byte [] buffer = new byte[512];
        try{
            serverSocket = new ServerSocket(8988);
            serverSocket.setReuseAddress(true);
            while(true && serviceEnabled){

                if(serverSocket.isClosed()){
                    break;
                }

                Socket client = serverSocket.accept();

                bout = new ByteArrayOutputStream();
                inputstream = new DataInputStream(client.getInputStream());
                byte[] clientIp = client.getInetAddress().getAddress();

                while (true){
                    int len = inputstream.read(buffer);
                    if(len < 0) break;
                    bout.write(buffer, 0, len);
                }
                System.arraycopy(clientIp,0, buffer, 4, clientIp.length);

                inputstream.close();
                bout.close();
                client.close();
                signalActivity("result", buffer);
            }

        }catch (Exception e){
            Log.e("doInBackground Error ",e.getMessage());
        }
    }

    public void signalActivity(String key, byte[] message) {
        Bundle b = new Bundle();
        b.putByteArray(key, message);
        serverResult.send(port, b);
    }

    @Override
    public void onDestroy() {
        serviceEnabled = false;
        if(serverSocket != null){
            if(!serverSocket.isClosed()){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        stopSelf();
    }

}