android生命周期有几种状态(android微信回调)

活动和服务通信分为两类：同一进程中的通信和不同进程中的通信。

可以在同一进程中直接实现IBinder接口，也可以继承Binder类。 Binder类是系统提供的IBinder接口的实现类。

Service中：

publicclassmybindextendsbinder { publicmyservicegetservice (} { return my service.this； onBind时返回MyBind

@ overridepublicibinderonbind (intent intent ) super.on bind (intent ) )； 返回new mybind (； } Activity中：

对于bindService，在服务连接回调中检索MyService对象

conn=newserviceconnection ((overridepublicvoidonserviceconnected ) componentnamename， IBinder service ) ) is bind=truubind if (服务instanceofmyservice.mybind ) myservice=() myservice.mybind ) service ) } log.I (生命周期，)服务连接--- -已连接)； } @ overridepublicvoidonservicedisconnected (组件名称) { isBind=false； log.I (生命周期，)服务连接--- -已连接)； }； 这样就成为了活动中的服务对象。 可以自由调用服务提供的方法。

在不同的过程中运行Messenger方式

Messenger必须与处理程序组合使用。 有send方法，最终调用的是handler方法。

Service中：

私有Myhandler处置器； 私有消息传感器； @Override public void onCreate () { super.onCreate )； handler=new MyHandler (； 消息传感器=new消息传感器(handler )； } . publicstaticclassmyhandlerextendshandler { @ overridepublicvoiddispatchmessage (message msg ) super.dispatchmessage log.I (生命，) myhandler----分布消息)； log.I('life '，Thread.currentThread ) ).getName ) )； } @ overridepublicvoidhandlemessage (消息msg ) super.handlemessage ) msg； log.I('life '，' myhandler---- handle消息)； 需要handler和Messenger对象。 handler最终负责发送和接收消息。 我们现在可以在MyHandler上处理来自活动的各种消息。

Activity中：

conn=newserviceconnection ((overridepublicvoidonserviceconnected ) componentnamename，IBinder service ) ) is bind=trubid

w Messenger(service); Log.i("life", "ServiceConnection-----onServiceConnected"); Log.i("life", Thread.currentThread().getName()); } @Override public void onServiceDisconnected(ComponentName name) { isBind = false; Log.i("life", "ServiceConnection----onServiceDisconnected"); } }; ....//点击发送Message message = Message.obtain();message.what = 5;try {messenger.send(message);} catch (RemoteException e) {e.printStackTrace();}

这样就完成了通过Messenger夸进程传递内容了。

Messenger源码浅析：

public final class Messenger implements Parcelable { private final IMessenger mTarget; /** *构造方法需要一个handler对象 *@param target 将接收发送的消息 */ public Messenger(Handler target) { mTarget = target.getIMessenger(); } /** * @return 返回当前Messenger的IBinder对象 */ public IBinder getBinder() { //其实也是封装了AIDL return mTarget.asBinder(); } /** *构造方法了 * @param target 需要传入之前通过getBinder（）的到的IBinder */ public Messenger(IBinder target) { mTarget = IMessenger.Stub.asInterface(target); } /** *发送消息 *如果handler已经不存在了，抛异常 */ public void send(Message message) throws RemoteException { mTarget.send(message); }

上面四个方法就是我们调用的，前面两个方法在Service中调用。后两个方法在Activity中调用。
类中有一个对象 private final IMessenger mTarget，在传入Handler对象的时候进行的实例化。
看下handler.getIMessenger();

....final IMessenger getIMessenger() { synchronized (mQueue) { if (mMessenger != null) { return mMessenger; } mMessenger = new MessengerImpl(); return mMessenger; } }.... private final class MessengerImpl extends IMessenger.Stub { public void send(Message msg) { msg.sendingUid = Binder.getCallingUid(); Handler.this.sendMessage(msg); } }

可以看到IMessenger 的对象来自handler的内部类MessengerImpl 。而这个类其实是继承了一个AIDL生成的类，AIDL提供了一个send(Message msg) 方法。并且还给这个msg赋值了sendingUid，也就是当前启动Service的应用ID，最终通过handler发送msg。
这样Looper就可以知道这个消息所在的应用和所对应的handler。在列子中，所在的线程在Service的主线程中，而一个线程只有一个Looper

双向通信

上面利用Messenger实现了Activity向Service夸进程发送消息。那如何来实现，Service像Activity发送消息呢。
当然还是要利用Messenger，那么如何传递一个Messenger对象到Service呢，Activity中可没有对应的回调。
来看代码：
Activity中：

//处理接收消息的handler。public class ActivityHandler extends Handler { @Override public void dispatchMessage(Message msg) { super.dispatchMessage(msg); Log.i("life", "ActivityHandler----dispatchMessage"); } @Override public void handleMessage(Message msg) { super.handleMessage(msg); Log.i("life", "ActivityHandler----handleMessage"); bt2.setText("service来消息啦"); } }....../** * Activity中的Messenger对象 */ private Messenger activityMessenger; /** * Activity中接收消息的handler */ private ActivityHandler handler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_service); ButterKnife.bind(this); .... handler = new ActivityHandler(); activityMessenger = new Messenger(handler); }

上面代码完成了Messenger和Handler对象的创建，接下来，把Messenger传递到Service中。

... case R.id.bt_1: Message message = Message.obtain(); message.what = 5; //将Activity中的Messenger对象，交给message对象 message.replyTo = activityMessenger; try { //向Service发送消息 serviceMessenger.send(message); } catch (RemoteException e) { e.printStackTrace(); } break; ...Meesage类的变量replyTo就是一个Messenger对象public final class Message implements Parcelable {..... /** * Optional Messenger where replies to this message can be sent. The * semantics of exactly how this is used are up to the sender and * receiver. */ public Messenger replyTo;.....}

通过上面的代码，把Activity中的Messenger对象，交给了发送过去的Message对象。
Service中的接收并向Activity中发送

@Override public void handleMessage(Message msg) { super.handleMessage(msg); Log.i("life", "MyHandler----handleMessage"); //取出Activity中传递过来的Messenger对象，并发送消息 Messenger activityMessenger=msg.replyTo; try { msg=Message.obtain(); activityMessenger.send(msg); } catch (RemoteException e) { e.printStackTrace(); } }

上面的代码在Service中完成了接收，和反馈消息。

总结：

同一个进程中，可以使用IBinder子类回调。当然也可以用Messenger。这个时候的Activity和Service运行在同一个线程中。不同进程，IBinder子类回调不在支持，Messenger是一种方式。这个时候的Activity和Service运行在不同的线程中。其实Messenger内部实现也是AIDL。

Messenger步骤：

利用需要handler作为参数的构造方法实例化Messenger对象。把Messenger通过某种方式回调到，消息发送方。
比如：文章中Service中使用onBind回调到Activity中；Activity利用发送的Message来携带到Service中。调用Messenger的send方法发送消息。handler处理消息。

进程之间的内存资源是独立的，那么message对象和Messenger对象，为啥可以传递呢？
没错就是序列化和反序列化。这样传输的数据就转化为能够在内存之间流通的形式了，也就是IO流操作了。Message和Messenger这两个类都是实现了Parcelable接口的。