Java Code Examples for android.os.Messenger#send()

/**
 * Send request to remote Espresso instances (if any).
 *
 * @param what User-defined message code so that the recipient can identify what this message is
 *     about.
 * @param data A Bundle of arbitrary data associated with this message
 */
private void sendMsgToRemoteEspressos(int what, Bundle data) {
  logDebugWithProcess(TAG, "sendMsgToRemoteEspressos called");

  Message msg = getEspressoMessage(what);
  msg.setData(data);

  Set<Messenger> remoteClients = instrumentationConnection.getClientsForType(TYPE);
  for (Messenger remoteEspresso : remoteClients) {
    if (messengerHandler.equals(remoteEspresso)) {
      // avoid sending message to self
      continue;
    }
    try {
      remoteEspresso.send(msg);
    } catch (RemoteException e) {
      // In this case the remote process was terminated or crashed before we could
      // even do anything with it; there is nothing we can do other than unregister the
      // Espresso instance.
      Log.w(TAG, "The remote process is terminated unexpectedly", e);
      instrumentationConnection.unregisterClient(TYPE, remoteEspresso);
    }
  }
}
 

public boolean notifyAPIStats(Messenger reply, ArrayList<CbStats> statsResult) {
	try {
		if (reply == null) {
			log("cannot notify, reply is null");
		} else {
			log("cbservice notifying, " + statsResult.size());
			reply.send(Message.obtain(null, MSG_STATS, statsResult));
		}

	} catch (RemoteException re) {
		re.printStackTrace();
	} catch (NullPointerException npe) {
		npe.printStackTrace();
	}
	return false;
}
 

public void onServiceConnected(ComponentName className, IBinder service) {
	Log.d(TAG, "Bound to service " + className.toString());
	routerServiceMessenger = new Messenger(service);
	isBound = true;
	//So we just established our connection
	//Register with router service
	Message msg = Message.obtain();
	msg.what = TransportConstants.ROUTER_STATUS_CONNECTED_STATE_REQUEST;
	msg.arg1 = flags;
	msg.replyTo = clientMessenger;
	try {
		routerServiceMessenger.send(msg);
	} catch (RemoteException e) {
		e.printStackTrace();
		if(cb!=null){
			cb.onConnectionStatusUpdate(false, routerService, context);
		}
	}			
}
 

private void a(Messenger messenger) {
    try {
        if (bu.q() && messenger != null) {
            bu.a("0");
            Message obtain = Message.obtain();
            obtain.what = 100;
            messenger.send(obtain);
        }
        if (bu.a()) {
            this.z.a();
        }
        if (bu.d() && !this.x) {
            this.x = true;
            this.d.sendEmptyMessage(4);
        }
        if (bu.f() && !this.y) {
            this.y = true;
            this.d.sendEmptyMessage(5);
        }
    } catch (Throwable th) {
    }
}
 

@Override
public void onServiceConnected(ComponentName className, IBinder service) {
  // This is called when the connection with the service has been
  // established, giving us the object we can use to
  // interact with the service
  mService = new Messenger(service);
  boundToTheService = true;
  try {
    Message msg = Message.obtain(null, InstrumentationService.ConnectToService);
    mService.send(msg);
  } catch (RemoteException e) {
    // service has crashed, nothing to do...
    SubstrateMain.log("<!> Thats a very bad news: service has crashed", e);
  }

  /**
   * Send previously stored events
   */
  this.sendEventsInCache();
}
 

/**
 * Deconstructs the given interaction proto and attempts to run it in the current process.
 *
 * <p>1. deconstruct InteractionRequestProto into an interaction Espresso can understand 2.
 * attempt to run the desired interaction 3. send a response to the caller whether there is
 * nothing to execute on (1 is false) or the interaction failed (e.g due to an assertion)
 *
 * @param caller The caller that initiated this request
 * @param data A Bundle including InteractionRequestProto repressing the Espresso interaction
 */
private void handleEspressoRequest(Messenger caller, Bundle data) {
  UUID uuid = (UUID) data.getSerializable(BUNDLE_KEY_UUID);
  logDebugWithProcess(
      TAG, String.format(Locale.ROOT, "handleEspressoRequest for id: %s", uuid));

  Message msg = getEspressoMessage(MSG_HANDLE_ESPRESSO_RESPONSE);
  Bundle resultData = msg.getData();
  // copy over the request UUID
  resultData.putSerializable(BUNDLE_KEY_UUID, uuid);
  // attempt to execute the request and save the result
  isRemoteProcess = true;
  InteractionResponse interactionResponse = executeRequest(data);
  resultData.putByteArray(BUNDLE_KEY_PROTO, interactionResponse.toProto().toByteArray());
  msg.setData(resultData);

  try {
    caller.send(msg);
  } catch (RemoteException e) {
    // In this case the remote process was terminated or crashed before we could
    // even do anything with it; there is nothing we can do other than unregister the
    // Espresso caller instance.
    Log.w(TAG, "The remote caller process is terminated unexpectedly", e);
    instrumentationConnection.unregisterClient(TYPE, caller);
  }
}
 

@Override
protected void onHandleIntent(Intent intent) {
    artist = intent.getStringExtra("artist");
    track = intent.getStringExtra("track");
    songID = intent.getLongExtra("id", 0);
    messenger = (Messenger) intent.getExtras().get("messenger");


    File path = new File(Environment.getExternalStorageDirectory() + File.separator + "Lyrically/");
    notFound = new File(path, "No Lyrics Found.txt");

    lyricsFile = new File(path, songID + ".txt");


    if (!lyricsFile.exists())
        getLyrics();
    else
        try { // if the text file with the current song ID already exists, skip fetching the lyrics
        messenger.send(new Message());
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}
 

@Override
public void handleMessage(Message msg) {
    switch (msg.what) {
        case Constant.MSG_FROM_CLIENT:
            try {
                // 缓存数据
                cacheStepData(StepService.this,StepDcretor.CURRENT_STEP + "");
                // 更新通知栏
                updateNotification(msg.getData());
                // 回复消息给Client
                Messenger messenger = msg.replyTo;
                Message replyMsg = Message.obtain(null, Constant.MSG_FROM_SERVER);
                Bundle bundle = new Bundle();
                bundle.putInt(STEP_KEY, StepDcretor.CURRENT_STEP);
                replyMsg.setData(bundle);
                messenger.send(replyMsg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            break;
        default:
            super.handleMessage(msg);
    }
}
 

private void handlePostEvent(Message msg) {
        Bundle bundle = msg.getData();
        String eventClz = bundle.getString(Constants.BUNDLE_STR_EVENT_CLZ);
        if (TextUtils.isEmpty(eventClz)) {
            ILogger.logger.error(ILogger.defaultTag,"cannot handle non class event");
            return;
        }

        List<WeakReference<Messenger>> subscribes = eventSubscriber.get(eventClz);
        if (subscribes == null)
            return;

        for (int i = 0;i<subscribes.size();i++) {
            WeakReference<Messenger> subscriberRef = subscribes.get(i);
            if (subscriberRef == null || subscriberRef.get() == null) {
                subscribes.remove(i);
                i--;
                continue;
            }

            Messenger messenger = subscriberRef.get();

            Message cm = Message.obtain();
            cm.what = Constants.WHAT_RECEIVE_EVENT_FROM_REMOTE;
            cm.setData(msg.getData());
            try {
                messenger.send(cm);
            } catch (RemoteException e) {
                e.printStackTrace();
                //remove the error subscriber
                subscriberRef.clear();
                subscribes.remove(i);
                i--;
//                continue;
            }
        }

    }
 

public void sendQRComplete(boolean success, String path, Messenger service){
    Message msg = Message.obtain(null, XPConstant.MSG_QR_COMPLETE);
    Bundle data = new Bundle();
    data.putBoolean(XPConstant.QR_SUCCESS, success);
    if(success){
        data.putString(XPConstant.QR_PATH, path);
    }
    msg.setData(data);
    try {
        service.send(msg);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}
 

public void onServiceConnected(ComponentName className, IBinder binderService) {
    wakeUpService = new Messenger(binderService);
    wakeUpServiceLock.lock();
    try {
        while (!wakeUpUnsentMessages.isEmpty()) {
            wakeUpService.send(wakeUpUnsentMessages.poll());
        }
    } catch (RemoteException e) {
        appendLog(getBaseContext(), TAG, e.getMessage(), e);
    } finally {
        wakeUpServiceLock.unlock();
    }
    serviceConnected(currentWeatherServiceConnection);
}
 

@Override
public void handleMessage(@NonNull android.os.Message msg) {
    super.handleMessage(msg);
    Bundle bundle = msg.getData();
    // Class not found when unmarshalling: com.chiclaim.ipc.bean.Message
    bundle.setClassLoader(Message.class.getClassLoader());
    Message data = bundle.getParcelable("message");
    Toast.makeText(getApplicationContext(), data.getContent(), Toast.LENGTH_SHORT).show();

    Messenger replyTo = msg.replyTo;
    Message raw = new Message();
    raw.setContent("I receive your message: " + data.getContent());
    android.os.Message message = new android.os.Message();
    Bundle replyBundle = new Bundle();
    replyBundle.putParcelable("message", raw);
    message.setData(replyBundle);
    try {
        replyTo.send(message);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}
 

@Override
public void onServiceConnected(ComponentName className, IBinder binderService) {
    widgetRefreshIconService = new Messenger(binderService);
    widgetRotationServiceLock.lock();
    try {
        while (!unsentMessages.isEmpty()) {
            widgetRefreshIconService.send(unsentMessages.poll());
        }
    } catch (RemoteException e) {
        appendLog(getBaseContext(), TAG, e.getMessage(), e);
    } finally {
        widgetRotationServiceLock.unlock();
    }
}
 

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    Log.d(TAG, "onServiceConnected");
    mService = new Messenger(service);
    Message msg = Message.obtain(null, XPConstant.TEST_JOIN);
    try {
        msg.replyTo = mReplyMessenger;
        mService.send(msg);
        mAliGenQR.setEnabled(true);
        mWeGenQR.setEnabled(true);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}
 

private static void sendReply(Context context, Intent intent, String packageName, Intent outIntent) {
    try {
        if (intent != null && intent.hasExtra(EXTRA_MESSENGER)) {
            Messenger messenger = intent.getParcelableExtra(EXTRA_MESSENGER);
            Message message = Message.obtain();
            message.obj = outIntent;
            messenger.send(message);
            return;
        }
    } catch (Exception e) {
        Log.w(TAG, e);
    }

    outIntent.setPackage(packageName);
    context.sendOrderedBroadcast(outIntent, null);
}
 

public void onServiceConnected(ComponentName className, IBinder binderService) {
    wakeUpService = new Messenger(binderService);
    wakeUpServiceLock.lock();
    try {
        while (!wakeUpUnsentMessages.isEmpty()) {
            wakeUpService.send(wakeUpUnsentMessages.poll());
        }
    } catch (RemoteException e) {
        appendLog(getBaseContext(), TAG, e.getMessage(), e);
    } finally {
        wakeUpServiceLock.unlock();
    }
}
 

public void onServiceConnected(ComponentName className,
        IBinder service) {
    // This is called when the connection with the service has been
    // established, giving us the service object we can use to
    // interact with the service.  We are communicating with our
    // service through an IDL interface, so get a client-side
    // representation of that from the raw service object.
    mService = new Messenger(service);
    mCallbackText.setText("Attached.");

    // We want to monitor the service for as long as we are
    // connected to it.
    try {
        Message msg = Message.obtain(null,
                MessengerService.MSG_REGISTER_CLIENT);
        msg.replyTo = mMessenger;
        mService.send(msg);
        
        // Give it some value as an example.
        msg = Message.obtain(null,
                MessengerService.MSG_SET_VALUE, this.hashCode(), 0);
        mService.send(msg);
    } catch (RemoteException e) {
        // In this case the service has crashed before we could even
        // do anything with it; we can count on soon being
        // disconnected (and then reconnected if it can be restarted)
        // so there is no need to do anything here.
    }
    
    // As part of the sample, tell the user what happened.
    Toast.makeText(Binding.this, R.string.remote_service_connected,
            Toast.LENGTH_SHORT).show();
}
 

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    try {
        messenger = new Messenger(service);
        Message msg = Message.obtain(null,Constant.Config.MSG_FROM_CLIENT);
        msg.replyTo = mGetReplyMessenger;
        messenger.send(msg);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}
 

void notifyMessenger(Messenger messenger, int slot, int err) {
    Message message = Message.obtain();
    message.what = EVENT_PACKET_KEEPALIVE;
    message.arg1 = slot;
    message.arg2 = err;
    message.obj = null;
    try {
        messenger.send(message);
    } catch (RemoteException e) {
        // Process died?
    }
}
 

@Override
public void handleMessage(Message msg) {
  switch (msg.what) {

    case ConnectToService:
    	SubstrateMain.log("New client is connected to instrumentation service");
    	//Create reporters, only if this is our first connection
      if (!parsingInProgess && eventReporters.size()==0) {
          createReportersFromConfigFile();
      }
      break;

    case Event:
      msg.getData().setClassLoader(InstrumentationServiceConnection.class.getClassLoader());
      InterceptEvent event = (InterceptEvent) msg.getData().getParcelable("eventkey");
      if (event != null) {
        reportEvent(event);
      }
      break;

    case GetConfiguration:
    	SubstrateMain.log("Configuration message has been received, sending current configuration to APK Instrumenter");
    	Messenger m = msg.replyTo;
    	Message response = Message.obtain(null, ApkInstrumenterActivity.Configuration);
    	
    	//Construct Bundle from our attributes
    	Bundle configuration = new Bundle();
    	configuration.putString("idxp", idXP);
    	configuration.putBoolean("fileMode", fileMode);
    	configuration.putBoolean("networkMode", networkMode);
    	configuration.putString("esIp", esIp);
    	configuration.putInt("esPort", esPort);
    	configuration.putInt("esNbThread", esNbThread);
    	configuration.putString("esIndex", esIndex);
    	configuration.putString("esDoctype", esDoctype);
    	configuration.putString("fileName", fileName);
    	response.setData(configuration);
    	
    	try {
    		m.send(response);
    	} catch (RemoteException e) {
    		SubstrateMain.log("Service has crashed");
    		e.printStackTrace();
			}
    	break;
    
    default:
      SubstrateMain.log("Unknown Message received: " + msg.toString());
      super.handleMessage(msg);
  }
}