Android Framework层和Native层通过原生socket实现通信

  本篇是Android Framework层和Native层系列的第一篇，先从最简单Socket通信来作为开篇。聊到Android Framework和Native之间的通信读者也许可以列举很多，为什么要从最简单的原生socket通信为例来最开始说明，这个是因为不可能一开始就上最难的，得循序渐进一步步进行，所以先从最简单的原生Socket开始是最好不过的了。在这里就不对Socket基础知识进行讲解了，直接开撸代码。

Native层C/C++服务端实现

   有了开篇的介绍，大家应该知道得开始Socket通信经典的C/S模式了，在这里我们将C/C++端实现的Native程序作为服务端，Android端作为客户端。下面直接上服务端代码，如下:

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <android/log.h>
#include <jni.h>
#include <assert.h>

#define PORT 8888               //服务器端监听端口号,这个端口号可以自行定义
#define MAX_BUFFER 1024         //数据缓冲区最大值

#define LOGE(TAG,...) if(1) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);

#define TAG "Service"
int main()
{
    struct sockaddr_in server_addr, client_addr;
    int server_sockfd, client_sockfd;
    int size, write_size;
    char buffer[MAX_BUFFER];

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)    //创建Socket
    {
        perror("Socket Created Failed!\n");
        exit(1);
    }
    printf("Socket Create Success!\n");
	LOGE(TAG,"Socket Create Success!\n");

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);
    bzero(&(server_addr.sin_zero), 8);

    int opt = 1;
    int res = setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));    //设置地址复用
    if (res < 0)
    {
        perror("Server reuse address failed!\n");
        exit(1);
    }

    if (bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)  //绑定本地地址
    {
        perror("Socket Bind Failed!\n");
        exit(1);
    }
    printf("Socket Bind Success!\n");
	LOGE(TAG,"Socket Bind Success!\n");

    if (listen(server_sockfd, 5) == -1)                 //监听
    {
        perror("Listened Failed!\n");
        exit(1);
    }
    printf("Listening ....\n");
	LOGE(TAG,"Listening ....\n");

    socklen_t len = sizeof(client_addr);

    printf("waiting connection...\n");
    if ((client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &len)) == -1)  //等待客户端连接
    {
        perror("Accepted Failed!\n");
        exit(1);
    }

    printf("connection established!\n");
	LOGE(TAG,"connection established!\n");
    printf("waiting message...\n");
	LOGE(TAG,"waiting message...\n");
    while (1)
    {
        memset(buffer, 0, sizeof(buffer));                             //清空数据缓冲区

        if ((size = read(client_sockfd, buffer, MAX_BUFFER)) == -1)    //读取客户端的数据
        {
            perror("Recv Failed!\n");
            exit(1);
        }

        if (size != 0)                                               
        {
            buffer[size] = '\0';
            printf("Recv msg from client: %s\n", buffer);
			LOGE(TAG,"Recv msg from client: %s\n", buffer);
            if ((write_size = write(client_sockfd, buffer, MAX_BUFFER)) > 0)   //把收到的数据回发给客户端
            {
                printf("Sent msg to client successfully!\n");
				LOGE(TAG,"Sent msg to client successfully!\n");
            }

        }
    }

    close(client_sockfd);   //关闭Socket
    close(server_sockfd);

    return 0;
}

有了具体的实现代码，还得有相关的编译脚本，编译脚本Android.mk的实现如下：

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE_TAGS :=optional
LOCAL_C_INCLUDES := $(KERNEL_HEADERS)
LOCAL_SHARED_LIBRARIES := libcutils liblog  libutils libicuuc
LOCAL_LDLIBS	:= -lm -llog 

LOCAL_MODULE:= Service
LOCAL_SRC_FILES:= Server.c
LOCAL_PRELINK_MODULE := false
include $(BUILD_EXECUTABLE)

在NDK或者源码环境下编译，将生成的可执行文件Service推入终端执行，具体步骤如下：

λ adb ppush  E:\workspace\Android2Native\obj\local\armeabi\Service    /system/bin
2591 KB/s (42456 bytes in 0.016s)


λ adb shell
xxx:/ # cd system
xxx:/system # cd bin
xxx:/system/bin # ./Service
Socket Create Success!
Socket Bind Success!
Listening ....
waiting connection...

Android客户端的实现

   在前面的章节里面，我们Linux C/C++服务端已经愉快的跑了起来，正在等待着客户端的连接，我们的Android客户端要来连接了，具体核心代码如下：

package com.xxx.android2native;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClientManager {

    private static TcpClientManager mTcpClientConnector;
    private Socket mClient;
    private ConnectListener mListener;
    private Thread mConnectThread;
    private static final int HANDMESSAGE = 0;

    public interface ConnectListener {
        void onReceiveData(String data);
    }

    public void setOnConnectListener(ConnectListener listener) {
        this.mListener = listener;
    }

    public static TcpClientManager getInstance() {
        if (mTcpClientConnector == null)
            mTcpClientConnector = new TcpClientManager();
        return mTcpClientConnector;
    }

    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
            case HANDMESSAGE:
                if (mListener != null) {
                    mListener.onReceiveData(msg.getData().getString("data"));
                }
                break;
            }
        }
    };

    public void createConnect(final String mSerIP, final int mSerPort) {
        if (mConnectThread == null) {
            mConnectThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    connect(mSerIP, mSerPort);
                }
            });
            mConnectThread.start();
        }
    }

    /**
     * 与服务端进行连接
     * 
     * @throws IOException
     */
    private void connect(String mSerIP, int mSerPort) {
        if (mClient == null) {
            try {
                mClient = new Socket(mSerIP, mSerPort);
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if (mClient.isConnected()) {
            Message message = Message.obtain();
            message.what = HANDMESSAGE;
            Bundle bundle = new Bundle();
            bundle.putString("data", "Connect Server success\n");
            message.setData(bundle);
            mHandler.sendMessage(message);
        }

    }

    /**
     * 发送数据
     * 
     * @param data
     *            需要发送的内容
     */
    public void send(String data) throws IOException {
        OutputStream outputStream = mClient.getOutputStream();
        outputStream.write(data.getBytes());

        InputStream inputStream;
        try {
            inputStream = mClient.getInputStream();
            if (inputStream == null) {
                Log.e("TAG", "inputStream error");
                return;
            }
            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = inputStream.read(buffer)) != -1) {
                String recedata = new String(buffer, 0, len);
                Message message = Message.obtain();
                message.what = HANDMESSAGE;
                Bundle bundle = new Bundle();
                bundle.putString("data", recedata);
                message.setData(bundle);
                mHandler.sendMessage(message);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 断开连接
     * 
     * @throws IOException
     */
    public void disconnect() throws IOException {
        if (mClient != null) {
            mClient.close();
            mClient = null;
        }
    }
}

效果演示

   在前面的章节里面，Android客户端和C/C++的核心代码已经提供了，下面演示一下最终的实际效果：
(1) 服务端 ：

xxx:/system/bin # ./Service
Socket Create Success!
Socket Bind Success!
Listening ....
waiting connection...
connection established!
waiting message...
Recv msg from client: 123456
Sent msg to client successfully!

(2) Android客户端 ：

总结

   如上的Android客户端和Linux C/C++的服务端我是在同一台Android终端设备上面部署的，且使用的127.0.0.1的本地IP进行的通信测试的。记得我刚参加工作的时候从事的是机顶盒的开发，当时对Jni全公司的人都不是非常的了解，但是由于一些解码的库都是使用C/C++实现的，当时就是通过这种本地网络端口进行通信从而实现调用C/C++的代码库的。当然这个可可以扩展开来，在不同的机器上部署从而通过局域网或者广域网来进行通信。前面的代码只是简单的演示程序，具体的业务逻辑可以根据实际情况进行扩展，这篇文章只是一个抛砖引玉的作用。

本文地址：https://blog.csdn.net/tkwxty/article/details/103064321