Android 使用Mina框架

/**
 * Created by luohan on 2016/12/9.
 */
public class MinaThread extends Thread {private static String TAG = "[MinaThread]";
    //30秒后超时
    private static final int IDELTIMEOUT = 10;
    //15秒发送一次心跳包
    private static final int HEARTBEATRATE = 10;
    //服务器地址
    private static final String SERVER_ADDRESS = "192.168.3.20";
    private static final int SERVER_POST = 6001; 

    public  DataCallbackListener mc_dataCallbackListener;
    private ClientHandler clientHandler;
    private ConnectFuture connectFuture;
    private IoSession session;
    private IoConnector connector;
    OBDConnectionService target;

    public MinaThread(OBDConnectionService target) {this.target = target;
    }@Override
    public void run() {super.run();
        initialize();
        conntection();
        minaClose();
        if(target != null){target.disconnect();
        }}public void setupConnectFuture() {if(connectFuture == null) {connectFuture = connector.connect(new InetSocketAddress(SERVER_ADDRESS, SERVER_POST) ); 
        }return;
    }/**
     * 设置外部回调
     */
    public void initialize() {/* ClientHandler */
        if (clientHandler == null) {clientHandler = new ClientHandler();
            clientHandler.setDataCallbackListener(new ClientHandler.DataCallbackListener() {@Override
                public void data(Map, String> iboxData) {if (mc_dataCallbackListener != null) {mc_dataCallbackListener.data(iboxData);
                    }}});
        }}private void conntection() {if(connector == null) {connector = new NioSocketConnector();
            /* 添加过滤器 */
            connector.getFilterChain().addLast("logger", new LoggingFilter());
            connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ClientCodecFactory()));
            /* ReadBufferSize */
            connector.getSessionConfig().setReadBufferSize(1024 * 10);
            /* 设置链接超时时间 */
            connector.setConnectTimeoutMillis(10 * 1000);
            /* timeout for read and write */
            connector.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, IDELTIMEOUT);
            //设置心跳工程
            KeepAliveMessageFactory heartBeatFactory = new KeepAliveMessageFactoryImpl();
             当读操作空闲时发送心跳
            KeepAliveFilter heartBeat = new KeepAliveFilter(heartBeatFactory);
            // 设置心跳包请求后超时无反馈情况下的处理机制，默认为关闭连接,在此处设置为输出日志提醒
            heartBeat.setRequestTimeoutHandler(KeepAliveRequestTimeoutHandler.LOG);
            /** 是否回发 */
            heartBeat.setForwardEvent(false);
            /** 发送频率 */
            heartBeat.setRequestInterval(HEARTBEATRATE);
            /** 设置心跳包请求后 等待反馈超时时间。 超过该时间后则调用KeepAliveRequestTimeoutHandler.CLOSE */
            heartBeat.setRequestTimeout(IDELTIMEOUT);
            //connector.getSessionConfig().setKeepAlive(true);
            connector.getFilterChain().addLast("heartbeat", heartBeat);

            //connector.getFilterChain().addLast("reconnect", new KeepAliveRequestTimeoutHandlerImpl()); //心跳超时后的处理,这里先默认处理

        }try{if(connectFuture == null) {connector.setHandler(clientHandler);
                setupConnectFuture();
            }Log.d(TAG,"开始于服务器建立连接...");
            connectFuture.awaitUninterruptibly(); //等待连接创建完成
            session = connectFuture.getSession(); //获得seccion
            //连接成功
            if (session != null && session.isConnected()) {target.connected();
                Log.d(TAG,"连接成功");
            } else {target.disconnect();
            }}catch (Exception e){Log.d(TAG, "客户端链接异常(在连接时直接抛出了异常):");
            Log.e(TAG, e.toString());
        }if (session != null && session.isConnected()) {session.getCloseFuture().awaitUninterruptibly();// 等待连接断开
            System.out.println("客户端断开");
        }}public void writeData(String order, String msg){if(session != null && session.isConnected()) {session.write(order);
            Log.d(TAG, "数据上报成功:" + msg);
            return;
        }}/**
     * 关闭Mina长连接 **
     */
    public void minaClose(){if (session != null) {session.close(false);
            session = null;
        }if (connectFuture != null && connectFuture.isConnected()) {connectFuture.cancel();
            connectFuture = null;
        }if (connector != null && !connector.isDisposed()) {//清空里面注册的所以过滤器
            connector.getFilterChain().clear();
            connector.dispose();
            connector = null;
        }Log.i(TAG, "MINA长连接已关闭...");
        Log.i(TAG, "MINA长连接已关闭...");
    }/* 接口 */
    public interface DataCallbackListener{public void data(Map, String> iboxData);
    }public void setDataCallbackListener(DataCallbackListener listener) {this.mc_dataCallbackListener = listener;
    }
}

private void connectionService(){closeMinaThread();
    if(minaThread == null) {minaThread = new MinaThread(this);
        minaThread.initialize();
        minaThread.setDataCallbackListener(minaCallbackListener);
        minaThread.start();
    }
}private void closeMinaThread() {if(minaThread != null) {minaThread.interrupt();
        minaThread = null;
    }
}private void sendOBDData(String order, String display) {if(minaThread!=null && isConnected)minaThread.writeData(order, display);
}public void disconnect(){isConnected = false;
    closeMinaThread();
    repetition();
}
public void connected(){isConnected = true;
}private void repetition() {stopCountdown();
    Log.e(TAG, "----------请求失败, 5s后重新连接--------");
    timer = new Timer();
    timer.schedule(new TimerTask() {@Override
        public void run() {connectionService();
        }}, 7000);
}private void stopCountdown(){if(timer != null){timer.cancel();
        timer = null;
    }
}