import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.AppGlobals;
-import android.app.IActivityContainer;
import android.app.IApplicationThread;
import android.app.PendingIntent;
import android.app.ProfilerInfo;
import android.app.WaitResult;
-import android.content.ComponentName;
import android.content.IIntentSender;
import android.content.Intent;
import android.content.IntentSender;
* an activity and associated task and stack.
*/
class ActivityStarter {
+ public static final int PID_NULL = 0;
+
private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityStarter" : TAG_AM;
private static final String TAG_RESULTS = TAG + POSTFIX_RESULTS;
private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS;
private boolean mAvoidMoveToFront;
private boolean mPowerHintSent;
+ // We must track when we deliver the new intent since multiple code paths invoke
+ // {@link #deliverNewIntent}. This is due to early returns in the code path. This flag is used
+ // inside {@link #deliverNewIntent} to suppress duplicate requests and ensure the intent is
+ // delivered at most once.
+ private boolean mIntentDelivered;
+
private IVoiceInteractionSession mVoiceSession;
private IVoiceInteractor mVoiceInteractor;
mVoiceInteractor = null;
mUsingVr2dDisplay = false;
+
+ mIntentDelivered = false;
}
ActivityStarter(ActivityManagerService service, ActivityStackSupervisor supervisor) {
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
- ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
- TaskRecord inTask, String reason) {
+ ActivityRecord[] outActivity, TaskRecord inTask, String reason) {
if (TextUtils.isEmpty(reason)) {
throw new IllegalArgumentException("Need to specify a reason.");
aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
- container, inTask);
+ inTask);
if (outActivity != null) {
// mLastStartActivityRecord[0] is set in the call to startActivity above.
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
- ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
- TaskRecord inTask) {
+ ActivityRecord[] outActivity, TaskRecord inTask) {
int err = ActivityManager.START_SUCCESS;
// Pull the optional Ephemeral Installer-only bundle out of the options early.
final Bundle verificationBundle
if (DEBUG_PERMISSIONS_REVIEW) {
Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true,
true, false) + "} from uid " + callingUid + " on display "
- + (container == null ? (mSupervisor.mFocusedStack == null ?
- DEFAULT_DISPLAY : mSupervisor.mFocusedStack.mDisplayId) :
- (container.mActivityDisplay == null ? DEFAULT_DISPLAY :
- container.mActivityDisplay.mDisplayId)));
+ + (mSupervisor.mFocusedStack == null
+ ? DEFAULT_DISPLAY : mSupervisor.mFocusedStack.mDisplayId));
}
}
}
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
- mSupervisor, container, options, sourceRecord);
+ mSupervisor, options, sourceRecord);
if (outActivity != null) {
outActivity[0] = r;
}
Intent.ACTION_INSTALL_INSTANT_APP_PACKAGE, originalIntent,
auxiliaryResponse.failureIntent, callingPackage, verificationBundle,
resolvedType, userId, auxiliaryResponse.packageName, auxiliaryResponse.splitName,
- auxiliaryResponse.versionCode, auxiliaryResponse.token,
- auxiliaryResponse.needsPhaseTwo);
+ auxiliaryResponse.installFailureActivity, auxiliaryResponse.versionCode,
+ auxiliaryResponse.token, auxiliaryResponse.needsPhaseTwo);
}
void postStartActivityProcessing(
null /*callingPackage*/, 0 /*realCallingPid*/, 0 /*realCallingUid*/,
0 /*startFlags*/, null /*options*/, false /*ignoreTargetSecurity*/,
false /*componentSpecified*/, mLastHomeActivityStartRecord /*outActivity*/,
- null /*container*/, null /*inTask*/, "startHomeActivity: " + reason);
+ null /*inTask*/, "startHomeActivity: " + reason);
if (mSupervisor.inResumeTopActivity) {
// If we are in resume section already, home activity will be initialized, but not
// resumed (to avoid recursive resume) and will stay that way until something pokes it
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,
Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
- IActivityContainer iContainer, TaskRecord inTask, String reason) {
+ TaskRecord inTask, String reason) {
+ return startActivityMayWait(caller, callingUid, PID_NULL, UserHandle.USER_NULL,
+ callingPackage, intent, resolvedType, voiceSession, voiceInteractor, resultTo,
+ resultWho, requestCode, startFlags, profilerInfo, outResult, globalConfig, bOptions,
+ ignoreTargetSecurity, userId, inTask, reason);
+ }
+
+ final int startActivityMayWait(IApplicationThread caller, int callingUid,
+ int requestRealCallingPid, int requestRealCallingUid,
+ String callingPackage, Intent intent, String resolvedType,
+ IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
+ IBinder resultTo, String resultWho, int requestCode, int startFlags,
+ ProfilerInfo profilerInfo, WaitResult outResult,
+ Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
+ TaskRecord inTask, String reason) {
// Refuse possible leaked file descriptors
if (intent != null && intent.hasFileDescriptors()) {
throw new IllegalArgumentException("File descriptors passed in Intent");
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
ActivityOptions options = ActivityOptions.fromBundle(bOptions);
- ActivityStackSupervisor.ActivityContainer container =
- (ActivityStackSupervisor.ActivityContainer)iContainer;
synchronized (mService) {
- if (container != null && container.mParentActivity != null &&
- container.mParentActivity.state != RESUMED) {
- // Cannot start a child activity if the parent is not resumed.
- return ActivityManager.START_CANCELED;
- }
- final int realCallingPid = Binder.getCallingPid();
- final int realCallingUid = Binder.getCallingUid();
+
+ final int realCallingPid = requestRealCallingPid != PID_NULL
+ ? requestRealCallingPid
+ : Binder.getCallingPid();
+ final int realCallingUid = requestRealCallingUid != UserHandle.USER_NULL
+ ? requestRealCallingUid
+ : Binder.getCallingUid();
+
int callingPid;
if (callingUid >= 0) {
callingPid = -1;
callingPid = callingUid = -1;
}
- final ActivityStack stack;
- if (container == null || container.mStack.isOnHomeDisplay()) {
- stack = mSupervisor.mFocusedStack;
- } else {
- stack = container.mStack;
- }
+ final ActivityStack stack = mSupervisor.mFocusedStack;
stack.mConfigWillChange = globalConfig != null
&& mService.getGlobalConfiguration().diff(globalConfig) != 0;
if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
aInfo, rInfo, voiceSession, voiceInteractor,
resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
- options, ignoreTargetSecurity, componentSpecified, outRecord, container,
- inTask, reason);
+ options, ignoreTargetSecurity, componentSpecified, outRecord, inTask,
+ reason);
Binder.restoreCallingIdentity(origId);
final int startActivities(IApplicationThread caller, int callingUid, String callingPackage,
Intent[] intents, String[] resolvedTypes, IBinder resultTo,
Bundle bOptions, int userId, String reason) {
+ return startActivities(caller, callingUid, PID_NULL, UserHandle.USER_NULL, callingPackage,
+ intents, resolvedTypes, resultTo, bOptions, userId, reason);
+ }
+
+ final int startActivities(IApplicationThread caller, int callingUid,
+ int incomingRealCallingPid, int incomingRealCallingUid, String callingPackage,
+ Intent[] intents, String[] resolvedTypes, IBinder resultTo,
+ Bundle bOptions, int userId, String reason) {
if (intents == null) {
throw new NullPointerException("intents is null");
}
throw new IllegalArgumentException("intents are length different than resolvedTypes");
}
- final int realCallingPid = Binder.getCallingPid();
- final int realCallingUid = Binder.getCallingUid();
+ final int realCallingPid = incomingRealCallingPid != PID_NULL
+ ? incomingRealCallingPid
+ : Binder.getCallingPid();
+
+ final int realCallingUid = incomingRealCallingUid != UserHandle.USER_NULL
+ ? incomingRealCallingUid
+ : Binder.getCallingUid();
int callingPid;
if (callingUid >= 0) {
} else {
callingPid = callingUid = -1;
}
+ boolean forceNewTask = false;
+ final int filterCallingUid = callingUid >= 0 ? callingUid : realCallingUid;
final long origId = Binder.clearCallingIdentity();
try {
synchronized (mService) {
// Don't modify the client's object!
intent = new Intent(intent);
+ if (forceNewTask) {
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ }
// Collect information about the target of the Intent.
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, resolvedTypes[i], 0,
resolvedTypes[i], aInfo, null /*rInfo*/, null, null, resultTo, null, -1,
callingPid, callingUid, callingPackage,
realCallingPid, realCallingUid, 0,
- options, false, componentSpecified, outActivity, null, null, reason);
+ options, false, componentSpecified, outActivity, null, reason);
if (res < 0) {
return res;
}
- resultTo = outActivity[0] != null ? outActivity[0].appToken : null;
+ final ActivityRecord started = outActivity[0];
+ if (started != null && started.getUid() == filterCallingUid) {
+ // Only the started activity which has the same uid as the source caller can
+ // be the caller of next activity.
+ resultTo = started.appToken;
+ forceNewTask = false;
+ } else {
+ // Different apps not adjacent to the caller are forced to be new task.
+ resultTo = null;
+ forceNewTask = true;
+ }
}
}
} finally {
return START_SUCCESS;
}
- void sendPowerHintForLaunchStartIfNeeded(boolean forceSend) {
+ void sendPowerHintForLaunchStartIfNeeded(boolean forceSend, ActivityRecord targetActivity) {
boolean sendHint = forceSend;
if (!sendHint) {
final ActivityRecord resumedActivity = mSupervisor.getResumedActivityLocked();
sendHint = resumedActivity == null
|| resumedActivity.app == null
- || !resumedActivity.app.equals(mStartActivity.app);
+ || !resumedActivity.app.equals(targetActivity.app);
}
if (sendHint && mService.mLocalPowerManager != null) {
// so make sure the task now has the identity of the new intent.
top.getTask().setIntent(mStartActivity);
}
- ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.getTask());
- top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
- mStartActivity.launchedFromPackage);
+ deliverNewIntent(top);
}
}
- sendPowerHintForLaunchStartIfNeeded(false /* forceSend */);
+ sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, reusedActivity);
reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
if (outActivity != null && outActivity.length > 0) {
outActivity[0] = reusedActivity;
}
+
return START_TASK_TO_FRONT;
}
}
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| mLaunchSingleTop || mLaunchSingleTask);
if (dontStart) {
- ActivityStack.logStartActivity(AM_NEW_INTENT, top, top.getTask());
// For paranoia, make sure we have correctly resumed the top activity.
topStack.mLastPausedActivity = null;
if (mDoResume) {
// anything if that is the case, so this is it!
return START_RETURN_INTENT_TO_CALLER;
}
- top.deliverNewIntentLocked(
- mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
+
+ deliverNewIntent(top);
// Don't use mStartActivity.task to show the toast. We're not starting a new activity
// but reusing 'top'. Fields in mStartActivity may not be fully initialized.
EventLogTags.AM_CREATE_ACTIVITY, mStartActivity, mStartActivity.getTask());
mTargetStack.mLastPausedActivity = null;
- sendPowerHintForLaunchStartIfNeeded(false /* forceSend */);
+ sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, mStartActivity);
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
mOptions);
if (mLaunchSingleInstance) {
// There can be one and only one instance of single instance activity in the
// history, and it is always in its own unique task, so we do a special search.
- intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info, false);
+ intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
+ mStartActivity.isHomeActivity());
} else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
// For the launch adjacent case we only want to put the activity in an existing
// task if the activity already exists in the history.
REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, DEFER_RESUME,
"reparentToDisplay");
mMovedToFront = true;
+ } else if (launchStack.getStackId() == StackId.HOME_STACK_ID
+ && mTargetStack.getStackId() != StackId.HOME_STACK_ID) {
+ // It is possible for the home activity to be in another stack initially.
+ // For example, the activity may have been initially started with an intent
+ // which placed it in the fullscreen stack. To ensure the proper handling of
+ // the activity based on home stack assumptions, we must move it over.
+ intentActivity.getTask().reparent(launchStack.mStackId, ON_TOP,
+ REPARENT_MOVE_STACK_TO_FRONT, ANIMATE, DEFER_RESUME,
+ "reparentingHome");
+ mMovedToFront = true;
}
mOptions = null;
// desires.
if (((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0 || mLaunchSingleTop)
&& intentActivity.realActivity.equals(mStartActivity.realActivity)) {
- ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity,
- intentActivity.getTask());
if (intentActivity.frontOfTask) {
intentActivity.getTask().setIntent(mStartActivity);
}
- intentActivity.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
- mStartActivity.launchedFromPackage);
+ deliverNewIntent(intentActivity);
} else if (!intentActivity.getTask().isSameIntentFilter(mStartActivity)) {
// In this case we are launching the root activity of the task, but with a
// different intent. We should start a new instance on top.
return START_SUCCESS;
}
+ private void deliverNewIntent(ActivityRecord activity) {
+ if (mIntentDelivered) {
+ return;
+ }
+
+ ActivityStack.logStartActivity(AM_NEW_INTENT, activity, activity.getTask());
+ activity.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
+ mStartActivity.launchedFromPackage);
+ mIntentDelivered = true;
+ }
+
private int setTaskFromSourceRecord() {
if (mSupervisor.isLockTaskModeViolation(mSourceRecord.getTask())) {
Slog.e(TAG, "Attempted Lock Task Mode violation mStartActivity=" + mStartActivity);
final TaskRecord sourceTask = mSourceRecord.getTask();
final ActivityStack sourceStack = mSourceRecord.getStack();
- // We only want to allow changing stack if the target task is not the top one,
- // otherwise we would move the launching task to the other side, rather than show
- // two side by side.
- final boolean moveStackAllowed = sourceStack.topTask() != sourceTask;
+ // We only want to allow changing stack in two cases:
+ // 1. If the target task is not the top one. Otherwise we would move the launching task to
+ // the other side, rather than show two side by side.
+ // 2. If activity is not allowed on target display.
+ final int targetDisplayId = mTargetStack != null ? mTargetStack.mDisplayId
+ : sourceStack.mDisplayId;
+ final boolean moveStackAllowed = sourceStack.topTask() != sourceTask
+ || !mStartActivity.canBeLaunchedOnDisplay(targetDisplayId);
if (moveStackAllowed) {
mTargetStack = getLaunchStack(mStartActivity, mLaunchFlags, mStartActivity.getTask(),
mOptions);
+ // If target stack is not found now - we can't just rely on the source stack, as it may
+ // be not suitable. Let's check other displays.
+ if (mTargetStack == null && targetDisplayId != sourceStack.mDisplayId) {
+ // Can't use target display, lets find a stack on the source display.
+ mTargetStack = mService.mStackSupervisor.getValidLaunchStackOnDisplay(
+ sourceStack.mDisplayId, mStartActivity);
+ }
+ if (mTargetStack == null) {
+ // There are no suitable stacks on the target and source display(s). Look on all
+ // displays.
+ mTargetStack = mService.mStackSupervisor.getNextValidLaunchStackLocked(
+ mStartActivity, -1 /* currentFocus */);
+ }
}
if (mTargetStack == null) {
mKeepCurTransition = true;
if (top != null) {
ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, top.getTask());
- top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
+ deliverNewIntent(top);
// For paranoia, make sure we have correctly resumed the top activity.
mTargetStack.mLastPausedActivity = null;
if (mDoResume) {
task.moveActivityToFrontLocked(top);
top.updateOptionsLocked(mOptions);
ActivityStack.logStartActivity(AM_NEW_INTENT, mStartActivity, task);
- top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
+ deliverNewIntent(top);
mTargetStack.mLastPausedActivity = null;
if (mDoResume) {
mSupervisor.resumeFocusedStackTopActivityLocked();
|| mLaunchSingleTop || mLaunchSingleTask) {
mTargetStack.moveTaskToFrontLocked(mInTask, mNoAnimation, mOptions,
mStartActivity.appTimeTracker, "inTaskToFront");
- ActivityStack.logStartActivity(AM_NEW_INTENT, top, top.getTask());
if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
// We don't need to start a new activity, and the client said not to do
// anything if that is the case, so this is it!
return START_RETURN_INTENT_TO_CALLER;
}
- top.deliverNewIntentLocked(mCallingUid, mStartActivity.intent,
- mStartActivity.launchedFromPackage);
+ deliverNewIntent(top);
return START_DELIVERED_TO_TOP;
}
}
return currentStack;
}
- final ActivityStackSupervisor.ActivityContainer container = r.mInitialActivityContainer;
- if (container != null) {
- // The first time put it on the desired stack, after this put on task stack.
- r.mInitialActivityContainer = null;
- return container.mStack;
- }
-
if (canLaunchIntoFocusedStack(r, newTask)) {
if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,
"computeStackFocus: Have a focused stack=" + mSupervisor.mFocusedStack);
default:
// Dynamic stacks behave similarly to the fullscreen stack and can contain any
// resizeable task.
- // TODO: Check ActivityView after fixing b/35349678.
canUseFocusedStack = isDynamicStack(focusedStackId)
&& r.canBeLaunchedOnDisplay(focusedStack.mDisplayId);
}
- return canUseFocusedStack
- && (!newTask || focusedStack.mActivityContainer.isEligibleForNewTasks())
+ return canUseFocusedStack && !newTask
// We strongly prefer to launch activities on the same display as their source.
&& (mSourceDisplayId == focusedStack.mDisplayId);
}
// The parent activity doesn't want to launch the activity on top of itself, but
// instead tries to put it onto other side in side-by-side mode.
- final ActivityStack parentStack = task != null ? task.getStack()
- : r.mInitialActivityContainer != null ? r.mInitialActivityContainer.mStack
- : mSupervisor.mFocusedStack;
+ final ActivityStack parentStack = task != null ? task.getStack(): mSupervisor.mFocusedStack;
if (parentStack != mSupervisor.mFocusedStack) {
// If task's parent stack is not focused - use it during adjacent launch.
case ASSISTANT_STACK_ID:
return r.isAssistantActivity();
default:
- // TODO: Check ActivityView after fixing b/35349678.
if (StackId.isDynamicStack(stackId)) {
return r.canBeLaunchedOnDisplay(displayId);
}
return didSomething;
}
- void dump(PrintWriter pw, String prefix) {
- pw.println(prefix + "ActivityStarter:");
+ void dump(PrintWriter pw, String prefix, String dumpPackage) {
prefix = prefix + " ";
- pw.println(prefix + "mCurrentUser=" + mSupervisor.mCurrentUser);
- pw.println(prefix + "mLastStartReason=" + mLastStartReason);
- pw.println(prefix + "mLastStartActivityTimeMs="
- + DateFormat.getDateTimeInstance().format(new Date(mLastStartActivityTimeMs)));
- pw.println(prefix + "mLastStartActivityResult=" + mLastStartActivityResult);
+ if (dumpPackage != null) {
+ if ((mLastStartActivityRecord[0] == null ||
+ !dumpPackage.equals(mLastHomeActivityStartRecord[0].packageName)) &&
+ (mLastHomeActivityStartRecord[0] == null ||
+ !dumpPackage.equals(mLastHomeActivityStartRecord[0].packageName)) &&
+ (mStartActivity == null || !dumpPackage.equals(mStartActivity.packageName))) {
+ pw.print(prefix);
+ pw.println("(nothing)");
+ return;
+ }
+ }
+
+ pw.print(prefix);
+ pw.print("mCurrentUser=");
+ pw.println(mSupervisor.mCurrentUser);
+ pw.print(prefix);
+ pw.print("mLastStartReason=");
+ pw.println(mLastStartReason);
+ pw.print(prefix);
+ pw.print("mLastStartActivityTimeMs=");
+ pw.println(DateFormat.getDateTimeInstance().format(new Date(mLastStartActivityTimeMs)));
+ pw.print(prefix);
+ pw.print("mLastStartActivityResult=");
+ pw.println(mLastStartActivityResult);
ActivityRecord r = mLastStartActivityRecord[0];
if (r != null) {
- pw.println(prefix + "mLastStartActivityRecord:");
- r.dump(pw, prefix + " ");
+ pw.print(prefix);
+ pw.println("mLastStartActivityRecord:");
+ r.dump(pw, prefix + " ");
}
- pw.println(prefix + "mLastHomeActivityStartResult=" + mLastHomeActivityStartResult);
+ pw.print(prefix);
+ pw.print("mLastHomeActivityStartResult=");
+ pw.println(mLastHomeActivityStartResult);
r = mLastHomeActivityStartRecord[0];
if (r != null) {
- pw.println(prefix + "mLastHomeActivityStartRecord:");
- r.dump(pw, prefix + " ");
+ pw.print(prefix);
+ pw.println("mLastHomeActivityStartRecord:");
+ r.dump(pw, prefix + " ");
}
if (mStartActivity != null) {
- pw.println(prefix + "mStartActivity:");
- mStartActivity.dump(pw, prefix + " ");
+ pw.print(prefix);
+ pw.println("mStartActivity:");
+ mStartActivity.dump(pw, prefix + " ");
}
if (mIntent != null) {
- pw.println(prefix + "mIntent=" + mIntent);
+ pw.print(prefix);
+ pw.print("mIntent=");
+ pw.println(mIntent);
}
if (mOptions != null) {
- pw.println(prefix + "mOptions=" + mOptions);
- }
- pw.println(prefix + "mLaunchSingleTop=" + mLaunchSingleTop
- + " mLaunchSingleInstance=" + mLaunchSingleInstance
- + " mLaunchSingleTask=" + mLaunchSingleTask
- + " mLaunchFlags=0x" + Integer.toHexString(mLaunchFlags)
- + " mDoResume=" + mDoResume + " mAddingToTask=" + mAddingToTask);
+ pw.print(prefix);
+ pw.print("mOptions=");
+ pw.println(mOptions);
+ }
+ pw.print(prefix);
+ pw.print("mLaunchSingleTop=");
+ pw.print(mLaunchSingleTop);
+ pw.print(" mLaunchSingleInstance=");
+ pw.print(mLaunchSingleInstance);
+ pw.print(" mLaunchSingleTask=");
+ pw.println(mLaunchSingleTask);
+ pw.print(prefix);
+ pw.print("mLaunchFlags=0x");
+ pw.print(Integer.toHexString(mLaunchFlags));
+ pw.print(" mDoResume=");
+ pw.print(mDoResume);
+ pw.print(" mAddingToTask=");
+ pw.println(mAddingToTask);
}
}
OSDN Git Service
