/**
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package org.kelar.inputmethod.dictionarypack;
import android.content.ContentProvider;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.content.res.AssetFileDescriptor;
import android.database.AbstractCursor;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import android.text.TextUtils;
import android.util.Log;
import org.kelar.inputmethod.latin.R;
import org.kelar.inputmethod.latin.common.LocaleUtils;
import org.kelar.inputmethod.latin.utils.DebugLogUtils;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
/**
* Provider for dictionaries.
*
* This class is a ContentProvider exposing all available dictionary data as managed by
* the dictionary pack.
*/
public final class DictionaryProvider extends ContentProvider {
private static final String TAG = DictionaryProvider.class.getSimpleName();
public static final boolean DEBUG = false;
public static final Uri CONTENT_URI =
Uri.parse(ContentResolver.SCHEME_CONTENT + "://" + DictionaryPackConstants.AUTHORITY);
private static final String QUERY_PARAMETER_MAY_PROMPT_USER = "mayPrompt";
private static final String QUERY_PARAMETER_TRUE = "true";
private static final String QUERY_PARAMETER_DELETE_RESULT = "result";
private static final String QUERY_PARAMETER_FAILURE = "failure";
public static final String QUERY_PARAMETER_PROTOCOL_VERSION = "protocol";
private static final int NO_MATCH = 0;
private static final int DICTIONARY_V1_WHOLE_LIST = 1;
private static final int DICTIONARY_V1_DICT_INFO = 2;
private static final int DICTIONARY_V2_METADATA = 3;
private static final int DICTIONARY_V2_WHOLE_LIST = 4;
private static final int DICTIONARY_V2_DICT_INFO = 5;
private static final int DICTIONARY_V2_DATAFILE = 6;
private static final UriMatcher sUriMatcherV1 = new UriMatcher(NO_MATCH);
private static final UriMatcher sUriMatcherV2 = new UriMatcher(NO_MATCH);
static
{
sUriMatcherV1.addURI(DictionaryPackConstants.AUTHORITY, "list", DICTIONARY_V1_WHOLE_LIST);
sUriMatcherV1.addURI(DictionaryPackConstants.AUTHORITY, "*", DICTIONARY_V1_DICT_INFO);
sUriMatcherV2.addURI(DictionaryPackConstants.AUTHORITY, "*/metadata",
DICTIONARY_V2_METADATA);
sUriMatcherV2.addURI(DictionaryPackConstants.AUTHORITY, "*/list", DICTIONARY_V2_WHOLE_LIST);
sUriMatcherV2.addURI(DictionaryPackConstants.AUTHORITY, "*/dict/*",
DICTIONARY_V2_DICT_INFO);
sUriMatcherV2.addURI(DictionaryPackConstants.AUTHORITY, "*/datafile/*",
DICTIONARY_V2_DATAFILE);
}
// MIME types for dictionary and dictionary list, as required by ContentProvider contract.
public static final String DICT_LIST_MIME_TYPE =
"vnd.android.cursor.item/vnd.google.dictionarylist";
public static final String DICT_DATAFILE_MIME_TYPE =
"vnd.android.cursor.item/vnd.google.dictionary";
public static final String ID_CATEGORY_SEPARATOR = ":";
private static final class WordListInfo {
public final String mId;
public final String mLocale;
public final String mRawChecksum;
public final int mMatchLevel;
public WordListInfo(final String id, final String locale, final String rawChecksum,
final int matchLevel) {
mId = id;
mLocale = locale;
mRawChecksum = rawChecksum;
mMatchLevel = matchLevel;
}
}
/**
* A cursor for returning a list of file ids from a List of strings.
*
* This simulates only the necessary methods. It has no error handling to speak of,
* and does not support everything a database does, only a few select necessary methods.
*/
private static final class ResourcePathCursor extends AbstractCursor {
// Column names for the cursor returned by this content provider.
static private final String[] columnNames = { MetadataDbHelper.WORDLISTID_COLUMN,
MetadataDbHelper.LOCALE_COLUMN, MetadataDbHelper.RAW_CHECKSUM_COLUMN };
// The list of word lists served by this provider that match the client request.
final WordListInfo[] mWordLists;
// Note : the cursor also uses mPos, which is defined in AbstractCursor.
public ResourcePathCursor(final Collection<WordListInfo> wordLists) {
// Allocating a 0-size WordListInfo here allows the toArray() method
// to ensure we have a strongly-typed array. It's thrown out. That's
// what the documentation of #toArray says to do in order to get a
// new strongly typed array of the correct size.
mWordLists = wordLists.toArray(new WordListInfo[0]);
mPos = 0;
}
@Override
public String[] getColumnNames() {
return columnNames;
}
@Override
public int getCount() {
return mWordLists.length;
}
@Override public double getDouble(int column) { return 0; }
@Override public float getFloat(int column) { return 0; }
@Override public int getInt(int column) { return 0; }
@Override public short getShort(int column) { return 0; }
@Override public long getLong(int column) { return 0; }
@Override public String getString(final int column) {
switch (column) {
case 0: return mWordLists[mPos].mId;
case 1: return mWordLists[mPos].mLocale;
case 2: return mWordLists[mPos].mRawChecksum;
default : return null;
}
}
@Override
public boolean isNull(final int column) {
if (mPos >= mWordLists.length) return true;
return column != 0;
}
}
@Override
public boolean onCreate() {
return true;
}
private static int matchUri(final Uri uri) {
int protocolVersion = 1;
final String protocolVersionArg = uri.getQueryParameter(QUERY_PARAMETER_PROTOCOL_VERSION);
if ("2".equals(protocolVersionArg)) protocolVersion = 2;
switch (protocolVersion) {
case 1: return sUriMatcherV1.match(uri);
case 2: return sUriMatcherV2.match(uri);
default: return NO_MATCH;
}
}
private static String getClientId(final Uri uri) {
int protocolVersion = 1;
final String protocolVersionArg = uri.getQueryParameter(QUERY_PARAMETER_PROTOCOL_VERSION);
if ("2".equals(protocolVersionArg)) protocolVersion = 2;
switch (protocolVersion) {
case 1: return null; // In protocol 1, the client ID is always null.
case 2: return uri.getPathSegments().get(0);
default: return null;
}
}
/**
* Returns the MIME type of the content associated with an Uri
*
* @see android.content.ContentProvider#getType(android.net.Uri)
*
* @param uri the URI of the content the type of which should be returned.
* @return the MIME type, or null if the URL is not recognized.
*/
@Override
public String getType(final Uri uri) {
PrivateLog.log("Asked for type of : " + uri);
final int match = matchUri(uri);
switch (match) {
case NO_MATCH: return null;
case DICTIONARY_V1_WHOLE_LIST:
case DICTIONARY_V1_DICT_INFO:
case DICTIONARY_V2_WHOLE_LIST:
case DICTIONARY_V2_DICT_INFO: return DICT_LIST_MIME_TYPE;
case DICTIONARY_V2_DATAFILE: return DICT_DATAFILE_MIME_TYPE;
default: return null;
}
}
/**
* Query the provider for dictionary files.
*
* This version dispatches the query according to the protocol version found in the
* ?protocol= query parameter. If absent or not well-formed, it defaults to 1.
* @see android.content.ContentProvider#query(Uri, String[], String, String[], String)
*
* @param uri a content uri (see sUriMatcherV{1,2} at the top of this file for format)
* @param projection ignored. All columns are always returned.
* @param selection ignored.
* @param selectionArgs ignored.
* @param sortOrder ignored. The results are always returned in no particular order.
* @return a cursor matching the uri, or null if the URI was not recognized.
*/
@Override
public Cursor query(final Uri uri, final String[] projection, final String selection,
final String[] selectionArgs, final String sortOrder) {
DebugLogUtils.l("Uri =", uri);
PrivateLog.log("Query : " + uri);
final String clientId = getClientId(uri);
final int match = matchUri(uri);
switch (match) {
case DICTIONARY_V1_WHOLE_LIST:
case DICTIONARY_V2_WHOLE_LIST:
final Cursor c = MetadataDbHelper.queryDictionaries(getContext(), clientId);
DebugLogUtils.l("List of dictionaries with count", c.getCount());
PrivateLog.log("Returned a list of " + c.getCount() + " items");
return c;
case DICTIONARY_V2_DICT_INFO:
// In protocol version 2, we return null if the client is unknown. Otherwise
// we behave exactly like for protocol 1.
if (!MetadataDbHelper.isClientKnown(getContext(), clientId)) return null;
// Fall through
case DICTIONARY_V1_DICT_INFO:
final String locale = uri.getLastPathSegment();
final Collection<WordListInfo> dictFiles =
getDictionaryWordListsForLocale(clientId, locale);
// TODO: pass clientId to the following function
DictionaryService.updateNowIfNotUpdatedInAVeryLongTime(getContext());
if (null != dictFiles && dictFiles.size() > 0) {
PrivateLog.log("Returned " + dictFiles.size() + " files");
return new ResourcePathCursor(dictFiles);
}
PrivateLog.log("No dictionary files for this URL");
return new ResourcePathCursor(Collections.<WordListInfo>emptyList());
// V2_METADATA and V2_DATAFILE are not supported for query()
default:
return null;
}
}
/**
* Helper method to get the wordlist metadata associated with a wordlist ID.
*
* @param clientId the ID of the client
* @param wordlistId the ID of the wordlist for which to get the metadata.
* @return the metadata for this wordlist ID, or null if none could be found.
*/
private ContentValues getWordlistMetadataForWordlistId(final String clientId,
final String wordlistId) {
final Context context = getContext();
if (TextUtils.isEmpty(wordlistId)) return null;
final SQLiteDatabase db = MetadataDbHelper.getDb(context, clientId);
return MetadataDbHelper.getInstalledOrDeletingWordListContentValuesByWordListId(
db, wordlistId);
}
/**
* Opens an asset file for an URI.
*
* Called by {@link android.content.ContentResolver#openAssetFileDescriptor(Uri, String)} or
* {@link android.content.ContentResolver#openInputStream(Uri)} from a client requesting a
* dictionary.
* @see android.content.ContentProvider#openAssetFile(Uri, String)
*
* @param uri the URI the file is for.
* @param mode the mode to read the file. MUST be "r" for readonly.
* @return the descriptor, or null if the file is not found or if mode is not equals to "r".
*/
@Override
public AssetFileDescriptor openAssetFile(final Uri uri, final String mode) {
if (null == mode || !"r".equals(mode)) return null;
final int match = matchUri(uri);
if (DICTIONARY_V1_DICT_INFO != match && DICTIONARY_V2_DATAFILE != match) {
// Unsupported URI for openAssetFile
Log.w(TAG, "Unsupported URI for openAssetFile : " + uri);
return null;
}
final String wordlistId = uri.getLastPathSegment();
final String clientId = getClientId(uri);
final ContentValues wordList = getWordlistMetadataForWordlistId(clientId, wordlistId);
if (null == wordList) return null;
try {
final int status = wordList.getAsInteger(MetadataDbHelper.STATUS_COLUMN);
if (MetadataDbHelper.STATUS_DELETING == status) {
// This will return an empty file (R.raw.empty points at an empty dictionary)
// This is how we "delete" the files. It allows Kelar Keyboard to fake deleting
// a default dictionary - which is actually in its assets and can't be really
// deleted.
final AssetFileDescriptor afd = getContext().getResources().openRawResourceFd(
R.raw.empty);
return afd;
}
final String localFilename =
wordList.getAsString(MetadataDbHelper.LOCAL_FILENAME_COLUMN);
final File f = getContext().getFileStreamPath(localFilename);
final ParcelFileDescriptor pfd =
ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
return new AssetFileDescriptor(pfd, 0, pfd.getStatSize());
} catch (FileNotFoundException e) {
// No file : fall through and return null
}
return null;
}
/**
* Reads the metadata and returns the collection of dictionaries for a given locale.
*
* Word list IDs are expected to be in the form category:manual_id. This method
* will select only one word list for each category: the one with the most specific
* locale matching the locale specified in the URI. The manual id serves only to
* distinguish a word list from another for the purpose of updating, and is arbitrary
* but may not contain a colon.
*
* @param clientId the ID of the client requesting the list
* @param locale the locale for which we want the list, as a String
* @return a collection of ids. It is guaranteed to be non-null, but may be empty.
*/
private Collection<WordListInfo> getDictionaryWordListsForLocale(final String clientId,
final String locale) {
final Context context = getContext();
final Cursor results =
MetadataDbHelper.queryInstalledOrDeletingOrAvailableDictionaryMetadata(context,
clientId);
if (null == results) {
return Collections.<WordListInfo>emptyList();
}
try {
final HashMap<String, WordListInfo> dicts = new HashMap<>();
final int idIndex = results.getColumnIndex(MetadataDbHelper.WORDLISTID_COLUMN);
final int localeIndex = results.getColumnIndex(MetadataDbHelper.LOCALE_COLUMN);
final int localFileNameIndex =
results.getColumnIndex(MetadataDbHelper.LOCAL_FILENAME_COLUMN);
final int rawChecksumIndex =
results.getColumnIndex(MetadataDbHelper.RAW_CHECKSUM_COLUMN);
final int statusIndex = results.getColumnIndex(MetadataDbHelper.STATUS_COLUMN);
if (results.moveToFirst()) {
do {
final String wordListId = results.getString(idIndex);
if (TextUtils.isEmpty(wordListId)) continue;
final String[] wordListIdArray =
TextUtils.split(wordListId, ID_CATEGORY_SEPARATOR);
final String wordListCategory;
if (2 == wordListIdArray.length) {
// This is at the category:manual_id format.
wordListCategory = wordListIdArray[0];
// We don't need to read wordListIdArray[1] here, because it's irrelevant to
// word list selection - it's just a name we use to identify which data file
// is a newer version of which word list. We do however return the full id
// string for each selected word list, so in this sense we are 'using' it.
} else {
// This does not contain a colon, like the old format does. Old-format IDs
// always point to main dictionaries, so we force the main category upon it.
wordListCategory = UpdateHandler.MAIN_DICTIONARY_CATEGORY;
}
final String wordListLocale = results.getString(localeIndex);
final String wordListLocalFilename = results.getString(localFileNameIndex);
final String wordListRawChecksum = results.getString(rawChecksumIndex);
final int wordListStatus = results.getInt(statusIndex);
// Test the requested locale against this wordlist locale. The requested locale
// has to either match exactly or be more specific than the dictionary - a
// dictionary for "en" would match both a request for "en" or for "en_US", but a
// dictionary for "en_GB" would not match a request for "en_US". Thus if all
// three of "en" "en_US" and "en_GB" dictionaries are installed, a request for
// "en_US" would match "en" and "en_US", and a request for "en" only would only
// match the generic "en" dictionary. For more details, see the documentation
// for LocaleUtils#getMatchLevel.
final int matchLevel = LocaleUtils.getMatchLevel(wordListLocale, locale);
if (!LocaleUtils.isMatch(matchLevel)) {
// The locale of this wordlist does not match the required locale.
// Skip this wordlist and go to the next.
continue;
}
if (MetadataDbHelper.STATUS_INSTALLED == wordListStatus) {
// If the file does not exist, it has been deleted and the IME should
// already have it. Do not return it. However, this only applies if the
// word list is INSTALLED, for if it is DELETING we should return it always
// so that Kelar Keyboard can perform the actual deletion.
final File f = getContext().getFileStreamPath(wordListLocalFilename);
if (!f.isFile()) {
continue;
}
} else if (MetadataDbHelper.STATUS_AVAILABLE == wordListStatus) {
// The locale is the id for the main dictionary.
UpdateHandler.installIfNeverRequested(context, clientId, wordListId);
continue;
}
final WordListInfo currentBestMatch = dicts.get(wordListCategory);
if (null == currentBestMatch
|| currentBestMatch.mMatchLevel < matchLevel) {
dicts.put(wordListCategory, new WordListInfo(wordListId, wordListLocale,
wordListRawChecksum, matchLevel));
}
} while (results.moveToNext());
}
return Collections.unmodifiableCollection(dicts.values());
} finally {
results.close();
}
}
/**
* Deletes the file pointed by Uri, as returned by openAssetFile.
*
* @param uri the URI the file is for.
* @param selection ignored
* @param selectionArgs ignored
* @return the number of files deleted (0 or 1 in the current implementation)
* @see android.content.ContentProvider#delete(Uri, String, String[])
*/
@Override
public int delete(final Uri uri, final String selection, final String[] selectionArgs)
throws UnsupportedOperationException {
final int match = matchUri(uri);
if (DICTIONARY_V1_DICT_INFO == match || DICTIONARY_V2_DATAFILE == match) {
return deleteDataFile(uri);
}
if (DICTIONARY_V2_METADATA == match) {
if (MetadataDbHelper.deleteClient(getContext(), getClientId(uri))) {
return 1;
}
return 0;
}
// Unsupported URI for delete
return 0;
}
private int deleteDataFile(final Uri uri) {
final String wordlistId = uri.getLastPathSegment();
final String clientId = getClientId(uri);
final ContentValues wordList = getWordlistMetadataForWordlistId(clientId, wordlistId);
if (null == wordList) {
return 0;
}
final int status = wordList.getAsInteger(MetadataDbHelper.STATUS_COLUMN);
final int version = wordList.getAsInteger(MetadataDbHelper.VERSION_COLUMN);
if (MetadataDbHelper.STATUS_DELETING == status) {
UpdateHandler.markAsDeleted(getContext(), clientId, wordlistId, version, status);
return 1;
}
if (MetadataDbHelper.STATUS_INSTALLED == status) {
final String result = uri.getQueryParameter(QUERY_PARAMETER_DELETE_RESULT);
if (QUERY_PARAMETER_FAILURE.equals(result)) {
if (DEBUG) {
Log.d(TAG,
"Dictionary is broken, attempting to retry download & installation.");
}
UpdateHandler.markAsBrokenOrRetrying(getContext(), clientId, wordlistId, version);
}
final String localFilename =
wordList.getAsString(MetadataDbHelper.LOCAL_FILENAME_COLUMN);
final File f = getContext().getFileStreamPath(localFilename);
// f.delete() returns true if the file was successfully deleted, false otherwise
return f.delete() ? 1 : 0;
}
Log.e(TAG, "Attempt to delete a file whose status is " + status);
return 0;
}
/**
* Insert data into the provider. May be either a metadata source URL or some dictionary info.
*
* @param uri the designated content URI. See sUriMatcherV{1,2} for available URIs.
* @param values the values to insert for this content uri
* @return the URI for the newly inserted item. May be null if arguments don't allow for insert
*/
@Override
public Uri insert(final Uri uri, final ContentValues values)
throws UnsupportedOperationException {
if (null == uri || null == values) return null; // Should never happen but let's be safe
PrivateLog.log("Insert, uri = " + uri.toString());
final String clientId = getClientId(uri);
switch (matchUri(uri)) {
case DICTIONARY_V2_METADATA:
// The values should contain a valid client ID and a valid URI for the metadata.
// The client ID may not be null, nor may it be empty because the empty client ID
// is reserved for internal use.
// The metadata URI may not be null, but it may be empty if the client does not
// want the dictionary pack to update the metadata automatically.
MetadataDbHelper.updateClientInfo(getContext(), clientId, values);
break;
case DICTIONARY_V2_DICT_INFO:
try {
final WordListMetadata newDictionaryMetadata =
WordListMetadata.createFromContentValues(
MetadataDbHelper.completeWithDefaultValues(values));
new ActionBatch.MarkPreInstalledAction(clientId, newDictionaryMetadata)
.execute(getContext());
} catch (final BadFormatException e) {
Log.w(TAG, "Not enough information to insert this dictionary " + values, e);
}
// We just received new information about the list of dictionary for this client.
// For all intents and purposes, this is new metadata, so we should publish it
// so that any listeners (like the Settings interface for example) can update
// themselves.
UpdateHandler.publishUpdateMetadataCompleted(getContext(), true);
break;
case DICTIONARY_V1_WHOLE_LIST:
case DICTIONARY_V1_DICT_INFO:
PrivateLog.log("Attempt to insert : " + uri);
throw new UnsupportedOperationException(
"Insertion in the dictionary is not supported in this version");
}
return uri;
}
/**
* Updating data is not supported, and will throw an exception.
* @see android.content.ContentProvider#update(Uri, ContentValues, String, String[])
* @see android.content.ContentProvider#insert(Uri, ContentValues)
*/
@Override
public int update(final Uri uri, final ContentValues values, final String selection,
final String[] selectionArgs) throws UnsupportedOperationException {
PrivateLog.log("Attempt to update : " + uri);
throw new UnsupportedOperationException("Updating dictionary words is not supported");
}
}
