全面总结Android面试知识要点：Android组件内核面试题

作者: 代码我写的怎么 | 来源:发表于2023-06-05 14:58 被阅读0次

请点赞，你的点赞对我意义重大，满足下我的虚荣心。
🔥常在河边走，哪有不湿鞋。或许面试过程中你遇到的问题就在这呢？
🔥关注我个人简介，面试不迷路~

一、Acitvity的生命周期，如何摧毁一个Activity? (美团)

这道题想考察什么

是否了解AMS、Activity的相关知识？

考察的知识点

AMS的基本知识
Activity的启动和销毁流程

考生应该如何回答

注意事项

本节内容会涉及到AMS的内容，如果不了解建议先学习相关章节

Activity销毁的相关流程图

image.png

ActivityFinish流程以及结果接收的流程

在执行完setResult以及finish之后，开始启动Activity销毁以及结果返回的流程。

setResult以及finish（用户进程）

保存resultCode以及data，并且通过finishActivity通知AMS开始销毁当前Activity，并且携带参数

public final void setResult(int resultCode, Intent data) {
        synchronized (this) {
            mResultCode = resultCode;
            mResultData = data;
        }
    }

private void finish(int finishTask) {
        if (mParent == null) {
            int resultCode;
            Intent resultData;
            synchronized (this) {
                resultCode = mResultCode;
                resultData = mResultData;
            }
            if (false) Log.v(TAG, "Finishing self: token=" + mToken);
            try {
                if (resultData != null) {
                    resultData.prepareToLeaveProcess(this);
                }
                if (ActivityManager.getService()
                        .finishActivity(mToken, resultCode, resultData, finishTask)) {
                    mFinished = true;
                }
            } catch (RemoteException e) {
                // Empty
            }
        } else {
            mParent.finishFromChild(this);
        }
    }

ActivityManagerService.finishActivity（System_Server进程）

在ActivityManagerService中，会判断是否要终止整个Task，如果是的话，则直接把Task从ActivityStackSupervisor中移除，如果不是的话，则调用requestFinishActivityLoacked销毁Activity，并且将resultData传入。

 final boolean finishWithRootActivity =
                        finishTask == Activity.FINISH_TASK_WITH_ROOT_ACTIVITY;
                if (finishTask == Activity.FINISH_TASK_WITH_ACTIVITY
                        || (finishWithRootActivity && r == rootR)) {
                    //  判断是否要结束整个Task
                    res = mStackSupervisor.removeTaskByIdLocked(tr.taskId, false, finishWithRootActivity);
                    if (!res) {
                        Slog.i(TAG, "Removing task failed to finish activity");
                    }
                } else {
                    //  如果不清除Task的话，则只清理单独的Activity
                    res = tr.getStack().requestFinishActivityLocked(token, resultCode,resultData, "app-request", true);
                    if (!res) {
                        Slog.i(TAG, "Failed to finish by app-request");
                    }
                }

ActivityStack.finishActivityLocked（System_Server进程）

ActivityStack.requestFinishActivityLocked最终会调用到finishActivityLocked函数中。

修改ActivityRecord中的finishing标识位为true
停止接收Key事件
将Result结果保存到接收者中
开始暂停当前Activity

...
try {
            //  将ActivityRecord中的finishing置成true，表示正在处于Finishing状态
            r.makeFinishingLocked();
            ...
            //  停止接收Key事件的分发
            r.pauseKeyDispatchingLocked();
            //  重新调整FocusedActivity栈
            adjustFocusedActivityStackLocked(r, "finishActivity");
            //  将resultData也就是返回的数据保存到r.resultTo的ActivityRecord中
            finishActivityResultsLocked(r, resultCode, resultData);
            //  如果当前的Activity是该Task最后一个Activity的话，那么就需要销毁Task
            final boolean endTask = index <= 0;
            if (mResumedActivity == r) {
                ...
                //  准备Activity切换的窗口动画
                mWindowManager.prepareAppTransition(transit, false);
                //  告诉WindowManager准备当前的Activity准备移除
                r.setVisibility(false);
                //  如果当前没有Pausing的Activity的话
                if (mPausingActivity == null) {
                    //  开始Pausing当前的Activity
                    startPausingLocked(false, false, null, pauseImmediately);
                }
                // 如果需要销毁Task的话，那么就开始销毁
                if (endTask) {
                    mStackSupervisor.removeLockedTaskLocked(task);
                }
            } else if (r.state != ActivityState.PAUSING) {
                //  如果当前的Activity正处于Pausing 的状态的话，那么就会等它Pausing完成之后开始销毁，否则在这个地方直接销毁
                if (r.visible) {
                    prepareActivityHideTransitionAnimation(r, transit);
                }
                final int finishMode = (r.visible || r.nowVisible) ? FINISH_AFTER_VISIBLE
                        : FINISH_AFTER_PAUSE;
                //  直接调用finishCurrentActivityLocked销毁当前的Activity
                final boolean removedActivity = finishCurrentActivityLocked(r, finishMode, oomAdj)
                        == null;
                ...
            }
...

ActivityStack. startPausingLocked（System_Server进程）

更新mResumedActivity、prev.state
执行schedulePauseActivity暂停Activity
延迟发送消息，检测Pause超时

...
ActivityRecord prev = mResumedActivity;
if (prev == null) {
      if (resuming == null) {
         // 如果没有要暂停的Activity的话，就直接resume栈顶的Activity
         mStackSupervisor.resumeFocusedStackTopActivityLocked();
      }
      return false;
}
...
//  更新当前保存的ResumedActivity，因为即将进入Pausing状态
mResumedActivity = null;
//  将正在Pausing的Activity赋值为即将进入Pausing的Activity
mPausingActivity = prev;
mLastPausedActivity = prev;
mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
                || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
//  将当前Activity状态置成Pausing
prev.state = ActivityState.PAUSING;
... 
final ActivityRecord next = mStackSupervisor.topRunningActivityLocked();
if (prev.app != null && prev.app.thread != null) {
       ...
       //  回调Activity的Pause函数，pauseImmediately为false
       prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, pauseImmediately);
           ...
        } else {
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }
}
...
        if (mPausingActivity != null) {
            //  判断是否是立即暂停，如果是的话，则立即调用completePauseLocked
            if (pauseImmediately) {
                // If the caller said they don't want to wait for the pause, then complete
                // the pause now.
                completePauseLocked(false, resuming);
                return false;
            } else {
                //  如果不是立即暂停的话，那么就会等待Activity的onPause完毕，并且检测超时
                //  如果pause超时的话，也会继续执行下面的流程
                schedulePauseTimeout(prev);
                return true;
            }
        } else {
            // This activity failed to schedule the
            // pause, so just treat it as being paused now.
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Activity not running, resuming next.");
            if (resuming == null) {
                mStackSupervisor.resumeFocusedStackTopActivityLocked();
            }
            return false;
        }

ActivityStack.activityPausedLocked（System_Server进程）

当Activity进入Pause的状态后，会通过Binder回调到activityPausedLocked该接口。

        // 根据mToken找到ActivityRecord
        final ActivityRecord r = isInStackLocked(token);
        if (r != null) {
            //  接收到ActivityPause完成的回调后，清理PAUSE_TIMEOUT_MSG
            mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
        }
         //  判断当前Pausing的Activity是否是已经回调过Pause的Activity
         if (mPausingActivity == r) {
             ...
             //  如果是的话，则调用该函数
             completePauseLocked(true /* resumeNext */, null /* resumingActivity */)；
         } else {
            ...
            if (r.state == ActivityState.PAUSING) {
                    r.state = ActivityState.PAUSED;
                    if (r.finishing) {
                        if (DEBUG_PAUSE) Slog.v(TAG,
                                "Executing finish of failed to pause activity: " + r);
                        finishCurrentActivityLocked(r, FINISH_AFTER_VISIBLE, false);
                    }
             }
        }

ActivityStack.completePauseLocked（System_Server进程）

如果Pause完毕之后，则开始处理Stop的流程。

如果prev.finishing为true的话，则会执行finishCurrentActivityLocked开始销毁
接着调用resumeFocusedStackTopActivityLocked开始Resume接下来的Activity

         ActivityRecord prev = mPausingActivity;
        if (prev != null) {
            //  判断当前是否是STOPPING的状态
            final boolean wasStopping = prev.state == STOPPING;
            //  将当前状态该成PAUSED
            prev.state = ActivityState.PAUSED;
            //  如果是finishing的话，则调用finishCurrentActivityLocked开始销毁
            if (prev.finishing) {
                if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Executing finish of activity: " + prev);
                prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false);
            } 
            ...
            //  将PausingActivity置空
             mPausingActivity = null;
        }
        //  开始resume下一个Activity
        if (resumeNext) {
            final ActivityStack topStack = mStackSupervisor.getFocusedStack();
            //  如果当前没有关机或者休眠的话
            if (!mService.isSleepingOrShuttingDownLocked()) {
                //  调用该函数开始resumeActivity
                mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
            } else {
                mStackSupervisor.checkReadyForSleepLocked();
                ActivityRecord top = topStack.topRunningActivityLocked();
                if (top == null || (prev != null && top != prev)) {
                    mStackSupervisor.resumeFocusedStackTopActivityLocked();
                }
            }
        }

ActivityStack. resumeTopActivityInnerLocked（System_Server进程）

当Pausing完毕后，会执行ActivityStackSupervisor.resumeFocusedStackTopActivityLocked来开始Resume下一个要显示的Activity。最终会执行到resumeTopActivityInnerLocked该函数。

回调ActivityResult的结果，即回调onActivityResult处理返回数据
回调newIntent，即回调onNewIntent
最后开始处理resume流程

 // Deliver all pending results.
                ArrayList<ResultInfo> a = next.results;
                if (a != null) {
                    final int N = a.size();
                    if (!next.finishing && N > 0) {
                        if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                                "Delivering results to " + next + ": " + a);
                        //  如果有ActivityResult需要回调的话，先回调onActivityResult
                        next.app.thread.scheduleSendResult(next.appToken, a);
                    }
                }

                if (next.newIntents != null) {
                    //  如果有newIntent的话，先回调onNewIntent
                    next.app.thread.scheduleNewIntent(
                            next.newIntents, next.appToken, false /* andPause */);
                }

               ... 
              //  开始回调onResume
                next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
                        mService.isNextTransitionForward(), resumeAnimOptions);

ActivityStack.finishCurrentActivityLocked（System_Server进程）

该函数主要用来完成销毁当前Activity。

//  获取下一个要Resume的Activity
final ActivityRecord next = mStackSupervisor.topRunningActivityLocked()

if (mode == FINISH_AFTER_VISIBLE && (r.visible || r.nowVisible)
                && next != null && !next.nowVisible) {
            //  如果要销毁的Activity目前还是可见的，而要Resume的Activity是不可见的
            //  那么就先把要销毁的Activity放到Stopping队列中，先把要展示的Activity
            //  先进行Resume操作，等Resume完后，回头再销毁这个Activity
            if (!mStackSupervisor.mStoppingActivities.contains(r)) {
                addToStopping(r, false /* scheduleIdle */, false /* idleDelayed */);
            }
            ...
            //  将要销毁的Activity改状态为STOPPING
            r.state = STOPPING;
            ...
            return r;
        }
//  如果mode不是FINISH_AFTER_VISIBLE的话，则从各种队列中先清除
        mStackSupervisor.mStoppingActivities.remove(r);
        mStackSupervisor.mGoingToSleepActivities.remove(r);
        mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(r);
        if (mResumedActivity == r) {
            mResumedActivity = null;
        }
        //  将状态从STOPPING变成FINISHING
       final ActivityState prevState = r.state;
        r.state = ActivityState.FINISHING;
if (mode == FINISH_IMMEDIATELY
                || (prevState == ActivityState.PAUSED
                    && (mode == FINISH_AFTER_PAUSE || mStackId == PINNED_STACK_ID))
                || finishingActivityInNonFocusedStack
                || prevState == STOPPING
                || prevState == STOPPED
                || prevState == ActivityState.INITIALIZING) {
          ... 
          //  开始销毁Activity
            boolean activityRemoved = destroyActivityLocked(r, true, "finish-imm");

            if (finishingActivityInNonFocusedStack) {
                //  如果Activity不在Focus的Stack中的话，则确保Resume的Activity窗口是可见的
                mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
            }
            if (activityRemoved) {
                mStackSupervisor.resumeFocusedStackTopActivityLocked();
            }
            return activityRemoved ? null : r;
        }

ActivityThread.handleResumeActivity（用户进程）

待Activity处于Resume状态时，ActivityThread会调用该函数。

回调Activity的onRestart、onStart、onResume函数
处理Activity Window相关的数据保存
如果是ActivityManagerService来的请求，则会将Idler加到主线程队列中，等待主线程空闲时，回调ActivityManagerService.activityIdle
回调ActivityManagerService. activityResumed告知已经处于Resume状态

//  获取Activity在用户进程的ActivityClientRecord
ActivityClientRecord r = mActivities.get(token);
...
//  回调Activity的onResume
 r = performResumeActivity(token, clearHide, reason);

if (r != null) {
            final Activity a = r.activity;
            ...
            //  处理Window相关的事情
            ...
            //  如果是从ActivityManagerService要求的Resume操作的话
            if (!r.onlyLocalRequest) {
                r.nextIdle = mNewActivities;
                mNewActivities = r;
                if (localLOGV) Slog.v(
                    TAG, "Scheduling idle handler for " + r);
                //  将Idler添加到Looper的队列中，而在Idler中
                //  当主线程队列空闲的时候会回调am.activityIdle
                Looper.myQueue().addIdleHandler(new Idler());
            }
            r.onlyLocalRequest = false;

            // Tell the activity manager we have resumed.
            if (reallyResume) {
                try { 
                    //  告知ActivityManagerService当前的Activity处于Resume状态了
                    ActivityManager.getService().activityResumed(token);
                } catch (RemoteException ex) {
                    throw ex.rethrowFromSystemServer();
                }
            }

ActivityStackSupervisor.activityIdleInternal（System_Server进程）

当用户进程处于空闲状态时，就会回调ActivityManagerService.activityIdle。而在该接口中，就会调用activityIdleInternalLocked函数。

//  根据token找到已经Resume的ActivityRecord
 ActivityRecord r = ActivityRecord.forTokenLocked(token);
 if (r != null) {
        //   先移除IDLE_TIMEOUT_MSG的消息
        mHandler.removeMessages(IDLE_TIMEOUT_MSG, r);
        ...
}
//  从mStoppingActivities列表中将要stop的Activity选出来
final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r,true /* remove */, processPausingActivities);
//  获取StopActivity的数量
 NS = stops != null ? stops.size() : 0;
//  判断当前是否有Finishing的Activity
 if ((NF = mFinishingActivities.size()) > 0) {
        finishes = new ArrayList<>(mFinishingActivities);
         mFinishingActivities.clear();
 }
...
//  遍历所有的StopActivity
 for (int i = 0; i < NS; i++) {
            r = stops.get(i);
            final ActivityStack stack = r.getStack();
            if (stack != null) {
            //  判断是否要finish，之前有标记过该位
                if (r.finishing) {
                    // 如果finishing的话，则调用该函数立即finish
                    stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false);
                } else {
                    //  否则只是调用onStop
                    stack.stopActivityLocked(r);
                }
            }
        }
        //  销毁finishing队列中的Activity
        for (int i = 0; i < NF; i++) {
            r = finishes.get(i);
            final ActivityStack stack = r.getStack();
            if (stack != null) {
                activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle");
            }
        }

ActivityStack.destroyActivityLocked（System_Server进程）

//  清理ActivityRecord相关的队列与窗口
  cleanUpActivityLocked(r, false, false);
//  判断Activity进程是否存在
  final boolean hadApp = r.app != null;
if (hadApp) {
      //  如果是finishing的话，则是从Activities中移除
     if (removeFromApp) {
        //  移除该ActivityRecord
         r.app.activities.remove(r);
     }
     ...
      boolean skipDestroy = false;
      try {
                //  回调用户进程的scheduleDestroyActivity，开始销毁Activity
                r.app.thread.scheduleDestroyActivity(r.appToken, r.finishing,
                        r.configChangeFlags);
      } catch (Exception e) {
                if (r.finishing) {
                    removeActivityFromHistoryLocked(r, reason + " exceptionInScheduleDestroy");
                    removedFromHistory = true;
                    //  如果销毁失败的话，置标识位
                    skipDestroy = true;
                }
       }
      ...
      if (r.finishing && !skipDestroy) {
               //  如果执行了Activity用户进程的onDestroy的话，
                r.state = ActivityState.DESTROYING;
               //  则需要定时检测用户进程将销毁成功的消息发送回来
                Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG, r);
                mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT);
            } else {
                //  如果出现意外了，则要清理app了
                r.state = ActivityState.DESTROYED;
                r.app = null;
            }

二、Activity的4大启动模式，与开发中需要注意的问题，如onNewIntent() 的调用

这道题想考察什么？

是否了解Activity的启动模式？

考察的知识点

Activity的启动模式
不同启动模式运用场景
开发中的注意事项

考生应该如何回答

一. Android启动模式详解

image.png

1. Standard 标准模式

说明： Android创建Activity时的默认模式，如果没有为Activity设置启动模式的话，默认为标准模式。每次启动一个Activity都会重新创建一个新的实例入栈，不管这个实例是否存在。

生命周期： 如上所示，每次被创建的实例Activity 的生命周期符合典型情况，它的onCreate、onStart、onResume都会被调用。

举例： 此时Activity 栈中以此有A、B、C三个Activity，此时C处于栈顶，启动模式为Standard 模式。若在C Activity中添加点击事件，需要跳转到另一个同类型的C Activity。结果是另一个C Activity进入栈中，成为栈顶。

image.png

2. SingleTop 栈顶复用模式

说明：分两种处理情况：需要创建的Activity已经处于栈顶时，此时会直接复用栈顶的Activity，不会再创建新的Activity；若需要创建的Activity不处于栈顶，此时会重新创建一个新的Activity入栈，同Standard模式一样。

生命周期：若情况一中栈顶的Activity被直接复用时，它的onCreate、onStart不会被系统调用，因为它并没有发生改变，但是一个新的方法 onNewIntent会被回调（Activity被正常创建时不会回调此方法）。

举例：此时Activity 栈中以此有A、B、C三个Activity，此时C处于栈顶，启动模式为SingleTop 模式。情况一：在C Activity中添加点击事件，需要跳转到另一个同类型的C Activity。结果是直接复用栈顶的C Activity。情况二：在C Activity中添加点击事件，需要跳转到另一个A Activity。结果是创建一个新的Activity入栈，成为栈顶。

[图片上传失败...(image-6e3769-1685949643113)]

3. SingleTask 栈内复用模式

说明：若需要创建的Activity已经处于栈中时，此时不会创建新的Activity，而是将存在栈中的Activity上面的其它Activity全部销毁，使它成为栈顶。

生命周期：同SingleTop 模式中的情况一相同，只会重新回调Activity中的 onNewIntent方法

举例：此时Activity 栈中以此有A、B、C三个Activity，此时C处于栈顶，启动模式为SingleTask 模式。情况一：在C Activity中添加点击事件，需要跳转到另一个同类型的C Activity。结果是直接用栈顶的C Activity。情况二：在C Activity中添加点击事件，需要跳转到另一个A Activity。结果是将A Activity上面的B、C全部销毁，使A Activity成为栈顶。

[图片上传失败...(image-bf892f-1686034647957)]

4. SingleInstance 单实例模式

说明： SingleInstance比较特殊，是全局单例模式，是一种加强的SingleTask模式，它除了具有它所有特性外，还加强了一点：具有此模式的Activity只能单独位于一个任务栈中。这个常用于系统中的应用，例如Launch、锁屏键的应用等等，整个系统中只有一个！所以在我们的应用中一般不会用到，了解即可。

举例： 比如 A Activity是该模式，启动A后，系统会为它创建一个单独的任务栈，由于栈内复用的特性，后续的请求均不会创建新的Activity，除非这个独特的任务栈被系统销毁。

二.启动模式的使用方法

1. 在 Manifest.xml中指定Activity启动模式

一种静态注册，在Manifest.xml文件中声明Activity的同时指定它的启动模式，这样在代码中跳转时会按照指定的模式来创建Activity。例子如下：

<activity android:name="..activity.MultiportActivity" android:launchMode="singleTask"/>

2. 启动Activity时，在Intent中指定启动模式去创建Activity

一种动态的启动模式，在new 一个Intent后，通过Intent的addFlags方法去动态指定一个启动模式。例子如下：

Intent intent = new Intent();
intent.setClass(context, MainActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);

注意： 以上两种方式都可以为Activity指定启动模式，但是二者还是有不一样的。

（1）优先级：动态指定方式即第二种比第一种优先级要高，若两者同时存在，是以第二种方式为准。 （2）限定范围：第一种方式无法为Activity直接指定 FLAG_ACTIVITY_CLEAR_TOP 标识，第二种方式无法为Activity指定 singleInstance 模式。

三. Activity 的 Flags

标记位既可以设定Activity的启动模式，如同上面介绍的，在动态指定启动模式，比如 FLAG_ACTIVITY_NEW_TASK 和 FLAG_ACTIVITY_SINGLE_TOP 等。它还可以影响Activity 的运行状态，比如 FLAG_ACTIVITY_CLEAN_TOP 和 FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS 等。下面介绍几个主要的标记位，不要死记，理解几个即可，需要时再查官方文档。

1. FLAG_ACTIVITY_NEW_TASK

作用是为Activity指定 “SingleTask”启动模式，跟在AndroidMainfest.xml指定效果相同。

2. FLAG_ACTIVITY_SINGLE_TOP

作用是为Activity指定 “SingleTop”启动模式，跟在AndroidMainfest.xml指定效果相同。

3. FLAG_ACTIVITY_CLEAN_TOP

具有此标记位的Activity，启动时会将与该Activity在同一任务栈的其它Activity出栈，一般与SingleTask启动模式一起出现。它会完成SingleTask的作用，但其实SingleTask启动模式默认具有此标记位的作用

4.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS

具有此标记位的Activity不会出现在历史Activity的列表中，使用场景：当某些情况下我们不希望用户通过历史列表回到Activity时，此标记位便体现了它的效果。它等同于在xml中指定Activity的属性：

android:excludeFromRecents="trure"

四. 启动模式的实际应用场景

这四种模式中的Standard模式是最常见的一种，没有什么特别注意，而SingleInstance模式是整个系统的单例模式，在我们的应用中一般不会应用到，所以，这里就具体讲解 SingleTop 和 SingleTask模式的运用场景：

SingleTask模式的运用场景最常见的应用场景就是保持我们应用开启后只有一个Activity的实例，最典型的例子就是应用中展示的主页（Home页）。假设用户在主页跳转到其它页面，执行多次操作后想返回到主页，如果不使用SingleTask模式，在点击返回的过程中会多次看到主页，这明显就是设计不合理了。

SingleTop模式的运用场景如果你在当前的Activity中又要启动同类型的Activity，此时建议将此类型Activity的启动模式指定为SingleTop，可以减少Activity的创建，节省内存！

注意：复用Activity时的生命周期回调这里还需要考虑一个Activity跳转时携带页面参数的问题。

因为当一个Activity设置了SingleTop或者SingleTask模式后，跳转此Activity出现复用原有Activity的情况时，此Activity的onCreate方法将不会再次执行！onCreate方法只会在第一次创建Activity时被执行。

而一般onCreate方法中会进行该页面的数据初始化、UI初始化，如果页面的展示数据无关页面跳转传递的参数，则不必担心此问题，若页面展示的数据就是通过getInten() 方法来得到，那么问题就会出现：getInten()获取的一直都是旧数据，根本无法接收跳转时传送的新数据！下面，通过一个例子来详解：

Manifest.xml
        <activity
            android:name=".activity.CourseDetailActivity"
            android:launchMode="singleTop"
            android:screenOrientation="portrait" />

public class CourseDetailActivity extends BaseActivity{
  ......
  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_course_detail_layout);
        initData();
        initView();
    }

   //初始化数据
    private void initData() {
        Intent intent = getIntent();
        mCourseID = intent.getStringExtra(COURSE_ID);
    }

    //初始化UI
    private void initView() {
    ......
    }
    ......
}

以上代码中的CourseDetailActivity在配置文件中配置了启动模式是SingleTop模式，根据上面启动模式的介绍可得知，当CourseDetailActivity处于栈顶时，再次跳转页面到CourseDetailActivity时会直接复用原有的Activity，而且此页面需要展示的数据是从getIntent(）方法得来，可是initData()方法不会再次被调用，此时页面就无法显示新的数据。

当然这种情况系统早就为我们想过了，这时我们需要另外一个回调 onNewIntent（Intent intent）方法，此方法会传入最新的intent，这样我们就可以解决上述问题。这里建议的方法是重新去setIntent，然后重新去初始化数据和UI，代码如下所示：

/*
* 复用Activity时的生命周期回调
*/
    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        setIntent(intent);
        initData();
        initView();
    }

这样，在一个页面中可以重复跳转并显示不同的内容。

三、Intent显示跳转与隐式跳转，如何使用？（美团）

这道题想考察什么？

是否了解Intent跳转的真实场景使用，是否熟悉Intent使用场景？

考察的知识点

Intent跳转处理在项目中使用与基本知识

考生应该如何回答

1.显示意图与隐式意图的区别，说说你的简单理解？

答：

在Activity的跳转中

Activity的跳转需要创建Intent对象，通过设置intent对象的参数指定要跳转Activity 通过设置Activity的包名和类名实现跳转，称为显式意图通过指定动作实现跳转，称为隐式意图

显式意图

跳转到同一项目下的另一个Activity，直接指定该Activity的字节码即可 Intent intent = new Intent(); intent.setClass(this, SecondActivity.class); startActivity(intent);
跳转至其他App中的Activity，需要指定该应用的包名和该Activity的类名 Intent intent = new Intent(); //启动系统自带的拨号器应用 intent.setClassName("com.android.dialer", "com.android.dialer.DialtactsActivity"); startActivity(intent);

隐式意图

隐式意图跳转至指定Activity Intent intent = new Intent(); //启动系统自带的拨号器应用 intent.setAction(Intent.ACTION_DIAL); startActivity(intent);
要让一个Activity可以被隐式启动，需要在清单文件的activity节点中设置intent-filter子节点 <intent-filter > <action android:name="com.itheima.second"/> <data android:scheme="asd" android:mimeType="aa/bb"/> <category android:name="android.intent.category.DEFAULT"/> </intent-filter>
action 指定动作（可以自定义，可以使用系统自带的）
data 指定数据（操作什么内容）
category 类别（默认类别，机顶盒，车载电脑）
隐式意图启动Activity，需要为intent设置以上三个属性，且值必须与该Activity在清单文件中对三个属性的定义匹配
intent-filter节点及其子节点都可以同时定义多个，隐式启动时只需与任意一个匹配即可

获取通过setData传递的数据

/ /获取启动此Activity的intent对象 Intent intent = getIntent(); Uri uri = intent.getData();

显式意图和隐式意图的应用场景

显式意图用于启动同一应用中的Activity
隐式意图用于启动不同应用中的Activity
如果系统中存在多个Activity的intent-filter同时与你的intent匹配，那么系统会显示一个对话框，列出所有匹配的Activity，由用户选择启动哪一个

2.你在工作中，留意过在Android中Intent显示跳转和隐式跳转，如何使用？

答：

显式 Intent 调用：

    // 创建一个显式的 Intent 对象(方法一：在构造函数中指定)
     Intent intent = new Intent(Intent_Demo1.this, Intent_Demo1_Result1.class);

     Bundle bundle = new Bundle();
     bundle.putString("id", strID);
     intent.putExtras(bundle);

     intent.putExtra("name", "derry");
     intent.putExtra("userInfo", new UserInfo(1, "name"));
     startActivity(intent);

     // 创建一个显式的 Intent 对象(方法二：用 setClass 方法)
     Intent intent = new Intent();
     Bundle bundle = new Bundle();
     bundle.putString("id", strID);
     intent.setClass(Intent_Demo1.this, Intent_Demo1_Result1.class);
     intent.putExtras(bundle);
     startActivity(intent);

     // 创建一个显式的 Intent 对象(方法三：用 setClass 方法)
     Intent intent = new Intent();
     Bundle bundle = new Bundle();
     bundle.putString("id", strID);
     intent.setClassName(Intent_Demo1.this, "com.great.activity_intent.Intent_Demo1_Result1");
     intent.putExtras(bundle);
     startActivity(intent);

     //创建一个显式的 Intent 对象(方法四：用 setComponent 方法)
     Intent intent = new Intent();
     Bundle bundle = new Bundle();
     bundle.putString("id", strID);
     //setComponent方法的参数：ComponentName
     intent.setComponent(new ComponentName(Intent_Demo1.this,
                                           Intent_Demo1_Result1.class));
     intent.putExtras(bundle);
     startActivity(intent);

Intent隐式跳转 Action:

    // 创建一个隐式的 Intent 对象：Action 动作
    /**
     * 这里指定的是 AndroidManifest.xml 文件中配置的
     * <intent-filter>标签中的<action android:name="com.great.activity_intent
     .Intent_Demo1_Result3" />
     * 所在的 Activity，注意这里都要设置 <category  android:name="android.intent.
     category.DEFAULT" />
     */

    Intent intent = new Intent();
    // 设置 Intent 的动作
    intent.setAction("com.great.activity_intent.Intent_Demo1_Result3");
    Bundle bundle = new Bundle();
    bundle.putString("id", strID);
    intent.putExtras(bundle);
    startActivity(intent);

AndroidManifest.xml:

        <activity android:name="Intent_Demo1_Result3"
                  android:label="Intent_Demo1_Result3">
            <intent-filter>
                <action android:name="com.great.activity_intent.Intent_Demo1_Result3" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>

Category 类别:

// 创建一个隐式的 Intent 对象：Category 类别
Intent intent = new Intent();
intent.setAction("com.great.activity_intent.Intent_Demo1_Result33");
/**
 * 不指定 Category 或 只指定 AndroidManifest.xml 文件中 <intent-filter> 
 * 标签中配置的任意一个 Category
 * <category android:name="android.intent.category.DEFAULT" /> 除外，就可以访问该 Activity，
 */
intent.addCategory(Intent.CATEGORY_INFO);
intent.addCategory(Intent.CATEGORY_DEFAULT);
Bundle bundle = new Bundle();
bundle.putString("id", strID);
intent.putExtras(bundle);
startActivity(intent);

AndroidManifest.xml:

        <activity android:name="Intent_Demo1_Result2"
                  android:label="Intent_Demo1_Result2">
            <intent-filter>
                
                <category android:name="android.intent.category.INFO" />
                <category android:name="android.intent.category.BROWSABLE" />
                <category android:name="android.intent.category.DEFAULT" />
                
            </intent-filter>
        </activity>

Date 数据跳转:

// 创建一个隐式的 Intent 对象，方法四：Date 数据
Intent intent = new Intent();
Uri uri = Uri.parse("http://www.great.org:8080/folder/subfolder/etc/abc.pdf");

// 注：setData、setDataAndType、setType 这三种方法只能单独使用，不可共用
// 要么单独以 setData 方法设置 URI
// intent.setData(uri);
// 要么单独以 setDataAndType 方法设置 URI 及 mime type
intent.setDataAndType(uri, "text/plain");
// 要么单独以 setDataAndType 方法设置 Type
//intent.setType("text/plain");

/**
 * 不指定 Category 或 只指定 AndroidManifest.xml 文件中 <intent-filter> 标签中配置的任意一个 Category
 * <category android:name="android.intent.category.DEFAULT" /> 除外，就可以访问该 Activity
 */
Bundle bundle = new Bundle();
bundle.putString("id", strID);
intent.putExtras(bundle);
startActivity(intent);

AndroidManifest.xml:

        <activity android:name="Intent_Demo1_Result2"
                  android:label="Intent_Demo1_Result2">
            <intent-filter>
                <category android:name="android.intent.category.DEFAULT" />
                <data
                    android:scheme="http"
                    android:host="www.great.org"
                    android:port="8080"
                    android:pathPattern=".*pdf"
                    android:mimeType="text/plain"/>
            </intent-filter>
        </activity>

四、Activity A跳转B，B跳转C，A不能直接跳转到C，A如何传递消息给C？(美团)

这道题想考察什么？

是否了解Activity间信息传递？

考察的知识点

消息传递的机制
事件总线
本地数据存储

考生应该如何回答

消息通信机制

Android 开发之中我们常常需要应用到消息传递，消息的传递有多种方式。消息传递的作用不必多说，主要是在不同的组件之间传播消息或者共享某些状态等，以下是几种常用的消息传递机制：

静态变量
全局变量及Application
Android系统剪切板
本地化存储方式
Android组件
EventBus
LiveDataBus

静态变量和全局变量、Application && Android 系统剪切板

这三种方式其实非常类似，静态变量和全局变量都可以采用static的方式来声明，如果采用这种方式还是推荐用一个专门的类结合单体模式进行管理，尽量减少对内存的消耗。而使用系统剪切板的方式一般也很少用，比较多限制，容易丢失数据，几乎没有看到有这样用的。

Application: 可以通过在Application 中的全局静态变量来实现

这里还有利用Application进行共享Handler来消息传递，方法很简单，就是在Application中定义一个全局的Handler，虽然这种方法可以实现，但是却保留了在整个App中保留了全局的Handler，如果在Handler的设置中引用了某个Activity，就容易造成内存泄露了。

本地化存储方式

本地存储方式有如下三种：

SharedPreference SQLite File

这三种方式的好处就是他们是持久存储的，只要不卸载APP或者不删除文件就可以一直保存下去，而且也几乎没有大小的限制，可以做一些统计。不过缺点也比较明显，这三种方式最好是采用多线程来进行读写，尤其是数据量大的时候，我们知道，IO的操作是非常耗费时间的，所以尽量不要在UI线程中使用这三种方式读写。

示例代码：

SharedPreference:

// 发送消息
SharedPreferences.Editor editor = MainActivity.this.getSharedPreferences("SEND", Context.MODE_PRIVATE).edit();
editor.putString("SEND","SharedPreferences的消息");
editor.apply();
startActivity(new Intent(MainActivity.this,ReceiveActivity.class));
// 接收消息
SharedPreferences sharedPreferences = getSharedPreferences("SEND", MODE_PRIVATE);
textView.setText(sharedPreferences.getString("SEND", ""));
附支持的数据类型如下：

SQLite

SQLite需要先创建数据库，后面向数据库中插入和读取数据实现信息共享。首先要继承SQLiteOpenHelper并在onCreate方法中创建数据库：

sqLiteDatabase.execSQL("CREATE TABLE Teacher(teacherId INTEGER PRIMARY KEY" +
           " AUTOINCREMENT,userId VARCHAR(20) UNIQUE,name VARCHAR(20),password VARCHAR(20))");

向数据库中插入：

String type = "Teacher";
sqLiteDatabase.execSQL("INSERT INTO " + type + "(userId,name,password) values (?,?,?)",
                    new String[]{userId, userName, userPassword});

从数据库中读取信息：

String type = "Teacher";
Cursor cursor = sqLiteDatabase.rawQuery("SELECT * FROM " + type + " WHERE userId = ?",
         new String[]{userId.getText().toString()});
if(cursor.moveToFirst()){
         String userId = cursor.getString(cursor.getColumnIndex("userId"));
         String name = cursor.getString(cursor.getColumnIndex("name"));
}
cursor.close();

File

文件方式要记得申请权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

写入数据：

try {
    File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + "/data/temp.txt");
    FileOutputStream out = new FileOutputStream(file);
    out.write("message".getBytes(Charset.forName("UTF-8")));
    out.flush();
    out.close();
} catch (IOException e) {
    e.printStackTrace();
}

读取数据：

try {
    FileInputStream in = new FileInputStream(Environment.getExternalStorageDirectory().getAbsolutePath() + "/temp.txt");
    byte[] reader = new byte[256];
    int read = in.read(reader);
    String content = "";
    if (read > 0)
        content = new String(reader, 0, read, Charset.forName("UTF-8"));
    Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
} catch (IOException e) {
    e.printStackTrace();
}

Broadcast方式

使用组件也就是说利用Broadcast进行消息传递。优选LocalBroadcast:

LocalBroadcastManager.getInstance(context).registerReceiver(@NonNull BroadcastReceiver receiver, @NonNull IntentFilter filter) LocalBroadcastManager.getInstance(context).sendBroadcast(intent); 如果说使用Android 进行消息传递的话，Broadcast是最好的了，顾名思义的我们清楚，广播就是有一个发送消息和接受消息的过程，所以可以用于消息传递。示例：

注册广播和接受消息

        // 定义广播
        final Button broadButton = findViewById(R.id.broadcast);
        final BroadcastReceiver receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                broadButton.setText("" + intent.getStringExtra("data"));
            }
        };
        broadButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                registerReceiver(receiver,new IntentFilter("broadsend.action"));
                startActivity(new Intent(MainActivity.this,ReceiveActivity.class));
            }
        });

发送广播：

    Intent intent = new Intent("broadsend.action");
    intent.putExtra("data","send");
    sendBroadcast(intent);

这种方式有一些限制，因为接收事件要比发送事件先定义好，所以只能在当前Activity中注册广播，在跳转的Activity发送，所以严格说这不能算是消息传递，因为是单向传递的。

Service方式

Service可以结合Broadcast进行消息传递，不过这样子就不能算是Service了。使用Service进行消息传递，我们可以定义接口，并利用接口进行消息传递。定义消息接收的接口：

    public static MessageCallback messageCallback = new MessageCallback() {
        @Override
        public void onMessage(String message) {
            Log.d("tag","" + message);
        }
    };
    public interface MessageCallback{
        public void onMessage(String message);
    }

进行消息发送：

MainActivity.messageCallback.onMessage("message"); 有的人讲这种方式不久和共享变量一样了吗，不不不，这是完全不一样的，如果是共享变量的话，当变量被改变了是不是还得程序员或者用户去响应这种改变呢，这就很不好了，而采用这种静态接口的方法，只要函数被调用，就立刻可以进行响应并处理，不是很方便吗。当然也可以想办法将接口的对象进行传递，例如利用Broadcast来进行传递。

EventBus

EventBus 是一款针对Android的发布以及订阅事件总线，使用它可以很方便的进行信息传递，而且使用起来很方便。首先是定义一个消息：

public class Event {
    private String message;
    public Event(){
        message = "EventBus message";
    }

    public void setMessage(String message){
        this.message = message;
    }
     
    public String getMessage(){
        return message;
    }
}

发送消息：

这里使用了postSticky，这是发送的粘性广播，使用这个发送就可以先发送信息再进行注册，后注册的也能接收到前面发送的广播。当然还有其他的使用方式。

EventBus.getDefault().postSticky(new Event());
startActivity(new Intent(MainActivity.this,ReceiveActivity.class));

注册事件的订阅者：

EventBus.getDefault().register(this); 接受粘性广播：

@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
public void onEventThread(Event event) {
    textView.setText(event.getMessage());
}

LiveDataBus

LiveDataBus是通过包装LiveData实现的消息总线组件，如果同学对LiveData不熟悉的同学，可以找到相对应的章节先学习一下。

LiveDataBus 的封装

通过 map 维护一个消息事件和 MutableLiveData 的映射关系，MutableLiveData 的类型默认为 Object，接收任意类型，实现总线通信将 LiveDataBus 封装为一个单例类。
消息注册时，如果当前 map 中不存在，则先将消息和对应的 MutableLiveData 对象放入维护的 map 中，添加映射关系，返回当前 map 中缓存的 MutableLiveData 对象

LiveDataBus 的组成

消息消息可以是任何的Object，可以定义不同类型的消息，如 Boolean、String。也可以定义自定义类型的消息。
消息总线 消息总线通过单例实现，不同的消息通道存放在一个 HashMap中。
订阅订阅者通过 with 方式获取消息通道，然后调用 observe 订阅这个通道的消息。
发布发布者通过 with 获取消息通道，然后调用 setValue 或者 postValue 发布消息。

LiveDataBus 的实现

public final class LiveDataBus {

    private final Map<String, MutableLiveData<Object>> bus;

    private LiveDataBus() {
        bus = new HashMap<>();
    }

    private static class SingletonHolder {
        private static final LiveDataBus DATA_BUS = new LiveDataBus();
    }

    public static LiveDataBus get() {
        return SingletonHolder.DATA_BUS;
    }

    public <T> MutableLiveData<T> with(String target, Class<T> type) {
        if (!bus.containsKey(target)) {
            bus.put(target, new MutableLiveData<>());
        }
        return (MutableLiveData<T>) bus.get(target);
    }

    public MutableLiveData<Object> with(String target) {
        return with(target, Object.class);
    }
}

注册订阅

LiveDataBus.get().with("key_test", Boolean.class)
    .observe(this, new Observer<Boolean>() {
        @Override
        public void onChanged(@Nullable Boolean aBoolean) {
        }
 });

发送消息

LiveDataBus.get().with("key_test").setValue(true);

今天的面试分享到此结束拉~下期在见

全面总结Android面试知识要点：Android组件内核面试题

一、Acitvity的生命周期，如何摧毁一个Activity? (美团)

这道题想考察什么

考察的知识点

考生应该如何回答

注意事项

Activity销毁的相关流程图

ActivityFinish流程以及结果接收的流程

setResult以及finish（用户进程）

ActivityManagerService.finishActivity（System_Server进程）

ActivityStack.finishActivityLocked（System_Server进程）

ActivityStack. startPausingLocked（System_Server进程）

ActivityStack.activityPausedLocked（System_Server进程）

ActivityStack.completePauseLocked（System_Server进程）

ActivityStack. resumeTopActivityInnerLocked（System_Server进程）

ActivityStack.finishCurrentActivityLocked（System_Server进程）

ActivityThread.handleResumeActivity（用户进程）

ActivityStackSupervisor.activityIdleInternal（System_Server进程）

ActivityStack.destroyActivityLocked（System_Server进程）

二、Activity的4大启动模式，与开发中需要注意的问题，如onNewIntent() 的调用

这道题想考察什么？

考察的知识点

考生应该如何回答

一. Android启动模式详解

1. Standard 标准模式

2. SingleTop 栈顶复用模式

3. SingleTask 栈内复用模式

4. SingleInstance 单实例模式

二.启动模式的使用方法

1. 在 Manifest.xml中指定Activity启动模式

2. 启动Activity时，在Intent中指定启动模式去创建Activity

三. Activity 的 Flags

1. FLAG_ACTIVITY_NEW_TASK

2. FLAG_ACTIVITY_SINGLE_TOP

3. FLAG_ACTIVITY_CLEAN_TOP

4.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS

四. 启动模式的实际应用场景

三、Intent显示跳转与隐式跳转，如何使用？（美团）

这道题想考察什么？

考察的知识点

考生应该如何回答

1.显示意图与隐式意图的区别，说说你的简单理解？

显式意图

隐式意图

获取通过setData传递的数据

显式意图和隐式意图的应用场景

显式 Intent 调用：

Intent隐式跳转 Action:

AndroidManifest.xml:

Category 类别:

AndroidManifest.xml:

Date 数据 跳转:

AndroidManifest.xml:

四、Activity A跳转B，B跳转C，A不能直接跳转到C，A如何传递消息给C？(美团)

这道题想考察什么？

考察的知识点

考生应该如何回答

消息通信机制

静态变量 和 全局变量、Application && Android 系统剪切板

本地化存储方式

Broadcast方式

注册广播和接受消息

发送广播：

Service方式

EventBus

发送消息：

注册事件的订阅者：

LiveDataBus

LiveDataBus 的封装

LiveDataBus 的组成

LiveDataBus 的实现

注册订阅

发送消息

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Date 数据跳转:

静态变量和全局变量、Application && Android 系统剪切板