Mac ADB环境搭建+Android adb forward转发TCP端口连接数试验

前言

下载好SDK，如果下载的有Android studio就是用他的SDK。

TCP端口转发：需要Android studio 和AVD（我的avd不好用太卡，用的是夜神模拟器）

一、Mac adb环境配置

打开终端执行：vim ~/.bsah_profile   //(新机器可能没有此文件，可以创建一个 touch ~/.bsah_profile )

然后在文件里加入下面语句：

export PATH=${PATH}:/Volumes/amusement/softwares/android-sdk-macosx/platform-tools
export PATH=${PATH}:/Volumes/amusement/softwares/android-sdk-macosx/tools

其中export PATH=${PATH}:/Volumes/amusement/softwares/android-sdk-macosx/platform-tools的/Volumes/amusement/softwares/android-sdk-macosx是自己的sdk路径，可根据自己的修改

保存退出之后执行sources ~/.bash_profile激活

验证：adb version

Android Debug Bridge version 1.0.40
Version 28.0.2-5303910
Installed as /Volumes/amusement/softwares/android-sdk-macosx/platform-tools/adb

连接手机（手机需要处于开发者模式并且处于允许调试）：adb shell

会自动搜索在线设备并进入，若果没有调试的手机，可以使用模拟器（夜神模拟器的连接接口是固定有序的：第一个是端口62001，第二个是62025，第三个是620025+1，以此类推）

命令：adb connect 127.0.0.1:62001

更多adb使用命令：传送门

二、Android adb forward转发TCP端口连接数试验

Android adb的一个命令 : adb forward，该命令转发PC电脑上的端口数据到Android设备的一个端口。

adb forward tcp:18000 tcp:19000

上面的命令，即把PC电脑端TCP端口18000的数据转发到与电脑通过adb连接的Android设备的TCP端口19000上。换言之，假设现在PC端在端口18000绑定，并在该端口读写数据，将会被转发到Android设备端的19000。

写一个例子，假设现在PC端作为客户端，用Java普通Socket写一个客户端绑定端口18000，并在这个端口写入和读取数据，然后Android作为服务器端绑定端口19000，等待客户端连接。服务器端与客户端建立连接后，两者进行数据的IO。

客户端（PC）：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

public class SocketTest {
    private ScheduledThreadPoolExecutor mScheduledThreadPoolExecutor = null;
    private Runnable mRunnable = null;
    private ScheduledFuture<?> mScheduledFuture = null;
    private Socket mSocket = null;

    private Logger mLogger = Logger.getLogger(SocketTest.class.getName());

    private void session() {
        DataInputStream dis = null;
        DataOutputStream dos = null;
        try {
            dis = new DataInputStream(mSocket.getInputStream());
            dos = new DataOutputStream(mSocket.getOutputStream());

            while (true) {
                String data = "PC时间:" + System.currentTimeMillis();
                dos.writeUTF(data);
                dos.flush();

                String s = dis.readUTF();
                mLogger.info("收到数据:" + s);

                Thread.sleep(5000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                mSocket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

            mSocket = null;
        }
    }

    public SocketTest() {
        mScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);

        mRunnable = new Runnable() {
            @Override
            public void run() {
                if (mSocket == null || !mSocket.isConnected()) {
                    mLogger.info("尝试建立连接...");
                    try {
                        mSocket = new Socket("localhost", 18000);
                        mLogger.info("建立新连接:" + mSocket.toString());

                        CompletableFuture.runAsync(new Runnable() {
                            @Override
                            public void run() {
                                session();
                            }
                        });
                    } catch (Exception e) {
                        mLogger.info("连接异常");
                    }
                } else {
                    mLogger.info("连接心跳检测:当前已经建立连接，无需重连");
                }
            }
        };

        // 每隔3秒周期性的执行心跳检测动作。
        mScheduledFuture = mScheduledThreadPoolExecutor.scheduleAtFixedRate(mRunnable, 0, 3, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        new SocketTest();
    }
}

安卓端（服务器端）：

package com.example.yrl.web;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class MainActivity extends AppCompatActivity {

    private String TAG = "Android端";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        new ServerThread().start();
    }

    private class ServerThread extends Thread {

        @Override
        public void run() {
            ServerSocket serverSocket = null;
            try {
                serverSocket = new ServerSocket(19000);
                while (true) {
                    Socket socket = serverSocket.accept();
                    Log.d(TAG, "接受连接");

                    new ClientThread(socket).start();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (serverSocket != null) {
                    try {
                        serverSocket.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    private class ClientThread extends Thread {
        private Socket socket;

        public ClientThread(Socket socket) {
            this.socket = socket;
            Log.d(TAG, "当前Socket:" + socket.toString());
        }

        @Override
        public void run() {
            try {
                DataInputStream dis = new DataInputStream(socket.getInputStream());
                DataOutputStream dos = new DataOutputStream(socket.getOutputStream());

                while (true) {

                    String data = dis.readUTF();
                    Log.d(TAG, "收到数据:" + data);

                    //回写给客户端。
                    String s = "手机时间:" + System.currentTimeMillis();
                    dos.writeUTF(s);
                    dos.flush();
                }

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

有了此代码，线启动服务器端

执行：adb forward tcp:18000 tcp:19000，然后启动Android studio边的代码，再启动PC端

可看到：服务器端（android）：

客户端（PC）：

过程中遇到的麻烦：

1.studio连接模拟器：在启动app时，显示在线设备，但是连不上，提示：minsdk（API 22） >deviceSDK(API 19),根据意思可知是app最小的sdk版本大于设备版本，只需要将app工程下的build gradle 文件，修改android:minSdkVersion="19"或更小，然后点击在右上侧的蓝色同步按钮，重新生成，即可解决问题

2.做这个也算另一种方法解决了困扰我很长时间的AVD打不开，一直在开机界面，提示“Emulator: emulator: ERROR: detected a hanging thread 'QEMU2 CPU0 thread'. No response for 15013 ms。”  一直没解决，索性不使用他，用模拟器代替。