public virtual void finish()
{
if (mParent == null)
{
int resultCode;
Intent resultData;
lock (this) {
resultCode = mResultCode;
resultData = mResultData;
}
if (resultData != null)
{
resultData.setAllowFds(false);
}
XobotActivityManager.FinishActivity(this, resultCode, resultData);
mFinished = true;
}
else
{
mParent.finishFromChild(this);
}
}
/// <summary>Execute a startActivity call made by the application.</summary>
/// <remarks>
/// Execute a startActivity call made by the application. The default
/// implementation takes care of updating any active
/// <see cref="ActivityMonitor">ActivityMonitor</see>
/// objects and dispatches this call to the system activity manager; you can
/// override this to watch for the application to start an activity, and
/// modify what happens when it does.
/// <p>This method returns an
/// <see cref="ActivityResult">ActivityResult</see>
/// object, which you can
/// use when intercepting application calls to avoid performing the start
/// activity action but still return the result the application is
/// expecting. To do this, override this method to catch the call to start
/// activity so that it returns a new ActivityResult containing the results
/// you would like the application to see, and don't call up to the super
/// class. Note that an application is only expecting a result if
/// <var>requestCode</var> is >= 0.
/// <p>This method throws
/// <see cref="android.content.ActivityNotFoundException">android.content.ActivityNotFoundException
/// </see>
/// if there was no Activity found to run the given Intent.
/// </remarks>
/// <param name="who">The Context from which the activity is being started.</param>
/// <param name="contextThread">
/// The main thread of the Context from which the activity
/// is being started.
/// </param>
/// <param name="token">
/// Internal token identifying to the system who is starting
/// the activity; may be null.
/// </param>
/// <param name="target">
/// Which activity is performing the start (and thus receiving
/// any result); may be null if this call is not being made
/// from an activity.
/// </param>
/// <param name="intent">The actual Intent to start.</param>
/// <param name="requestCode">
/// Identifier for this request's result; less than zero
/// if the caller is not expecting a result.
/// </param>
/// <returns>
/// To force the return of a particular result, return an
/// ActivityResult object containing the desired data; otherwise
/// return null. The default implementation always returns null.
/// </returns>
/// <exception cref="android.content.ActivityNotFoundException">android.content.ActivityNotFoundException
/// </exception>
/// <seealso cref="Activity.startActivity(android.content.Intent)">Activity.startActivity(android.content.Intent)
/// </seealso>
/// <seealso cref="Activity.startActivityForResult(android.content.Intent, int)">Activity.startActivityForResult(android.content.Intent, int)
/// </seealso>
/// <seealso cref="Activity.startActivityFromChild(Activity, android.content.Intent, int)
/// "><hide></hide></seealso>
public virtual ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode)
{
IApplicationThread whoThread = (IApplicationThread)contextThread;
if (mActivityMonitors != null)
{
lock (mSync) {
int N = mActivityMonitors.size();
{
for (int i = 0; i < N; i++)
{
ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent))
{
am.mHits++;
if (am.isBlocking())
{
return(requestCode >= 0 ? am.getResult() : null);
}
break;
}
}
}
}
}
try {
intent.setAllowFds(false);
int result = XobotActivityManager.StartActivity(
whoThread, intent, intent.resolveTypeIfNeeded(who.getContentResolver()), target,
requestCode);
checkStartActivityResult(result, intent);
} catch (RemoteException) {
}
return(null);
}
/// <summary>
/// Enqueue a message into the message queue after all pending messages
/// before the absolute time (in milliseconds) <var>uptimeMillis</var>.
/// </summary>
/// <remarks>
/// Enqueue a message into the message queue after all pending messages
/// before the absolute time (in milliseconds) <var>uptimeMillis</var>.
/// <b>The time-base is
/// <see cref="SystemClock.uptimeMillis()">SystemClock.uptimeMillis()</see>
/// .</b>
/// You will receive it in
/// <see cref="handleMessage(Message)">handleMessage(Message)</see>
/// , in the thread attached
/// to this handler.
/// </remarks>
/// <param name="uptimeMillis">
/// The absolute time at which the message should be
/// delivered, using the
/// <see cref="SystemClock.uptimeMillis()">SystemClock.uptimeMillis()</see>
/// time-base.
/// </param>
/// <returns>
/// Returns true if the message was successfully placed in to the
/// message queue. Returns false on failure, usually because the
/// looper processing the message queue is exiting. Note that a
/// result of true does not mean the message will be processed -- if
/// the looper is quit before the delivery time of the message
/// occurs then the message will be dropped.
/// </returns>
public virtual bool sendMessageAtTime(Message msg, long uptimeMillis)
{
XobotActivityManager.SendMessage(this, msg, uptimeMillis);
return(true);
}
public static Window makeNewWindow(Context context)
{
return(XobotActivityManager.CreateMainWindow(context));
}
