aidl长连接小记

1:aidl类

interface IBackService{
	boolean sendMessage(String message);
}

2:长连接服务类

public class SocketService extends Service {
    private static final String TAG = "BackService";
    private static final long HEART_BEAT_RATE = 30 * 1000;

    private long receiverTime = 0L;
 
    public static final String HOST = "192.168.1.21";//
    public static final int PORT = 51001;
     
    public static final String MESSAGE_ACTION="com.dingmore.terminal.socket";
    public static final String HEART_BEAT_ACTION="com.dingmore.terminal.socket.heart";

    public static final String HEART_BEAT_STRING="{\"cmd\":\"00\"}";//心跳包内容
     
    private ReadThread mReadThread;
 
    private LocalBroadcastManager mLocalBroadcastManager;
 
    private WeakReference<Socket> mSocket;
 
    // For heart Beat
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
 
        @Override
        public void run() {
            if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
                boolean isSuccess = sendMsg(HEART_BEAT_STRING);//就发送一个HEART_BEAT_STRING过去 如果发送失败，就重新初始化一个socket
                if (!isSuccess) {
                	try{
                		if(mHandler!=null&& heartBeatRunnable!=null)
                			mHandler.removeCallbacks(heartBeatRunnable);
                		if(mReadThread!=null)
                			mReadThread.release();
                		if(mSocket!=null)
                			releaseLastSocket(mSocket);
	                    new InitSocketThread().start();
                	}catch(Exception e){
                		e.printStackTrace();
                	}
                }
            }
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };
 
    private long sendTime = 0L;
    private IBackService.Stub iBackService = new IBackService.Stub() {
 
        @Override
        public boolean sendMessage(String message) throws RemoteException {
            return sendMsg(message);
        }
    };
 
    @Override
    public IBinder onBind(Intent arg0) {
        return iBackService;
    }
     @Override
    public boolean onUnbind(Intent intent) {
    	// TODO Auto-generated method stub
    	 try{
	    	 mHandler.removeCallbacks(heartBeatRunnable);
	         mReadThread.release();
	         releaseLastSocket(mSocket);
    	 }catch(Exception e){
    		 e.printStackTrace();
    	 }
    	return super.onUnbind(intent);
    }
    @Override
    public void onCreate() {
        super.onCreate();
        new InitSocketThread().start();
        mLocalBroadcastManager=LocalBroadcastManager.getInstance(this);
         
    }
    public boolean sendMsg(String msg) {
    	//如果经过2*HEART_BEAT_RATE秒没收到心跳包也算失败，要重新启动。
        if (null == mSocket || null == mSocket.get()||(receiverTime>0&&System.currentTimeMillis()-receiverTime>2*HEART_BEAT_RATE)) {
        	receiverTime=System.currentTimeMillis();
            return false;
        }
        Socket soc = mSocket.get();
        try {
            if (!soc.isClosed() && !soc.isOutputShutdown()) {
                OutputStream os = soc.getOutputStream();
                String message = msg;
                os.write(message.getBytes());
                os.flush();
                sendTime = System.currentTimeMillis();//每次发送成数据，就改一下最后成功发送的时间，节省心跳间隔时间
            } else {
                return false;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
 
    private void initSocket() {//初始化Socket
        try {
            mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//初始化成功后，就准备发送心跳包
            Socket so = new Socket(HOST, PORT);
            mSocket = new WeakReference<Socket>(so);
            mReadThread = new ReadThread(so);
            mReadThread.start();
//            login();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    private void releaseLastSocket(WeakReference<Socket> mSocket) {
        try {
            if (null != mSocket) {
                Socket sk = mSocket.get();
                if (!sk.isClosed()) {
                    sk.close();
                }
                sk = null;
                mSocket = null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    class InitSocketThread extends Thread {
        @Override
        public void run() {
            super.run();
            initSocket();
        }
    }
 
    // Thread to read content from Socket
    class ReadThread extends Thread {
        private WeakReference<Socket> mWeakSocket;
        private boolean isStart = true;
 
        public ReadThread(Socket socket) {
            mWeakSocket = new WeakReference<Socket>(socket);
        }
 
        public void release() {
            isStart = false;
            releaseLastSocket(mWeakSocket);
        }
 
        @Override
        public void run() {
            super.run();
            Socket socket = mWeakSocket.get();
            if (null != socket) {
            	login();
                try {
                    InputStream is = socket.getInputStream();
                    byte[] buffer = new byte[1024 * 4];
                    int length = 0;
                    while (!socket.isClosed() && !socket.isInputShutdown()
                            && isStart && ((length = is.read(buffer)) != -1)) {
                        if (length > 0) {
                        	receiverTime=System.currentTimeMillis();
                            String message = new String(Arrays.copyOf(buffer,
                                    length)).trim();
                            Log.e(TAG, message);
                            //收到服务器过来的消息，就通过Broadcast发送出去
                            if(message.equals(HEART_BEAT_STRING)){//处理心跳回复
                                Intent intent=new Intent(HEART_BEAT_ACTION);
                                mLocalBroadcastManager.sendBroadcast(intent);
                            }else{
                                //其他消息回复
                                Intent intent=new Intent(MESSAGE_ACTION);
                                intent.putExtra("message", message);
                                mLocalBroadcastManager.sendBroadcast(intent);
                            }
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

	public void login() {
		// TODO Auto-generated method stub
		String login_id=GlobalApp.getInstance().getUser().login_id;
		String session_id=GlobalApp.getInstance().getUser().session_id;
		JsonObject jsonObject=new JsonObject();
		JsonObject paramsObject=new JsonObject();
		jsonObject.addProperty("cmd", "login");
		paramsObject.addProperty("password", "");
		paramsObject.addProperty("session_id", session_id);
		paramsObject.addProperty("login_id", login_id);
		jsonObject.add("param_list", paramsObject);
		System.out.println("##jsonObject.toString()===="+jsonObject.toString());
		System.out.println("##jsonObject.toString()===="+sendMsg(jsonObject.toString()+"#####"));
	}
 
}

3：长连接指令管理类

/**
 * 用于管理长连接指令管理
 * @author lianwanfei
 *
 */
public class CMDOrderManager {
	Activity cxt;
	CMDCallback callBack;
	private static CMDOrderManager cmdOrderManager;
	private CMDOrderManager(Activity cxt,CMDCallback callBack) {
		// TODO Auto-generated constructor stub
		this.cxt=cxt;
		this.callBack=callBack;
	}
	public static CMDOrderManager getInstance(Activity cxt,CMDCallback callBack){
		if(cmdOrderManager==null)
			cmdOrderManager=new CMDOrderManager(cxt,callBack);
		return cmdOrderManager;
	}
    private MessageBackReciver mReciver;
    private IntentFilter mIntentFilter;
    private Intent mServiceIntent;
    private LocalBroadcastManager mLocalBroadcastManager;
	private IBackService iBackService;
    private ServiceConnection conn = new ServiceConnection() {
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
            iBackService = null;
        }
 
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iBackService = IBackService.Stub.asInterface(service);
        }
    };
	public void initSocket() {
		mLocalBroadcastManager = LocalBroadcastManager.getInstance(cxt);
        mReciver = new MessageBackReciver();
        mServiceIntent = new Intent(cxt, SocketService.class);
        mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(SocketService.HEART_BEAT_ACTION);
        mIntentFilter.addAction(SocketService.MESSAGE_ACTION);

		mLocalBroadcastManager.registerReceiver(mReciver, mIntentFilter);
		cxt.getApplicationContext().bindService(mServiceIntent, conn, Context.BIND_AUTO_CREATE);
	}
	class MessageBackReciver extends BroadcastReceiver {
		@Override
		public void onReceive(Context context, Intent intent) {
			String action = intent.getAction();
			if (action.equals(SocketService.HEART_BEAT_ACTION)) {
//				Toast.makeText(Main2Activity.this, "Get a heart heat",
//						Toast.LENGTH_SHORT).show();
			} else {
				String message = intent.getStringExtra("message");
				analysisOrder(message);
			}
		};
	}

	public void analysisOrder(String message) {
		//解析收到的消息
	}
	/**
	 * 应用销毁时调用，销毁长连接和广播监听器。
	 */
	public void onDestroy() {
		 cxt.getApplicationContext().unbindService(conn);
	     mLocalBroadcastManager.unregisterReceiver(mReciver);
	}
	

}