Java Code Examples for android.os.Message

private void logStatus(String msg,Status status){
  String log=String.format("%s: %s",msg,status);
  if (status == Status.OK) {
    Log.i(TAG,log);
  }
 else {
    Message toastMsg=mHandler.obtainMessage(MESSAGE_POST_TOAST,log);
    mHandler.sendMessage(toastMsg);
    Log.e(TAG,log);
  }
}
 

protected void queueNextRefresh(final long delay){
  if (!paused) {
    final Message msg=mHandler.obtainMessage(REFRESH);
    mHandler.removeMessages(REFRESH);
    mHandler.sendMessageDelayed(msg,delay);
  }
}
 

protected Message obtainMessage(int responseMessage,Object response){
  Message msg=null;
  if (handler != null) {
    msg=this.handler.obtainMessage(responseMessage,response);
  }
 else {
    msg=new Message();
    msg.what=responseMessage;
    msg.obj=response;
  }
  return msg;
}
 

private void refreshToken(){
  Bundle requestData=new Bundle();
  requestData.putString(TOKEN,mAccessToken);
  Message request=Message.obtain();
  request.setData(requestData);
  request.replyTo=messageReceiver;
  try {
    messageSender.send(request);
  }
 catch (  RemoteException e) {
    serviceListener.onError(new Error("Service connection error"));
  }
}
 

@Override public void onPreviewFrame(byte[] data,Camera camera){
  Point cameraResolution=configManager.getCameraResolution();
  Handler thePreviewHandler=previewHandler;
  if (cameraResolution != null && thePreviewHandler != null) {
    Message message=thePreviewHandler.obtainMessage(previewMessage,cameraResolution.x,cameraResolution.y,data);
    message.sendToTarget();
    previewHandler=null;
  }
 else {
    Log.d(TAG,"Got preview callback, but no handler or resolution available");
  }
}
 

private void refreshToken(){
  Bundle requestData=new Bundle();
  requestData.putString(TOKEN,mAccessToken);
  Message request=Message.obtain();
  request.setData(requestData);
  request.replyTo=messageReceiver;
  try {
    messageSender.send(request);
  }
 catch (  RemoteException e) {
    serviceListener.onError(new Error("Service connection error"));
  }
}
 

@Override public int onStartCommand(Intent intent,int flags,int startId){
  Ln.d("Got start command");
  Message message=new Message();
  message.obj=intent;
  messageLoop.mHandler.sendMessage(message);
  return START_STICKY;
}
 

private void sendSingleMessage(Handler handler,int what,ICurrentlyPlaying curr){
  Message msg=Message.obtain(handler);
  msg.what=what;
  Bundle bundle=msg.getData();
  bundle.putSerializable(BUNDLE_CURRENTLY_PLAYING,curr);
  bundle.putInt(BUNDLE_LAST_PLAYLIST,mPlayList);
  bundle.putInt(BUNDLE_LAST_PLAYPOSITION,mPosition);
  msg.setTarget(handler);
  handler.sendMessage(msg);
}
 

private void postUpdateBookCovers(){
  Handler handler=mScrollHandler;
  Message message=handler.obtainMessage(MESSAGE_UPDATE_BOOK_COVERS,ShelvesActivity.this);
  handler.removeMessages(MESSAGE_UPDATE_BOOK_COVERS);
  mPendingCoversUpdate=true;
  handler.sendMessage(message);
}
 

public void onItemClick(AdapterView parent,View v,int position,long id){
  getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS,Window.PROGRESS_VISIBILITY_ON);
  mTargetBand=(BandListItem)parent.getAdapter().getItem(position);
  if (DBG)   log("Select band : " + mTargetBand.toString());
  Message msg=mHandler.obtainMessage(EVENT_BAND_SELECTION_DONE);
  mPhone.setBandMode(mTargetBand.getBand(),msg);
}
 

private void updateProgress(int progress,int maxProgress){
  if ((progress % PROGRESS_STEPS) == 0) {
    long curTime=SystemClock.uptimeMillis();
    if (curTime - operationStartTime < 1000L) {
      return;
    }
    Message msg=handler.obtainMessage(FileManagerActivity.MESSAGE_SET_PROGRESS);
    msg.arg1=progress;
    msg.arg2=maxProgress;
    msg.sendToTarget();
  }
}
 

public void postDelayedGetterCallback(Runnable callback,long delay){
  if (callback == null) {
    throw new NullPointerException();
  }
  Message message=Message.obtain();
  message.what=IMAGE_GETTER_CALLBACK;
  message.obj=callback;
  sendMessageDelayed(message,delay);
}
 

private void deleteAfterAnimation(int duration){
  MediaItem item=mModel.getMediaItem(mTouchBoxIndex);
  if (item == null)   return;
  mListener.onCommitDeleteImage();
  mUndoIndexHint=mModel.getCurrentIndex() + mTouchBoxIndex;
  mHolding|=HOLD_DELETE;
  Message m=mHandler.obtainMessage(MSG_DELETE_ANIMATION_DONE);
  m.obj=item.getPath();
  m.arg1=mTouchBoxIndex;
  mHandler.sendMessageDelayed(m,duration);
}
 

private void sendInitialMessage(){
  mNumRetries=0;
  Message checkStorage=new Message();
  checkStorage.what=CHECK_STORAGE;
  handler.sendMessage(checkStorage);
}
 

/** 
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 */
public AsyncTaskEx(){
  mWorker=new WorkerRunnable<Params,Result>(){
    public Result call() throws Exception {
      Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
      return doInBackground(mParams);
    }
  }
;
  mFuture=new FutureTask<Result>(mWorker){
    @Override protected void done(){
      Message message;
      Result result=null;
      try {
        result=get();
      }
 catch (      InterruptedException e) {
        com.jaeckel.amenoid.util.Log.w(LOG_TAG,e);
      }
catch (      ExecutionException e) {
        throw new RuntimeException("An error occured while executing doInBackground()",e.getCause());
      }
catch (      CancellationException e) {
        message=sHandler.obtainMessage(MESSAGE_POST_CANCEL,new AsyncTaskExResult<Result>(AsyncTaskEx.this,(Result[])null));
        message.sendToTarget();
        return;
      }
catch (      Throwable t) {
        throw new RuntimeException("An error occured while executing " + "doInBackground()",t);
      }
      message=sHandler.obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskExResult<Result>(AsyncTaskEx.this,result));
      message.sendToTarget();
    }
  }
;
}
 

private void login(int loginStatus){
  if (loginStatus == 200) {
    Log.d("Login","successful");
    getIntent().putExtra(INTENT_EXTRA_GET_USERNAME,username);
    getIntent().putExtra(INTENT_EXTRA_GET_PASSWORD,password);
    getIntent().putExtra(INTENT_EXTRA_GET_URL,url);
    setResult(Activity.RESULT_OK,getIntent());
    finish();
  }
 else   if (loginStatus == 401) {
    Log.d("Login","wrong username or password");
    Message ms=new Message();
    ms.arg1=0;
    Bundle data=new Bundle();
    data.putString("msg","Authentication failed \n check username password");
    ms.setData(data);
    handler.sendMessage(ms);
  }
 else   if (loginStatus == HttpConnector.RESP_CODE_CLIENT_CON_TIMEOUT) {
    Message ms=Message.obtain();
    Bundle data=new Bundle();
    data.putString("msg","Cannot establish Connection with server. \n Client Connection Timed out");
    ms.setData(data);
    ms.arg1=HttpConnector.RESP_CODE_CLIENT_CON_TIMEOUT;
    handler.sendMessage(ms);
  }
 else {
    Log.d("Login","unable to connect");
    Message ms=new Message();
    Bundle data=new Bundle();
    data.putString("msg","Unable to connect \n Resp Code: " + loginStatus);
    ms.setData(data);
    ms.arg1=1;
    handler.sendMessage(ms);
  }
}
 

public void run(){
  BufferedInputStream mBuffIn;
  BufferedOutputStream mBuffOut;
  Message msg;
  int len=mDataSource.size();
  int read=0;
  for (int i=0; i < len; i++) {
    ApplicationInfo info=mDataSource.get(i);
    String source_dir=info.sourceDir;
    String out_file=source_dir.substring(source_dir.lastIndexOf("/") + 1,source_dir.length());
    try {
      mBuffIn=new BufferedInputStream(new FileInputStream(source_dir));
      mBuffOut=new BufferedOutputStream(new FileOutputStream(BACKUP_LOC + out_file));
      while ((read=mBuffIn.read(mData,0,BUFFER)) != -1)       mBuffOut.write(mData,0,read);
      mBuffOut.flush();
      mBuffIn.close();
      mBuffOut.close();
      msg=new Message();
      msg.what=SET_PROGRESS;
      msg.obj=i + " out of " + len+ " apps backed up";
      mHandler.sendMessage(msg);
    }
 catch (    FileNotFoundException e) {
      e.printStackTrace();
    }
catch (    IOException e) {
      e.printStackTrace();
    }
  }
  mHandler.sendEmptyMessage(FINISH_PROGRESS);
}
 

public ClientSocketThread(String device,Handler handle){
  mMACAddres=device.substring(device.lastIndexOf('\n') + 1,device.lastIndexOf(":")).toUpperCase();
  mHandle=handle;
  try {
    mRemoteDevice=mBluetoothAdapter.getRemoteDevice(mMACAddres);
    mSocket=mRemoteDevice.createRfcommSocketToServiceRecord(UUID.fromString(DEV_UUID));
  }
 catch (  IllegalArgumentException e) {
    mSocket=null;
    Message msg=new Message();
    msg.obj=e.getMessage();
    mHandle.sendEmptyMessage(DIALOG_CANCEL);
  }
catch (  IOException e) {
    Message msg=new Message();
    msg.obj=e.getMessage();
    mHandle.sendEmptyMessage(DIALOG_CANCEL);
  }
}
 

@Override public void onReceive(Context context,Intent intent){
  String action=intent.getAction();
  if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION) || mListening == false) {
    Log.w(TAG,"onReceived() called with " + mState.toString() + " and "+ intent);
    return;
  }
  boolean noConnectivity=intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY,false);
  if (noConnectivity) {
    mState=State.NOT_CONNECTED;
  }
 else {
    mState=State.CONNECTED;
  }
  mNetworkInfo=(NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
  mOtherNetworkInfo=(NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);
  mReason=intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
  mIsFailover=intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER,false);
  if (DBG) {
    Log.d(TAG,"onReceive(): mNetworkInfo=" + mNetworkInfo + " mOtherNetworkInfo = "+ (mOtherNetworkInfo == null ? "[none]" : mOtherNetworkInfo + " noConn=" + noConnectivity)+ " mState="+ mState.toString());
  }
  Iterator<Handler> it=mHandlers.keySet().iterator();
  while (it.hasNext()) {
    Handler target=it.next();
    Message message=Message.obtain(target,mHandlers.get(target));
    target.sendMessage(message);
  }
}
 

@Override public void onReceive(Context context,Intent intent){
  String action=intent.getAction();
  if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION) || mListening == false) {
    Log.w(TAG,"onReceived() called with " + mState.toString() + " and "+ intent);
    return;
  }
  boolean noConnectivity=intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY,false);
  if (noConnectivity) {
    mState=State.NOT_CONNECTED;
  }
 else {
    mState=State.CONNECTED;
  }
  mNetworkInfo=(NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
  mOtherNetworkInfo=(NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);
  mReason=intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
  mIsFailover=intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER,false);
  if (DBG) {
    Log.d(TAG,"onReceive(): mNetworkInfo=" + mNetworkInfo + " mOtherNetworkInfo = "+ (mOtherNetworkInfo == null ? "[none]" : mOtherNetworkInfo + " noConn=" + noConnectivity)+ " mState="+ mState.toString());
  }
  Iterator<Handler> it=mHandlers.keySet().iterator();
  while (it.hasNext()) {
    Handler target=it.next();
    Message message=Message.obtain(target,mHandlers.get(target));
    target.sendMessage(message);
  }
}
 

public void handleMessage(Message msg){
switch (msg.what) {
case KILLER:
    LogEx.verbose("*********** Alarm killer triggered ***********");
  stopSelf();
break;
}
}
 

public boolean handleMessage(Message msg){
switch (msg.what) {
case COMPLETE:
    mImage.setImageDrawable(mDrawable);
  mImage.setVisibility(View.VISIBLE);
mSpinner.setVisibility(View.GONE);
break;
case FAILED:
default :
mImage.setScaleType(ScaleType.FIT_XY);
mImage.setImageDrawable(getResources().getDrawable(R.drawable.no_image_found));
mImage.setVisibility(View.VISIBLE);
mSpinner.setVisibility(View.GONE);
break;
}
return true;
}
 

private void StoreSocial() throws Exception {
  try {
    entityManager=EntityManager.GetManager(this);
    SocialEntity social=new SocialEntity();
    social.Contact.setValue(SocialMonitor.getContact());
    social.Communication.setValue(SocialMonitor.getCommunication());
    social.Message.setValue(SocialMonitor.getMessage());
    social.LastIncoming.setValue(SocialMonitor.getLastInDate());
    social.LastOutgoing.setValue(SocialMonitor.getLastOutDate());
    int uid=entityManager.store(social);
    if (DEBUG) {
      buffer.write("" + System.currentTimeMillis() + ","+ SocialMonitor.getContact()+ ","+ SocialMonitor.getCommunication()+ ","+ SocialMonitor.getMessage()+ ","+ SocialMonitor.getLastInDate()+ ","+ SocialMonitor.getLastOutDate()+ "\n");
    }
  }
 catch (  Exception e) {
    throw e;
  }
}
 

@Override public void handleMessage(Message msg){
  pd.dismiss();
switch (msg.what) {
case 0:
{
      availLessons=(ArrayList<AvailLesson>)(msg.obj);
      setListAdapter(new ArrayAdapter<AvailLesson>(me,android.R.layout.simple_list_item_1,availLessons));
      getListView().setTextFilterEnabled(true);
      return;
    }
case 1:
{
    AlertDialog alertDialog=new AlertDialog.Builder(me).create();
    alertDialog.setTitle("Error");
    alertDialog.setMessage("Sorry, but an error occured trying to download the list of available lessons:\n" + msg.obj);
    alertDialog.setButton(DialogInterface.BUTTON_POSITIVE,"OK",new DialogInterface.OnClickListener(){
      public void onClick(      DialogInterface dialog,      int which){
        finish();
        return;
      }
    }
);
    alertDialog.show();
  }
}
}
 

@Override public boolean handleMessage(Message msg){
  if (msg.what == MSG_SURFACE_CREATED) {
    contentWidth=0;
    contentHeight=0;
    requestLayout();
    return true;
  }
  return false;
}
 

private void setupZoomControls(){
  this.zoomControls=new ZoomControls(this.activity);
  this.zoomControls.setVisibility(View.GONE);
  this.zoomControls.setOnZoomInClickListener(new OnClickListener(){
    @Override public void onClick(    View v){
      zoom((byte)1,1);
    }
  }
);
  this.zoomControls.setOnZoomOutClickListener(new OnClickListener(){
    @Override public void onClick(    View v){
      zoom((byte)-1,1);
    }
  }
);
  this.zoomControlsHideHandler=new Handler(){
    @Override public void handleMessage(    Message msg){
      hideZoomZontrols();
    }
  }
;
  addView(this.zoomControls,new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,ViewGroup.LayoutParams.WRAP_CONTENT));
}
 

@Override protected void onCreate(Bundle icicle){
  super.onCreate(icicle);
  Log.d(cTag,"onCreate");
  setDefaultKeyMode(DEFAULT_KEYS_SHORTCUT);
  requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
  setContentView(R.layout.welcome);
  mSampleDataButton.setOnClickListener(new View.OnClickListener(){
    public void onClick(    View v){
      disableButtons();
      startProgressAnimation();
      performCreateSampleData();
    }
  }
);
  mCleanSlateButton.setOnClickListener(new View.OnClickListener(){
    public void onClick(    View v){
      disableButtons();
      startProgressAnimation();
      performCleanSlate();
    }
  }
);
  mHandler=new Handler(){
    @Override public void handleMessage(    Message msg){
      updateFirstTimePref(false);
      getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS,Window.PROGRESS_VISIBILITY_OFF);
      startActivity(new Intent(WelcomeActivity.this,TopLevelActivity.class));
      finish();
    }
  }
;
}
 

@Override public void handleMessage(Message msg){
  if (!mIsRunning) {
    return;
  }
  if (msg.what == NEW_INPUT) {
    readFromProcess();
  }
}
 

public void handleMessage(Message msg){
  scroller.computeScrollOffset();
  int currY=scroller.getCurrY();
  int delta=lastScrollY - currY;
  lastScrollY=currY;
  if (delta != 0) {
    listener.onScroll(delta);
  }
  if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
    currY=scroller.getFinalY();
    scroller.forceFinished(true);
  }
  if (!scroller.isFinished()) {
    animationHandler.sendEmptyMessage(msg.what);
  }
 else   if (msg.what == MESSAGE_SCROLL) {
    justify();
  }
 else {
    finishScrolling();
  }
}
 

public void handleMessage(Message msg){
  scroller.computeScrollOffset();
  int currY=scroller.getCurrY();
  int delta=lastScrollY - currY;
  lastScrollY=currY;
  if (delta != 0) {
    listener.onScroll(delta);
  }
  if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
    currY=scroller.getFinalY();
    scroller.forceFinished(true);
  }
  if (!scroller.isFinished()) {
    animationHandler.sendEmptyMessage(msg.what);
  }
 else   if (msg.what == MESSAGE_SCROLL) {
    justify();
  }
 else {
    finishScrolling();
  }
}
 

public void handleMessage(Message msg){
  scroller.computeScrollOffset();
  int currY=scroller.getCurrY();
  int delta=lastScrollY - currY;
  lastScrollY=currY;
  if (delta != 0) {
    listener.onScroll(delta);
  }
  if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
    currY=scroller.getFinalY();
    scroller.forceFinished(true);
  }
  if (!scroller.isFinished()) {
    animationHandler.sendEmptyMessage(msg.what);
  }
 else   if (msg.what == MESSAGE_SCROLL) {
    justify();
  }
 else {
    finishScrolling();
  }
}
 

@Override public void handleMessage(Message msg){
switch (msg.what) {
case SWITCH_TAB:
    Log.i("handler","using the handler");
  host.setCurrentTab(msg.arg1);
break;
}
}
 

public void handleMessage(Message msg){
  scroller.computeScrollOffset();
  int currY=scroller.getCurrY();
  int delta=lastScrollY - currY;
  lastScrollY=currY;
  if (delta != 0) {
    listener.onScroll(delta);
  }
  if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
    currY=scroller.getFinalY();
    scroller.forceFinished(true);
  }
  if (!scroller.isFinished()) {
    animationHandler.sendEmptyMessage(msg.what);
  }
 else   if (msg.what == MESSAGE_SCROLL) {
    justify();
  }
 else {
    finishScrolling();
  }
}
 

@Override public void handleMessage(Message msg){
switch (msg.what) {
case ALERT_SOUND_FINISHED:
    if (DBG)     log("ALERT_SOUND_FINISHED");
  stop();
if (mMessageBody != null && mTtsEngineReady && mTtsLanguageSupported) {
  mHandler.sendMessageDelayed(mHandler.obtainMessage(ALERT_PAUSE_FINISHED),PAUSE_DURATION_BEFORE_SPEAKING_MSEC);
  mState=STATE_PAUSING;
}
 else {
  stopSelf();
  mState=STATE_IDLE;
}
break;
case ALERT_PAUSE_FINISHED:
if (DBG) log("ALERT_PAUSE_FINISHED");
if (mMessageBody != null && mTtsEngineReady && mTtsLanguageSupported) {
if (DBG) log("Speaking broadcast text: " + mMessageBody);
mTts.speak(mMessageBody,TextToSpeech.QUEUE_FLUSH,null);
mState=STATE_SPEAKING;
}
 else {
Log.w(TAG,"TTS engine not ready or language not supported");
stopSelf();
mState=STATE_IDLE;
}
break;
default :
Log.e(TAG,"Handler received unknown message, what=" + msg.what);
}
}
 

public void handleMessage(Message msg){
switch (msg.what) {
case 0:
    if (msg.obj != null) {
      ListPreference p=(ListPreference)findPreference(msg.obj.toString());
      p.setSummary(p.getEntry());
    }
  break;
}
}