Launcher3学习记录-Launcher第一次启动时的快捷方式、Widget加载流程

Launcher3的主Activity是Launcher.java，在onCreate()方法中可以找到数据下载的入口。mModel 是类LauncherModel的引用。

1         if (!mModel.startLoader(mWorkspace.getRestorePage())) {
2             // If we are not binding synchronously, show a fade in animation when
3             // the first page bind completes.
4             mDragLayer.setAlpha(0);
5         } else {
6             setWorkspaceLoading(true);
7         }

在startLoader方法中可以看到，启动了一个名为LoaderTask的子线程。

1     public boolean startLoader(int synchronousBindPage) {
2         // Enable queue before starting loader. It will get disabled in Launcher#finishBindingItems
3         InstallShortcutReceiver.enableInstallQueue();
4         synchronized (mLock) {
5             // Don't bother to start the thread if we know it's not going to do anything
6             if (mCallbacks != null && mCallbacks.get() != null) {
7                 final Callbacks oldCallbacks = mCallbacks.get();
8                 // Clear any pending bind-runnables from the synchronized load process.
9                 runOnMainThread(new Runnable() {
10                     public void run() {
11                         oldCallbacks.clearPendingBinds();
12                     }
13                 });
14
15                 // If there is already one running, tell it to stop.
16                 stopLoaderLocked();
17                 mLoaderTask = new LoaderTask(mApp.getContext(), synchronousBindPage);
18                 // TODO: mDeepShortcutsLoaded does not need to be true for synchronous bind.
19                 if (synchronousBindPage != PagedView.INVALID_RESTORE_PAGE && mAllAppsLoaded
20                         && mWorkspaceLoaded && mDeepShortcutsLoaded && !mIsLoaderTaskRunning) {
21                     mLoaderTask.runBindSynchronousPage(synchronousBindPage);
22                     return true;
23                 } else {
24                     sWorkerThread.setPriority(Thread.NORM_PRIORITY);
25                     sWorker.post(mLoaderTask);
26                 }
27             }
28         }
29         return false;
30     }

可以看到，LoaderTask 类 实现了Runnable接口，run()方法中明确了加载的三步骤：1、loadAndBindWorkspace() 加载桌面，包括加载桌面上的应用、widget、快捷方式等图标；2、loadAndBindAllApps() 加载AllApps 界面；3、loadAndBindDeepShortcuts() 加载 deep shortcuts ，这个是7.1的ROM上才会有的功能。

1     private class LoaderTask implements Runnable {
2         public void run() {
3             synchronized (mLock) {
4                 if (mStopped) {
5                     return;
6                 }
7                 mIsLoaderTaskRunning = true;
8             }
9             // Optimize for end-user experience: if the Launcher is up and // running with the
10             // All Apps interface in the foreground, load All Apps first. Otherwise, load the
11             // workspace first (default).
12             keep_running: {
13                 if (DEBUG_LOADERS) Log.d(TAG, "step 1: loading workspace");
14                 loadAndBindWorkspace();
15
16                 if (mStopped) {
17                     break keep_running;
18                 }
19
20                 waitForIdle();
21
22                 // second step
23                 if (DEBUG_LOADERS) Log.d(TAG, "step 2: loading all apps");
24                 loadAndBindAllApps();
25
26                 waitForIdle();
27
28                 // third step
29                 if (DEBUG_LOADERS) Log.d(TAG, "step 3: loading deep shortcuts");
30                 loadAndBindDeepShortcuts();
31             }
32
33             // Clear out this reference, otherwise we end up holding it until all of the
34             // callback runnables are done.
35             mContext = null;
36
37             synchronized (mLock) {
38                 // If we are still the last one to be scheduled, remove ourselves.
39                 if (mLoaderTask == this) {
40                     mLoaderTask = null;
41                 }
42                 mIsLoaderTaskRunning = false;
43                 mHasLoaderCompletedOnce = true;
44             }
45         }
46     }

接下来看下loadAndBindWorkspace() 方法，其中loadWorkspace()方法 加载数据，bindWorkspace()方法 将快捷方式和widget显示到界面上。

1         private void loadAndBindWorkspace() {
2             mIsLoadingAndBindingWorkspace = true;
3
4             // Load the workspace
5             if (DEBUG_LOADERS) {
6                 Log.d(TAG, "loadAndBindWorkspace mWorkspaceLoaded=" + mWorkspaceLoaded);
7             }
8
9             if (!mWorkspaceLoaded) {
10                 loadWorkspace();
11                 synchronized (LoaderTask.this) {
12                     if (mStopped) {
13                         return;
14                     }
15                     mWorkspaceLoaded = true;
16                 }
17             }
18
19             // Bind the workspace
20             bindWorkspace(mPageToBindFirst);
21         }

loadWorkspace()方法就比较复杂了，但是大致分为几部：1、加载launcher的默认布局；2、查询并遍历数据库，将数据缓存起来，同时将异常数据添加到待删除数组中，比如被禁用的应用、已卸载的应用 等异常数据；3、删除异常数据，异常的图标、异常的文件夹、异常的页面；4、重新整理剩下的数据。

1         private void loadWorkspace() {
2             ...
3             Log.d(TAG, "loadWorkspace: loading default favorites");
4             LauncherSettings.Settings.call(contentResolver, LauncherSettings.Settings.METHOD_LOAD_DEFAULT_FAVORITES);
5
6                 sBgWorkspaceScreens.addAll(loadWorkspaceScreensDb(mContext));//加载页面顺序
7
8                 final Uri contentUri = LauncherSettings.Favorites.CONTENT_URI;
9                 if (DEBUG_LOADERS) Log.d(TAG, "loading model from " + contentUri);
10                 final Cursor c = contentResolver.query(contentUri, null, null, null, null);
11                 while (!mStopped && c.moveToNext()) {
12                     int itemType = c.getInt(itemTypeIndex);
13                     container = c.getInt(containerIndex);
14                     switch (itemType) {
15                     case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
16                     case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
17                     case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT:
18                     ...
19                     sBgWorkspaceItems.add(info);
20                     sBgItemsIdMap.put(info.id, info);
21                     break;
22                     case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
23                     ...
24                     sBgWorkspaceItems.add(folderInfo);
25                     sBgItemsIdMap.put(folderInfo.id, folderInfo);
26                     sBgFolders.put(folderInfo.id, folderInfo);
27                     break;
28                     case LauncherSettings.Favorites.ITEM_TYPE_APPWIDGET:
29                     case LauncherSettings.Favorites.ITEM_TYPE_CUSTOM_APPWIDGET:
30                     sBgItemsIdMap.put(appWidgetInfo.id, appWidgetInfo);
31                     sBgAppWidgets.add(appWidgetInfo);
32                     break;
33                     }
34                 }
35             ...
36         }

这段加载过程将数据库中有用的数据，基本都加载到内存中来了，下面是各个数据的注释：

// sBgItemsIdMap maps *all* the ItemInfos (shortcuts, folders, and widgets) created by
// LauncherModel to their ids
static final LongArrayMap<ItemInfo> sBgItemsIdMap = new LongArrayMap<>();

// sBgWorkspaceItems is passed to bindItems, which expects a list of all folders and shortcuts
//       created by LauncherModel that are directly on the home screen (however, no widgets or
//       shortcuts within folders).
static final ArrayList<ItemInfo> sBgWorkspaceItems = new ArrayList<ItemInfo>();

// sBgAppWidgets is all LauncherAppWidgetInfo created by LauncherModel. Passed to bindAppWidget()
static final ArrayList<LauncherAppWidgetInfo> sBgAppWidgets =
new ArrayList<LauncherAppWidgetInfo>();

// sBgFolders is all FolderInfos created by LauncherModel. Passed to bindFolders()
static final LongArrayMap<FolderInfo> sBgFolders = new LongArrayMap<>();

// sBgWorkspaceScreens is the ordered set of workspace screens.
static final ArrayList<Long> sBgWorkspaceScreens = new ArrayList<Long>();

加载完数据，接下来就得将数据转化成View绑定到界面了，bindWorkspace()方法中可以看到，分别调了bindWorkspaceScreens、bindWorkspaceItems方法，而这两个方法中，又分别调到了Launcher.java的bindScreens、bindItems、bindAppWidget

private void bindWorkspace(int synchronizeBindPage) {
...
bindWorkspaceScreens(oldCallbacks, orderedScreenIds);

Executor mainExecutor = new DeferredMainThreadExecutor();
// Load items on the current page.
bindWorkspaceItems(oldCallbacks, currentWorkspaceItems, currentAppWidgets, mainExecutor);

// In case of validFirstPage, only bind the first screen, and defer binding the
// remaining screens after first onDraw (and an optional the fade animation whichever
// happens later).
// This ensures that the first screen is immediately visible (eg. during rotation)
// In case of !validFirstPage, bind all pages one after other.
final Executor deferredExecutor =
validFirstPage ? new ViewOnDrawExecutor(mHandler) : mainExecutor;

mainExecutor.execute(new Runnable() {
@Override
public void run() {
Callbacks callbacks = tryGetCallbacks(oldCallbacks);
if (callbacks != null) {
callbacks.finishFirstPageBind(
validFirstPage ? (ViewOnDrawExecutor) deferredExecutor : null);
}
}
});

bindWorkspaceItems(oldCallbacks, otherWorkspaceItems, otherAppWidgets, deferredExecutor);
...
}
private void bindWorkspaceScreens(final Callbacks oldCallbacks,
final ArrayList<Long> orderedScreens) {
final Runnable r = new Runnable() {
@Override
public void run() {
Callbacks callbacks = tryGetCallbacks(oldCallbacks);
if (callbacks != null) {
callbacks.bindScreens(orderedScreens);
}
}
};
runOnMainThread(r);
}

private void bindWorkspaceItems(final Callbacks oldCallbacks,
final ArrayList<ItemInfo> workspaceItems,
final ArrayList<LauncherAppWidgetInfo> appWidgets,
final Executor executor) {

// Bind the workspace items
int N = workspaceItems.size();
for (int i = 0; i < N; i += ITEMS_CHUNK) {
final int start = i;
final int chunkSize = (i+ITEMS_CHUNK <= N) ? ITEMS_CHUNK : (N-i);
final Runnable r = new Runnable() {
@Override
public void run() {
Callbacks callbacks = tryGetCallbacks(oldCallbacks);
if (callbacks != null) {
callbacks.bindItems(workspaceItems, start, start+chunkSize,
false);
}
}
};
executor.execute(r);
}

// Bind the widgets, one at a time
N = appWidgets.size();
for (int i = 0; i < N; i++) {
final LauncherAppWidgetInfo widget = appWidgets.get(i);
final Runnable r = new Runnable() {
public void run() {
Callbacks callbacks = tryGetCallbacks(oldCallbacks);
if (callbacks != null) {
callbacks.bindAppWidget(widget);
}
}
};
executor.execute(r);
}
}

通过下面代码可以看到，bindScreens()方法跟踪到最后，Workspace的 addView()方法，将一个CellLayout 添加到Workspace；而bindItems()方法跟踪到最后，走到了 CellLayout的 addViewToCellLayout()方法，被添加到CellLayout的ShortcutAndWidgetContainer 中去了。

@Override
public void bindScreens(ArrayList<Long> orderedScreenIds) {
...
bindAddScreens(orderedScreenIds);
...
}

private void bindAddScreens(ArrayList<Long> orderedScreenIds) {
int count = orderedScreenIds.size();
for (int i = 0; i < count; i++) {
long screenId = orderedScreenIds.get(i);
if (!FeatureFlags.QSB_ON_FIRST_SCREEN || screenId != Workspace.FIRST_SCREEN_ID) {
// No need to bind the first screen, as its always bound.
mWorkspace.insertNewWorkspaceScreenBeforeEmptyScreen(screenId);
}
}
}
@Override
public void bindItems(final ArrayList<ItemInfo> shortcuts, final int start, final int end,
final boolean forceAnimateIcons) {
...
Workspace workspace = mWorkspace;
long newShortcutsScreenId = -1;
for (int i = start; i < end; i++) {
final ItemInfo item = shortcuts.get(i);

// Short circuit if we are loading dock items for a configuration which has no dock
if (item.container == LauncherSettings.Favorites.CONTAINER_HOTSEAT &&
mHotseat == null) {
continue;
}

final View view;
switch (item.itemType) {
case LauncherSettings.Favorites.ITEM_TYPE_APPLICATION:
case LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT:
case LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT:
ShortcutInfo info = (ShortcutInfo) item;
view = createShortcut(info);
break;
case LauncherSettings.Favorites.ITEM_TYPE_FOLDER:
view = FolderIcon.fromXml(R.layout.folder_icon, this,
(ViewGroup) workspace.getChildAt(workspace.getCurrentPage()),
(FolderInfo) item, mIconCache);
break;
default:
throw new RuntimeException("Invalid Item Type");
}
...
workspace.addInScreenFromBind(view, item.container, item.screenId, item.cellX,
item.cellY, 1, 1);
if (animateIcons) {
// Animate all the applications up now
view.setAlpha(0f);
view.setScaleX(0f);
view.setScaleY(0f);
bounceAnims.add(createNewAppBounceAnimation(view, i));
newShortcutsScreenId = item.screenId;
}
}
...
}
/**
* Add the views for a widget to the workspace.
*
* Implementation of the method from LauncherModel.Callbacks.
*/
public void bindAppWidget(final LauncherAppWidgetInfo item) {
...
final LauncherAppWidgetProviderInfo appWidgetInfo;

if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)) {
// If the provider is not ready, bind as a pending widget.
appWidgetInfo = null;
} else if (item.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
// The widget id is not valid. Try to find the widget based on the provider info.
appWidgetInfo = mAppWidgetManager.findProvider(item.providerName, item.user);
} else {
appWidgetInfo = mAppWidgetManager.getLauncherAppWidgetInfo(item.appWidgetId);
}
...

if (item.restoreStatus == LauncherAppWidgetInfo.RESTORE_COMPLETED) {
...
item.minSpanX = appWidgetInfo.minSpanX;
item.minSpanY = appWidgetInfo.minSpanY;
addAppWidgetToWorkspace(
mAppWidgetHost.createView(this, item.appWidgetId, appWidgetInfo),
item, appWidgetInfo, false);
} else {
PendingAppWidgetHostView view = new PendingAppWidgetHostView(this, item, false);
view.updateIcon(mIconCache);
view.updateAppWidget(null);
view.setOnClickListener(this);
addAppWidgetToWorkspace(view, item, null, false);
}
...
}

private void addAppWidgetToWorkspace(
AppWidgetHostView hostView, LauncherAppWidgetInfo item,
LauncherAppWidgetProviderInfo appWidgetInfo, boolean insert) {
hostView.setTag(item);
item.onBindAppWidget(this, hostView);

hostView.setFocusable(true);
hostView.setOnFocusChangeListener(mFocusHandler);

mWorkspace.addInScreen(hostView, item.container, item.screenId,
item.cellX, item.cellY, item.spanX, item.spanY, insert);

if (!item.isCustomWidget()) {
addWidgetToAutoAdvanceIfNeeded(hostView, appWidgetInfo);
}
}

public void insertNewWorkspaceScreenBeforeEmptyScreen(long screenId) {
// Find the index to insert this view into.  If the empty screen exists, then
// insert it before that.
int insertIndex = mScreenOrder.indexOf(EXTRA_EMPTY_SCREEN_ID);
if (insertIndex < 0) {
insertIndex = mScreenOrder.size();
}
insertNewWorkspaceScreen(screenId, insertIndex);
}

public CellLayout insertNewWorkspaceScreen(long screenId, int insertIndex) {
if (mWorkspaceScreens.containsKey(screenId)) {
throw new RuntimeException("Screen id " + screenId + " already exists!");
}

// Inflate the cell layout, but do not add it automatically so that we can get the newly
// created CellLayout.
CellLayout newScreen = (CellLayout) mLauncher.getLayoutInflater().inflate(
R.layout.workspace_screen, this, false /* attachToRoot */);
newScreen.setOnLongClickListener(mLongClickListener);
newScreen.setOnClickListener(mLauncher);
newScreen.setSoundEffectsEnabled(false);
mWorkspaceScreens.put(screenId, newScreen);
mScreenOrder.add(insertIndex, screenId);
addView(newScreen, insertIndex);

if (mLauncher.getAccessibilityDelegate().isInAccessibleDrag()) {
newScreen.enableAccessibleDrag(true, CellLayout.WORKSPACE_ACCESSIBILITY_DRAG);
}

return newScreen;
}

// At bind time, we use the rank (screenId) to compute x and y for hotseat items.
// See implementation for parameter definition.
public void addInScreenFromBind(View child, long container, long screenId, int x, int y,
int spanX, int spanY) {
addInScreen(child, container, screenId, x, y, spanX, spanY, false, true);
}

void addInScreen(View child, long container, long screenId, int x, int y, int spanX, int spanY,
boolean insert) {
addInScreen(child, container, screenId, x, y, spanX, spanY, insert, false);
}
void addInScreen(View child, long container, long screenId, int x, int y, int spanX, int spanY,
boolean insert, boolean computeXYFromRank) {
...
final CellLayout layout;
if (container == LauncherSettings.Favorites.CONTAINER_HOTSEAT) {
layout = mLauncher.getHotseat().getLayout();
...
} else {
layout = getScreenWithId(screenId);
...
}
...
if (!layout.addViewToCellLayout(child, insert ? 0 : -1, childId, lp, markCellsAsOccupied)) {
// TODO: This branch occurs when the workspace is adding views
// outside of the defined grid
// maybe we should be deleting these items from the LauncherModel?
Log.e(TAG, "Failed to add to item at (" + lp.cellX + "," + lp.cellY + ") to CellLayout");
}
...
}

public boolean addViewToCellLayout(View child, int index, int childId, LayoutParams params,
boolean markCells) {
final LayoutParams lp = params;

// Hotseat icons - remove text
if (child instanceof BubbleTextView) {
BubbleTextView bubbleChild = (BubbleTextView) child;
bubbleChild.setTextVisibility(!mIsHotseat);
}

child.setScaleX(getChildrenScale());
child.setScaleY(getChildrenScale());

// Generate an id for each view, this assumes we have at most 256x256 cells
// per workspace screen
if (lp.cellX >= 0 && lp.cellX <= mCountX - 1 && lp.cellY >= 0 && lp.cellY <= mCountY - 1) {
// If the horizontal or vertical span is set to -1, it is taken to
// mean that it spans the extent of the CellLayout
if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;

child.setId(childId);
if (LOGD) {
Log.d(TAG, "Adding view to ShortcutsAndWidgetsContainer: " + child);
}
mShortcutsAndWidgets.addView(child, index, lp);

if (markCells) markCellsAsOccupiedForView(child);

return true;
}
return false;
}

到这里，Launcher第一次启动时 加载快捷方式、Widget的流程就结束了。