Android系统默认Home应用程序（Launcher）的启动过程源代码分析

时间：2022-02-28 16:11:22

在前面一篇文章中，我们分析了Android系统在启动时安装应用程序的过程，这些应用程序安装好之后，还需要有一个 Home应用程序来负责把它们在桌面上展示出来，在Android系统中，这个默认的Home应用程序就是Launcher了，本文将详细分析 Launcher应用程序的启动过程。

Android系统的Home应用程序Launcher是由ActivityManagerService启动的，而 ActivityManagerService和PackageManagerService一样，都是在开机时由SystemServer组件启动 的，SystemServer组件首先是启动ePackageManagerServic，由它来负责安装系统的应用程序，具体可以参考前面一篇文章Android应用程序安装过程源代码分析， 系统中的应用程序安装好了以后，SystemServer组件接下来就要通过ActivityManagerService来启动Home应用程序 Launcher了，Launcher在启动的时候便会通过PackageManagerServic把系统中已经安装好的应用程序以快捷图标的形式展示 在桌面上，这样用户就可以使用这些应用程序了，整个过程如下图所示：

Android系统默认Home应用程序（Launcher）的启动过程源代码分析

点击查看大图

下面详细分析每一个步骤。

Step 1. SystemServer.main

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 1。

Step 2. SystemServer.init1

这个函数是一个JNI方法，实现在 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 2。

Step 3. libsystem_server.system_init

函数system_init实现在libsystem_server库中，源代码位于frameworks/base/cmds/system_server/library/system_init.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 3。

Step 4. AndroidRuntime.callStatic

这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 4。

Step 5. SystemServer.init2

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 5。

Step 6. ServerThread.run

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 6。

Step 7. ActivityManagerService.main

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public static final Context main(int factoryTest) {
  5. AThread thr = new AThread();
  6. thr.start();
  7. synchronized (thr) {
  8. while (thr.mService == null) {
  9. try {
  10. thr.wait();
  11. } catch (InterruptedException e) {
  12. }
  13. }
  14. }
  15. ActivityManagerService m = thr.mService;
  16. mSelf = m;
  17. ActivityThread at = ActivityThread.systemMain();
  18. mSystemThread = at;
  19. Context context = at.getSystemContext();
  20. m.mContext = context;
  21. m.mFactoryTest = factoryTest;
  22. m.mMainStack = new ActivityStack(m, context, true);
  23. m.mBatteryStatsService.publish(context);
  24. m.mUsageStatsService.publish(context);
  25. synchronized (thr) {
  26. thr.mReady = true;
  27. thr.notifyAll();
  28. }
  29. m.startRunning(null, null, null, null);
  30. return context;
  31. }
  32. ......
  33. }

这个函数首先通过AThread线程对象来内部创建了一个ActivityManagerService实例，然后将这个实例保存其成员变量 mService中，接着又把这个ActivityManagerService实例保存在ActivityManagerService类的静态成员变 量mSelf中，最后初始化其它成员变量，就结束了。

Step 8. PackageManagerService.main

这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 7。执行完这一步之后，系统中的应用程序的所有信息都保存在PackageManagerService中了，后面Home应用程序Launcher启动 起来后，就会把PackageManagerService中的应用程序信息取出来，然后以快捷图标的形式展示在桌面上，后面我们将会看到这个过程。

Step 9. ActivityManagerService.setSystemProcess

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public static void setSystemProcess() {
  5. try {
  6. ActivityManagerService m = mSelf;
  7. ServiceManager.addService("activity", m);
  8. ServiceManager.addService("meminfo", new MemBinder(m));
  9. if (MONITOR_CPU_USAGE) {
  10. ServiceManager.addService("cpuinfo", new CpuBinder(m));
  11. }
  12. ServiceManager.addService("permission", new PermissionController(m));
  13. ApplicationInfo info =
  14. mSelf.mContext.getPackageManager().getApplicationInfo(
  15. "android", STOCK_PM_FLAGS);
  16. mSystemThread.installSystemApplicationInfo(info);
  17. synchronized (mSelf) {
  18. ProcessRecord app = mSelf.newProcessRecordLocked(
  19. mSystemThread.getApplicationThread(), info,
  20. info.processName);
  21. app.persistent = true;
  22. app.pid = MY_PID;
  23. app.maxAdj = SYSTEM_ADJ;
  24. mSelf.mProcessNames.put(app.processName, app.info.uid, app);
  25. synchronized (mSelf.mPidsSelfLocked) {
  26. mSelf.mPidsSelfLocked.put(app.pid, app);
  27. }
  28. mSelf.updateLruProcessLocked(app, true, true);
  29. }
  30. } catch (PackageManager.NameNotFoundException e) {
  31. throw new RuntimeException(
  32. "Unable to find android system package", e);
  33. }
  34. }
  35. ......
  36. }

这个函数首先是将这个ActivityManagerService实例添加到ServiceManager中去托管，这样其它地方就可以通过 ServiceManager.getService接口来访问这个全局唯一的ActivityManagerService实例了，接着又通过调用 mSystemThread.installSystemApplicationInfo函数来把应用程序框架层下面的android包加载进来 ，这里的mSystemThread是一个ActivityThread类型的实例变量，它是在上面的Step 7中创建的，后面就是一些其它的初始化工作了。

Step 10.  ActivityManagerService.systemReady

这个函数是在上面的Step 6中的ServerThread.run函数在将系统中的一系列服务都初始化完毕之后才调用的，它定义在frameworks/base /services/java/com/android/server/am/ActivityManagerServcie.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. public void systemReady(final Runnable goingCallback) {
  5. ......
  6. synchronized (this) {
  7. ......
  8. mMainStack.resumeTopActivityLocked(null);
  9. }
  10. }
  11. ......
  12. }

这个函数的内容比较多，这里省去无关的部分，主要关心启动Home应用程序的逻辑，这里就是通过 mMainStack.resumeTopActivityLocked函数来启动Home应用程序的了，这里的mMainStack是一个 ActivityStack类型的实例变量。

Step 11. ActivityStack.resumeTopActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

  1. public class ActivityStack {
  2. ......
  3. final boolean resumeTopActivityLocked(ActivityRecord prev) {
  4. // Find the first activity that is not finishing.
  5. ActivityRecord next = topRunningActivityLocked(null);
  6. ......
  7. if (next == null) {
  8. // There are no more activities!  Let's just start up the
  9. // Launcher...
  10. if (mMainStack) {
  11. return mService.startHomeActivityLocked();
  12. }
  13. }
  14. ......
  15. }
  16. ......
  17. }

这里调用函数topRunningActivityLocked返回的是当前系统Activity堆栈最顶端的Activity，由于此时还没有 Activity被启动过，因此，返回值为null，即next变量的值为null，于是就调用 mService.startHomeActivityLocked语句，这里的mService就是前面在Step 7中创建的ActivityManagerService实例了。

Step 12. ActivityManagerService.startHomeActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：

  1. public final class ActivityManagerService extends ActivityManagerNative
  2. implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
  3. ......
  4. boolean startHomeActivityLocked() {
  5. ......
  6. Intent intent = new Intent(
  7. mTopAction,
  8. mTopData != null ? Uri.parse(mTopData) : null);
  9. intent.setComponent(mTopComponent);
  10. if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
  11. intent.addCategory(Intent.CATEGORY_HOME);
  12. }
  13. ActivityInfo aInfo =
  14. intent.resolveActivityInfo(mContext.getPackageManager(),
  15. STOCK_PM_FLAGS);
  16. if (aInfo != null) {
  17. intent.setComponent(new ComponentName(
  18. aInfo.applicationInfo.packageName, aInfo.name));
  19. // Don't do this if the home app is currently being
  20. // instrumented.
  21. ProcessRecord app = getProcessRecordLocked(aInfo.processName,
  22. aInfo.applicationInfo.uid);
  23. if (app == null || app.instrumentationClass == null) {
  24. intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);
  25. mMainStack.startActivityLocked(null, intent, null, null, 0, aInfo,
  26. null, null, 0, 0, 0, false, false);
  27. }
  28. }
  29. return true;
  30. }
  31. ......
  32. }

函数首先创建一个CATEGORY_HOME类型的Intent，然后通过Intent.resolveActivityInfo函数向
PackageManagerService查询Category类型为HOME的Activity，这里我们假设只有系统自带的Launcher应用程
序注册了HOME类型的Activity（见packages/apps/Launcher2/AndroidManifest.xml文件）：

  1. <manifest
  2. xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="com.android.launcher"
  4. android:sharedUserId="@string/sharedUserId"
  5. >
  6. ......
  7. <application
  8. android:name="com.android.launcher2.LauncherApplication"
  9. android:process="@string/process"
  10. android:label="@string/application_name"
  11. android:icon="@drawable/ic_launcher_home">
  12. <activity
  13. android:name="com.android.launcher2.Launcher"
  14. android:launchMode="singleTask"
  15. android:clearTaskOnLaunch="true"
  16. android:stateNotNeeded="true"
  17. android:theme="@style/Theme"
  18. android:screenOrientation="nosensor"
  19. android:windowSoftInputMode="stateUnspecified|adjustPan">
  20. <intent-filter>
  21. <action android:name="android.intent.action.MAIN" />
  22. <category android:name="android.intent.category.HOME" />
  23. <category android:name="android.intent.category.DEFAULT" />
  24. <category android:name="android.intent.category.MONKEY"/>
  25. </intent-filter>
  26. </activity>
  27. ......
  28. </application>
  29. </manifest>

因此，这里就返回com.android.launcher2.Launcher这个Activity了。由于是第一次启动这个Activity，接下
来调用函数getProcessRecordLocked返回来的ProcessRecord值为null，于是，就调用
mMainStack.startActivityLocked函数启动com.android.launcher2.Launcher这个
Activity了，这里的mMainStack是一个ActivityStack类型的成员变量。

Step 13.  ActivityStack.startActivityLocked

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中，具体可以参考Android应用程序启动过程源代码分析一文，这里就不详述了，在我们这个场景中，调用这个函数的最后结果就是把com.android.launcher2.Launcher启动起来，接着调用它的onCreate函数。

Step 14. Launcher.onCreate

这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/Launcher.java文件中：

  1. public final class Launcher extends Activity
  2. implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
  3. ......
  4. @Override
  5. protected void onCreate(Bundle savedInstanceState) {
  6. ......
  7. if (!mRestoring) {
  8. mModel.startLoader(this, true);
  9. }
  10. ......
  11. }
  12. ......
  13. }

这里的mModel是一个LauncherModel类型的成员变量，这里通过调用它的startLoader成员函数来执行加应用程序的操作。

Step 15. LauncherModel.startLoader

这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

  1. public class LauncherModel extends BroadcastReceiver {
  2. ......
  3. public void startLoader(Context context, boolean isLaunching) {
  4. ......
  5. synchronized (mLock) {
  6. ......
  7. // Don't bother to start the thread if we know it's not going to do anything
  8. if (mCallbacks != null && mCallbacks.get() != null) {
  9. // If there is already one running, tell it to stop.
  10. LoaderTask oldTask = mLoaderTask;
  11. if (oldTask != null) {
  12. if (oldTask.isLaunching()) {
  13. // don't downgrade isLaunching if we're already running
  14. isLaunching = true;
  15. }
  16. oldTask.stopLocked();
  17. }
  18. mLoaderTask = new LoaderTask(context, isLaunching);
  19. sWorker.post(mLoaderTask);
  20. }
  21. }
  22. }
  23. ......
  24. }

这里不是直接加载应用程序，而是把加载应用程序的操作作为一个消息来处理。这里的sWorker是一个Handler，通过它的post方式把一个消息
放在消息队列中去，然后系统就会调用传进去的参数mLoaderTask的run函数来处理这个消息，这个mLoaderTask是LoaderTask
类型的实例，于是，下面就会执行LoaderTask类的run函数了。

Step 16. LoaderTask.run

这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

  1. public class LauncherModel extends BroadcastReceiver {
  2. ......
  3. private class LoaderTask implements Runnable {
  4. ......
  5. public void run() {
  6. ......
  7. keep_running: {
  8. ......
  9. // second step
  10. if (loadWorkspaceFirst) {
  11. ......
  12. loadAndBindAllApps();
  13. } else {
  14. ......
  15. }
  16. ......
  17. }
  18. ......
  19. }
  20. ......
  21. }
  22. ......
  23. }

这里调用loadAndBindAllApps成员函数来进一步操作。

Step 17. LoaderTask.loadAndBindAllApps
        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

  1. public class LauncherModel extends BroadcastReceiver {
  2. ......
  3. private class LoaderTask implements Runnable {
  4. ......
  5. private void loadAndBindAllApps() {
  6. ......
  7. if (!mAllAppsLoaded) {
  8. loadAllAppsByBatch();
  9. if (mStopped) {
  10. return;
  11. }
  12. mAllAppsLoaded = true;
  13. } else {
  14. onlyBindAllApps();
  15. }
  16. }
  17. ......
  18. }
  19. ......
  20. }

由于还没有加载过应用程序，这里的mAllAppsLoaded为false，于是就继续调用loadAllAppsByBatch函数来进一步操作了。

Step 18. LoaderTask.loadAllAppsByBatch
        这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/LauncherModel.java文件中：

  1. public class LauncherModel extends BroadcastReceiver {
  2. ......
  3. private class LoaderTask implements Runnable {
  4. ......
  5. private void loadAllAppsByBatch() {
  6. ......
  7. final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
  8. mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
  9. final PackageManager packageManager = mContext.getPackageManager();
  10. List<ResolveInfo> apps = null;
  11. int N = Integer.MAX_VALUE;
  12. int startIndex;
  13. int i=0;
  14. int batchSize = -1;
  15. while (i < N && !mStopped) {
  16. if (i == 0) {
  17. mAllAppsList.clear();
  18. ......
  19. apps = packageManager.queryIntentActivities(mainIntent, 0);
  20. ......
  21. N = apps.size();
  22. ......
  23. if (mBatchSize == 0) {
  24. batchSize = N;
  25. } else {
  26. batchSize = mBatchSize;
  27. }
  28. ......
  29. Collections.sort(apps,
  30. new ResolveInfo.DisplayNameComparator(packageManager));
  31. }
  32. startIndex = i;
  33. for (int j=0; i<N && j<batchSize; j++) {
  34. // This builds the icon bitmaps.
  35. mAllAppsList.add(new ApplicationInfo(apps.get(i), mIconCache));
  36. i++;
  37. }
  38. final boolean first = i <= batchSize;
  39. final Callbacks callbacks = tryGetCallbacks(oldCallbacks);
  40. final ArrayList<ApplicationInfo> added = mAllAppsList.added;
  41. mAllAppsList.added = new ArrayList<ApplicationInfo>();
  42. mHandler.post(new Runnable() {
  43. public void run() {
  44. final long t = SystemClock.uptimeMillis();
  45. if (callbacks != null) {
  46. if (first) {
  47. callbacks.bindAllApplications(added);
  48. } else {
  49. callbacks.bindAppsAdded(added);
  50. }
  51. ......
  52. } else {
  53. ......
  54. }
  55. }
  56. });
  57. ......
  58. }
  59. ......
  60. }
  61. ......
  62. }
  63. ......
  64. }

函数首先构造一个CATEGORY_LAUNCHER类型的Intent：

  1. final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
  2. mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);

接着从mContext变量中获得PackageManagerService的接口：

  1. final PackageManager packageManager = mContext.getPackageManager();

下一步就是通过这个PackageManagerService.queryIntentActivities接口来取回所有Action类型为
Intent.ACTION_MAIN，并且Category类型为Intent.CATEGORY_LAUNCHER的Activity了。

我们先进入到PackageManagerService.queryIntentActivities函数中看看是如何获得这些Activity的，然后再回到这个函数中来看其余操作。

Step 19. PackageManagerService.queryIntentActivities

这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java文件中：

  1. class PackageManagerService extends IPackageManager.Stub {
  2. ......
  3. public List<ResolveInfo> queryIntentActivities(Intent intent,
  4. String resolvedType, int flags) {
  5. ......
  6. synchronized (mPackages) {
  7. String pkgName = intent.getPackage();
  8. if (pkgName == null) {
  9. return (List<ResolveInfo>)mActivities.queryIntent(intent,
  10. resolvedType, flags);
  11. }
  12. ......
  13. }
  14. ......
  15. }
  16. ......
  17. }

回忆前面一篇文章Android应用程序安装过程源代码分析，
系统在前面的Step
8中启动PackageManagerService时，会把系统中的应用程序都解析一遍，然后把解析得到的Activity都保存在
mActivities变量中，这里通过这个mActivities变量的queryIntent函数返回符合条件intent的Activity，这里
要返回的便是Action类型为Intent.ACTION_MAIN，并且Category类型为Intent.CATEGORY_LAUNCHER的
Activity了。

回到Step
18中的 LoaderTask.loadAllAppsByBatch函数中，从queryIntentActivities函数调用处返回所要求的
Activity后，便调用函数tryGetCallbacks(oldCallbacks)得到一个返CallBack接口，这个接口是由
Launcher类实现的，接着调用这个接口的.bindAllApplications函数来进一步操作。注意，这里又是通过消息来处理加载应用程序的
操作的。

Step 20. Launcher.bindAllApplications

这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/Launcher.java文件中：

  1. public final class Launcher extends Activity
  2. implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
  3. ......
  4. private AllAppsView mAllAppsGrid;
  5. ......
  6. public void bindAllApplications(ArrayList<ApplicationInfo> apps) {
  7. mAllAppsGrid.setApps(apps);
  8. }
  9. ......
  10. }

这里的mAllAppsGrid是一个AllAppsView类型的变量，它的实际类型一般就是AllApps2D了。

Step 21. AllApps2D.setApps

这个函数定义在packages/apps/Launcher2/src/com/android/launcher2/AllApps2D.java文件中：

  1. public class AllApps2D
  2. extends RelativeLayout
  3. implements AllAppsView,
  4. AdapterView.OnItemClickListener,
  5. AdapterView.OnItemLongClickListener,
  6. View.OnKeyListener,
  7. DragSource {
  8. ......
  9. public void setApps(ArrayList<ApplicationInfo> list) {
  10. mAllAppsList.clear();
  11. addApps(list);
  12. }
  13. public void addApps(ArrayList<ApplicationInfo> list) {
  14. final int N = list.size();
  15. for (int i=0; i<N; i++) {
  16. final ApplicationInfo item = list.get(i);
  17. int index = Collections.binarySearch(mAllAppsList, item,
  18. LauncherModel.APP_NAME_COMPARATOR);
  19. if (index < 0) {
  20. index = -(index+1);
  21. }
  22. mAllAppsList.add(index, item);
  23. }
  24. mAppsAdapter.notifyDataSetChanged();
  25. }
  26. ......
  27. }

函数setApps首先清空mAllAppsList列表，然后调用addApps函数来为上一步得到的每一个应用程序创建一个
ApplicationInfo实例了，有了这些ApplicationInfo实例之后，就可以在桌面上展示系统中所有的应用程序了。

到了这里，系统默认的Home应用程序Launcher就把PackageManagerService中的应用程序加载进来了，当我们在屏幕上点击下面这个图标时，就会把刚才加载好的应用程序以图标的形式展示出来了：

Android系统默认Home应用程序（Launcher）的启动过程源代码分析

点击这个按钮时，便会响应Launcher.onClick函数：

  1. public final class Launcher extends Activity
  2. implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
  3. ......
  4. public void onClick(View v) {
  5. Object tag = v.getTag();
  6. if (tag instanceof ShortcutInfo) {
  7. ......
  8. } else if (tag instanceof FolderInfo) {
  9. ......
  10. } else if (v == mHandleView) {
  11. if (isAllAppsVisible()) {
  12. ......
  13. } else {
  14. showAllApps(true);
  15. }
  16. }
  17. }
  18. ......
  19. }

接着就会调用showAllApps函数显示应用程序图标：

  1. public final class Launcher extends Activity
  2. implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
  3. ......
  4. void showAllApps(boolean animated) {
  5. mAllAppsGrid.zoom(1.0f, animated);
  6. ((View) mAllAppsGrid).setFocusable(true);
  7. ((View) mAllAppsGrid).requestFocus();
  8. // TODO: fade these two too
  9. mDeleteZone.setVisibility(View.GONE);
  10. }
  11. ......
  12. }

这样我们就可以看到系统中的应用程序了：

Android系统默认Home应用程序（Launcher）的启动过程源代码分析

当点击上面的这些应用程序图标时，便会响应AllApps2D.onItemClick函数：

  1. public class AllApps2D
  2. extends RelativeLayout
  3. implements AllAppsView,
  4. AdapterView.OnItemClickListener,
  5. AdapterView.OnItemLongClickListener,
  6. View.OnKeyListener,
  7. DragSource {
  8. ......
  9. public void onItemClick(AdapterView parent, View v, int position, long id) {
  10. ApplicationInfo app = (ApplicationInfo) parent.getItemAtPosition(position);
  11. mLauncher.startActivitySafely(app.intent, app);
  12. }
  13. ......
  14. }<span style="font-family:Arial, Verdana, sans-serif;"><span style="white-space: normal;">
  15. </span></span>

这里的成员变量mLauncher的类型为Launcher，于是就调用Launcher.startActivitySafely函数来启动应用程序了，这个过程具体可以参考Android应用程序启动过程源代码分析一文。

老罗的新浪微博：http://weibo.com/shengyangluo，欢迎关注！

相关文章