1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.inputmethod.latin;
18
19import android.content.ContentResolver;
20import android.content.Context;
21import android.database.ContentObserver;
22import android.database.Cursor;
23import android.database.sqlite.SQLiteException;
24import android.net.Uri;
25import android.provider.UserDictionary.Words;
26import android.text.TextUtils;
27import android.util.Log;
28
29import com.android.inputmethod.annotations.ExternallyReferenced;
30import com.android.inputmethod.latin.utils.SubtypeLocaleUtils;
31
32import java.io.File;
33import java.util.Arrays;
34import java.util.Locale;
35
36import javax.annotation.Nullable;
37
38/**
39 * An expandable dictionary that stores the words in the user dictionary provider into a binary
40 * dictionary file to use it from native code.
41 */
42public class UserBinaryDictionary extends ExpandableBinaryDictionary {
43    private static final String TAG = ExpandableBinaryDictionary.class.getSimpleName();
44
45    // The user dictionary provider uses an empty string to mean "all languages".
46    private static final String USER_DICTIONARY_ALL_LANGUAGES = "";
47    private static final int HISTORICAL_DEFAULT_USER_DICTIONARY_FREQUENCY = 250;
48    private static final int LATINIME_DEFAULT_USER_DICTIONARY_FREQUENCY = 160;
49
50    private static final String[] PROJECTION_QUERY = new String[] {Words.WORD, Words.FREQUENCY};
51
52    private static final String NAME = "userunigram";
53
54    private ContentObserver mObserver;
55    final private String mLocaleString;
56    final private boolean mAlsoUseMoreRestrictiveLocales;
57
58    protected UserBinaryDictionary(final Context context, final Locale locale,
59                                   final boolean alsoUseMoreRestrictiveLocales,
60                                   final File dictFile, final String name) {
61        super(context, getDictName(name, locale, dictFile), locale, Dictionary.TYPE_USER, dictFile);
62        if (null == locale) throw new NullPointerException(); // Catch the error earlier
63        final String localeStr = locale.toString();
64        if (SubtypeLocaleUtils.NO_LANGUAGE.equals(localeStr)) {
65            // If we don't have a locale, insert into the "all locales" user dictionary.
66            mLocaleString = USER_DICTIONARY_ALL_LANGUAGES;
67        } else {
68            mLocaleString = localeStr;
69        }
70        mAlsoUseMoreRestrictiveLocales = alsoUseMoreRestrictiveLocales;
71        ContentResolver cres = context.getContentResolver();
72
73        mObserver = new ContentObserver(null) {
74            @Override
75            public void onChange(final boolean self) {
76                // This hook is deprecated as of API level 16 (Build.VERSION_CODES.JELLY_BEAN),
77                // but should still be supported for cases where the IME is running on an older
78                // version of the platform.
79                onChange(self, null);
80            }
81            // The following hook is only available as of API level 16
82            // (Build.VERSION_CODES.JELLY_BEAN), and as such it will only work on JellyBean+
83            // devices. On older versions of the platform, the hook above will be called instead.
84            @Override
85            public void onChange(final boolean self, final Uri uri) {
86                setNeedsToRecreate();
87            }
88        };
89        cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
90        reloadDictionaryIfRequired();
91    }
92
93    // Note: This method is called by {@link DictionaryFacilitator} using Java reflection.
94    @ExternallyReferenced
95    public static UserBinaryDictionary getDictionary(
96            final Context context, final Locale locale, final File dictFile,
97            final String dictNamePrefix, @Nullable final String account) {
98        return new UserBinaryDictionary(
99                context, locale, false /* alsoUseMoreRestrictiveLocales */,
100                dictFile, dictNamePrefix + NAME);
101    }
102
103    @Override
104    public synchronized void close() {
105        if (mObserver != null) {
106            mContext.getContentResolver().unregisterContentObserver(mObserver);
107            mObserver = null;
108        }
109        super.close();
110    }
111
112    @Override
113    public void loadInitialContentsLocked() {
114        // Split the locale. For example "en" => ["en"], "de_DE" => ["de", "DE"],
115        // "en_US_foo_bar_qux" => ["en", "US", "foo_bar_qux"] because of the limit of 3.
116        // This is correct for locale processing.
117        // For this example, we'll look at the "en_US_POSIX" case.
118        final String[] localeElements =
119                TextUtils.isEmpty(mLocaleString) ? new String[] {} : mLocaleString.split("_", 3);
120        final int length = localeElements.length;
121
122        final StringBuilder request = new StringBuilder("(locale is NULL)");
123        String localeSoFar = "";
124        // At start, localeElements = ["en", "US", "POSIX"] ; localeSoFar = "" ;
125        // and request = "(locale is NULL)"
126        for (int i = 0; i < length; ++i) {
127            // i | localeSoFar    | localeElements
128            // 0 | ""             | ["en", "US", "POSIX"]
129            // 1 | "en_"          | ["en", "US", "POSIX"]
130            // 2 | "en_US_"       | ["en", "en_US", "POSIX"]
131            localeElements[i] = localeSoFar + localeElements[i];
132            localeSoFar = localeElements[i] + "_";
133            // i | request
134            // 0 | "(locale is NULL)"
135            // 1 | "(locale is NULL) or (locale=?)"
136            // 2 | "(locale is NULL) or (locale=?) or (locale=?)"
137            request.append(" or (locale=?)");
138        }
139        // At the end, localeElements = ["en", "en_US", "en_US_POSIX"]; localeSoFar = en_US_POSIX_"
140        // and request = "(locale is NULL) or (locale=?) or (locale=?) or (locale=?)"
141
142        final String[] requestArguments;
143        // If length == 3, we already have all the arguments we need (common prefix is meaningless
144        // inside variants
145        if (mAlsoUseMoreRestrictiveLocales && length < 3) {
146            request.append(" or (locale like ?)");
147            // The following creates an array with one more (null) position
148            final String[] localeElementsWithMoreRestrictiveLocalesIncluded =
149                    Arrays.copyOf(localeElements, length + 1);
150            localeElementsWithMoreRestrictiveLocalesIncluded[length] =
151                    localeElements[length - 1] + "_%";
152            requestArguments = localeElementsWithMoreRestrictiveLocalesIncluded;
153            // If for example localeElements = ["en"]
154            // then requestArguments = ["en", "en_%"]
155            // and request = (locale is NULL) or (locale=?) or (locale like ?)
156            // If localeElements = ["en", "en_US"]
157            // then requestArguments = ["en", "en_US", "en_US_%"]
158        } else {
159            requestArguments = localeElements;
160        }
161        final String requestString = request.toString();
162        addWordsFromProjectionLocked(PROJECTION_QUERY, requestString, requestArguments);
163    }
164
165    private void addWordsFromProjectionLocked(final String[] query, String request,
166                                              final String[] requestArguments)
167            throws IllegalArgumentException {
168        Cursor cursor = null;
169        try {
170            cursor = mContext.getContentResolver().query(
171                    Words.CONTENT_URI, query, request, requestArguments, null);
172            addWordsLocked(cursor);
173        } catch (final SQLiteException e) {
174            Log.e(TAG, "SQLiteException in the remote User dictionary process.", e);
175        } finally {
176            try {
177                if (null != cursor) cursor.close();
178            } catch (final SQLiteException e) {
179                Log.e(TAG, "SQLiteException in the remote User dictionary process.", e);
180            }
181        }
182    }
183
184    private static int scaleFrequencyFromDefaultToLatinIme(final int defaultFrequency) {
185        // The default frequency for the user dictionary is 250 for historical reasons.
186        // Latin IME considers a good value for the default user dictionary frequency
187        // is about 160 considering the scale we use. So we are scaling down the values.
188        if (defaultFrequency > Integer.MAX_VALUE / LATINIME_DEFAULT_USER_DICTIONARY_FREQUENCY) {
189            return (defaultFrequency / HISTORICAL_DEFAULT_USER_DICTIONARY_FREQUENCY)
190                    * LATINIME_DEFAULT_USER_DICTIONARY_FREQUENCY;
191        }
192        return (defaultFrequency * LATINIME_DEFAULT_USER_DICTIONARY_FREQUENCY)
193                / HISTORICAL_DEFAULT_USER_DICTIONARY_FREQUENCY;
194    }
195
196    private void addWordsLocked(final Cursor cursor) {
197        if (cursor == null) return;
198        if (cursor.moveToFirst()) {
199            final int indexWord = cursor.getColumnIndex(Words.WORD);
200            final int indexFrequency = cursor.getColumnIndex(Words.FREQUENCY);
201            while (!cursor.isAfterLast()) {
202                final String word = cursor.getString(indexWord);
203                final int frequency = cursor.getInt(indexFrequency);
204                final int adjustedFrequency = scaleFrequencyFromDefaultToLatinIme(frequency);
205                // Safeguard against adding really long words.
206                if (word.length() <= MAX_WORD_LENGTH) {
207                    runGCIfRequiredLocked(true /* mindsBlockByGC */);
208                    addUnigramLocked(word, adjustedFrequency, false /* isNotAWord */,
209                            false /* isPossiblyOffensive */,
210                            BinaryDictionary.NOT_A_VALID_TIMESTAMP);
211                }
212                cursor.moveToNext();
213            }
214        }
215    }
216}
217