android socket通信

最新推荐文章于 2019-11-06 11:48:09 发布
最新推荐文章于 2019-11-06 11:48:09 发布
阅读量755 收藏
点赞数
分类专栏： android

转自： http://blog.csdn.net/htttw/article/details/7574409

在android socket通信（上），我们完成了一个模拟器上运行的android socket通信实例程序：

http://blog.csdn.net/htttw/article/details/7574372



今天我们将它移植到真实的android手机上，不过要先确保环境配置正确，请参考上一讲。



主机的lwan0的ip地址是路由器自动分配的：192.168.1.100，android手机的ip地址是路由器自动分配的：192.168.1.101，可以在主机上ping手机，理论上是通的，不过很奇怪，我经常会碰到ping不通的情况，然后我在android手机里装了一个模拟终端，ping主机，一般都是通的，难道是android手机的问题？




下面直接上代码，和上一讲的代码基本没有差别，改动的部分如下：

1.

ip地址修改过了

2.

端口由9400改为了9500（呵呵，这是任意的，不改也可以的）



2.

src/RealclientActivity.java

[java] view plain copy print ?
  1. package real.client.com;
  3. import java.io.IOException;
  4. import java.io.PrintStream;
  5. import java.net.Socket;
  6. import java.net.UnknownHostException;
  8. import android.app.Activity;
  9. import android.os.Bundle;
  10. import android.view.View;
  11. import android.widget.Button;
  12. import android.widget.EditText;
  13. import android.widget.Toast;
  16. public class RealclientActivity extends Activity
  17. {
  18. /* 服务器地址 */
  19. private final String SERVER_HOST_IP = "192.168.1.100";
  21. /* 服务器端口 */
  22. private final int SERVER_HOST_PORT = 9500;
  24. private Button btnConnect;
  25. private Button btnSend;
  26. private EditText editSend;
  27. private Socket socket;
  28. private PrintStream output;
  31. public void toastText(String message)
  32. {
  33. Toast.makeText(this, message, Toast.LENGTH_LONG).show();
  34. }
  36. public void handleException(Exception e, String prefix)
  37. {
  38. e.printStackTrace();
  39. toastText(prefix + e.toString());
  40. }
  42. /** Called when the activity is first created. */
  43. @Override
  44. public void onCreate(Bundle savedInstanceState)
  45. {
  46. super.onCreate(savedInstanceState);
  47. setContentView(R.layout.main);
  49. initView();
  51. btnConnect.setOnClickListener(new Button.OnClickListener()
  52. {
  53. @Override
  54. public void onClick(View v)
  55. {
  56. initClientSocket();
  57. }
  58. });
  60. btnSend.setOnClickListener(new Button.OnClickListener()
  61. {
  62. @Override
  63. public void onClick(View v)
  64. {
  65. sendMessage(editSend.getText().toString());
  66. }
  67. });
  68. }
  70. public void initView()
  71. {
  72. btnConnect = (Button)findViewById(R.id.btnConnect);
  73. btnSend = (Button)findViewById(R.id.btnSend);
  74. editSend = (EditText)findViewById(R.id.sendMsg);
  76. btnSend.setEnabled(false);
  77. editSend.setEnabled(false);
  78. }
  80. public void closeSocket()
  81. {
  82. try
  83. {
  84. output.close();
  85. socket.close();
  86. }
  87. catch (IOException e)
  88. {
  89. handleException(e, "close exception: ");
  90. }
  91. }
  93. private void initClientSocket()
  94. {
  95. try
  96. {
  97. /* 连接服务器 */
  98. socket = new Socket(SERVER_HOST_IP, SERVER_HOST_PORT);
  100. /* 获取输出流 */
  101. output = new PrintStream(socket.getOutputStream(), true, "utf-8");
  103. btnConnect.setEnabled(false);
  104. editSend.setEnabled(true);
  105. btnSend.setEnabled(true);
  106. }
  107. catch (UnknownHostException e)
  108. {
  109. handleException(e, "unknown host exception: " + e.toString());
  110. }
  111. catch (IOException e)
  112. {
  113. handleException(e, "io exception: " + e.toString());
  114. }
  115. }
  117. private void sendMessage(String msg)
  118. {
  119. output.print(msg);
  120. }
  121. } 
package real.client.com;

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;


public class RealclientActivity extends Activity
{
  /* 服务器地址 */
  private final String SERVER_HOST_IP = "192.168.1.100";

  /* 服务器端口 */
  private final int SERVER_HOST_PORT = 9500;
  
  private Button btnConnect;
  private Button btnSend;
  private EditText editSend;
  private Socket socket;
  private PrintStream output;


  public void toastText(String message)
  {
    Toast.makeText(this, message, Toast.LENGTH_LONG).show();
  }

  public void handleException(Exception e, String prefix)
  {
    e.printStackTrace();
    toastText(prefix + e.toString());
  }

  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState)
  {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    initView();

    btnConnect.setOnClickListener(new Button.OnClickListener()
    {
      @Override
      public void onClick(View v)
      {
        initClientSocket();
      }
    });
    
    btnSend.setOnClickListener(new Button.OnClickListener()
    {
      @Override
      public void onClick(View v)
      {
        sendMessage(editSend.getText().toString());
      }
    });
  }
  
  public void initView()
  {
    btnConnect = (Button)findViewById(R.id.btnConnect);
    btnSend = (Button)findViewById(R.id.btnSend);
    editSend = (EditText)findViewById(R.id.sendMsg);

    btnSend.setEnabled(false);
    editSend.setEnabled(false);
  }

  public void closeSocket()
  {
    try
    {
      output.close();
      socket.close();
	}
    catch (IOException e)
    {
      handleException(e, "close exception: ");
	}
  }
  
  private void initClientSocket()
  {
    try
    {
      /* 连接服务器 */
      socket = new Socket(SERVER_HOST_IP, SERVER_HOST_PORT);

      /* 获取输出流 */
      output = new PrintStream(socket.getOutputStream(), true, "utf-8");
      
      btnConnect.setEnabled(false);
      editSend.setEnabled(true);
      btnSend.setEnabled(true);
    }
    catch (UnknownHostException e)
    {
      handleException(e, "unknown host exception: " + e.toString());
    }
    catch (IOException e)
    {
      handleException(e, "io exception: " + e.toString());
    }
  }
  
  private void sendMessage(String msg)
  {
    output.print(msg);
  }
}


layout/main.xml

[plain] view plain copy print ?
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:layout_width="fill_parent"
  4. android:layout_height="fill_parent"
  5. android:orientation="vertical" >
  7. <TextView
  8. android:layout_width="fill_parent"
  9. android:layout_height="wrap_content"
  10. android:text="@string/hello" />
  12. <Button
  13. android:id="@+id/btnConnect"
  14. android:layout_width="fill_parent"
  15. android:layout_height="wrap_content"
  16. android:text="@string/connect" />
  18. <EditText
  19. android:id="@+id/sendMsg"
  20. android:layout_width="match_parent"
  21. android:layout_height="wrap_content"
  22. android:inputType="text" />
  24. <Button
  25. android:id="@+id/btnSend"
  26. android:layout_width="fill_parent"
  27. android:layout_height="wrap_content"
  28. android:text="@string/send" />
  30. </LinearLayout> 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

    <Button
        android:id="@+id/btnConnect"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/connect" />

    <EditText
        android:id="@+id/sendMsg"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:inputType="text" />

    <Button
        android:id="@+id/btnSend"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/send" />

</LinearLayout>



不要忘了，在AndroidManifest.xml中添加访问网络权限：
<uses-permission android:name="android.permission.INTERNET" />



把上面的代码编译并下载到手机中



3.

服务器端的代码，用c++实现：

server.c

[cpp] view plain copy print ?
  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <netinet/in.h>
  4. #include <arpa/inet.h>
  5. #include <unistd.h>
  6. #include <stdlib.h>
  7. #include <stdio.h>
  9. #define PORT 9500
  10. #define MAX_BUFFER 1024
  13. int main()
  14. {
  15. /* create a socket */
  16. int server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
  18. struct sockaddr_in server_addr;
  19. server_addr.sin_family = AF_INET;
  20. server_addr.sin_addr.s_addr = inet_addr("192.168.1.100");
  21. server_addr.sin_port = htons(PORT);
  23. /* bind with the local file */
  24. bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
  26. /* listen */
  27. listen(server_sockfd, 5);
  29. int size;
  30. char buffer[MAX_BUFFER + 1];
  31. int client_sockfd;
  32. struct sockaddr_in client_addr;
  33. socklen_t len = sizeof(client_addr);
  35. /* accept a connection */
  36. printf("waiting connection...\n");
  37. client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &len);
  38. printf("connection established!\n");
  40. while(1)
  41. {
  42. printf("waiting message...\n");
  44. /* exchange data */
  45. size = read(client_sockfd, buffer, MAX_BUFFER);
  46. buffer[size] = '\0';
  47. printf("Got %d bytes: %s\n", size, buffer);
  48. }
  50. /* close the socket */
  51. close(client_sockfd);
  53. return 0;
  54. } 
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#define PORT 9500
#define MAX_BUFFER 1024


int main()
{
  /* create a socket */
  int server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
  
  struct sockaddr_in server_addr;
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = inet_addr("192.168.1.100");
  server_addr.sin_port = htons(PORT);
  
  /* bind with the local file */
  bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
  
  /* listen */
  listen(server_sockfd, 5);
  
  int size;
  char buffer[MAX_BUFFER + 1];
  int client_sockfd;
  struct sockaddr_in client_addr;
  socklen_t len = sizeof(client_addr);
  
  /* accept a connection */
  printf("waiting connection...\n");
  client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &len);
  printf("connection established!\n");
    
  while(1)
  {
    printf("waiting message...\n");
    
    /* exchange data */
    size = read(client_sockfd, buffer, MAX_BUFFER);
    buffer[size] = '\0';
    printf("Got %d bytes: %s\n", size, buffer);
  }

  /* close the socket */
  close(client_sockfd);
      
  return 0;
}



Makefile：

[plain] view plain copy print ?
  1. all: server.c
  2. gcc -g -Wall -o server server.c
  4. clean:
  5. rm -rf *.o server 
all: server.c
	gcc -g -Wall -o server server.c

clean:
	rm -rf *.o server


4.
运行结果：

代码不过多解释了，注释挺详细的，有关pc机上的tcp通信，可以参考：

http://blog.csdn.net/htttw/article/details/7519964

最后，我把这个服务器和客户端两个程序都上传上来，供大家下载：

http://download.csdn.net/detail/htttw/4307666

秦超
关注
专栏目录
android socket通信（下）
htttw的专栏
05-16 1万+
android socket通信（下） 在android socket通信（上），我们完成了一个模拟器上运行的android socket通信实例程序： http://blog.csdn.net/htttw/article/details/7574372 今天我们将它移植到真实的android手机上，不过要先确保环境配置正确，请参考上一讲。
Socket 通信原理(Android客户端和服务器以TCP&&UDP方式互通)
热门推荐
其实并不难,是你太悲观
06-21 16万+
ZERO、前言 有关通信原理内容是在网上或百科整理得到，代码部分为本人所写，如果不当，还望指教。 一、Socket通信简介  Android与服务器的通信方式主要有两种，一是Http通信，一是Socket通信。两者的最大差异在于，http连接使用的是“请求—响应方式”，即在请求时建立连接通道，当客户端向服务器发送请求后，服务器端才能向客户端返回数据。而Socket通信则是在双
Android socket 通信
大家好，我是+V
11-06 357
Android socket 通信 安卓编写Socket客户端，实现连接Socket服务端通信。 创建Socket连接并获取服务端数据 先创建几个全局变量吧 private BufferedWriter writer = null; Socket socket; 创建Socket // 填好IPV4的IP地址和端口，服务端会提供，问服务端要 ...
Android socket通信聊天，客户端+服务端
06-25
在Android平台上进行网络通信时，Socket通信是一种常见且重要的方式，尤其在实现聊天应用时。本文将深入探讨如何在Android中实现基于Socket的客户端和服务端通信，以构建一个简单的聊天应用。 首先，让我们理解...
Android socket通信
11-18
下面将详细介绍Android客户端和Java服务端如何实现Socket通信以及服务端如何转发所有客户端的消息。 1. **Android客户端Socket通信**： - 首先，Android客户端需要创建一个Socket实例，指定服务端的IP地址和端口号...
Android Socket通信 demo
最新发布
10-10
Android 使用netty实现Socket通信demo+Sokit工具
android Socket通信
07-12
在Android开发中，Socket通信是一种常见的网络编程方式，它允许设备之间通过TCP/IP协议进行双向数据传输。Socket基于TCP协议，提供了低级别的、面向连接的、可靠的字节流通信。本教程将深入讲解如何在Android中实现...
Android Socket 通信
不枉少年
11-01 490
socket的关闭：后创建的先关闭，先创建的后关闭。（一）服务器端（java程序）:1.阻塞监听客户端连接：serverSocker = new ServerSocket(8888);socket = this.serverSocket.accept();In = socket.getInputSteam();out = socket.getOutputStream(); 2.把流装饰成带全缓冲的
Android Socket连接（心跳检测，断线重连，状态监测等）
09-27
Android Socket连接，包含心跳检测，断线重连，数据发送等等 博客地址：http://blog.csdn.net/yuzhiqiang_1993/article/details/78094909
Android app Socket客户端
01-22
Android app Socket客户端，可以连接Socket服务端，用于测试。 开发工具为AndroidStudio
Android-Socket通信
dream_xang的博客
10-23 311
Android-Socket通信 Socket通信的应用 编写一个Socket连接的工具类SocketConnect，其中handle是用来传递连接状态的。 import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStre...
Android Socket通信
myfwjy的博客
07-11 344
Android Socket通信
Android Socket通信详解：建立可靠连接与数据传输
本文将深入探讨Android Socket通信的详解，针对Android平台与服务器之间的两种主要通信方式——HTTP和Socket通信，重点聚焦于Socket通信。Socket通信相较于HTTP，采用更为直接的连接模式，允许双向数据交换和主动推...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值