androidsocketjni

1. android socket有几种方法

/***第一种：客户端Socket通过构造方法连接服务器***/
//客户端Socket可以通过指定IP地址或域名两种方式来连接服务器端,实际最终都是通过IP地址来连接服务器
//新建一个Socket，指定其IP地址及端口号
Socket socket = new Socket("192.168.0.7",80);
/***Socket 客户端 一些常用设置***/
//客户端socket在接收数据时，有两种超时：1.连接服务器超时，即连接超时；2.连接服务器成功后，接收服务器数据超时，即接收超时
//*设置socket 读取数据流的超时时间
socket.setSoTimeout(5000);
//发送数据包，默认为false，即客户端发送数据采用Nagle算法；
//但是对于实时交互性高的程序，建议其改为true，即关闭Nagle算法，客户端每发送一次数据，无论数据包大小都会将这些数据发送出去
socket.setTcpNoDelay(true);
//设置客户端socket关闭时，close（）方法起作用时延迟1分钟关闭，如果1分钟内尽量将未发送的数据包发送出去
socket.setSoLinger(true, 60);
//设置输出流的发送缓冲区大小，默认是8KB，即8096字节
socket.setSendBufferSize(8096);
//设置输入流的接收缓冲区大小，默认是8KB，即8096字节
socket.setReceiveBufferSize(8096);
//作用：每隔一段时间检查服务器是否处于活动状态，如果服务器端长时间没响应，自动关闭客户端socket
//防止服务器端无效时，客户端长时间处于连接状态
socket.setKeepAlive(true);
/*** Socket客户端向服务器端发送数据 ****/
//客户端向服务器端发送数据，获取客户端向服务器端输出流
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
//代表可以立即向服务器端发送单字节数据
socket.setOOBInline(true);
//数据不经过输出缓冲区，立即发送
socket.sendUrgentData(65);//"A"
//向服务器端写数据，写入一个缓冲区
//注：此处字符串最后必须包含“\r\n\r\n”，告诉服务器HTTP头已经结束，可以处理数据，否则会造成下面的读取数据出现阻塞
//在write（）方法中可以定义规则，与后台匹配来识别相应的功能，例如登录Login（）方法，可以写为write("Login|test,123 \r\n\r\n"),供后台识别;
bw.write("Login|test,123 \r\n\r\n");
//发送缓冲区中数据，必须有
bw.flush();

/*** Socket客户端读取服务器端响应数据 ****/
//socket.isConnected代表是否连接成功过
if((socket.isConnected() == true) && (socket.isClosed() == false)){//判断Socket是否处于连接状态
//客户端接收服务器端的响应，读取服务器端向客户端的输入流
InputStream is = socket.getInputStream();
//缓冲区
byte[] buffer = new byte[is.available()];
//读取缓冲区
is.read(buffer);
//转换为字符串
String responseInfo = new String(buffer);
//日志中输出
Log.i("TEST", responseInfo);
} //关闭网络
socket.close();
/***第二种：通过connect方法连接服务器***/
Socket socket_other = new Socket();
//使用默认的连接超时
socket_other.connect(new InetSocketAddress("192.168.0.7",80));
//连接超时2s
socket_other.connect(new InetSocketAddress("192.168.0.7",80),2000);
//关闭socket
socket_other.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

2. Android socket源码解析(三)socket的connect源码解析

上一篇文章着重的聊了socket服务端的bind，listen，accpet的逻辑。本文来着重聊聊connect都做了什么？

如果遇到什么问题，可以来本文 https://www.jianshu.com/p/da6089fdcfe1 下讨论

当服务端一切都准备好了。客户端就会尝试的通过 connect 系统调用，尝试的和服务端建立远程连接。

首先校验当前socket中是否有正确的目标地址。然后获取IP地址和端口调用 connectToAddress 。

在这个方法中，能看到有一个 NetHooks 跟踪socket的调用，也能看到 BlockGuard 跟踪了socket的connect调用。因此可以hook这两个地方跟踪socket，不过很少用就是了。

核心方法是 socketConnect 方法，这个方法就是调用 IoBridge.connect 方法。同理也会调用到jni中。

能看到也是调用了 connect 系统调用。

文件：/ net / ipv4 / af_inet.c

在这个方法中做的事情如下：

注意 sk_prot 所指向的方法是， tcp_prot 中 connect 所指向的方法，也就是指 tcp_v4_connect .

文件：/ net / ipv4 / tcp_ipv4.c

本质上核心任务有三件:

想要能够理解下文内容，先要明白什么是路由表。

路由表分为两大类：

每个路由器都有一个路由表(RIB)和转发表 (fib表)，路由表用于决策路由，转发表决策转发分组。下文会接触到这两种表。

这两个表有什么区别呢？

网上虽然给了如下的定义：

但实际上在linux 3.8.1中并没有明确的区分。整个路由相关的逻辑都是使用了fib转发表承担的。

先来看看几个和FIB转发表相关的核心结构体：

熟悉Linux命令朋友一定就能认出这里面大部分的字段都可以通过route命令查找到。

命令执行结果如下：

在这route命令结果的字段实际上都对应上了结构体中的字段含义：

知道路由表的的内容后。再来FIB转发表的内容。实际上从下面的源码其实可以得知，路由表的获取，实际上是先从fib转发表的路由字典树获取到后在同感加工获得路由表对象。

转发表的内容就更加简单

还记得在之前总结的ip地址的结构吗？

需要进行一次tcp的通信，意味着需要把ip报文准备好。因此需要决定源ip地址和目标IP地址。目标ip地址在之前通过netd查询到了，此时需要得到本地发送的源ip地址。

然而在实际情况下，往往是面对如下这么情况：公网一个对外的ip地址，而内网会被映射成多个不同内网的ip地址。而这个过程就是通过DDNS动态的在内存中进行更新。

因此 ip_route_connect 实际上就是选择一个缓存好的，通过DDNS设置好的内网ip地址并找到作为结果返回，将会在之后发送包的时候填入这些存在结果信息。而查询内网ip地址的过程，可以成为RTNetLink。

在Linux中有一个常用的命令 ifconfig 也可以实现类似增加一个内网ip地址的功能：

比如说为网卡eth0增加一个IPV6的地址。而这个过程实际上就是调用了devinet内核模块设定好的添加新ip地址方式，并在回调中把该ip地址刷新到内存中。

注意 devinet 和 RTNetLink 严格来说不是一个存在同一个模块。虽然都是使用 rtnl_register 注册方法到rtnl模块中：

文件：/ net / ipv4 / devinet.c

文件：/ net / ipv4 / route.c

实际上整个route模块，是跟着ipv4 内核模块一起初始化好的。能看到其中就根据不同的rtnl操作符号注册了对应不同的方法。

整个DDNS的工作流程大体如下：

当然，在tcp三次握手执行之前，需要得到当前的源地址，那么就需要通过rtnl进行查询内存中分配的ip。

文件：/ include / net / route.h

这个方法核心就是 __ip_route_output_key .当目的地址或者源地址有其一为空，则会调用 __ip_route_output_key 填充ip地址。目的地址为空说明可能是在回环链路中通信，如果源地址为空，那个说明可能往目的地址通信需要填充本地被DDNS分配好的内网地址。

在这个方法中核心还是调用了 flowi4_init_output 进行flowi4结构体的初始化。

文件：/ include / net / flow.h

能看到这个过程把数据中的源地址，目的地址，源地址端口和目的地址端口，协议类型等数据给记录下来，之后内网ip地址的查询与更新就会频繁的和这个结构体进行交互。

能看到实际上 flowi4 是一个用于承载数据的临时结构体，包含了本次路由操作需要的数据。

执行的事务如下：

想要弄清楚ip路由表的核心逻辑，必须明白路由表的几个核心的数据结构。当然网上搜索到的和本文很可能大为不同。本文是基于LInux 内核3.1.8.之后的设计几乎都沿用这一套。

而内核将路由表进行大规模的重新设计，很大一部分的原因是网络环境日益庞大且复杂。需要全新的方式进行优化管理系统中的路由表。

下面是fib_table 路由表所涉及的数据结构：

依次从最外层的结构体介绍：

能看到路由表的存储实际上通过字典树的数据结构压缩实现的。但是和常见的字典树有点区别，这种特殊的字典树称为LC-trie 快速路由查找算法。

这一篇文章对于快速路由查找算法的理解写的很不错: https://blog.csdn.net/dog250/article/details/6596046

首先理解字典树：字典树简单的来说，就是把一串数据化为二进制格式，根据左0，右1的方式构成的。

如图下所示：

这个过程用图来展示，就是沿着字典树路径不断向下读，比如依次读取abd节点就能得到00这个数字。依次读取abeh就能得到010这个数字。

说到底这种方式只是存储数据的一种方式。而使用数的好处就能很轻易的找到公共前缀，在字典树中找到公共最大子树，也就找到了公共前缀。

而LC-trie 则是在这之上做了压缩优化处理，想要理解这个算法，必须要明白在 tnode 中存在两个十分核心的数据：

这负责什么事情呢？下面就简单说说整个lc-trie的算法就能明白了。

当然先来看看方法 __ip_dev_find 是如何查找

文件：/ net / ipv4 / fib_trie.c

整个方法就是通过 tkey_extract_bits 生成tnode中对应的叶子节点所在index，从而通过 tnode_get_child_rcu 拿到tnode节点中index所对应的数组中获取叶下一级别的tnode或者叶子结点。

其中查找index最为核心方法如上，这个过程，先通过key左移动pos个位，再向右边移动（32 - bits）算法找到对应index。

在这里能对路由压缩算法有一定的理解即可，本文重点不在这里。当从路由树中找到了结果就返回 fib_result 结构体。

查询的结果最为核心的就是 fib_table 路由表，存储了真正的路由转发信息

文件：/ net / ipv4 / route.c

这个方法做的事情很简单，本质上就是想要找到这个路由的下一跳是哪里？

在这里面有一个核心的结构体名为 fib_nh_exception 。这个是指fib表中去往目的地址情况下最理想的下一跳的地址。

而这个结构体在上一个方法通过 find_exception 获得.遍历从 fib_result 获取到 fib_nh 结构体中的 nh_exceptions 链表。从这链表中找到一模一样的目的地址并返回得到的。

文件：/ net / ipv4 / tcp_output.c

3. 如何在Android下使用JNI

1.引言
我们知道，Android系统的底层库由c/c++编写，上层Android应用程序通过java虚拟机调用底层接口，衔接底层c/c++库与Java应用程序间的接口正是JNI（JavaNative Interface)。本文描述了如何在ubuntu下配置AndroidJNI的开发环境，以及如何编写一个简单的c函数库和JNI接口，并通过编写Java程序调用这些接口，最终运行在模拟器上的过程。

2.环境配置

2.1.安装jdk1.6
（1）从jdk官方网站下载jdk-6u29-linux-i586.bin文件。
（2）执行jdk安装文件
[html] view plainprint?
01.$chmod a+x jdk-6u29-linux-i586.bin
02.$jdk-6u29-linux-i586.bin
$chmod a+x jdk-6u29-linux-i586.bin
$jdk-6u29-linux-i586.bin
(3)配置jdk环境变量

[html] view plainprint?
01.$sudo vim /etc/profile
02.#JAVAEVIRENMENT
03.exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
04.exportJRE_HOME=$JAVA_HOME/jre
05.exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
06.exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
$sudo vim /etc/profile
#JAVAEVIRENMENT
exportJAVA_HOME=/usr/lib/java/jdk1.6.0_29
exportJRE_HOME=$JAVA_HOME/jre
exportCLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
保存后退出编辑，并重启系统。

（4）验证安装

[html] view plainprint?
01.$java -version
02.javaversion "1.6.0_29"
03.Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
04.JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
05.$javah
06.用法：javah[选项]<类>
07.其中[选项]包括：
08.-help输出此帮助消息并退出
09.-classpath<路径>用于装入类的路径
10.-bootclasspath<路径>用于装入引导类的路径
11.-d<目录>输出目录
12.-o<文件>输出文件（只能使用-d或-o中的一个）
13.-jni生成JNI样式的头文件（默认）
14.-version输出版本信息
15.-verbose启用详细输出
16.-force始终写入输出文件
17.使用全限定名称指定<类>（例
18.如，java.lang.Object）。
$java -version
javaversion "1.6.0_29"
Java(TM)SE Runtime Environment (build 1.6.0_29-b11)
JavaHotSpot(TM) Server VM (build 20.4-b02, mixed mode)
$javah
用法：javah[选项]<类>
其中[选项]包括：
-help输出此帮助消息并退出
-classpath<路径>用于装入类的路径
-bootclasspath<路径>用于装入引导类的路径
-d<目录>输出目录
-o<文件>输出文件（只能使用-d或-o中的一个）
-jni生成JNI样式的头文件（默认）
-version输出版本信息
-verbose启用详细输出
-force始终写入输出文件
使用全限定名称指定<类>（例
如，java.lang.Object）。2.2.安装android应用程序开发环境
ubuntu下安装android应用程序开发环境与windows类似，依次安装好以下软件即可：
（1）Eclipse
（2）ADT
（3）AndroidSDK
与windows下安装唯一不同的一点是，下载这些软件的时候要下载Linux版本的安装包。
安装好以上android应用程序的开发环境后，还可以选择是否需要配置emulator和adb工具的环境变量，以方便在进行JNI开发的时候使用。配置步骤如下：
把emulator所在目录android-sdk-linux/tools以及adb所在目录android-sdk-linux/platform-tools添加到环境变量中，android-sdk-linux指androidsdk安装包android-sdk_rxx-linux的解压目录。
[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=~/software/android/android-sdk-linux/tools:$PATH
03. exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
$sudo vim /etc/profile
exportPATH=~/software/android/android-sdk-linux/tools:$PATH
exportPATH=~/software/android/android-sdk-linux/platform-tools:$PATH
编辑完毕后退出，并重启生效。

2.3.安装NDK
NDK是由android提供的编译android本地代码的一个工具。
（1）从androidndk官网http://developer.android.com/sdk/ndk/index.html下载ndk，目前最新版本为android-ndk-r6b-linux-x86.tar.bz2.
（2）解压ndk到工作目录：
[plain] view plainprint?
01.$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
02.$sudo mv android-ndk-r6b /usr/local/ndk
$tar -xvf android-ndk-r6b-linux-x86.tar.bz2
$sudo mv android-ndk-r6b /usr/local/ndk
（3）设置ndk环境变量

[plain] view plainprint?
01.$sudo vim /etc/profile
02.exportPATH=/usr/local/ndk:$PATH
$sudo vim /etc/profile
exportPATH=/usr/local/ndk:$PATH

编辑完毕后保存退出，并重启生效

（4）验证安装

[plain] view plainprint?
01.$ cd/usr/local/ndk/samples/hello-jni/
02.$ ndk-build
03.Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
04.Gdbsetup : libs/armeabi/gdb.setup
05.Install : libhello-jni.so => libs/armeabi/libhello-jni.so
$ cd/usr/local/ndk/samples/hello-jni/
$ ndk-build
Gdbserver : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver
Gdbsetup : libs/armeabi/gdb.setup
Install : libhello-jni.so => libs/armeabi/libhello-jni.so

3.JNI实现
我们需要定义一个符合JNI接口规范的c/c++接口，这个接口不用太复杂，例如输出一个字符串。接下来，则需要把c/c++接口的代码文件编译成共享库（动态库）.so文件，并放到模拟器的相关目录下。最后，启动Java应用程序，就可以看到最终效果了。

3.1.编写Java应用程序代码
（1）启动Eclipse，新建android工程

Project：JNITest

Package：org.tonny.jni

Activity：JNITest

（2）编辑资源文件

编辑res/values/strings.xml文件如下：编辑res/layout/main.xml文件
我们在主界面上添加了一个EditText控件和一个Button控件。

（3）编辑JNITest.java文件


static表示在系统第一次加载类的时候，先执行这一段代码，在这里表示加载动态库libJNITest.so文件。

再看这一段：

[java] view plainprint?
01.privatenativeString GetReply();
privatenativeString GetReply();
native表示这个方法由本地代码定义，需要通过jni接口调用本地c/c++代码。

[java] view plainprint?
01.publicvoidonClick(View arg0) {
02.edtName.setText(reply);
03.}
publicvoidonClick(View arg0) {
edtName.setText(reply);
}

这段代码表示点击按钮后，把native方法的返回的字符串显示到EditText控件。

（4）编译工程，生成.class文件。

3.2.用javah工具生成符合JNI规范的c语言头文件

在终端中，进入android工程所在的bin目录

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/bin
$cd ~/project/Android/JNITest/bin
我们用ls命令查看，可以看到bin目录下有个classes目录，其目录结构为classes/org/tonny/jni，即classes的子目录结构是android工程的包名org.tonny.jni。请注意，下面我们准备执行javah命令的时候，必须进入到org/tonny/jni的上级目录，即classes目录，否则javah会提示找不到相关的java类。

下面继续：

[plain] view plainprint?
01.$cd classes
02.$javah org.tonny.jni.JNITest
03.$ls
04.org org_tonny_jni_JNITest.h
$cd classes
$javah org.tonny.jni.JNITest
$ls
org org_tonny_jni_JNITest.h

执行javahorg.tonny.jni.JNITest命令，在classes目录下会生成org_tonny_jni_JNITest.h头文件。如果不进入到classes目录下的话，也可以这样：

[plain] view plainprint?
01.$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
$javah -classpath ~/project/Android/JNITest/bin/classesorg.tonny.jni.JNITest
-classpath 参数表示装载类的目录。

3.3.编写c/c++代码
生成org_tonny_jni_JNITest.h头文件后，我们就可以编写相应的函数代码了。下面在android工程目录下新建jni目录，即~/project/Android/JNITest/jni，把org_tonny_jni_JNITest.h头文件拷贝到jni目录下，并在jni目录下新建org_tonny_jni_JNITest.c文件，编辑代码如下：

[cpp] view plainprint?
01.#include<jni.h>
02.#include<string.h>
03.#include"org_tonny_jni_JNITest.h"
04.
05.
06.JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
07.(JNIEnv *env, jobject obj){
08.return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
09.}
#include<jni.h>
#include<string.h>
#include"org_tonny_jni_JNITest.h"

JNIEXPORTjstring JNICALLJava_org_tonny_jni_JNITest_GetReply
(JNIEnv *env, jobject obj){
return(*env)->NewStringUTF(env,(char*)"Hello,JNITest");
}

我们可以看到，该函数的实现相当简单，返回一个字符串为："Hello,JNITest"

3.4.编写Android.mk文件
在~/project/Android/JNITest/jni目录下新建Android.mk文件，android可以根据这个文件的编译参数编译模块。编辑Android.mk文件如下：

[plain] view plainprint?
01.LOCAL_PATH:= $(call my-dir)
02.include$(CLEAR_VARS)
03.LOCAL_MODULE := libJNITest
04.LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
05.include$(BUILD_SHARED_LIBRARY)
LOCAL_PATH:= $(call my-dir)
include$(CLEAR_VARS)
LOCAL_MODULE := libJNITest
LOCAL_SRC_FILES:= org_tonny_jni_JNITest.c
include$(BUILD_SHARED_LIBRARY)

LOCAL_MODULE表示编译的动态库名称

LOCAL_SRC_FILES 表示源代码文件

3.5.用ndk工具编译并生成.so文件
进入到JNITest的工程目录，执行ndk-build命令即可生成libJNITest.so文件。

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/
02.$ndk-build
03.Invalidattribute name:
04.package
05.Install : libJNITest.so => libs/armeabi/libJNITest.so
$cd ~/project/Android/JNITest/
$ndk-build
Invalidattribute name:
package
Install : libJNITest.so => libs/armeabi/libJNITest.so
可以看到，在工程目录的libs/armeabi目录下生成了libJNITest.so文件。

3.6.在模拟器上运行
（1）首先，我们把android模拟器启动起来。进入到emulator所在目录，执行emulator命令：

[plain] view plainprint?
01.$cd ~/software/android/android-sdk-linux/tools
02.$./emulator @AVD-2.3.3-V10 -partition-size 512
$cd ~/software/android/android-sdk-linux/tools
$./emulator @AVD-2.3.3-V10 -partition-size 512
AVD-2.3.3-V10表示你的模拟器名称，与在Eclipse->AVDManager下的AVDName对应，-partition-size表示模拟器的存储设备容量。

（2）接下来，我们需要把libJNITest.so文件拷贝到模拟器的/system/lib目录下，执行以下命令：

[plain] view plainprint?
01.$cd ~/project/Android/JNITest/libs/armeabi/
02.$adb remount
03.$adb push libJNITest.so /system/lib
04.80 KB/s (10084 bytes in 0.121s)
$cd ~/project/Android/JNITest/libs/armeabi/
$adb remount
$adb push libJNITest.so /system/lib
80 KB/s (10084 bytes in 0.121s)

当在终端上看到有80 KB/s (10084 bytes in 0.121s)传输速度等信息的时候，说明拷贝成功。

（3）在终端上执行JNITest程序，这个我们可以在Eclipse下，右键点击JNITest工程，RunAs->Android Application，即可在模拟器上启动程序

4. androidsocket连接成功发不了消息

系统bug，网络问题。
1、系统bug是androidsocket系统出携耐现了问题导致连接成功发不了消息手做，等辩薯春待官方修复即可。
2、网络问题是自身设备连接的网络出现较大波动，导致androidsocket系统连接成功发不了消息，更换网络重新打开即可。

5. 在android JNI中通过socket获取MAC硬件地址，socket创建成功，但调用ioctl的时候，返回-1，怎么回事

这跟具体的WLAN驱动有关系，在你手机上不行说明你手机的WLAN驱动没有实现这个参数的ioctl

6. Android 多个Activity 共用一个socket

想要让多个activity共用一个socket（本文使用bluetoothsocket，TCP通信其实也是一样的，只是socket引入的库不同而已），网上三个方法，这里只是实现了比较简单的一种（application实体类）。

第一步实现socket实体类：

第二步：设置AndroidManifest.xml

加入android:name=".Mysocket"

第三步：在第一次创建链接时对它初始化：

因为我是蓝牙与51单片机进行通信，初始化bluetoothsocket后，再使用((Mysocket)getApplication()).setSocket(socket8051);这句话初始化实体类。

第四步：在其他的activity调用这个socket可以使用

不出意外可以正常运行。

实体类

`hello`