public override void handleMessage(android.os.Message msg) { switch (msg.what) { case android.widget.ZoomButtonsController.MSG_POST_CONFIGURATION_CHANGED: { this._enclosing.onPostConfigurationChanged(); break; } case android.widget.ZoomButtonsController.MSG_DISMISS_ZOOM_CONTROLS: { this._enclosing.setVisible(false); break; } case android.widget.ZoomButtonsController.MSG_POST_SET_VISIBLE: { if (this._enclosing.mOwnerView.getWindowToken() == null) { // Doh, it is still null, just ignore the set visible call android.util.Log.e(android.widget.ZoomButtonsController.TAG, "Cannot make the zoom controller visible if the owner view is " + "not attached to a window."); } else { this._enclosing.setVisible(true); } break; } } }
/// <summary> /// Same as /// <see cref="obtain()">obtain()</see> /// , but sets the values for both <em>target</em> and /// <em>what</em> members on the Message. /// </summary> /// <param name="h">Value to assign to the <em>target</em> member.</param> /// <param name="what">Value to assign to the <em>what</em> member.</param> /// <returns>A Message object from the global pool.</returns> public static android.os.Message obtain(android.os.Handler h, int what) { android.os.Message m = obtain(); m.target = h; m.what = what; return(m); }
public void setKeepScreenOn(bool screenOn) { android.os.Message msg = this._enclosing.mHandler.obtainMessage(android.view.SurfaceView .KEEP_SCREEN_ON_MSG); msg.arg1 = screenOn ? 1 : 0; this._enclosing.mHandler.sendMessage(msg); }
public void onClick(android.view.View v) { android.os.Message m = null; if (v == this._enclosing.mButtonPositive && this._enclosing.mButtonPositiveMessage != null) { m = android.os.Message.obtain(this._enclosing.mButtonPositiveMessage); } else { if (v == this._enclosing.mButtonNegative && this._enclosing.mButtonNegativeMessage != null) { m = android.os.Message.obtain(this._enclosing.mButtonNegativeMessage); } else { if (v == this._enclosing.mButtonNeutral && this._enclosing.mButtonNeutralMessage != null) { m = android.os.Message.obtain(this._enclosing.mButtonNeutralMessage); } } } if (m != null) { m.sendToTarget(); } // Post a message so we dismiss after the above handlers are executed this._enclosing.mHandler.obtainMessage([email protected] .MSG_DISMISS_DIALOG, this._enclosing.mDialogInterface).sendToTarget(); }
public override void handleMessage(android.os.Message msg) { switch (msg.what) { case android.view.GestureDetector.SHOW_PRESS: { this._enclosing.mListener.onShowPress(this._enclosing.mCurrentDownEvent); break; } case android.view.GestureDetector.LONG_PRESS: { this._enclosing.dispatchLongPress(); break; } case android.view.GestureDetector.TAP: { // If the user's finger is still down, do not count it as a tap if (this._enclosing.mDoubleTapListener != null && !this._enclosing.mStillDown) { this._enclosing.mDoubleTapListener.onSingleTapConfirmed(this._enclosing.mCurrentDownEvent ); } break; } default: { throw new java.lang.RuntimeException("Unknown message " + msg); } } }
public override void handleMessage(Message msg) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final android.os.Bundle bundle = msg.getData(); Bundle bundle = msg.Data; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int action = bundle.getInt(ACTION); int action = bundle.getInt(ACTION); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String timestamp = bundle.getString(TIMESTAMP); string timestamp = bundle.getString(TIMESTAMP); switch (action) { case ADD_TIMESTAMP: realm.beginTransaction(); realm.createObject(typeof(TimeStamp)).TimeStamp = timestamp; realm.commitTransaction(); break; case REMOVE_TIMESTAMP: realm.beginTransaction(); realm.@where(typeof(TimeStamp)).equalTo("timeStamp", timestamp).findAll().clear(); realm.commitTransaction(); break; } }
/// <summary> /// Same as /// <see cref="obtain(Handler)">obtain(Handler)</see> /// , but assigns a callback Runnable on /// the Message that is returned. /// </summary> /// <param name="h">Handler to assign to the returned Message object's <em>target</em> member. /// </param> /// <param name="callback">Runnable that will execute when the message is handled.</param> /// <returns>A Message object from the global pool.</returns> public static android.os.Message obtain(android.os.Handler h, java.lang.Runnable callback) { android.os.Message m = obtain(); m.target = h; m.callback = callback; return(m); }
public override void handleMessage(android.os.Message msg) { // TODO Auto-generated method stub if (outerInstance.mInfo != null) { MotionTest.playSound(); outerInstance.displayData(outerInstance.mInfo); } }
public override void handleMessage(android.os.Message msg) { // TODO Auto-generated method stub if (outerInstance.mInfo[0] != null) { MotionTest.playSound(); outerInstance.displayData(SmotionActivity.Info.MODE_REALTIME, outerInstance.mInfo); } }
public override void dispatchGetNewSurface() { android.view.SurfaceView surfaceView = mSurfaceView.get(); if (surfaceView != null) { android.os.Message msg = surfaceView.mHandler.obtainMessage(GET_NEW_SURFACE_MSG); surfaceView.mHandler.sendMessage(msg); } }
/// <summary> /// Same as /// <see cref="obtain()">obtain()</see> /// , but sets the values of the <em>target</em>, <em>what</em>, /// <em>arg1</em>, and <em>arg2</em> members. /// </summary> /// <param name="h">The <em>target</em> value to set.</param> /// <param name="what">The <em>what</em> value to set.</param> /// <param name="arg1">The <em>arg1</em> value to set.</param> /// <param name="arg2">The <em>arg2</em> value to set.</param> /// <returns>A Message object from the global pool.</returns> public static android.os.Message obtain(android.os.Handler h, int what, int arg1, int arg2) { android.os.Message m = obtain(); m.target = h; m.what = what; m.arg1 = arg1; m.arg2 = arg2; return(m); }
public override void handleMessage(android.os.Message m) { if (this._enclosing.mRunning) { this._enclosing.updateText(android.os.SystemClock.elapsedRealtime()); this._enclosing.dispatchChronometerTick(); this.sendMessageDelayed(android.os.Message.obtain(this, android.widget.Chronometer .TICK_WHAT), 1000); } }
public override void handleMessage(android.os.Message msg) { if (msg.what == this._enclosing.FLIP_MSG) { if (this._enclosing.mRunning) { this._enclosing.showNext(); } } }
public override void showPrevious() { // if the flipper is currently flipping automatically, and showPrevious() is called // we should we should make sure to reset the timer if (mRunning) { mHandler.removeMessages(FLIP_MSG); android.os.Message msg = mHandler.obtainMessage(FLIP_MSG); mHandler.sendMessageDelayed(msg, mFlipInterval); } base.showPrevious(); }
public virtual void onTooManyRedirects(android.webkit.WebView arg0, android.os.Message arg1, android.os.Message arg2) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { @__env.CallVoidMethod(this.JvmHandle, global::android.webkit.WebViewClient._onTooManyRedirects10680, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg2)); } else { @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.webkit.WebViewClient.staticClass, global::android.webkit.WebViewClient._onTooManyRedirects10680, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg2)); } }
public virtual void dispatchMessage(android.os.Message arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { @__env.CallVoidMethod(this.JvmHandle, global::android.os.Handler._dispatchMessage6424, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } else { @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.os.Handler.staticClass, global::android.os.Handler._dispatchMessage6424, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } }
public virtual bool sendMessageAtFrontOfQueue(android.os.Message arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { return(@__env.CallBooleanMethod(this.JvmHandle, global::android.os.Handler._sendMessageAtFrontOfQueue6443, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } else { return(@__env.CallNonVirtualBooleanMethod(this.JvmHandle, global::android.os.Handler.staticClass, global::android.os.Handler._sendMessageAtFrontOfQueue6443, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } }
public override void handleMessage(android.os.Message arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { @__env.CallVoidMethod(this.JvmHandle, global::android.content.AsyncQueryHandler._handleMessage1073, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } else { @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.content.AsyncQueryHandler.staticClass, global::android.content.AsyncQueryHandler._handleMessage1073, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } }
public void copyFrom(android.os.Message arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { @__env.CallVoidMethod(this.JvmHandle, global::android.os.Message._copyFrom6507, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } else { @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.os.Message.staticClass, global::android.os.Message._copyFrom6507, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0)); } }
public override void handleMessage(android.os.Message msg) { if (msg.what == this._enclosing.FLIP_MSG) { if (this._enclosing.mRunning) { this._enclosing.showNext(); msg = this.obtainMessage(this._enclosing.FLIP_MSG); this.sendMessageDelayed(msg, this._enclosing.mFlipInterval); } } }
bool android.os.Handler.Callback.handleMessage(android.os.Message arg0) { global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv; if (!IsClrObject) { return(@__env.CallBooleanMethod(this.JvmHandle, global::android.os.Handler.Callback_._handleMessage6420, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } else { return(@__env.CallNonVirtualBooleanMethod(this.JvmHandle, global::android.os.Handler.Callback_.staticClass, global::android.os.Handler.Callback_._handleMessage6420, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0))); } }
/// <summary>Return a Message instance to the global pool.</summary> /// <remarks> /// Return a Message instance to the global pool. You MUST NOT touch /// the Message after calling this function -- it has effectively been /// freed. /// </remarks> public void recycle() { clearForRecycle(); lock (sPoolSync) { if (sPoolSize < MAX_POOL_SIZE) { next = sPool; sPool = this; sPoolSize++; } } }
// sometimes we store linked lists of these things /// <summary>Return a new Message instance from the global pool.</summary> /// <remarks> /// Return a new Message instance from the global pool. Allows us to /// avoid allocating new objects in many cases. /// </remarks> public static android.os.Message obtain() { lock (sPoolSync) { if (sPool != null) { android.os.Message m = sPool; sPool = m.next; m.next = null; sPoolSize--; return(m); } } return(new android.os.Message()); }
/// <summary> /// Same as /// <see cref="obtain()">obtain()</see> /// , but copies the values of an existing /// message (including its target) into the new one. /// </summary> /// <param name="orig">Original message to copy.</param> /// <returns>A Message object from the global pool.</returns> public static android.os.Message obtain(android.os.Message orig) { android.os.Message m = obtain(); m.what = orig.what; m.arg1 = orig.arg1; m.arg2 = orig.arg2; m.obj = orig.obj; m.replyTo = orig.replyTo; if (orig.data != null) { m.data = new android.os.Bundle(orig.data); } m.target = orig.target; m.callback = orig.callback; return(m); }
/// <summary>Make this message like o.</summary> /// <remarks> /// Make this message like o. Performs a shallow copy of the data field. /// Does not copy the linked list fields, nor the timestamp or /// target/callback of the original message. /// </remarks> public void copyFrom(android.os.Message o) { this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM; this.what = o.what; this.arg1 = o.arg1; this.arg2 = o.arg2; this.obj = o.obj; this.replyTo = o.replyTo; if (o.data != null) { this.data = (android.os.Bundle)o.data.clone(); } else { this.data = null; } }
public override void handleMessage(android.os.Message message) { switch (message.what) { case android.view.accessibility.AccessibilityManager.DO_SET_STATE: { this._enclosing.setState(message.arg1); return; } default: { android.util.Log.w(android.view.accessibility.AccessibilityManager.LOG_TAG, "Unknown message type: " + message.what); break; } } }
/// <summary> /// Internal method to start or stop dispatching flip /// <see cref="android.os.Message">android.os.Message</see> /// based /// on /// <see cref="mRunning">mRunning</see> /// and /// <see cref="mVisible">mVisible</see> /// state. /// </summary> /// <param name="flipNow"> /// Determines whether or not to execute the animation now, in /// addition to queuing future flips. If omitted, defaults to /// true. /// </param> private void updateRunning(bool flipNow) { bool running = mVisible && mStarted && mUserPresent; if (running != mRunning) { if (running) { showOnly(mWhichChild, flipNow); android.os.Message msg = mHandler.obtainMessage(FLIP_MSG); mHandler.sendMessageDelayed(msg, mFlipInterval); } else { mHandler.removeMessages(FLIP_MSG); } mRunning = running; } }
public override void handleMessage(android.os.Message msg) { switch (msg.what) { case android.content.DialogInterfaceClass.BUTTON_POSITIVE: case android.content.DialogInterfaceClass.BUTTON_NEGATIVE: case android.content.DialogInterfaceClass.BUTTON_NEUTRAL: { ((android.content.DialogInterfaceClass.OnClickListener)msg.obj).onClick(mDialog.get (), msg.what); break; } case MSG_DISMISS_DIALOG: { ((android.content.DialogInterface)msg.obj).dismiss(); break; } } }
public override void handleMessage(android.os.Message msg) { switch (msg.what) { case android.view.SurfaceView.KEEP_SCREEN_ON_MSG: { this._enclosing.setKeepScreenOn(msg.arg1 != 0); break; } case android.view.SurfaceView.GET_NEW_SURFACE_MSG: { this._enclosing.handleGetNewSurface(); break; } case android.view.SurfaceView.UPDATE_WINDOW_MSG: { this._enclosing.updateWindow(false, false); break; } } }
/// <summary>Sets a click listener or a message to be sent when the button is clicked. /// </summary> /// <remarks> /// Sets a click listener or a message to be sent when the button is clicked. /// You only need to pass one of /// <code>listener</code> /// or /// <code>msg</code> /// . /// </remarks> /// <param name="whichButton"> /// Which button, can be one of /// <see cref="android.content.DialogInterfaceClass.BUTTON_POSITIVE">android.content.DialogInterfaceClass.BUTTON_POSITIVE /// </see> /// , /// <see cref="android.content.DialogInterfaceClass.BUTTON_NEGATIVE">android.content.DialogInterfaceClass.BUTTON_NEGATIVE /// </see> /// , or /// <see cref="android.content.DialogInterfaceClass.BUTTON_NEUTRAL">android.content.DialogInterfaceClass.BUTTON_NEUTRAL /// </see> /// </param> /// <param name="text">The text to display in positive button.</param> /// <param name="listener"> /// The /// <see cref="android.content.DialogInterfaceClass.OnClickListener">android.content.DialogInterfaceClass.OnClickListener /// </see> /// to use. /// </param> /// <param name="msg"> /// The /// <see cref="android.os.Message">android.os.Message</see> /// to be sent when clicked. /// </param> public virtual void setButton(int whichButton, java.lang.CharSequence text, android.content.DialogInterfaceClass .OnClickListener listener, android.os.Message msg) { if (msg == null && listener != null) { msg = mHandler.obtainMessage(whichButton, listener); } switch (whichButton) { case android.content.DialogInterfaceClass.BUTTON_POSITIVE: { mButtonPositiveText = text; mButtonPositiveMessage = msg; break; } case android.content.DialogInterfaceClass.BUTTON_NEGATIVE: { mButtonNegativeText = text; mButtonNegativeMessage = msg; break; } case android.content.DialogInterfaceClass.BUTTON_NEUTRAL: { mButtonNeutralText = text; mButtonNeutralMessage = msg; break; } default: { throw new System.ArgumentException("Button does not exist"); } } }