Android源码之Gallery专题研究（1）

前言

时光飞逝，从事Android系统开发已经两年了，总想写点什么来安慰自己。思考了很久总是无法下笔，觉得没什么好写的。现在终于决定写一些符合大多数人需求的东西，想必使用过Android手机的人们一定对“图库”（以下简称Gallery）这个应用非常熟悉。在Android市场里面有各种关于图库的应用，他们的最初原型其实就是Android系统原生“图库”，只是做了不同的差异化而已（UI差异化）。在研究Gallery源码之前，我们需要对设计模式有一定的了解，根据自己对Gallery的了解，Gallery的设计就好比是一座设计精良的并且高效运转的机器（32个攒）。毫不夸张地说，在Android市场里，没有一款“图库”应用的设计设计能够和Gallery媲美。接下来的一段时间，就让我们共同来揭开Gallery的神秘面纱。

数据加载

在研究Gallery之前，我们还是来欣赏一下Gallery的整体效果，具体见图1-1所示：

图1-1

首先我们先来看一下Gallery的发展历史，在Android2.3之前Android系统的“图库”名为Gallery3D，在Android2.3之后系统将之前的Gallery3D更改为Gallery2，一直沿用到目前最新版本（4.4），Gallery2在UI和功能上面做了质的飞跃，是目前Android源码中非常优秀的模块，对于Android应用开发者来说是非常好的开源项目，其中的设计新思想和设计模式都值得我们借鉴。

现在回到我们研究的主题-数据加载，我们先来看一下Gallery2在源码中的路径(package/app/Gallery2/),在该路径下包含了“图库”使用的资源和源码。我们在设计一款软件的时候首先考虑的是数据的存储和访问，因此我们也按照这样的设计思路来探究Gallery2的数据加载过程。说到这儿稍微提一下我分析源码的方式，可能大家对Android源码稍微有一点了解的同学应该知道，Android源码是非常庞大的，因此选择分析程序的切入点大致可以分为两类：第一种是按照操程序操作步骤分析源码——适用于界面跳转清晰的程序；第二种是根据打印的Log信息分析程序的运行逻辑——适用于复杂的操作逻辑。

首先我们先来看一下BucketHelper.java类（/src/com/android/gallery3d/data/BucketHelper.java），该类主要是负责读取MediaProvider数据库中Image和Video数据，具体代码如下所示：

1. package com.android.gallery3d.data;
2. import android.annotation.TargetApi;
3. import android.content.ContentResolver;
4. import android.database.Cursor;
5. import android.net.Uri;
6. import android.provider.MediaStore.Files;
7. import android.provider.MediaStore.Files.FileColumns;
8. import android.provider.MediaStore.Images;
9. import android.provider.MediaStore.Images.ImageColumns;
10. import android.provider.MediaStore.Video;
11. import android.util.Log;
12. import com.android.gallery3d.common.ApiHelper;
13. import com.android.gallery3d.common.Utils;
14. import com.android.gallery3d.util.ThreadPool.JobContext;
15. import java.util.ArrayList;
16. import java.util.Arrays;
17. import java.util.Comparator;
18. import java.util.HashMap;
19. class BucketHelper {
20. private static final String TAG = "BucketHelper";
21. private static final String EXTERNAL_MEDIA = "external";
22. // BUCKET_DISPLAY_NAME is a string like "Camera" which is the directory
23. // name of where an image or video is in. BUCKET_ID is a hash of the path
24. // name of that directory (see computeBucketValues() in MediaProvider for
25. // details). MEDIA_TYPE is video, image, audio, etc.
26. // BUCKET_DISPLAY_NAME字段为文件目录名称 BUCKET_ID字段为目录路径（path）的HASH值
27. // The "albums" are not explicitly recorded in the database, but each image
28. // or video has the two columns (BUCKET_ID, MEDIA_TYPE). We define an
29. // "album" to be the collection of images/videos which have the same value
30. // for the two columns.
31. // "专辑"的划分方式为：当文件具有相同的目录（BUCKET_ID）和多媒体类型（MEDIA_TYPE）即属于同一专辑
32. // The goal of the query (used in loadSubMediaSetsFromFilesTable()) is to
33. // find all albums, that is, all unique values for (BUCKET_ID, MEDIA_TYPE).
34. // In the meantime sort them by the timestamp of the latest image/video in
35. // each of the album.
36. //
37. // The order of columns below is important: it must match to the index in
38. // MediaStore.
39. private static final String[] PROJECTION_BUCKET = {
40. ImageColumns.BUCKET_ID,
41. FileColumns.MEDIA_TYPE,
42. ImageColumns.BUCKET_DISPLAY_NAME};
43. // The indices should match the above projections.
44. private static final int INDEX_BUCKET_ID = 0;
45. private static final int INDEX_MEDIA_TYPE = 1;
46. private static final int INDEX_BUCKET_NAME = 2;
47. // We want to order the albums by reverse chronological order. We abuse the
48. // "WHERE" parameter to insert a "GROUP BY" clause into the SQL statement.
49. // The template for "WHERE" parameter is like:
50. //    SELECT ... FROM ... WHERE (%s)
51. // and we make it look like:
52. //    SELECT ... FROM ... WHERE (1) GROUP BY 1,(2)
53. // The "(1)" means true. The "1,(2)" means the first two columns specified
54. // after SELECT. Note that because there is a ")" in the template, we use
55. // "(2" to match it.
56. private static final String BUCKET_GROUP_BY = "1) GROUP BY 1,(2";
57. private static final String BUCKET_ORDER_BY = "MAX(datetaken) DESC";
58. // Before HoneyComb there is no Files table. Thus, we need to query the
59. // bucket info from the Images and Video tables and then merge them
60. // together.
61. //
62. // A bucket can exist in both tables. In this case, we need to find the
63. // latest timestamp from the two tables and sort ourselves. So we add the
64. // MAX(date_taken) to the projection and remove the media_type since we
65. // already know the media type from the table we query from.
66. private static final String[] PROJECTION_BUCKET_IN_ONE_TABLE = {
67. ImageColumns.BUCKET_ID,
68. "MAX(datetaken)",
69. ImageColumns.BUCKET_DISPLAY_NAME};
70. // We keep the INDEX_BUCKET_ID and INDEX_BUCKET_NAME the same as
71. // PROJECTION_BUCKET so we can reuse the values defined before.
72. private static final int INDEX_DATE_TAKEN = 1;
73. // When query from the Images or Video tables, we only need to group by BUCKET_ID.
74. private static final String BUCKET_GROUP_BY_IN_ONE_TABLE = "1) GROUP BY (1";
75. public static BucketEntry[] loadBucketEntries(
76. JobContext jc, ContentResolver resolver, int type) {
77. if (ApiHelper.HAS_MEDIA_PROVIDER_FILES_TABLE) {//当API1>= 11(即Android3.0版本之后)
78. return loadBucketEntriesFromFilesTable(jc, resolver, type);//获取MediaScanner数据库中多媒体文件（图片和视频）的目录路径和目录名称
79. } else {//Android3.0之前版本
80. return loadBucketEntriesFromImagesAndVideoTable(jc, resolver, type);
81. }
82. }
83. private static void updateBucketEntriesFromTable(JobContext jc,
84. ContentResolver resolver, Uri tableUri, HashMap<Integer, BucketEntry> buckets) {
85. Cursor cursor = resolver.query(tableUri, PROJECTION_BUCKET_IN_ONE_TABLE,
86. BUCKET_GROUP_BY_IN_ONE_TABLE, null, null);
87. if (cursor == null) {
88. Log.w(TAG, "cannot open media database: " + tableUri);
89. return;
90. }
91. try {
92. while (cursor.moveToNext()) {
93. int bucketId = cursor.getInt(INDEX_BUCKET_ID);
94. int dateTaken = cursor.getInt(INDEX_DATE_TAKEN);
95. BucketEntry entry = buckets.get(bucketId);
96. if (entry == null) {
97. entry = new BucketEntry(bucketId, cursor.getString(INDEX_BUCKET_NAME));
98. buckets.put(bucketId, entry);
99. entry.dateTaken = dateTaken;
100. } else {
101. entry.dateTaken = Math.max(entry.dateTaken, dateTaken);
102. }
103. }
104. } finally {
105. Utils.closeSilently(cursor);
106. }
107. }
108. private static BucketEntry[] loadBucketEntriesFromImagesAndVideoTable(
109. JobContext jc, ContentResolver resolver, int type) {
110. HashMap<Integer, BucketEntry> buckets = new HashMap<Integer, BucketEntry>(64);
111. if ((type & MediaObject.MEDIA_TYPE_IMAGE) != 0) {
112. updateBucketEntriesFromTable(
113. jc, resolver, Images.Media.EXTERNAL_CONTENT_URI, buckets);
114. }
115. if ((type & MediaObject.MEDIA_TYPE_VIDEO) != 0) {
116. updateBucketEntriesFromTable(
117. jc, resolver, Video.Media.EXTERNAL_CONTENT_URI, buckets);
118. }
119. BucketEntry[] entries = buckets.values().toArray(new BucketEntry[buckets.size()]);
120. Arrays.sort(entries, new Comparator<BucketEntry>() {
121. @Override
122. public int compare(BucketEntry a, BucketEntry b) {
123. // sorted by dateTaken in descending order
124. return b.dateTaken - a.dateTaken;
125. }
126. });
127. return entries;
128. }
129. private static BucketEntry[] loadBucketEntriesFromFilesTable(
130. JobContext jc, ContentResolver resolver, int type) {
131. Uri uri = getFilesContentUri();
132. Cursor cursor = resolver.query(uri,
133. PROJECTION_BUCKET, BUCKET_GROUP_BY,
134. null, BUCKET_ORDER_BY);
135. if (cursor == null) {
136. Log.w(TAG, "cannot open local database: " + uri);
137. return new BucketEntry[0];
138. }
139. ArrayList<BucketEntry> buffer = new ArrayList<BucketEntry>();
140. int typeBits = 0;
141. if ((type & MediaObject.MEDIA_TYPE_IMAGE) != 0) {
142. typeBits |= (1 << FileColumns.MEDIA_TYPE_IMAGE);
143. }
144. if ((type & MediaObject.MEDIA_TYPE_VIDEO) != 0) {
145. typeBits |= (1 << FileColumns.MEDIA_TYPE_VIDEO);
146. }
147. try {
148. while (cursor.moveToNext()) {
149. if ((typeBits & (1 << cursor.getInt(INDEX_MEDIA_TYPE))) != 0) {
150. BucketEntry entry = new BucketEntry(
151. cursor.getInt(INDEX_BUCKET_ID),
152. cursor.getString(INDEX_BUCKET_NAME));//构造元数据BucketEntry
153. if (!buffer.contains(entry)) {
154. buffer.add(entry);//添加数据信息
155. }
156. }
157. if (jc.isCancelled()) return null;
158. }
159. } finally {
160. Utils.closeSilently(cursor);
161. }
162. return buffer.toArray(new BucketEntry[buffer.size()]);
163. }
164. private static String getBucketNameInTable(
165. ContentResolver resolver, Uri tableUri, int bucketId) {
166. String selectionArgs[] = new String[] {String.valueOf(bucketId)};
167. Uri uri = tableUri.buildUpon()
168. .appendQueryParameter("limit", "1")
169. .build();
170. Cursor cursor = resolver.query(uri, PROJECTION_BUCKET_IN_ONE_TABLE,
171. "bucket_id = ?", selectionArgs, null);
172. try {
173. if (cursor != null && cursor.moveToNext()) {
174. return cursor.getString(INDEX_BUCKET_NAME);
175. }
176. } finally {
177. Utils.closeSilently(cursor);
178. }
179. return null;
180. }
181. @TargetApi(ApiHelper.VERSION_CODES.HONEYCOMB)
182. private static Uri getFilesContentUri() {
183. return Files.getContentUri(EXTERNAL_MEDIA);
184. }
185. public static String getBucketName(ContentResolver resolver, int bucketId) {
186. if (ApiHelper.HAS_MEDIA_PROVIDER_FILES_TABLE) {
187. String result = getBucketNameInTable(resolver, getFilesContentUri(), bucketId);
188. return result == null ? "" : result;
189. } else {
190. String result = getBucketNameInTable(
191. resolver, Images.Media.EXTERNAL_CONTENT_URI, bucketId);
192. if (result != null) return result;
193. result = getBucketNameInTable(
194. resolver, Video.Media.EXTERNAL_CONTENT_URI, bucketId);
195. return result == null ? "" : result;
196. }
197. }
198. public static class BucketEntry {
199. public String bucketName;
200. public int bucketId;
201. public int dateTaken;
202. public BucketEntry(int id, String name) {
203. bucketId = id;
204. bucketName = Utils.ensureNotNull(name);
205. }
206. @Override
207. public int hashCode() {
208. return bucketId;
209. }
210. @Override
211. public boolean equals(Object object) {
212. if (!(object instanceof BucketEntry)) return false;
213. BucketEntry entry = (BucketEntry) object;
214. return bucketId == entry.bucketId;
215. }
216. }
217. }

接下来我们再来看看BucketHelper类的调用关系的时序图，具体如1-2所示：

 图1-2

到目前为止我们大致了解了Gallery数据加载的一个大体流程，接下来的文章将分析Album数据的读取以及数据封装。