Netty在Android中使用

public void init(boolean isCentral) {
        //进行初始化
        NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup(); //初始化线程组
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.channel(NioSocketChannel.class).group(nioEventLoopGroup);
        bootstrap.option(ChannelOption.TCP_NODELAY, true); //无阻塞
        bootstrap.option(ChannelOption.SO_KEEPALIVE, true); //长连接
//                        bootstrap.option(ChannelOption.SO_TIMEOUT, 5000); //收发超时
        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline()
                        .addLast(new IdleStateHandler(30,//30秒没收到数据会触发读超时回调
                                0,//10秒没有进行写会触发写超时回调,0代表不处理
                                0))//未执行读取或写入时触发超时回调,0代表不处理
                        .addLast(new ByteArrayDecoder())  //接收解码方式
                        .addLast(new ByteArrayEncoder())  //发送编码方式
                        .addLast(new ChannelHandle(NettyChannelHelper.this)); //处理数据接收

            }
        });

        sHandlerThread = new HandlerThread("发送数据");
        sHandlerThread.start();
        sHandler = new Handler(sHandlerThread.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(@NonNull Message message) {
                if (message.what == 22) {
                    Log.d("SocketChannelHelper", "operationComplete: handleMessage");
                    if (isOpenSocket) {
                        isOpenSocket = false;

                        //开始建立连接并监听返回
                        future = bootstrap.connect(new InetSocketAddress(ip, Integer.parseInt(port)));
                        channelFutureListener = new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture channelFuture) {
                                if (channelFuture.isSuccess()) {
                                    isResetSocket = true;
                                    Log.d("ccc", "SocketChannelHelper success---连接成功!");
                                    sendData();
                                } else {
                                    Log.d("ccc", "SocketChannelHelper failed---连接失败!");
                                }
                            }
                        };
                        future.addListener(channelFutureListener);
                    }
                    Message message2 = new Message();
                    message2.what = 22;
                    sHandler.sendMessageDelayed(message2, 1000);
                }
                return false;
            }
        });
        Message message = new Message();
        message.what = 22;
        sHandler.sendMessage(message);
    }

    /**
     * @param isReset ture重启 false不重启
     */
    public void restart(boolean isReset) {

        if (handlerThread != null) {
            handlerThread.quit();
        }
        if (handler != null) {
            handler.removeMessages(11);
            handler.removeCallbacks(handlerThread);
        }
        handler = null;
        handlerThread = null;
        if (null != future && null != channelFutureListener) {
            future.removeListener(channelFutureListener);
            future.cancel(true);
            future.channel().close();
            future = null;
        }
        if(isResetSocket){
            //间隔1秒再重启
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            isOpenSocket = true;
        } else {
            if (iSocketClose != null) {
                iSocketClose.close();
                Log.d("SocketChannelHelper", "operationComplete: 连接结束");
            }
        }
    }

   

    private Handler handler;
    private HandlerThread handlerThread;
    private void sendData() {
        handlerThread = new HandlerThread("发送数据");
        handlerThread.start();
        handler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(@NonNull Message message) {
                if (message.what == 11) {

                    while (V2CentralStationHelper.isWrite) {
                        try {
                            long startTime = System.currentTimeMillis();
                            if (null != future && future.channel().isActive()) {
                                // 发送消息                         future.channel().writeAndFlush(Unpooled.copiedBuffer("测试",CharsetUtil.UTF_8));
                            }
                            long stopTime = System.currentTimeMillis();
                            long interval = (1000 - (stopTime - startTime));
                            Thread.sleep(interval);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    restart(false);
                }
                return false;
            }
        });
        Message message = new Message();
        message.what = 11;
        handler.sendMessage(message);
    }