private void addWordsLocked(final Cursor cursor) {
    if (cursor == null) return;
    if (cursor.moveToFirst()) {
        final int indexWord = cursor.getColumnIndex(Words.WORD);
        final int indexFrequency = cursor.getColumnIndex(Words.FREQUENCY);
        while (!cursor.isAfterLast()) {
            final String word = cursor.getString(indexWord);
            final int frequency = cursor.getInt(indexFrequency);
            final int adjustedFrequency = scaleFrequencyFromDefaultToLatinIme(frequency);
            // Safeguard against adding really long words.
            if (word.length() <= MAX_WORD_LENGTH) {
                runGCIfRequiredLocked(true /* mindsBlockByGC */);
                addUnigramLocked(word, adjustedFrequency, false /* isNotAWord */,
                        false /* isPossiblyOffensive */,
                        BinaryDictionary.NOT_A_VALID_TIMESTAMP);
            }
            cursor.moveToNext();
        }
    }
}
 

public UserDictionary(Context context, String locale) {
    super(context, Suggest.DIC_USER);
    mLocale = locale;
    // Perform a managed query. The Activity will handle closing and requerying the cursor
    // when needed.
    ContentResolver cres = context.getContentResolver();
    
    cres.registerContentObserver(Words.CONTENT_URI, true, mObserver = new ContentObserver(null) {
        @Override
        public void onChange(boolean self) {
            setRequiresReload(true);
        }
    });

    loadDictionary();
}
 

private void addWordsLocked(final Cursor cursor) {
    if (cursor == null) return;
    if (cursor.moveToFirst()) {
        final int indexWord = cursor.getColumnIndex(Words.WORD);
        final int indexFrequency = cursor.getColumnIndex(Words.FREQUENCY);
        while (!cursor.isAfterLast()) {
            final String word = cursor.getString(indexWord);
            final int frequency = cursor.getInt(indexFrequency);
            final int adjustedFrequency = scaleFrequencyFromDefaultToLatinIme(frequency);
            // Safeguard against adding really long words.
            if (word.length() <= MAX_WORD_LENGTH) {
                runGCIfRequiredLocked(true /* mindsBlockByGC */);
                addUnigramLocked(word, adjustedFrequency, false /* isNotAWord */,
                        false /* isPossiblyOffensive */,
                        BinaryDictionary.NOT_A_VALID_TIMESTAMP);
            }
            cursor.moveToNext();
        }
    }
}
 

AndroidWordLevelSpellCheckerSession(final AndroidSpellCheckerService service) {
    mService = service;
    final ContentResolver cres = service.getContentResolver();

    mObserver = new ContentObserver(null) {
        @Override
        public void onChange(boolean self) {
            mSuggestionsCache.clearCache();
        }
    };
    cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
}
 

private void addWordsLocked(final Cursor cursor) {
    final boolean hasShortcutColumn = true;
    if (cursor == null) return;
    if (cursor.moveToFirst()) {
        final int indexWord = cursor.getColumnIndex(Words.WORD);
        final int indexShortcut = hasShortcutColumn ? cursor.getColumnIndex(Words.SHORTCUT) : 0;
        final int indexFrequency = cursor.getColumnIndex(Words.FREQUENCY);
        while (!cursor.isAfterLast()) {
            final String word = cursor.getString(indexWord);
            final String shortcut = hasShortcutColumn ? cursor.getString(indexShortcut) : null;
            final int frequency = cursor.getInt(indexFrequency);
            final int adjustedFrequency = scaleFrequencyFromDefaultToLatinIme(frequency);
            // Safeguard against adding really long words.
            if (word.length() <= MAX_WORD_LENGTH) {
                runGCIfRequiredLocked(true /* mindsBlockByGC */);
                addUnigramLocked(word, adjustedFrequency, null /* shortcutTarget */,
                        0 /* shortcutFreq */, false /* isNotAWord */,
                        false /* isPossiblyOffensive */,
                        BinaryDictionary.NOT_A_VALID_TIMESTAMP);
                if (null != shortcut && shortcut.length() <= MAX_WORD_LENGTH) {
                    runGCIfRequiredLocked(true /* mindsBlockByGC */);
                    addUnigramLocked(shortcut, adjustedFrequency, word,
                            USER_DICT_SHORTCUT_FREQUENCY, true /* isNotAWord */,
                            false /* isPossiblyOffensive */,
                            BinaryDictionary.NOT_A_VALID_TIMESTAMP);
                }
            }
            cursor.moveToNext();
        }
    }
}
 

AndroidWordLevelSpellCheckerSession(final AndroidSpellCheckerService service) {
    mService = service;
    final ContentResolver cres = service.getContentResolver();

    mObserver = new ContentObserver(null) {
        @Override
        public void onChange(boolean self) {
            mSuggestionsCache.clearCache();
        }
    };
    cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
}
 

AndroidWordLevelSpellCheckerSession(final AndroidSpellCheckerService service) {
    mService = service;
    final ContentResolver cres = service.getContentResolver();

    mObserver = new ContentObserver(null) {
        @Override
        public void onChange(boolean self) {
            mSuggestionsCache.clearCache();
        }
    };
    cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
}
 

@Override
public void loadDictionaryAsync() {
    Cursor cursor = getContext().getContentResolver()
            .query(Words.CONTENT_URI, PROJECTION, "(locale IS NULL) or (locale=?)", 
                    new String[] { mLocale }, null);
    addWords(cursor);
}
 

/**
 * Adds a word to the dictionary and makes it persistent.
 * @param word the word to add. If the word is capitalized, then the dictionary will
 * recognize it as a capitalized word when searched.
 * @param frequency the frequency of occurrence of the word. A frequency of 255 is considered
 * the highest.
 * @TODO use a higher or float range for frequency
 */
@Override
public synchronized void addWord(String word, int frequency) {
    // Force load the dictionary here synchronously
    if (getRequiresReload()) loadDictionaryAsync();
    // Safeguard against adding long words. Can cause stack overflow.
    if (word.length() >= getMaxWordLength()) return;

    super.addWord(word, frequency);

    // Update the user dictionary provider
    final ContentValues values = new ContentValues(5);
    values.put(Words.WORD, word);
    values.put(Words.FREQUENCY, frequency);
    values.put(Words.LOCALE, mLocale);
    values.put(Words.APP_ID, 0);

    final ContentResolver contentResolver = getContext().getContentResolver();
    new Thread("addWord") {
        public void run() {
            contentResolver.insert(Words.CONTENT_URI, values);
        }
    }.start();

    // In case the above does a synchronous callback of the change observer
    setRequiresReload(false);
}
 

AndroidWordLevelSpellCheckerSession(final AndroidSpellCheckerService service) {
    mService = service;
    final ContentResolver cres = service.getContentResolver();

    mObserver = new ContentObserver(null) {
        @Override
        public void onChange(boolean self) {
            mSuggestionsCache.clearCache();
        }
    };
    cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
}