| /** |
| * Copyright (C) 2014 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 com.android.server.voiceinteraction; |
| |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.database.sqlite.SQLiteDatabase; |
| import android.database.sqlite.SQLiteOpenHelper; |
| import android.hardware.soundtrigger.SoundTrigger; |
| import android.hardware.soundtrigger.SoundTrigger.Keyphrase; |
| import android.hardware.soundtrigger.SoundTrigger.KeyphraseSoundModel; |
| import android.text.TextUtils; |
| import android.util.Slog; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.UUID; |
| |
| /** |
| * Helper to manage the database of the sound models that have been registered on the device. |
| * |
| * @hide |
| */ |
| public class DatabaseHelper extends SQLiteOpenHelper { |
| static final String TAG = "SoundModelDBHelper"; |
| static final boolean DBG = false; |
| |
| private static final String NAME = "sound_model.db"; |
| private static final int VERSION = 6; |
| |
| public static interface SoundModelContract { |
| public static final String TABLE = "sound_model"; |
| public static final String KEY_MODEL_UUID = "model_uuid"; |
| public static final String KEY_VENDOR_UUID = "vendor_uuid"; |
| public static final String KEY_KEYPHRASE_ID = "keyphrase_id"; |
| public static final String KEY_TYPE = "type"; |
| public static final String KEY_DATA = "data"; |
| public static final String KEY_RECOGNITION_MODES = "recognition_modes"; |
| public static final String KEY_LOCALE = "locale"; |
| public static final String KEY_HINT_TEXT = "hint_text"; |
| public static final String KEY_USERS = "users"; |
| } |
| |
| // Table Create Statement |
| private static final String CREATE_TABLE_SOUND_MODEL = "CREATE TABLE " |
| + SoundModelContract.TABLE + "(" |
| + SoundModelContract.KEY_MODEL_UUID + " TEXT," |
| + SoundModelContract.KEY_VENDOR_UUID + " TEXT," |
| + SoundModelContract.KEY_KEYPHRASE_ID + " INTEGER," |
| + SoundModelContract.KEY_TYPE + " INTEGER," |
| + SoundModelContract.KEY_DATA + " BLOB," |
| + SoundModelContract.KEY_RECOGNITION_MODES + " INTEGER," |
| + SoundModelContract.KEY_LOCALE + " TEXT," |
| + SoundModelContract.KEY_HINT_TEXT + " TEXT," |
| + SoundModelContract.KEY_USERS + " TEXT," |
| + "PRIMARY KEY (" + SoundModelContract.KEY_KEYPHRASE_ID + "," |
| + SoundModelContract.KEY_LOCALE + "," |
| + SoundModelContract.KEY_USERS + ")" |
| + ")"; |
| |
| public DatabaseHelper(Context context) { |
| super(context, NAME, null, VERSION); |
| } |
| |
| @Override |
| public void onCreate(SQLiteDatabase db) { |
| // creating required tables |
| db.execSQL(CREATE_TABLE_SOUND_MODEL); |
| } |
| |
| @Override |
| public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { |
| if (oldVersion < 4) { |
| // For old versions just drop the tables and recreate new ones. |
| db.execSQL("DROP TABLE IF EXISTS " + SoundModelContract.TABLE); |
| onCreate(db); |
| } else { |
| // In the jump to version 5, we added support for the vendor UUID. |
| if (oldVersion == 4) { |
| Slog.d(TAG, "Adding vendor UUID column"); |
| db.execSQL("ALTER TABLE " + SoundModelContract.TABLE + " ADD COLUMN " |
| + SoundModelContract.KEY_VENDOR_UUID + " TEXT"); |
| oldVersion++; |
| } |
| } |
| if (oldVersion == 5) { |
| // We need to enforce the new primary key constraint that the |
| // keyphrase id, locale, and users are unique. We have to first pull |
| // everything out of the database, remove duplicates, create the new |
| // table, then push everything back in. |
| String selectQuery = "SELECT * FROM " + SoundModelContract.TABLE; |
| Cursor c = db.rawQuery(selectQuery, null); |
| List<SoundModelRecord> old_records = new ArrayList<SoundModelRecord>(); |
| try { |
| if (c.moveToFirst()) { |
| do { |
| try { |
| old_records.add(new SoundModelRecord(5, c)); |
| } catch (Exception e) { |
| Slog.e(TAG, "Failed to extract V5 record", e); |
| } |
| } while (c.moveToNext()); |
| } |
| } finally { |
| c.close(); |
| } |
| db.execSQL("DROP TABLE IF EXISTS " + SoundModelContract.TABLE); |
| onCreate(db); |
| for (SoundModelRecord record : old_records) { |
| if (record.ifViolatesV6PrimaryKeyIsFirstOfAnyDuplicates(old_records)) { |
| try { |
| long return_value = record.writeToDatabase(6, db); |
| if (return_value == -1) { |
| Slog.e(TAG, "Database write failed " + record.modelUuid + ": " |
| + return_value); |
| } |
| } catch (Exception e) { |
| Slog.e(TAG, "Failed to update V6 record " + record.modelUuid, e); |
| } |
| } |
| } |
| oldVersion++; |
| } |
| } |
| |
| /** |
| * Updates the given keyphrase model, adds it, if it doesn't already exist. |
| * |
| * TODO: We only support one keyphrase currently. |
| */ |
| public boolean updateKeyphraseSoundModel(KeyphraseSoundModel soundModel) { |
| synchronized(this) { |
| SQLiteDatabase db = getWritableDatabase(); |
| ContentValues values = new ContentValues(); |
| values.put(SoundModelContract.KEY_MODEL_UUID, soundModel.uuid.toString()); |
| if (soundModel.vendorUuid != null) { |
| values.put(SoundModelContract.KEY_VENDOR_UUID, soundModel.vendorUuid.toString()); |
| } |
| values.put(SoundModelContract.KEY_TYPE, SoundTrigger.SoundModel.TYPE_KEYPHRASE); |
| values.put(SoundModelContract.KEY_DATA, soundModel.data); |
| |
| if (soundModel.keyphrases != null && soundModel.keyphrases.length == 1) { |
| values.put(SoundModelContract.KEY_KEYPHRASE_ID, soundModel.keyphrases[0].id); |
| values.put(SoundModelContract.KEY_RECOGNITION_MODES, |
| soundModel.keyphrases[0].recognitionModes); |
| values.put(SoundModelContract.KEY_USERS, |
| getCommaSeparatedString(soundModel.keyphrases[0].users)); |
| values.put(SoundModelContract.KEY_LOCALE, soundModel.keyphrases[0].locale); |
| values.put(SoundModelContract.KEY_HINT_TEXT, soundModel.keyphrases[0].text); |
| try { |
| return db.insertWithOnConflict(SoundModelContract.TABLE, null, values, |
| SQLiteDatabase.CONFLICT_REPLACE) != -1; |
| } finally { |
| db.close(); |
| } |
| } |
| return false; |
| } |
| } |
| |
| /** |
| * Deletes the sound model and associated keyphrases. |
| */ |
| public boolean deleteKeyphraseSoundModel(int keyphraseId, int userHandle, String bcp47Locale) { |
| // Sanitize the locale to guard against SQL injection. |
| bcp47Locale = Locale.forLanguageTag(bcp47Locale).toLanguageTag(); |
| synchronized(this) { |
| KeyphraseSoundModel soundModel = getKeyphraseSoundModel(keyphraseId, userHandle, |
| bcp47Locale); |
| if (soundModel == null) { |
| return false; |
| } |
| |
| // Delete all sound models for the given keyphrase and specified user. |
| SQLiteDatabase db = getWritableDatabase(); |
| String soundModelClause = SoundModelContract.KEY_MODEL_UUID |
| + "='" + soundModel.uuid.toString() + "'"; |
| try { |
| return db.delete(SoundModelContract.TABLE, soundModelClause, null) != 0; |
| } finally { |
| db.close(); |
| } |
| } |
| } |
| |
| /** |
| * Returns a matching {@link KeyphraseSoundModel} for the keyphrase ID. |
| * Returns null if a match isn't found. |
| * |
| * TODO: We only support one keyphrase currently. |
| */ |
| public KeyphraseSoundModel getKeyphraseSoundModel(int keyphraseId, int userHandle, |
| String bcp47Locale) { |
| // Sanitize the locale to guard against SQL injection. |
| bcp47Locale = Locale.forLanguageTag(bcp47Locale).toLanguageTag(); |
| synchronized(this) { |
| // Find the corresponding sound model ID for the keyphrase. |
| String selectQuery = "SELECT * FROM " + SoundModelContract.TABLE |
| + " WHERE " + SoundModelContract.KEY_KEYPHRASE_ID + "= '" + keyphraseId |
| + "' AND " + SoundModelContract.KEY_LOCALE + "='" + bcp47Locale + "'"; |
| SQLiteDatabase db = getReadableDatabase(); |
| Cursor c = db.rawQuery(selectQuery, null); |
| |
| try { |
| if (c.moveToFirst()) { |
| do { |
| int type = c.getInt(c.getColumnIndex(SoundModelContract.KEY_TYPE)); |
| if (type != SoundTrigger.SoundModel.TYPE_KEYPHRASE) { |
| if (DBG) { |
| Slog.w(TAG, "Ignoring SoundModel since it's type is incorrect"); |
| } |
| continue; |
| } |
| |
| String modelUuid = c.getString( |
| c.getColumnIndex(SoundModelContract.KEY_MODEL_UUID)); |
| if (modelUuid == null) { |
| Slog.w(TAG, "Ignoring SoundModel since it doesn't specify an ID"); |
| continue; |
| } |
| |
| String vendorUuidString = null; |
| int vendorUuidColumn = c.getColumnIndex(SoundModelContract.KEY_VENDOR_UUID); |
| if (vendorUuidColumn != -1) { |
| vendorUuidString = c.getString(vendorUuidColumn); |
| } |
| byte[] data = c.getBlob(c.getColumnIndex(SoundModelContract.KEY_DATA)); |
| int recognitionModes = c.getInt( |
| c.getColumnIndex(SoundModelContract.KEY_RECOGNITION_MODES)); |
| int[] users = getArrayForCommaSeparatedString( |
| c.getString(c.getColumnIndex(SoundModelContract.KEY_USERS))); |
| String modelLocale = c.getString( |
| c.getColumnIndex(SoundModelContract.KEY_LOCALE)); |
| String text = c.getString( |
| c.getColumnIndex(SoundModelContract.KEY_HINT_TEXT)); |
| |
| // Only add keyphrases meant for the current user. |
| if (users == null) { |
| // No users present in the keyphrase. |
| Slog.w(TAG, "Ignoring SoundModel since it doesn't specify users"); |
| continue; |
| } |
| |
| boolean isAvailableForCurrentUser = false; |
| for (int user : users) { |
| if (userHandle == user) { |
| isAvailableForCurrentUser = true; |
| break; |
| } |
| } |
| if (!isAvailableForCurrentUser) { |
| if (DBG) { |
| Slog.w(TAG, "Ignoring SoundModel since user handles don't match"); |
| } |
| continue; |
| } else { |
| if (DBG) Slog.d(TAG, "Found a SoundModel for user: " + userHandle); |
| } |
| |
| Keyphrase[] keyphrases = new Keyphrase[1]; |
| keyphrases[0] = new Keyphrase( |
| keyphraseId, recognitionModes, modelLocale, text, users); |
| UUID vendorUuid = null; |
| if (vendorUuidString != null) { |
| vendorUuid = UUID.fromString(vendorUuidString); |
| } |
| KeyphraseSoundModel model = new KeyphraseSoundModel( |
| UUID.fromString(modelUuid), vendorUuid, data, keyphrases); |
| if (DBG) { |
| Slog.d(TAG, "Found SoundModel for the given keyphrase/locale/user: " |
| + model); |
| } |
| return model; |
| } while (c.moveToNext()); |
| } |
| Slog.w(TAG, "No SoundModel available for the given keyphrase"); |
| } finally { |
| c.close(); |
| db.close(); |
| } |
| return null; |
| } |
| } |
| |
| private static String getCommaSeparatedString(int[] users) { |
| if (users == null) { |
| return ""; |
| } |
| StringBuilder sb = new StringBuilder(); |
| for (int i = 0; i < users.length; i++) { |
| if (i != 0) { |
| sb.append(','); |
| } |
| sb.append(users[i]); |
| } |
| return sb.toString(); |
| } |
| |
| private static int[] getArrayForCommaSeparatedString(String text) { |
| if (TextUtils.isEmpty(text)) { |
| return null; |
| } |
| String[] usersStr = text.split(","); |
| int[] users = new int[usersStr.length]; |
| for (int i = 0; i < usersStr.length; i++) { |
| users[i] = Integer.parseInt(usersStr[i]); |
| } |
| return users; |
| } |
| |
| private static class SoundModelRecord { |
| public final String modelUuid; |
| public final String vendorUuid; |
| public final int keyphraseId; |
| public final int type; |
| public final byte[] data; |
| public final int recognitionModes; |
| public final String locale; |
| public final String hintText; |
| public final String users; |
| |
| public SoundModelRecord(int version, Cursor c) { |
| modelUuid = c.getString(c.getColumnIndex(SoundModelContract.KEY_MODEL_UUID)); |
| if (version >= 5) { |
| vendorUuid = c.getString(c.getColumnIndex(SoundModelContract.KEY_VENDOR_UUID)); |
| } else { |
| vendorUuid = null; |
| } |
| keyphraseId = c.getInt(c.getColumnIndex(SoundModelContract.KEY_KEYPHRASE_ID)); |
| type = c.getInt(c.getColumnIndex(SoundModelContract.KEY_TYPE)); |
| data = c.getBlob(c.getColumnIndex(SoundModelContract.KEY_DATA)); |
| recognitionModes = c.getInt(c.getColumnIndex(SoundModelContract.KEY_RECOGNITION_MODES)); |
| locale = c.getString(c.getColumnIndex(SoundModelContract.KEY_LOCALE)); |
| hintText = c.getString(c.getColumnIndex(SoundModelContract.KEY_HINT_TEXT)); |
| users = c.getString(c.getColumnIndex(SoundModelContract.KEY_USERS)); |
| } |
| |
| private boolean V6PrimaryKeyMatches(SoundModelRecord record) { |
| return keyphraseId == record.keyphraseId && stringComparisonHelper(locale, record.locale) |
| && stringComparisonHelper(users, record.users); |
| } |
| |
| // Returns true if this record is a) the only record with the same V6 primary key, or b) the |
| // first record in the list of all records that have the same primary key and equal data. |
| // It will return false if a) there are any records that have the same primary key and |
| // different data, or b) there is a previous record in the list that has the same primary |
| // key and data. |
| // Note that 'this' object must be inside the list. |
| public boolean ifViolatesV6PrimaryKeyIsFirstOfAnyDuplicates( |
| List<SoundModelRecord> records) { |
| // First pass - check to see if all the records that have the same primary key have |
| // duplicated data. |
| for (SoundModelRecord record : records) { |
| if (this == record) { |
| continue; |
| } |
| // If we have different/missing data with the same primary key, then we should drop |
| // everything. |
| if (this.V6PrimaryKeyMatches(record) && !Arrays.equals(data, record.data)) { |
| return false; |
| } |
| } |
| |
| // We only want to return true for the first duplicated model. |
| for (SoundModelRecord record : records) { |
| if (this.V6PrimaryKeyMatches(record)) { |
| return this == record; |
| } |
| } |
| return true; |
| } |
| |
| public long writeToDatabase(int version, SQLiteDatabase db) { |
| ContentValues values = new ContentValues(); |
| values.put(SoundModelContract.KEY_MODEL_UUID, modelUuid); |
| if (version >= 5) { |
| values.put(SoundModelContract.KEY_VENDOR_UUID, vendorUuid); |
| } |
| values.put(SoundModelContract.KEY_KEYPHRASE_ID, keyphraseId); |
| values.put(SoundModelContract.KEY_TYPE, type); |
| values.put(SoundModelContract.KEY_DATA, data); |
| values.put(SoundModelContract.KEY_RECOGNITION_MODES, recognitionModes); |
| values.put(SoundModelContract.KEY_LOCALE, locale); |
| values.put(SoundModelContract.KEY_HINT_TEXT, hintText); |
| values.put(SoundModelContract.KEY_USERS, users); |
| |
| return db.insertWithOnConflict( |
| SoundModelContract.TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE); |
| } |
| |
| // Helper for checking string equality - including the case when they are null. |
| static private boolean stringComparisonHelper(String a, String b) { |
| if (a != null) { |
| return a.equals(b); |
| } |
| return a == b; |
| } |
| } |
| } |
