| /* |
| * 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 com.android.cellbroadcastreceiver; |
| |
| import static java.nio.file.Files.copy; |
| |
| import android.annotation.NonNull; |
| import android.content.ContentProviderClient; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.database.Cursor; |
| import android.database.sqlite.SQLiteDatabase; |
| import android.database.sqlite.SQLiteOpenHelper; |
| import android.os.RemoteException; |
| import android.preference.PreferenceManager; |
| import android.provider.Telephony; |
| import android.provider.Telephony.CellBroadcasts; |
| import android.util.Log; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| |
| import java.io.File; |
| |
| /** |
| * Open, create, and upgrade the cell broadcast SQLite database. Previously an inner class of |
| * {@code CellBroadcastDatabase}, this is now a top-level class. The column definitions in |
| * {@code CellBroadcastDatabase} have been moved to {@link Telephony.CellBroadcasts} in the |
| * framework, to simplify access to this database from third-party apps. |
| */ |
| public class CellBroadcastDatabaseHelper extends SQLiteOpenHelper { |
| |
| private static final String TAG = "CellBroadcastDatabaseHelper"; |
| |
| /** |
| * Database version 1: initial version (support removed) |
| * Database version 2-9: (reserved for OEM database customization) (support removed) |
| * Database version 10: adds ETWS and CMAS columns and CDMA support (support removed) |
| * Database version 11: adds delivery time index |
| * Database version 12: add slotIndex |
| * Database version 13: add smsSyncPending |
| */ |
| private static final int DATABASE_VERSION = 13; |
| |
| private static final String OLD_DATABASE_NAME = "cell_broadcasts.db"; |
| private static final String DATABASE_NAME_V13 = "cell_broadcasts_v13.db"; |
| @VisibleForTesting |
| public static final String TABLE_NAME = "broadcasts"; |
| |
| // Preference key for whether the data migration from pre-R CBR app was complete. |
| public static final String KEY_LEGACY_DATA_MIGRATION = "legacy_data_migration"; |
| |
| /** |
| * Is the message pending for sms synchronization. |
| * when received cellbroadcast message in direct boot mode, we will retry synchronizing |
| * alert message to sms inbox after user unlock if needed. |
| * <P>Type: Boolean</P> |
| */ |
| public static final String SMS_SYNC_PENDING = "isSmsSyncPending"; |
| |
| /* |
| * Query columns for instantiating SmsCbMessage. |
| */ |
| public static final String[] QUERY_COLUMNS = { |
| Telephony.CellBroadcasts._ID, |
| Telephony.CellBroadcasts.SLOT_INDEX, |
| Telephony.CellBroadcasts.GEOGRAPHICAL_SCOPE, |
| Telephony.CellBroadcasts.PLMN, |
| Telephony.CellBroadcasts.LAC, |
| Telephony.CellBroadcasts.CID, |
| Telephony.CellBroadcasts.SERIAL_NUMBER, |
| Telephony.CellBroadcasts.SERVICE_CATEGORY, |
| Telephony.CellBroadcasts.LANGUAGE_CODE, |
| Telephony.CellBroadcasts.MESSAGE_BODY, |
| Telephony.CellBroadcasts.DELIVERY_TIME, |
| Telephony.CellBroadcasts.MESSAGE_READ, |
| Telephony.CellBroadcasts.MESSAGE_FORMAT, |
| Telephony.CellBroadcasts.MESSAGE_PRIORITY, |
| Telephony.CellBroadcasts.ETWS_WARNING_TYPE, |
| Telephony.CellBroadcasts.CMAS_MESSAGE_CLASS, |
| Telephony.CellBroadcasts.CMAS_CATEGORY, |
| Telephony.CellBroadcasts.CMAS_RESPONSE_TYPE, |
| Telephony.CellBroadcasts.CMAS_SEVERITY, |
| Telephony.CellBroadcasts.CMAS_URGENCY, |
| Telephony.CellBroadcasts.CMAS_CERTAINTY |
| }; |
| |
| /** |
| * Returns a string used to create the cell broadcast table. This is exposed so the unit test |
| * can construct its own in-memory database to match the cell broadcast db. |
| */ |
| @VisibleForTesting |
| public static String getStringForCellBroadcastTableCreation(String tableName) { |
| return "CREATE TABLE " + tableName + " (" |
| + CellBroadcasts._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," |
| + CellBroadcasts.SLOT_INDEX + " INTEGER DEFAULT 0," |
| + CellBroadcasts.GEOGRAPHICAL_SCOPE + " INTEGER," |
| + CellBroadcasts.PLMN + " TEXT," |
| + CellBroadcasts.LAC + " INTEGER," |
| + CellBroadcasts.CID + " INTEGER," |
| + CellBroadcasts.SERIAL_NUMBER + " INTEGER," |
| + Telephony.CellBroadcasts.SERVICE_CATEGORY + " INTEGER," |
| + Telephony.CellBroadcasts.LANGUAGE_CODE + " TEXT," |
| + Telephony.CellBroadcasts.MESSAGE_BODY + " TEXT," |
| + Telephony.CellBroadcasts.DELIVERY_TIME + " INTEGER," |
| + Telephony.CellBroadcasts.MESSAGE_READ + " INTEGER," |
| + Telephony.CellBroadcasts.MESSAGE_FORMAT + " INTEGER," |
| + Telephony.CellBroadcasts.MESSAGE_PRIORITY + " INTEGER," |
| + Telephony.CellBroadcasts.ETWS_WARNING_TYPE + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_MESSAGE_CLASS + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_CATEGORY + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_RESPONSE_TYPE + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_SEVERITY + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_URGENCY + " INTEGER," |
| + Telephony.CellBroadcasts.CMAS_CERTAINTY + " INTEGER," |
| + SMS_SYNC_PENDING + " BOOLEAN);"; |
| } |
| |
| private final Context mContext; |
| final boolean mLegacyProvider; |
| |
| private ContentProviderClient mOverrideContentProviderClient = null; |
| |
| @VisibleForTesting |
| public CellBroadcastDatabaseHelper(Context context, boolean legacyProvider) { |
| super(context, DATABASE_NAME_V13, null, DATABASE_VERSION); |
| mContext = context; |
| mLegacyProvider = legacyProvider; |
| } |
| |
| @VisibleForTesting |
| public CellBroadcastDatabaseHelper(Context context, boolean legacyProvider, String dbName) { |
| super(context, dbName, null, DATABASE_VERSION); |
| mContext = context; |
| mLegacyProvider = legacyProvider; |
| } |
| |
| @Override |
| public void onCreate(SQLiteDatabase db) { |
| db.execSQL(getStringForCellBroadcastTableCreation(TABLE_NAME)); |
| |
| db.execSQL("CREATE INDEX IF NOT EXISTS deliveryTimeIndex ON " + TABLE_NAME |
| + " (" + Telephony.CellBroadcasts.DELIVERY_TIME + ");"); |
| if (!mLegacyProvider) { |
| migrateFromLegacyIfNeeded(db); |
| } |
| } |
| |
| @Override |
| public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { |
| if (oldVersion == newVersion) { |
| return; |
| } |
| // always log database upgrade |
| log("Upgrading DB from version " + oldVersion + " to " + newVersion); |
| |
| if (oldVersion < 12) { |
| db.execSQL("ALTER TABLE " + TABLE_NAME + " ADD COLUMN " |
| + Telephony.CellBroadcasts.SLOT_INDEX + " INTEGER DEFAULT 0;"); |
| } |
| if (oldVersion < 13) { |
| db.execSQL("ALTER TABLE " + TABLE_NAME + " ADD COLUMN " + SMS_SYNC_PENDING |
| + " BOOLEAN DEFAULT 0;"); |
| } |
| } |
| |
| private synchronized void tryToMigrateV13() { |
| File oldDb = mContext.getDatabasePath(OLD_DATABASE_NAME); |
| File newDb = mContext.getDatabasePath(DATABASE_NAME_V13); |
| if (!oldDb.exists()) { |
| return; |
| } |
| // We do the DB copy in two scenarios: |
| // 1. device receives v13 upgrade. |
| // 2. device receives v13 upgrade, gets rollback to v12, then receives v13 upgrade again. |
| // If the DB is modified after rollback, we want to copy those changes again. |
| if (!newDb.exists() || oldDb.lastModified() > newDb.lastModified()) { |
| try { |
| // copy() requires that the destination file does not exist |
| Log.d(TAG, "copying to v13 db"); |
| if (newDb.exists()) newDb.delete(); |
| copy(oldDb.toPath(), newDb.toPath()); |
| } catch (Exception e) { |
| // If the copy failed we don't know if the db is in a safe state, so just delete it |
| // and continue with an empty new db. Ignore the exception and just log an error. |
| mContext.deleteDatabase(DATABASE_NAME_V13); |
| loge("could not copy DB to v13. e=" + e); |
| } |
| } |
| // else the V13 database has already been created. |
| } |
| |
| @Override |
| public SQLiteDatabase getReadableDatabase() { |
| tryToMigrateV13(); |
| return super.getReadableDatabase(); |
| } |
| |
| @Override |
| public SQLiteDatabase getWritableDatabase() { |
| tryToMigrateV13(); |
| return super.getWritableDatabase(); |
| } |
| |
| @VisibleForTesting |
| public void setOverrideContentProviderClient(ContentProviderClient client) { |
| mOverrideContentProviderClient = client; |
| } |
| |
| private ContentProviderClient getContentProviderClient() { |
| if (mOverrideContentProviderClient != null) { |
| return mOverrideContentProviderClient; |
| } |
| return mContext.getContentResolver() |
| .acquireContentProviderClient(Telephony.CellBroadcasts.AUTHORITY_LEGACY); |
| } |
| |
| /** |
| * This is the migration logic to accommodate OEMs move to mainlined CBR for the first time. |
| * When the db is initially created, this is called once to |
| * migrate predefined data through {@link Telephony.CellBroadcasts#AUTHORITY_LEGACY_URI} |
| * from OEM app. |
| */ |
| @VisibleForTesting |
| public void migrateFromLegacyIfNeeded(@NonNull SQLiteDatabase db) { |
| SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(mContext); |
| if (sp.getBoolean(CellBroadcastDatabaseHelper.KEY_LEGACY_DATA_MIGRATION, false)) { |
| log("Data migration was complete already"); |
| return; |
| } |
| |
| try (ContentProviderClient client = getContentProviderClient()) { |
| if (client == null) { |
| log("No legacy provider available for migration"); |
| return; |
| } |
| |
| db.beginTransaction(); |
| log("Starting migration from legacy provider"); |
| // migration columns are same as query columns |
| try (Cursor c = client.query(Telephony.CellBroadcasts.AUTHORITY_LEGACY_URI, |
| QUERY_COLUMNS, null, null, null)) { |
| final ContentValues values = new ContentValues(); |
| while (c.moveToNext()) { |
| values.clear(); |
| for (String column : QUERY_COLUMNS) { |
| copyFromCursorToContentValues(column, c, values); |
| } |
| // remove the primary key to avoid UNIQUE constraint failure. |
| values.remove(Telephony.CellBroadcasts._ID); |
| |
| try { |
| if (db.insert(TABLE_NAME, null, values) == -1) { |
| // We only have one shot to migrate data, so log and |
| // keep marching forward |
| loge("Failed to insert " + values + "; continuing"); |
| } |
| } catch (Exception e) { |
| // If insert for one message fails, continue with other messages |
| loge("Failed to insert " + values + " due to exception: " + e); |
| } |
| } |
| |
| log("Finished migration from legacy provider"); |
| } catch (RemoteException e) { |
| throw new IllegalStateException(e); |
| } finally { |
| // if beginTransaction() is called then setTransactionSuccessful() must be called. |
| // This is a nested begin/end transcation block -- since this is called from |
| // onCreate() which is inside another block in SQLiteOpenHelper. If a nested |
| // transaction fails, all transaction fail and that would result in table not being |
| // created (it's created in onCreate()). |
| db.setTransactionSuccessful(); |
| db.endTransaction(); |
| } |
| } catch (Exception e) { |
| // We have to guard ourselves against any weird behavior of the |
| // legacy provider by trying to catch everything |
| loge("Failed migration from legacy provider: " + e); |
| } finally { |
| // Mark data migration was triggered to make sure this is done only once. |
| sp.edit().putBoolean(KEY_LEGACY_DATA_MIGRATION, true).commit(); |
| } |
| } |
| |
| public static void copyFromCursorToContentValues(@NonNull String column, @NonNull Cursor cursor, |
| @NonNull ContentValues values) { |
| final int index = cursor.getColumnIndex(column); |
| if (index != -1) { |
| if (cursor.isNull(index)) { |
| values.putNull(column); |
| } else { |
| values.put(column, cursor.getString(index)); |
| } |
| } |
| } |
| |
| private static void log(String msg) { |
| Log.d(TAG, msg); |
| } |
| |
| private static void loge(String msg) { |
| Log.e(TAG, msg); |
| } |
| } |
