Java ActivityInfo.LAUNCH_SINGLE_TOP属性代码示例

public static void handleActivityStack(ActivityInfo info, Intent intent) {
    // Handle launchMode with singleTop, and flag with FLAG_ACTIVITY_SINGLE_TOP
    int launchMode = info.launchMode;
    int flag = intent.getFlags();
    String launchActivityName = info.name;

    String prevActivityName = null;
    List<WeakReference<Activity>> activityList = ActivityTaskMgr.getInstance().getActivityList();

    if (activityList.size() > 0) {
        Activity lastActivity = activityList.get(activityList.size() - 1).get();
        prevActivityName = lastActivity.getClass().getName();
    }

    if (StringUtils.equals(prevActivityName, launchActivityName)
            && (launchMode == ActivityInfo.LAUNCH_SINGLE_TOP || (flag & Intent.FLAG_ACTIVITY_SINGLE_TOP) == Intent.FLAG_ACTIVITY_SINGLE_TOP)) {
        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
    } else if (launchMode == ActivityInfo.LAUNCH_SINGLE_TASK || launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE
            || (flag & Intent.FLAG_ACTIVITY_CLEAR_TOP) == Intent.FLAG_ACTIVITY_CLEAR_TOP) {
        int i;
        boolean isExist = false;
        for (i = 0; i < activityList.size(); i++) {
            WeakReference<Activity> ref = activityList.get(i);
            if (ref!=null && ref.get()!=null && ref.get().getClass().getName().equals(launchActivityName)) {
                isExist = true;
                break;
            }
        }
        if (isExist) {
            for (WeakReference<Activity> act : activityList.subList(i + 1, activityList.size())) {
                if(act!=null && act.get()!=null) {
                    act.get().finish();
                }
            }
            activityList.subList(i + 1, activityList.size()).clear();
            intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
        }
    }
}
 

/**
 * This method checks if the current instance is the same one as the one before it, and then invokes {@link #onBlockingStop()} and
 * {@link #onBlockingDestroy()} if they haven't been invoked yet. After these have been invoked once, they will not be invoked again from this class.
 */
private void invokeLifecycleOperations() {
    // singleTop launch mode has nasty side effects, disable the workaround when that launch mode is detected
    try {
        int launchMode = getPackageManager().getActivityInfo(getComponentName(), PackageManager.GET_META_DATA).launchMode;
        if (launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
            return;
        }
    } catch (PackageManager.NameNotFoundException ignored) {}

    // invoke lifecycle events that haven't been invoked yet
    BlockingLifecycleActivity activityInstance = lastInstance != null && lastInstance.get() != null ? lastInstance.get() : null;
    if (activityInstance != null && activityInstance != this && activityInstance.getClass().getName().equals(getClass().getName())) {
        if (!activityInstance.isStopInvoked()) {
            activityInstance.onBlockingStop();
            activityInstance.setStopInvoked(true);
        }
        if (!activityInstance.isDestroyInvoked()) {
            activityInstance.onBlockingDestroy();
            activityInstance.setDestroyInvoked(true);
        }
    }

    lastInstance = new WeakReference<>(this);
}
 

public static void onActivtyDestory(Activity activity) {
    synchronized (mRunningActivityList) {
        RunningActivityRecord value = mRunningActivityList.remove(activity);
        if (value != null) {
            ActivityInfo targetActivityInfo = value.targetActivityInfo;
            if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE) {
                mRunningSingleStandardActivityList.remove(value.index);
            } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
                mRunningSingleTopActivityList.remove(value.index);
            } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
                mRunningSingleTaskActivityList.remove(value.index);
            } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
                mRunningSingleInstanceActivityList.remove(value.index);
            }
        }
    }
}
 

public static Intent modify(Activity target, Intent intent) {
    if (!intent.hasExtra(ApkConstant.EXTRA_APK_PATH)
            && target.getIntent().hasExtra(ApkConstant.EXTRA_APK_PATH)) {
        Bundle extras = intent.getExtras();
        if (extras != null) {
            intent.replaceExtras(new Bundle());
            String extras_id = ApkExtras.putExtras(extras);
            intent.putExtra(ApkConstant.EXTRA_APK_EXTRAS, extras_id);
        }
        String apkPath = target.getIntent().getStringExtra(ApkConstant.EXTRA_APK_PATH);
        intent.putExtra(ApkConstant.EXTRA_APK_PATH, apkPath);
        // launch mode
        if (intent.getComponent() != null) {
            try {
                ActivityInfo activityInfo = ApkLoaded.get(target, apkPath).getActivityInfo(intent.getComponent().getClassName());
                String launchModeStr = HookActivity_Component.STANDARD;
                int launchMode = activityInfo.launchMode;
                if (launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
                    launchModeStr = HookActivity_Component.SINGLE_INSTANCE;
                } else if (launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
                    launchModeStr = HookActivity_Component.SINGLE_TASK;
                } else if (launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
                    launchModeStr = HookActivity_Component.SINGLE_TOP;
                }
                intent.putExtra(ApkConstant.EXTRA_APK_LAUNCH_MODE, launchModeStr);
            } catch (Exception e) {
            }
        }
    }
    return HookActivity_Component.modify(intent);
}
 

/**
 * 获取 launchMode 对应的前缀
 */
private static String getLaunchModeInfix(int launchMode) {
    switch (launchMode) {
        case ActivityInfo.LAUNCH_SINGLE_TOP:
            return "STP";
        case ActivityInfo.LAUNCH_SINGLE_TASK:
            return "ST";
        case ActivityInfo.LAUNCH_SINGLE_INSTANCE:
            return "SI";
        default:
            return "NR";
    }
}
 

public static void onActivtyCreate(Activity activity, ActivityInfo targetActivityInfo, ActivityInfo stubActivityInfo) {
    synchronized (mRunningActivityList) {
        RunningActivityRecord value = new RunningActivityRecord(activity, targetActivityInfo, stubActivityInfo, findMaxIndex() + 1);
        mRunningActivityList.put(activity, value);
        if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE) {
            mRunningSingleStandardActivityList.put(value.index, value);
        } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
            mRunningSingleTopActivityList.put(value.index, value);
        } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
            mRunningSingleTaskActivityList.put(value.index, value);
        } else if (targetActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
            mRunningSingleInstanceActivityList.put(value.index, value);
        }
    }
}
 

public static void beforeStartActivity() {
    synchronized (mRunningActivityList) {
        for (RunningActivityRecord record : mRunningActivityList.values()) {
            if (record.stubActivityInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE) {
                continue;
            } else if (record.stubActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) {
                doFinshIt(mRunningSingleTopActivityList);
            } else if (record.stubActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
                doFinshIt(mRunningSingleTopActivityList);
            } else if (record.stubActivityInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
                doFinshIt(mRunningSingleTopActivityList);
            }
        }
    }
}