i have a java client and c# server
the server code is

    static Socket listeningSocket;
            static Socket socket;
            static Thread thrReadRequest;
            static int iPort = 4444;
            static int iConnectionQueue = 100;

            static void Main(string[] args)
            {
                Console.WriteLine(IPAddress.Parse(getLocalIPAddress()).ToString());
                try
                {
                    listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    //listeningSocket.Bind(new IPEndPoint(0, iPort));                                
                    listeningSocket.Bind(new IPEndPoint(IPAddress.Parse(getLocalIPAddress()), iPort));
                    listeningSocket.Listen(iConnectionQueue);

                    thrReadRequest = new Thread(new ThreadStart(getRequest));
                    thrReadRequest.Start();
                }
                catch (Exception e)
                {
                    Console.WriteLine("Winsock error: " + e.ToString());
                    //throw;
                }
            }

            static private void getRequest()
            {
                int i = 0;
                while (true)
                {
                    i++;
                    Console.WriteLine("Outside Try i = {0}", i.ToString());

                    try
                    {
                        socket = listeningSocket.Accept();

                        // Receiving
                        //byte[] rcvLenBytes = new byte[4];
                        //socket.Receive(rcvLenBytes);
                        //int rcvLen = System.BitConverter.ToInt32(rcvLenBytes, 0);
                        //byte[] rcvBytes = new byte[rcvLen];
                        //socket.Receive(rcvBytes);
                        //String formattedBuffer = System.Text.Encoding.ASCII.GetString(rcvBytes);

                        byte[] buffer = new byte[socket.SendBufferSize];
                        int iBufferLength = socket.Receive(buffer, 0, buffer.Length, 0);
                        Console.WriteLine("Received {0}", iBufferLength);
                        Array.Resize(ref buffer, iBufferLength);
                        string formattedBuffer = Encoding.ASCII.GetString(buffer);

                        Console.WriteLine("Data received by Client: {0}", formattedBuffer);

                        if (formattedBuffer == "quit")
                        {
                            socket.Close();
                            listeningSocket.Close();
                            Environment.Exit(0);
                        }

                        Console.WriteLine("Inside Try i = {0}", i.ToString());
                        Thread.Sleep(500);
                    }
                    catch (Exception e)
                    {
                        //socket.Close();
                        Console.WriteLine("Receiving error: " + e.ToString());
                        Console.ReadKey();
                        //throw;
                    }

                    finally
                    {
                        socket.Close();
                        //listeningsocket.close();
                    }
                }
            }

            static private string getLocalIPAddress()
            {
                IPHostEntry host;
                string localIP = "";
                host = Dns.GetHostEntry(Dns.GetHostName());
                foreach (IPAddress ip in host.AddressList)
                {
                    if (ip.AddressFamily == AddressFamily.InterNetwork)
                    {
                        localIP = ip.ToString();
                        break;
                    }
                }
                return localIP;
            }

        }

and the jave android code is

    private TCPClient mTcpClient;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final EditText editText = (EditText) findViewById(R.id.edit_message);
        Button send = (Button)findViewById(R.id.sendbutton);        

        // connect to the server
        new connectTask().execute("");

        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                String message = editText.getText().toString(); 

                //sends the message to the server
                if (mTcpClient != null) {
                    mTcpClient.sendMessage(message);
                }

                editText.setText("");
            }
        });
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {

        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    public class connectTask extends AsyncTask<String,String,TCPClient> {

        @Override
        protected TCPClient doInBackground(String... message) {

            mTcpClient = new TCPClient(new TCPClient.OnMessageReceived() {
                @Override

                public void messageReceived(String message) {

                    publishProgress(message);
                }
            });
            mTcpClient.run();

            return null;
        }

        @Override
        protected void onProgressUpdate(String... values) {
            super.onProgressUpdate(values); 
        }
    }
  }

the tcp class looks like

public class TCPClient {
    private String serverMessage;
    public static final String SERVERIP = "192.168.15.254"; 
    public static final int SERVERPORT = 4444;
    private OnMessageReceived mMessageListener = null;
    private boolean mRun = false;

    PrintWriter out;
    BufferedReader in;
    DataOutputStream dataOutputStream = null;

    //OutputStream os;

    public TCPClient(OnMessageReceived listener) {
        mMessageListener = listener;
    }

    public void sendMessage(String message){

        if (out != null && !out.checkError()) {

            /*
            String toSend = "a";
            byte[] toSendBytes = toSend.getBytes();

            int toSendLen = toSendBytes.length;
            byte[] toSendLenBytes = new byte[4];
            toSendLenBytes[0] = (byte)(toSendLen & 0xff);
            toSendLenBytes[1] = (byte)((toSendLen >> 8) & 0xff);
            toSendLenBytes[2] = (byte)((toSendLen >> 16) & 0xff);
            toSendLenBytes[3] = (byte)((toSendLen >> 24) & 0xff);
            try {
                os.write(toSendLenBytes);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

            try {
                os.write(toSendBytes);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            */
            String st=out.toString();
           //out.print(message);            
           out.flush();           


        }

    }

    public void stopClient(){
        mRun = false;
    }

    public void run() {

        mRun = true;

        try {

            InetAddress serverAddr = InetAddress.getByName(SERVERIP);

            Log.e("TCP Client", "C: Connecting...");

            Socket socket = new Socket(serverAddr, SERVERPORT);    

            ///
            //os = socket.getOutputStream();

            if(socket.isBound()){
                Log.i("SOCKET", "Socket: Connected");            
            }
            else{
                Log.e("SOCKET", "Socket: Not Connected");
            }
            try {

                //out=new FileWriter( null, true);
                out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

                /*
                dataOutputStream = new DataOutputStream(socket.getOutputStream());
                byte[] bytes = new byte[] {1}; 
                dataOutputStream.write(bytes, 0, bytes.length);
                */
                Log.e("TCP Client", "C: Sent.");                

                Log.e("TCP Client", "C: Done.");

                if(out.checkError())
                {
                    Log.e("PrintWriter", "CheckError");
                }

                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                while (mRun) {
                    serverMessage = in.readLine();

                    if (serverMessage != null && mMessageListener != null) {
                        mMessageListener.messageReceived(serverMessage);
                    }
                    serverMessage = null;

                }


                Log.e("RESPONSE FROM SERVER", "S: Received Message: '" + serverMessage + "'");


            } catch (Exception e) {

                Log.e("TCP", "S: Error", e);

            } finally {

                socket.close();
            }

        } catch (Exception e) {

            Log.e("TCP", "C: Error", e);

        }

    }

    public interface OnMessageReceived {
        public void messageReceived(String message);
    }

}

when i run the server it gives output of try i=1.
can any one tell me what to do next

Edited 3 Years Ago by zunairah

no. since you don't say what it is you want it to do. we can't help to improve the result, unless we know what the expected/perfect result is.

Comments
Didn’t you know we are super geniuses who can read minds?

i just want to make a chat application with android client and C# server.
the server is running perfectly but nothing is happening after
try i=1
on server screen

Now put lots of print statements into your code so you can see exactkly what is and what is not happening - eg is the client conecting? - does the server receive the message? ... etc etc

i had already too such output statements.Can you simply check it that why the client is not connecting with server??

Are you seriously asking someone to set up and run a test environemnt with your code and do your debugging for you? Or maybe spend hours studying hundreds of lines of mixed-language undocumented code?
Dream on.

This article has been dead for over six months. Start a new discussion instead.