分析Android Launcher源码中的一些重要类之间的关系，基本的加载流程。先来看一个类图

  Launcher.java 是主Activity 在onCreate方法里面初始化了LauncherMode实例.

[java] view plaincopy

1. LauncherApplication app = ((LauncherApplication)getApplication());  

[java] view plaincopy

1. mModel = app.setLauncher(this);  

[java] view plaincopy

1. LauncherModel setLauncher(Launcher launcher) {  
2.     mModel.initialize(launcher);  
3.     return mModel;  
4. }  

这里Launcher实现了Callbacks接口，直接加入到callbacks列表中，后面的很多功能都要靠它回调处理

[java] view plaincopy

1. public void initialize(Callbacks callbacks) {  
2.     synchronized (mLock) {  
3.         mCallbacks = new WeakReference<Callbacks>(callbacks);  
4.     }  
5. }  

在Launcher.java  onCreate的代码中看下面的一段代码.

[java] view plaincopy

1. if (!mRestoring) {  
2.     if (sPausedFromUserAction) {  
3.         // If the user leaves launcher, then we should just load items asynchronously when  
4.         // they return.  
5.         mModel.startLoader(true, -1);  
6.     } else {  
7.         // We only load the page synchronously if the user rotates (or triggers a  
8.         // configuration change) while launcher is in the foreground  
9.         mModel.startLoader(true, mWorkspace.getCurrentPage());  
10.     }  
11. }  

另外一种情况是 刷新当前页面的app信息数据. 

现在定位到LauncherMode.java源码中startLoader方法 部分代码如下.

[java] view plaincopy

1. if (synchronousBindPage > -1 && mAllAppsLoaded && mWorkspaceLoaded) {  
2.     mLoaderTask.runBindSynchronousPage(synchronousBindPage);//同步加载当前页  
3. } else {  
4.     sWorkerThread.setPriority(Thread.NORM_PRIORITY);  
5.     sWorker.post(mLoaderTask);//异步加载  
6. }  

我们用到了LoaderTask这个类是一个Runnable实现.  这个地方用的是HandlerThread (这个类我以前没用过，一直是自己获取Looper再处理的 )

这个类就是具体载入appinfo，appwidget，  folder的信息了。

我们看看LoaderTask run方法实现. 注意 LoaderTask 是LauncherMode的内部类.  

[java] view plaincopy

1. keep_running: {  
2.     // Elevate priority when Home launches for the first time to avoid  
3.     // starving at boot time. Staring at a blank home is not cool.  
4.     synchronized (mLock) {  
5.         if (DEBUG_LOADERS) Log.d(TAG, "Setting thread priority to " +  
6.                 (mIsLaunching ? "DEFAULT" : "BACKGROUND"));  
7.         android.os.Process.setThreadPriority(mIsLaunching  
8.                 ? Process.THREAD_PRIORITY_DEFAULT : Process.THREAD_PRIORITY_BACKGROUND);  
9.     }  
10.     if (loadWorkspaceFirst) {  
11.         if (DEBUG_LOADERS) Log.d(TAG, "step 1: loading workspace");  
12.         loadAndBindWorkspace();//第一次载入  
13.     } else {  
14.         if (DEBUG_LOADERS) Log.d(TAG, "step 1: special: loading all apps");  
15.         loadAndBindAllApps(); //更新数据  
16.     }  
17.   
18.     if (mStopped) {  
19.         break keep_running;  
20.     }  
21.   
22.     // Whew! Hard work done.  Slow us down, and wait until the UI thread has  
23.     // settled down.  
24.     synchronized (mLock) {  
25.         if (mIsLaunching) {  
26.             if (DEBUG_LOADERS) Log.d(TAG, "Setting thread priority to BACKGROUND");  
27.             android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
28.         }  
29.     }  
30.     waitForIdle();  
31.   
32.     // second step  
33.     if (loadWorkspaceFirst) {  
34.         if (DEBUG_LOADERS) Log.d(TAG, "step 2: loading all apps");  
35.         loadAndBindAllApps();  
36.     } else {  
37.         if (DEBUG_LOADERS) Log.d(TAG, "step 2: special: loading workspace");  
38.         loadAndBindWorkspace();  
39.     }  
40.   
41.     // Restore the default thread priority after we are done loading items  
42.     synchronized (mLock) {  
43.         android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);  
44.     }  
45. }  

我的理解就是  先执行加载workspace 再执行加载all apps.

我们定位到 loadAndBindWorkspace方法中，

[java] view plaincopy

1. if (!mWorkspaceLoaded) {  
2.              loadWorkspace();  
3.              synchronized (LoaderTask.this) {  
4.                  if (mStopped) {  
5.                      return;  
6.                  }  
7.                  mWorkspaceLoaded = true;  
8.              }  
9.          }  

直接调用了 PackageManager，AppWidgetManager，ContentResolver 获取信息.

读取信息保存后 我们需要与workspace汇合，这个地方是调用bindWorkspace

在这个方面里面我们会发现使用前面说的callbacks进行回调完整数据与View的绑定显示.

[java] view plaincopy

1. /** 
2.    * Binds all loaded data to actual views on the main thread. 
3.    */  
4.   private void bindWorkspace(int synchronizeBindPage) {  
5.       final long t = SystemClock.uptimeMillis();  
6.       Runnable r;  
7.   
8.       // Don‘t use these two variables in any of the callback runnables.  
9.       // Otherwise we hold a reference to them.  
10.       final Callbacks oldCallbacks = mCallbacks.get();  
11.       if (oldCallbacks == null) {  
12.           // This launcher has exited and nobody bothered to tell us.  Just bail.  
13.           Log.w(TAG, "LoaderTask running with no launcher");  
14.           return;  
15.       }  
16.   
17.       final boolean isLoadingSynchronously = (synchronizeBindPage > -1);  
18.       final int currentScreen = isLoadingSynchronously ? synchronizeBindPage :  
19.           oldCallbacks.getCurrentWorkspaceScreen();  
20.   
21.       // Load all the items that are on the current page first (and in the process, unbind  
22.       // all the existing workspace items before we call startBinding() below.  
23.       unbindWorkspaceItemsOnMainThread();  
24.       ArrayList<ItemInfo> workspaceItems = new ArrayList<ItemInfo>();  
25.       ArrayList<LauncherAppWidgetInfo> appWidgets =  
26.               new ArrayList<LauncherAppWidgetInfo>();  
27.       HashMap<Long, FolderInfo> folders = new HashMap<Long, FolderInfo>();  
28.       HashMap<Long, ItemInfo> itemsIdMap = new HashMap<Long, ItemInfo>();  
29.       synchronized (sBgLock) {  
30.           workspaceItems.addAll(sBgWorkspaceItems);  
31.           appWidgets.addAll(sBgAppWidgets);  
32.           folders.putAll(sBgFolders);  
33.           itemsIdMap.putAll(sBgItemsIdMap);  
34.       }  
35.   
36.       ArrayList<ItemInfo> currentWorkspaceItems = new ArrayList<ItemInfo>();  
37.       ArrayList<ItemInfo> otherWorkspaceItems = new ArrayList<ItemInfo>();  
38.       ArrayList<LauncherAppWidgetInfo> currentAppWidgets =  
39.               new ArrayList<LauncherAppWidgetInfo>();  
40.       ArrayList<LauncherAppWidgetInfo> otherAppWidgets =  
41.               new ArrayList<LauncherAppWidgetInfo>();  
42.       HashMap<Long, FolderInfo> currentFolders = new HashMap<Long, FolderInfo>();  
43.       HashMap<Long, FolderInfo> otherFolders = new HashMap<Long, FolderInfo>();  
44.   
45.       // Separate the items that are on the current screen, and all the other remaining items  
46.       filterCurrentWorkspaceItems(currentScreen, workspaceItems, currentWorkspaceItems,  
47.               otherWorkspaceItems);  
48.       filterCurrentAppWidgets(currentScreen, appWidgets, currentAppWidgets,  
49.               otherAppWidgets);  
50.       filterCurrentFolders(currentScreen, itemsIdMap, folders, currentFolders,  
51.               otherFolders);  
52.       sortWorkspaceItemsSpatially(currentWorkspaceItems);  
53.       sortWorkspaceItemsSpatially(otherWorkspaceItems);  
54.   
55.       // Tell the workspace that we‘re about to start binding items  
56.       r = new Runnable() {  
57.           public void run() {  
58.               Callbacks callbacks = tryGetCallbacks(oldCallbacks);  
59.               if (callbacks != null) {  
60.                   callbacks.startBinding();  
61.               }  
62.           }  
63.       };  
64.       runOnMainThread(r);  
65.   
66.       // Load items on the current page  
67.       bindWorkspaceItems(oldCallbacks, currentWorkspaceItems, currentAppWidgets,  
68.               currentFolders, null);  
69.       if (isLoadingSynchronously) {  
70.           r = new Runnable() {  
71.               public void run() {  
72.                   Callbacks callbacks = tryGetCallbacks(oldCallbacks);  
73.                   if (callbacks != null) {  
74.                       callbacks.onPageBoundSynchronously(currentScreen);  
75.                   }  
76.               }  
77.           };  
78.           runOnMainThread(r);  
79.       }  
80.   
81.       // Load all the remaining pages (if we are loading synchronously, we want to defer this  
82.       // work until after the first render)  
83.       mDeferredBindRunnables.clear();  
84.       bindWorkspaceItems(oldCallbacks, otherWorkspaceItems, otherAppWidgets, otherFolders,  
85.               (isLoadingSynchronously ? mDeferredBindRunnables : null));  
86.   
87.       // Tell the workspace that we‘re done binding items  
88.       r = new Runnable() {  
89.           public void run() {  
90.               Callbacks callbacks = tryGetCallbacks(oldCallbacks);  
91.               if (callbacks != null) {  
92.                   callbacks.finishBindingItems();  
93.               }  
94.   
95.               // If we‘re profiling, ensure this is the last thing in the queue.  
96.               if (DEBUG_LOADERS) {  
97.                   Log.d(TAG, "bound workspace in "  
98.                       + (SystemClock.uptimeMillis()-t) + "ms");  
99.               }  
100.   
101.               mIsLoadingAndBindingWorkspace = false;  
102.           }  
103.       };  
104.       if (isLoadingSynchronously) {  
105.           mDeferredBindRunnables.add(r);  
106.       } else {  
107.           runOnMainThread(r);  
108.       }  
109.   }