Android 에서 Messenger 원리 및 기본 용법 상세 설명

이 블 로 그 는 주로 Android 에서 Messenger 의 기본 원리 와 용법 을 기록 합 니 다.
쉽게 말 하면 Messenger 는 Binder 통신 의 포장 기 이 고 메시지 전달 을 바탕 으로 하 는 프로 세 스 간 통신 도구 이다.

//Messenger   Parcelable  ，         
public final class Messenger implements Parcelable {
 ...............
}

일반적인 상황 에서 우 리 는 A 프로 세 스에 Messenger 를 만 들 고 이 Messenger 를 B 프로 세 스에 전달 할 수 있다.
그래서 B 프로 세 스 는 Messenger 를 통 해 A 프로 세 스 와 통신 할 수 있 습 니 다.
Messenger 는 보통 Handler 와 함께 사용 합 니 다.우 리 는 해당 하 는 소스 코드 를 봅 니 다.

public final class Messenger implements Parcelable {
 private final IMessenger mTarget;

 public Messenger(Handler target) {
  mTarget = target.getIMessenger();
 }
 ...........
}

Handler 의 getIMessenger 함 수 를 따라 가세 요:

 .............
 final IMessenger getIMessenger() {
  synchronized (mQueue) {
   if (mMessenger != null) {
    return mMessenger;
   }
   //    Handler    MessengerImpl
   mMessenger = new MessengerImpl();
   return mMessenger;
  }
 }

 //  MessengerImpl   IMessenger.Stub
 //    MessengerImpl   Binder      
 private final class MessengerImpl extends IMessenger.Stub {
  public void send(Message msg) {
   msg.sendingUid = Binder.getCallingUid();
   Handler.this.sendMessage(msg);
  }
 }

상기 코드 를 통 해 알 수 있 듯 이 Messenger 는 실제로 Binder 서버 의 wrapper 가 되 었 다.
우리 가 A 프로 세 스에 Messenger 를 만 들 고 B 프로 세 스에 전달 할 때 Messenger 는 Parcelable 인터페이스 정의 작업 을 실행 해 야 합 니 다.그래서:

 // A    Binder     Parcel 
 public void writeToParcel(Parcel out, int flags) {
  out.writeStrongBinder(mTarget.asBinder());
 }

 public static final Parcelable.Creator<Messenger> CREATOR
   = new Parcelable.Creator<Messenger>() {
  // B   ，    Binder
  public Messenger createFromParcel(Parcel in) {
   IBinder target = in.readStrongBinder();

   //  Messenger        
   return target != null ? new Messenger(target) : null;
  }

  public Messenger[] newArray(int size) {
   return new Messenger[size];
  }
 };

Messenger 의 또 다른 구조 함수 따라 가기:

public Messenger(IBinder target) {
 //    Binder      
 mTarget = IMessenger.Stub.asInterface(target);
}

따라서 Messenger 가 프로 세 스 A 에서 프로 세 스 B 로 전 달 될 때 Binder 통신 클 라 이언 트 의 wrapper 로 변 합 니 다.
프로 세 스 B 에서 Messenger 인 터 페 이 스 를 사용 할 때:

public void send(Message message) throws RemoteException {
 //mTarget Binder      ，          send  
 //    Handler MessengerImpl send  
 //           ，             Handler  
 mTarget.send(message);
}

메 신 저 통신 의 원리 입 니 다.이제 실제 테스트 를 해 보 겠 습 니 다.
저 희 는 하나의 Activity 와 하나의 Service 를 포함 하 는 간단 한 demo 를 정의 합 니 다.그 중에서 Service 와 Activity 는 서로 다른 프로 세 스 에 있 습 니 다.
AndroidManifest.xml 의 정 의 는 다음 과 같 습 니 다.

  .....................
  <activity android:name=".MainActivity">
   <intent-filter>
    <action android:name="android.intent.action.MAIN"/>

    <category android:name="android.intent.category.LAUNCHER"/>
   </intent-filter>
  </activity>

  <service
   android:name=".RemoteService"
   android:enabled="true"
   android:exported="true"
   <!--           -->
   android:process=".remote">
  </service>
  ..............

Activity 의 화면 은 매우 간단 합 니 다.클릭 하면 Service 처럼 메 시 지 를 보 냅 니 다.Activity 코드 는 다음 과 같 습 니 다.

public class MainActivity extends AppCompatActivity {
 private Button mButton;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  //  Activity pid       
  Log.d("ZJTest", "Activity, pid: " + Process.myPid() +
    ", name: " + Util.getProcessName(this));

  //    
  startService();

  //    
  bindService();

  mButton = (Button) findViewById(R.id.test_button);
  mButton.setEnabled(false);
  //     ，  Messenger Service    
  mButton.setOnClickListener(new View.OnClickListener() {
   @Override
   public void onClick(View v) {
    if (mMessenger != null) {
     try {
      Message msg = Message.obtain();
      msg.what = 1;
      mMessenger.send(msg);
     } catch (RemoteException e) {
      Log.d("ZJTest", e.toString());
     }
    }
   }
  });
 }

 @Override
 public void onDestroy() {
  super.onDestroy();
  unBindService();
  stopService();
 }

 private Intent mIntent;
 private void startService() {
  mIntent = new Intent(this, RemoteService.class);
  this.startService(mIntent);
 }

 private ServiceConnection mServiceConnection;
 private void bindService() {
  mServiceConnection = new LocalServiceConnection();
  this.bindService(mIntent, mServiceConnection, BIND_AUTO_CREATE);
 }

 Messenger mMessenger;
 private class LocalServiceConnection implements android.content.ServiceConnection {
  @Override
  public void onServiceConnected(ComponentName name, IBinder service) {
   //     ，  Messenger   Button
   mMessenger = new Messenger(service);
   mButton.setEnabled(true);
  }

  @Override
  public void onServiceDisconnected(ComponentName name) {
   mButton.setEnabled(false);
  }
 }

 private void stopService() {
  stopService(mIntent);
 }

 private void unBindService() {
  unbindService(mServiceConnection);
 }
}

Service 에 대응 하 는 코드 는 다음 과 같 습 니 다.

public class RemoteService extends Service {
 private Messenger mMessenger;

 @Override
 public void onCreate() {
  super.onCreate();

  //          
  Log.d("ZJTest", "Service, pid: " + Process.myPid()
    + ", name: " + Util.getProcessName(this));

  LocalHandler mHandler = new LocalHandler();

  mMessenger = new Messenger(mHandler);
 }

 private static class LocalHandler extends Handler{
  @Override
  public void handleMessage(Message msg) {
   Log.d("ZJTest", "receive msg: " + msg.what);
  }
 }

 @Override
 public IBinder onBind(Intent intent) {
  //    ，  Messenger
  return mMessenger.getBinder();
 }
}

프로 세 스 이름 을 가 져 오 는 코드 는 다음 과 같 습 니 다.

class Util {
 static String getProcessName(Context context) {
  int pid = Process.myPid();
  ActivityManager am = (ActivityManager) context
    .getSystemService(Context.ACTIVITY_SERVICE);

  for (ActivityManager.RunningAppProcessInfo appProcessInfo:
    am.getRunningAppProcesses()) {
   if (appProcessInfo.pid == pid) {
    return appProcessInfo.processName;
   }
  }

  return null;
 }
}

상기 코드 는 모두 비교적 간단 합 니 다.지금 실행 결 과 를 보 겠 습 니 다.
02-20 21:25:15.760 D/ZJTest  (30460): Activity, pid: 30460, name: stark.a.is.zhang.messengertest
02-20 21:25:15.769 D/ZJTest  (30428): Service, pid: 30428, name: .remote
02-20 21:25:32.111 D/ZJTest  (30428): receive msg: 1
log 에서 알 수 있 듯 이 Activity 와 Servie 는 서로 다른 프로 세 스 에서 실행 되 고 Messenger 는 서로 다른 프로 세 스 간 에 메 시 지 를 전달 할 수 있 습 니 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.