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

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

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

这道题想考察什么
  1. 是否了解AMS、Activity的相关知识？
考察的知识点
  1. AMS的基本知识
  2. 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() 的调用

这道题想考察什么？
  1. 是否了解Activity的启动模式？
考察的知识点
  1. Activity的启动模式
  2. 不同启动模式运用场景
  3. 开发中的注意事项
考生应该如何回答
一. 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模式的运用场景：

  1. SingleTask模式的运用场景 最常见的应用场景就是保持我们应用开启后只有一个Activity的实例，最典型的例子就是应用中展示的主页（Home页）。假设用户在主页跳转到其它页面，执行多次操作后想返回到主页，如果不使用SingleTask模式，在点击返回的过程中会多次看到主页，这明显就是设计不合理了。
  1. SingleTop模式的运用场景 如果你在当前的Activity中又要启动同类型的Activity，此时建议将此类型Activity的启动模式指定为SingleTop，可以减少Activity的创建，节省内存！
  1. 注意：复用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显示跳转与隐式跳转，如何使用？（美团）

这道题想考察什么？
  1. 是否了解Intent跳转的真实场景使用，是否熟悉Intent使用场景？
考察的知识点
  1. 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？(美团)

这道题想考察什么？
  1. 是否了解Activity间信息传递？
考察的知识点
  1. 消息传递的机制
  2. 事件总线
  3. 本地数据存储
考生应该如何回答
消息通信机制

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);

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

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 201,468评论 5赞 473
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 84,620评论 2赞 377
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 148,427评论 0赞 334
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,160评论 1赞 272
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,197评论 5赞 363
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,334评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,775评论 3赞 393
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,444评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,628评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,459评论 2赞 317
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,508评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,210评论 3赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,767评论 3赞 303
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,850评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,076评论 1赞 258
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,627评论 2赞 348
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,196评论 2赞 341

推荐阅读更多精彩内容