步骤4比目前为止的其他几个步骤要复杂一些。这里需要像类SimpleFinchVideo-ContentProvider一样逐步说明RESTful FinchVideoContentProvider类。首先，FinchVideoContentProvider扩展了RESTfulContentProvider，RESTfulContentProvider又扩展了ContentProvider：
FinchVideoContentProvider extend RESTfulContentProvider {
RESTfulContentProvider提供异步REST操作，它支持Finch提供者植入定制的请求-响应处理器组件。在探讨升级query方法时，将详细解释这一点。
常量和初始化
FinchVideoContentProvider初始化和简单视频应用的内容提供者很相似。对于简单版的FinchVideoContentProvider，我们设置了一个URI匹配器，其唯一的任务是支持匹配特定的缩略图。没有添加匹配多个缩略图的支持，因为这个视图活动不需要这个功能——它只需要加载单个缩略图：
sUriMatcher.addURI(FinchVideo.AUTHORITY,
FinchVideo.Videos.THUMB + "/#", THUMB_ID);
创建数据库
在Java代码中使用下面的这个SQL语句创建Finch视频数据库：
CREATE TABLE video (_ID INTEGER PRIMARY KEY AUTOINCREMENT,
title TEXT, description TEXT, thumb_url TEXT,
thumb_width TEXT, thumb_height TEXT, timestamp TEXT,
query_text TEXT, media_id TEXT UNIQUE);
注意，相对于简单版本，我们增加了以下属性：
thumb_url,thumb_width,thumb_height
它们分别是给定视频的缩略图的URL、宽度和高度。
timestamp
当插入一条新的视频记录时，给它添加当前时间戳。
query_text
在数据库中保存查询文本或查询关键字以及每条查询结果。
media_id
这是从GData API中接收的每个视频响应的唯一值。视频项的media_id必须唯一。
网络Query方法
以下方式是我们所倡导的：在FinchYouTubeProvider查询方法的实现中连接网络以满足YouTube数据的查询请求。它是通过调用它的超类中的方法RESTfulContentProvider.asyncQueryRequest(String queryTag,String queryUri)实现这个功能。在这里，queryTag是唯一字符串，它支持合理地拒绝重复的处理请求，queryUri是完整的需要异步下载的URI。而且，在附加了从应用搜索文本框字段中获取的URLEncoder.encoded查询参数后，URI调用请求如下所示：
/** URI for querying video, expects appended keywords. */
private static final String QUERY_URI =
"http://gdata.youtube.com/feeds/api/videos?" +
"max-results=15&format=1&q=";
注意：你可以很容易学会如何创建满足应用需求的GData YouTube URI。Google在http://gdata.youtube.com创建了beta版的工具。如果你在浏览器中访问该页面，它会显示包含了很多选项的Web UI，你可以通过定制这个UI的方式来创建如前一个代码列表中给出的URI。我们使用该UI选择15项结果，并且选择使用移动视频格式。
我们的网络查询方法执行了URI匹配，并增加了以下任务，即操作序列中的“第4步：实现RESTful请求”：
/**
* Content provider query method that converts its parameters into a YouTube
* RESTful search query.
*
* @param uri a reference to the query URI. It may contain "q=
* which are sent to the google YouTube
* API where they are used to search the YouTube video database.
* @param projection
* @param where not used in this provider.
* @param whereArgs not used in this provider.
* @param sortOrder not used in this provider.
* @return a cursor containing the results of a YouTube search query.
*/
@Override
public Cursor query(Uri uri, String projection, String where,
String whereArgs, String sortOrder)
{
Cursor queryCursor;
int match = sUriMatcher.match(uri);
switch (match) {
case VIDEOS:
// the query is passed out of band of other information passed
// to this method -- it's not an argument.
String queryText = uri.
getQueryParameter(FinchVideo.Videos.QUERY_PARAM_NAME);
①
if (queryText == null) {
// A null cursor is an acceptable argument to the method,
// CursorAdapter.changeCursor(Cursor c), which interprets
// the value by canceling all adapter state so that the
// component for which the cursor is adapting data will
// display no content.
return null;
}
String select = FinchVideo.Videos.QUERY_TEXT_NAME +
" = '" + queryText + "'";
// quickly return already matching data
queryCursor =
mDb.query(VIDEOS_TABLE_NAME, projection,
select,
whereArgs,
null,
null, sortOrder);
②
// make the cursor observe the requested query
queryCursor.setNotificationUri(
getContext.getContentResolver, uri);
③
/*
* Always try to update results with the latest data from the
* network.
*
* Spawning an asynchronous load task thread guarantees that
* the load has no chance to block any content provider method,
* and therefore no chance to block the UI thread.
*
* While the request loads, we return the cursor with existing
* data to the client.
*
* If the existing cursor is empty, the UI will render no
* content until it receives URI notification.
*
* Content updates that arrive when the asynchronous network
* request completes will appear in the already returned cursor,
* since that cursor query will match that of
* newly arrived items.
*/
if (!"".equals(queryText)) {
asyncQueryRequest(queryText, QUERY_URI + encode(queryText));
④
}
break;
case VIDEO_ID:
case THUMB_VIDEO_ID:
long videoID = ContentUris.parseId(uri);
queryCursor =
mDb.query(VIDEOS_TABLE_NAME, projection,
FinchVideo.Videos._ID + " = " + videoID,
whereArgs, null, null, null);
queryCursor.setNotificationUri(
getContext.getContentResolver, uri);
break;
case THUMB_ID:
String uriString = uri.toString;
int lastSlash = uriString.lastIndexOf("/");
String mediaID = uriString.substring(lastSlash + 1);
queryCursor =
mDb.query(VIDEOS_TABLE_NAME, projection,
FinchVideo.Videos.MEDIA_ID_NAME + " = " +
mediaID,
whereArgs, null, null, null);
queryCursor.setNotificationUri(
getContext.getContentResolver, uri);
break;
default:
throw new IllegalArgumentException("unsupported uri: " +
QUERY_URI);
}
return queryCursor;
}
以下是关于代码的一些说明：
① 从输入的URI中提取查询参数。只需要把URI中的查询参数传递给query方法，而URI中的其他参数不需要传递，因为它们在query方法中的功能不同，不能用于保存查询关键字。
② 首先检查和查询关键字匹配的本地数据库中已有的数据。
③ 设置通知URI，当提供者改变数据时，query方法返回的游标会接收到更新事件。该操作会启动第6步，当提供者发起数据变化的事件通知时，会触发视图更新。一旦接收到通知，当UI重新绘制时会执行第7步。注意，第6步和第7步没有给出描述，但是这里可以讨论这些步骤，因为它们和URI通知及查询相关。
④ 扩展异步查询，下载给定查询URI。asyncQueryRequest方法封装了每次请求创建的新的线程连接服务。注意，在我们给出的图中，这是第5步；异步请求会扩展线程，从而真正初始化网络通信，YouTube服务会返回响应。
RESTfulContentProvider：REST helper
现在，我们来分析FinchVideoProvider，它继承了RESTful ContentProvider以便执行RESTful请求。首先，要考虑的是给定YouTube请求的行为。正如我们看到的，查询请求和主线程异步运行。RESTful提供者需要处理一些特殊情况，例如某个用户查找“Funny Cats”，而另一个用户正在查询同样的关键字，提供者会删掉第二次请求。另一方面，例如某个用户查找“dogs”，并且在“dogs”查找完成之前又查找了“cats”，provider支持“dogs”查询和“cats”查询并发运行，因为用户可能还会搜索“dogs”，这样就可以复用之前搜索的缓存。
RESTfulContentProvider支持子类扩展异步请求，而且当请求数据到达时，支持使用简单的名为ResponseHandler的插件来自定义处理方式。子类应该覆盖抽象方法RESTfulContentProvider.newResponseHandler，以返回专门用于解析由宿主提供者所请求的响应数据的处理程序。每个处理程序覆盖ResponseHandler.handleResponse(HttpResponse)方法，提供自定义的处理或包含在传递的HttpResponse对象中的HttpEntitys。例如，提供者使用YouTubeHandler来解析YouTube RSS订阅，把读取的每个数据项插入到数据库视频记录中。后面将详细说明这一点。
此外，RESTfulContentProvider类支持子类轻松地执行异步请求，并拒绝重复请求。RESTfulContentProvider通过唯一标签跟踪每个请求，支持子类丢弃重复查询。Finch VideoContentProvider以用户的查询关键字作为请求标签，因为它们能唯一标识某个给定的搜索请求。
FinchVideoContentProvider重写了newResponseHandler方法，如下：
/**
* Provides a handler that can parse YouTube GData RSS content.
*
* @param requestTag unique tag identifying this request.
* @return a YouTubeHandler object.
*/
@Override
protected ResponseHandler newResponseHandler(String requestTag) {
return new YouTubeHandler(this, requestTag);
}
现在，探讨RESTfulContentProvider的实现，解释它提供给子类的操作。类UriRequestTask提供了runnable接口，可以异步执行REST请求。RESTfulContentProvider使用map mRequestsInProgress，以字符串作为关键字来保证请求的唯一性：
/**
* Encapsulates functions for asynchronous RESTful requests so that subclass
* content providers can use them for initiating requests while still using
* custom methods for interpreting REST-based content such as RSS, ATOM,
* JSON, etc.
*/
public abstract class RESTfulContentProvider extends ContentProvider {
protected FileHandlerFactory mFileHandlerFactory;
private Map<String, UriRequestTask> mRequestsInProgress =
new HashMap<String, UriRequestTask>;
public RESTfulContentProvider(FileHandlerFactory fileHandlerFactory) {
mFileHandlerFactory = fileHandlerFactory;
}
public abstract Uri insert(Uri uri, ContentValues cv, SQLiteDatabase db);
private UriRequestTask getRequestTask(String queryText) {
return mRequestsInProgress.get(queryText);
①
}
/**
* Allows the subclass to define the database used by a response handler.
*
* @return database passed to response handler.
*/
public abstract SQLiteDatabase getDatabase;
public void requestComplete(String mQueryText) {
synchronized (mRequestsInProgress) {
mRequestsInProgress.remove(mQueryText);
②
}
}
/**
* Abstract method that allows a subclass to define the type of handler
* that should be used to parse the response of a given request.
*
* @param requestTag unique tag identifying this request.
* @return The response handler created by a subclass used to parse the
* request response.
*/
protected abstract ResponseHandler newResponseHandler(String requestTag);
UriRequestTask newQueryTask(String requestTag, String url) {
UriRequestTask requestTask;
final HttpGet get = new HttpGet(url);
ResponseHandler handler = newResponseHandler(requestTag);
requestTask = new UriRequestTask(requestTag, this, get,
③
handler, getContext);
mRequestsInProgress.put(requestTag, requestTask);
return requestTask;
}
/**
* Creates a new worker thread to carry out a RESTful network invocation.
*
* @param queryTag unique tag that identifies this request.
*
* @param queryUri the complete URI that should be accessed by this request.
*/
public void asyncQueryRequest(String queryTag, String queryUri) {
synchronized (mRequestsInProgress) {
UriRequestTask requestTask = getRequestTask(queryTag);
if (requestTask == null) {
requestTask = newQueryTask(queryTag, queryUri);
④
Thread t = new Thread(requestTask);
// allows other requests to run in parallel.
t.start;
}
}
}
...
}
以下是关于上述代码的一些说明：
① getRequestTask方法使用mRequestsInProgress方法访问正在执行的请求，看是否有相同的请求，它允许asyncQueryRequest通过简单的if语句阻塞重复请求。
② 请求会在ResponseHandler.handleResponse方法返回后完成，RESTfulContentProvider删除mRequestsInProgress。
③ newQueryTask，创建UriRequestTask实例，UriRequestTask是Runnable实例，会打开HTTP连接，然后在合适的handler上调用handleResponse。
④ 最后，代码包含了一个唯一的请求，创建任务以运行它，然后在线程中封装任务用于异步执行。
虽然RESTfulContentProvider是可重用的任务系统的核心，但为了完整性，我们还要对框架中的其他组件进行介绍。
UriRequestTask。UriRequestTask封装了处理REST请求的异步操作。它是一个简单的类，支持在run方法中执行RESTful GET方法。该操作是步骤4的一部分，即操作序列中的“实现RESTful请求”。正如我们所讨论的，一旦UriRequestTask接收到响应，它会把该响应传递给ResponseHandler.handleResponse方法。我们期望handleResponse方法会执行数据库插入操作，在YouTubeHandler中将看到这一功能：
/**
* Provides a runnable that uses an HttpClient to asynchronously load a given
* URI. After the network content is loaded, the task delegates handling of the
* request to a ResponseHandler specialized to handle the given content.
*/
public class UriRequestTask implements Runnable {
private HttpUriRequest mRequest;
private ResponseHandler mHandler;
protected Context mAppContext;
private RESTfulContentProvider mSiteProvider;
private String mRequestTag;
private int mRawResponse = -1;
public UriRequestTask(HttpUriRequest request,
ResponseHandler handler, Context appContext)
{
this(null, null, request, handler, appContext);
}
public UriRequestTask(String requestTag,
RESTfulContentProvider siteProvider,
HttpUriRequest request,
ResponseHandler handler, Context appContext)
{
mRequestTag = requestTag;
mSiteProvider = siteProvider;
mRequest = request;
mHandler = handler;
mAppContext = appContext;
}
public void setRawResponse(int rawResponse) {
mRawResponse = rawResponse;
}
/**
* Carries out the request on the complete URI as indicated by the protocol,
* host, and port contained in the configuration, and the URI supplied to
* the constructor.
*/
public void run {
HttpResponse response;
try {
response = execute(mRequest);
mHandler.handleResponse(response, getUri);
} catch (IOException e) {
Log.w(Finch.LOG_TAG, "exception processing asynch request", e);
} finally {
if (mSiteProvider != null) {
mSiteProvider.requestComplete(mRequestTag);
}
}
}
private HttpResponse execute(HttpUriRequest mRequest) throws IOException {
if (mRawResponse >= 0) {
return new RawResponse(mAppContext, mRawResponse);
} else {
HttpClient client = new DefaultHttpClient;
return client.execute(mRequest);
}
}
public Uri getUri {
return Uri.parse(mRequest.getURI.toString);
}
}
YouTubeHandler。正如在抽象方法RESTfulContentProvider.newResponseHandler中一样，FinchVideoContentProvider方法返回YouTubeHandler来处理YouTube RSS订阅。YouTubeHandler在内存中使用XML Pull解析器解析输入的数据，遍历获取到的XML RSS数据并处理。YouTubeHandler包含一些复杂特性，但是总体而言，它只是根据需要匹配XML标签来创建ContentValues对象，该对象可以插入到FinchVideoContentProvider的数据库中。当处理程序把解析出的结果都插入提供者数据库时，会执行第5步的一部分。
/**
* Parses YouTube Entity data and inserts it into the finch video content
* provider.
*/
public class YouTubeHandler implements ResponseHandler {
public static final String MEDIA = "media";
public static final String GROUP = "group";
public static final String DESCRIPTION = "description";
public static final String THUMBNAIL = "thumbnail";
public static final String TITLE = "title";
public static final String CONTENT = "content";
public static final String WIDTH = "width";
public static final String HEIGHT = "height";
public static final String YT = "yt";
public static final String DURATION = "duration";
public static final String FORMAT = "format";
public static final String URI = "uri";
public static final String THUMB_URI = "thumb_uri";
public static final String MOBILE_FORMAT = "1";
public static final String ENTRY = "entry";
public static final String ID = "id";
private static final String FLUSH_TIME = "5 minutes";
private RESTfulContentProvider mFinchVideoProvider;
private String mQueryText;
private boolean isEntry;
public YouTubeHandler(RESTfulContentProvider restfulProvider,
String queryText)
{
mFinchVideoProvider = restfulProvider;
mQueryText = queryText;
}
/*
* Handles the response from the YouTube GData server, which is in the form
* of an RSS feed containing references to YouTube videos.
*/
public void handleResponse(HttpResponse response, Uri uri)
throws IOException
{
try {
int newCount = parseYoutubeEntity(response.getEntity);
①
// only flush old state now that new state has arrived
if (newCount > 0) {
deleteOld;
}
} catch (IOException e) {
// use the exception to avoid clearing old state, if we cannot
// get new state. This way we leave the application with some
// data to work with in absence of network connectivity.
// we could retry the request for data in the hope that the network
// might return.
}
}
private void deleteOld {
// delete any old elements, not just ones that match the current query.
Cursor old = null;
try {
SQLiteDatabase db = mFinchVideoProvider.getDatabase;
old = db.query(FinchVideo.Videos.VIDEO, null,
"video." + FinchVideo.Videos.TIMESTAMP +
" < strftime('%s', 'now', '-" + FLUSH_TIME + "')",
null, null, null, null);
int c = old.getCount;
if (old.getCount > 0) {
StringBuffer sb = new StringBuffer;
boolean next;
if (old.moveToNext) {
do {
String ID = old.getString(FinchVideo.ID_COLUMN);
sb.append(FinchVideo.Videos._ID);
sb.append(" = ");
sb.append(ID);
// get rid of associated cached thumb files
mFinchVideoProvider.deleteFile(ID);
next = old.moveToNext;
if (next) {
sb.append(" OR ");
}
} while (next);
}
String where = sb.toString;
db.delete(FinchVideo.Videos.VIDEO, where, null);
Log.d(Finch.LOG_TAG, "flushed old query results: " + c);
}
} finally {
if (old != null) {
old.close;
}
}
}
private int parseYoutubeEntity(HttpEntity entity) throws IOException {
InputStream youTubeContent = entity.getContent;
InputStreamReader inputReader = new InputStreamReader(youTubeContent);
int inserted = 0;
try {
XmlPullParserFactory factory = XmlPullParserFactory.newInstance;
factory.setNamespaceAware(false);
XmlPullParser xpp = factory.newPullParser;
xpp.setInput(inputReader);
int eventType = xpp.getEventType;
String startName = null;
ContentValues mediaEntry = null;
// iterative pull parsing is a useful way to extract data from
// streams, since we don't have to hold the DOM model in memory
// during the parsing step.
while (eventType != XmlPullParser.END_DOCUMENT) {
if (eventType == XmlPullParser.START_DOCUMENT) {
} else if (eventType == XmlPullParser.END_DOCUMENT) {
} else if (eventType == XmlPullParser.START_TAG) {
startName = xpp.getName;
if ((startName != null)) {
if ((ENTRY).equals(startName))
{
mediaEntry = new ContentValues;
mediaEntry.put(FinchVideo.Videos.QUERY_TEXT_NAME,
mQueryText);
}
if ((MEDIA + ":" + CONTENT).equals(startName)) {
int c = xpp.getAttributeCount;
String mediaUri = null;
boolean isMobileFormat = false;
for (int i = 0; i < c; i++) {
String attrName = xpp.getAttributeName(i);
String attrValue = xpp.getAttributeValue(i);
if ((attrName != null) &&
URI.equals(attrName))
{
mediaUri = attrValue;
}
if ((attrName != null) && (YT + ":" + FORMAT).
equals(MOBILE_FORMAT))
{
isMobileFormat = true;
}
}
if (isMobileFormat && (mediaUri != null)) {
mediaEntry.put(URI, mediaUri);
}
}
if ((MEDIA + ":" + THUMBNAIL).equals(startName)) {
int c = xpp.getAttributeCount;
for (int i = 0; i < c; i++) {
String attrName = xpp.getAttributeName(i);
String attrValue = xpp.getAttributeValue(i);
if (attrName != null) {
if ("url".equals(attrName)) {
mediaEntry.put(
FinchVideo.Videos.
THUMB_URI_NAME,
attrValue);
} else if (WIDTH.equals(attrName))
{
mediaEntry.put(
FinchVideo.Videos.
THUMB_WIDTH_NAME,
attrValue);
} else if (HEIGHT.equals(attrName))
{
mediaEntry.put(
FinchVideo.Videos.
THUMB_HEIGHT_NAME,
attrValue);
}
}
}
}
if (ENTRY.equals(startName)) {
isEntry = true;
}
}
} else if(eventType == XmlPullParser.END_TAG) {
String endName = xpp.getName;
if (endName != null) {
if (ENTRY.equals(endName)) {
isEntry = false;
} else if (endName.equals(MEDIA + ":" + GROUP)) {
// insert the complete media group
inserted++;
// Directly invoke insert on the finch video
// provider, without using content resolver. We
// would not want the content provider to sync this
// data back to itself.
SQLiteDatabase db =
mFinchVideoProvider.getDatabase;
String mediaID = (String) mediaEntry.get(
FinchVideo.Videos.MEDIA_ID_NAME);
// insert thumb uri
String thumbContentUri =
FinchVideo.Videos.THUMB_URI + "/" + mediaID;
mediaEntry.put(FinchVideo.Videos.
THUMB_CONTENT_URI_NAME,
thumbContentUri);
String cacheFileName =
mFinchVideoProvider.getCacheName(mediaID);
mediaEntry.put(FinchVideo.Videos._DATA,
cacheFileName);
Uri providerUri = mFinchVideoProvider.
insert(FinchVideo.Videos.CONTENT_URI,
mediaEntry, db);
②
if (providerUri != null) {
String thumbUri = (String) mediaEntry.
get(FinchVideo.Videos.THUMB_URI_NAME);
// We might consider lazily downloading the
// image so that it was only downloaded on
// viewing. Downloading more aggressively
// could also improve performance.
mFinchVideoProvider.
cacheUri2File(String.valueOf(ID),
thumbUrl);
③
}
}
}
} else if (eventType == XmlPullParser.TEXT) {
// newline can turn into an extra text event
String text = xpp.getText;
if (text != null) {
text = text.trim;
if ((startName != null) && (!"".equals(text))){
if (ID.equals(startName) && isEntry) {
int lastSlash = text.lastIndexOf("/");
String entryId =
text.substring(lastSlash + 1);
mediaEntry.put(FinchVideo.Videos.MEDIA_ID_NAME,
entryId);
} else if ((MEDIA + ":" + TITLE).
equals(startName))
{
mediaEntry.put(TITLE, text);
} else if ((MEDIA + ":" +
DESCRIPTION).equals(startName))
{
mediaEntry.put(DESCRIPTION, text);
}
}
}
}
eventType = xpp.next;
}
// an alternate notification scheme might be to notify only after
// all entries have been inserted.
} catch (XmlPullParserException e) {
Log.d(Ch11.LOG_TAG,
"could not parse video feed", e);
} catch (IOException e) {
Log.d(Ch11.LOG_TAG,
"could not process video stream", e);
}
return inserted;
}
}
以下是关于上述代码的一些说明：
① 处理程序通过在parseYoutubeEntity方法中解析YouTube HTTP实体实现了handleResponse，parseYoutubeEntity方法会插入新的视频数据。然后，处理程序查询出一段时间之前的元素并删除。
② 处理程序完成了媒体元素的解析，使用其包含的内容提供者插入新解析的ContentValues对象。注意，这个操作在我们描述的操作序列中属于步骤5“响应处理程序将元素添加到本地缓存”。
③ 提供者在插入一条新的媒体项后，会初始化自身的异步请求，下载缩略图内容。后面将很快解释提供者的这个特性。
插入和ResponseHandlers
下面详细探讨步骤5，Finch视频提供者中insert的实现方式和简单的视频提供者的几乎相同。此外，正如我们在应用中看到的，视频插入是query方法的副产品。值得一提的是，insert方法可以分成两部分，内容提供者客户端调用第一部分，响应处理程序调用第二部分，其实现代码如下所示。第一种方式委托给第二种方式。我们把insert方法分成两部分，是因为响应处理程序是内容提供者的一部分，而且不需要将内容解析程序再定向到其本身：
@Override
public Uri insert(Uri uri, ContentValues initialValues) {
// Validate the requested uri
if (sUriMatcher.match(uri) != VIDEOS) {
throw new IllegalArgumentException("Unknown URI " + uri);
}
ContentValues values;
if (initialValues != null) {
values = new ContentValues(initialValues);
} else {
values = new ContentValues;
}
SQLiteDatabase db = getDatabase;
return insert(uri, initialValues, db);
}
YouTubeHandler使用以下方式，直接把记录插入到简单的视频数据库中。注意，如果数据库中已经包含准备插入的媒体的mediaID，就不需要插入该记录。通过这种方式可以避免视频项重复，当把新的数据和老的且尚未过期的数据集成起来时，可能会出现视频项重复：
public Uri insert(Uri uri, ContentValues values, SQLiteDatabase db) {
verifyValues(values);
// Validate the requested uri
int m = sUriMatcher.match(uri);
if (m != VIDEOS) {
throw new IllegalArgumentException("Unknown URI " + uri);
}
// insert the values into a new database row
String mediaID = (String) values.get(FinchVideo.Videos.MEDIA_ID);
Long rowID = mediaExists(db, mediaID);
if (rowID == null) {
long time = System.currentTimeMillis;
values.put(FinchVideo.Videos.TIMESTAMP, time);
long rowId = db.insert(VIDEOS_TABLE_NAME,
FinchVideo.Videos.VIDEO, values);
if (rowId >= 0) {
Uri insertUri =
ContentUris.withAppendedId(
FinchVideo.Videos.CONTENT_URI, rowId);
mContentResolver.notifyChange(insertUri, null);
return insertUri;
} else {
throw new IllegalStateException("could not insert " +
"content values: " + values);
}
}
return ContentUris.withAppendedId(FinchVideo.Videos.CONTENT_URI, rowID);
}
文件管理：缩略图存储
现在，我们已经了解了RESTful提供者框架是如何运作的，接下来将解释提供者是如何处理缩略图的。
前面描述了ContentResolver.openInputStream方法作为内容提供者为客户端打开文件的方式。在Finch视频实例中，我们使用该特征提供缩略图服务。把图像保存成文件使得我们能够避免使用数据库的blob类型及其带来的性能开销，并且当客户端请求这些图片时，可以只下载这些图片。如果内容提供者要提供文件服务，必须重写ContentProvider.openFile方法，ContentProvider.openFile方法会打开要提供服务的文件描述符。该方法最简单的实现方式是调用openFileHelper，执行一些便捷的功能，支持ContentResolver读取_data变量，加载其引用的文件。如果provider没有重写该方法，你会看到如下异常："No files supported by provider at..."。这种简单的实现方式只支持“只读”访问方式，如下所示：
/**
* Provides read-only access to files that have been downloaded and stored
* in the provider cache. Specifically, in this provider, clients can
* access the files of downloaded thumbnail images.
*/
@Override
public ParcelFileDescriptor openFile(Uri uri, String mode)
throws FileNotFoundException
{
// only support read-only files
if (!"r".equals(mode.toLowerCase)) {
throw new FileNotFoundException("Unsupported mode, " +
mode + ", for uri: " + uri);
}
return openFileHelper(uri, mode);
}
最后，通过ResponseHandler的FileHandler实现，从每个媒体程序对应的YouTube缩略图URL下载图像数据。该FileHandlerFactory支持管理在特定的缓存目录下保存的缓存文件，而且该FileHandlerFactory支持选择在哪里保存这些文件：
/**
* Creates instances of FileHandler objects that use a common cache directory.
* The cache directory is set in the constructor to the file handler factory.
*/
public class FileHandlerFactory {
private String mCacheDir;
public FileHandlerFactory(String cacheDir) {
mCacheDir = cacheDir;
init;
}
private void init {
File cacheDir = new File(mCacheDir);
if (!cacheDir.exists) {
cacheDir.mkdir;
}
}
public FileHandler newFileHandler(String id) {
return new FileHandler(mCacheDir, id);
}
// not really used since ContentResolver uses _data field.
public File getFile(String ID) {
String cachePath = getFileName(ID);
File cacheFile = new File(cachePath);
if (cacheFile.exists) {
return cacheFile;
}
return null;
}
public void delete(String ID) {
String cachePath = mCacheDir + "/" + ID;
File cacheFile = new File(cachePath);
if (cacheFile.exists) {
cacheFile.delete;
}
}
public String getFileName(String ID) {
return mCacheDir + "/" + ID;
}
}
/**
* Writes data from URLs into a local file cache that can be referenced by a
* database ID.
*/
public class FileHandler implements ResponseHandler {
private String mId;
private String mCacheDir;
public FileHandler(String cacheDir, String id) {
mCacheDir = cacheDir;
mId = id;
}
public
String getFileName(String ID) {
return mCacheDir + "/" + ID;
}
public void handleResponse(HttpResponse response, Uri uri)
throws IOException
{
InputStream urlStream = response.getEntity.getContent;
FileOutputStream fout =
new FileOutputStream(getFileName(mId));
byte bytes = new byte[256];
int r = 0;
do {
r = urlStream.read(bytes);
if (r >= 0) {
fout.write(bytes, 0, r);
}
} while (r >= 0);
urlStream.close;
fout.close;
}
}