1/* 2 * Copyright (C) 2014 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.providers.tv; 18 19import android.annotation.SuppressLint; 20import android.app.AlarmManager; 21import android.app.PendingIntent; 22import android.content.ContentProvider; 23import android.content.ContentProviderOperation; 24import android.content.ContentProviderResult; 25import android.content.ContentValues; 26import android.content.Context; 27import android.content.Intent; 28import android.content.OperationApplicationException; 29import android.content.SharedPreferences; 30import android.content.UriMatcher; 31import android.content.pm.PackageManager; 32import android.database.Cursor; 33import android.database.DatabaseUtils; 34import android.database.SQLException; 35import android.database.sqlite.SQLiteDatabase; 36import android.database.sqlite.SQLiteOpenHelper; 37import android.database.sqlite.SQLiteQueryBuilder; 38import android.graphics.Bitmap; 39import android.graphics.BitmapFactory; 40import android.media.tv.TvContract; 41import android.media.tv.TvContract.BaseTvColumns; 42import android.media.tv.TvContract.Channels; 43import android.media.tv.TvContract.PreviewPrograms; 44import android.media.tv.TvContract.Programs; 45import android.media.tv.TvContract.Programs.Genres; 46import android.media.tv.TvContract.RecordedPrograms; 47import android.media.tv.TvContract.WatchedPrograms; 48import android.media.tv.TvContract.WatchNextPrograms; 49import android.net.Uri; 50import android.os.AsyncTask; 51import android.os.Bundle; 52import android.os.Handler; 53import android.os.Message; 54import android.os.ParcelFileDescriptor; 55import android.os.ParcelFileDescriptor.AutoCloseInputStream; 56import android.preference.PreferenceManager; 57import android.provider.BaseColumns; 58import android.text.TextUtils; 59import android.text.format.DateUtils; 60import android.util.Log; 61 62import com.android.internal.annotations.VisibleForTesting; 63import com.android.internal.os.SomeArgs; 64import com.android.providers.tv.util.SqlParams; 65 66import libcore.io.IoUtils; 67 68import java.io.ByteArrayOutputStream; 69import java.io.FileNotFoundException; 70import java.io.IOException; 71import java.util.ArrayList; 72import java.util.HashMap; 73import java.util.HashSet; 74import java.util.Iterator; 75import java.util.Map; 76import java.util.Set; 77import java.util.concurrent.ConcurrentHashMap; 78 79/** 80 * TV content provider. The contract between this provider and applications is defined in 81 * {@link android.media.tv.TvContract}. 82 */ 83public class TvProvider extends ContentProvider { 84 private static final boolean DEBUG = false; 85 private static final String TAG = "TvProvider"; 86 87 static final int DATABASE_VERSION = 34; 88 static final String SHARED_PREF_BLOCKED_PACKAGES_KEY = "blocked_packages"; 89 static final String CHANNELS_TABLE = "channels"; 90 static final String PROGRAMS_TABLE = "programs"; 91 static final String RECORDED_PROGRAMS_TABLE = "recorded_programs"; 92 static final String PREVIEW_PROGRAMS_TABLE = "preview_programs"; 93 static final String WATCH_NEXT_PROGRAMS_TABLE = "watch_next_programs"; 94 static final String WATCHED_PROGRAMS_TABLE = "watched_programs"; 95 static final String PROGRAMS_TABLE_PACKAGE_NAME_INDEX = "programs_package_name_index"; 96 static final String PROGRAMS_TABLE_CHANNEL_ID_INDEX = "programs_channel_id_index"; 97 static final String PROGRAMS_TABLE_START_TIME_INDEX = "programs_start_time_index"; 98 static final String PROGRAMS_TABLE_END_TIME_INDEX = "programs_end_time_index"; 99 static final String WATCHED_PROGRAMS_TABLE_CHANNEL_ID_INDEX = 100 "watched_programs_channel_id_index"; 101 // The internal column in the watched programs table to indicate whether the current log entry 102 // is consolidated or not. Unconsolidated entries may have columns with missing data. 103 static final String WATCHED_PROGRAMS_COLUMN_CONSOLIDATED = "consolidated"; 104 static final String CHANNELS_COLUMN_LOGO = "logo"; 105 private static final String DATABASE_NAME = "tv.db"; 106 private static final String DELETED_CHANNELS_TABLE = "deleted_channels"; // Deprecated 107 private static final String DEFAULT_PROGRAMS_SORT_ORDER = Programs.COLUMN_START_TIME_UTC_MILLIS 108 + " ASC"; 109 private static final String DEFAULT_WATCHED_PROGRAMS_SORT_ORDER = 110 WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC"; 111 private static final String CHANNELS_TABLE_INNER_JOIN_PROGRAMS_TABLE = CHANNELS_TABLE 112 + " INNER JOIN " + PROGRAMS_TABLE 113 + " ON (" + CHANNELS_TABLE + "." + Channels._ID + "=" 114 + PROGRAMS_TABLE + "." + Programs.COLUMN_CHANNEL_ID + ")"; 115 116 // Operation names for createSqlParams(). 117 private static final String OP_QUERY = "query"; 118 private static final String OP_UPDATE = "update"; 119 private static final String OP_DELETE = "delete"; 120 121 122 private static final UriMatcher sUriMatcher; 123 private static final int MATCH_CHANNEL = 1; 124 private static final int MATCH_CHANNEL_ID = 2; 125 private static final int MATCH_CHANNEL_ID_LOGO = 3; 126 private static final int MATCH_PASSTHROUGH_ID = 4; 127 private static final int MATCH_PROGRAM = 5; 128 private static final int MATCH_PROGRAM_ID = 6; 129 private static final int MATCH_WATCHED_PROGRAM = 7; 130 private static final int MATCH_WATCHED_PROGRAM_ID = 8; 131 private static final int MATCH_RECORDED_PROGRAM = 9; 132 private static final int MATCH_RECORDED_PROGRAM_ID = 10; 133 private static final int MATCH_PREVIEW_PROGRAM = 11; 134 private static final int MATCH_PREVIEW_PROGRAM_ID = 12; 135 private static final int MATCH_WATCH_NEXT_PROGRAM = 13; 136 private static final int MATCH_WATCH_NEXT_PROGRAM_ID = 14; 137 138 private static final int MAX_LOGO_IMAGE_SIZE = 256; 139 140 private static final String EMPTY_STRING = ""; 141 142 private static final long MAX_PROGRAM_DATA_DELAY_IN_MILLIS = 10 * 1000; // 10 seconds 143 144 private static final Map<String, String> sChannelProjectionMap; 145 private static final Map<String, String> sProgramProjectionMap; 146 private static final Map<String, String> sWatchedProgramProjectionMap; 147 private static final Map<String, String> sRecordedProgramProjectionMap; 148 private static final Map<String, String> sPreviewProgramProjectionMap; 149 private static final Map<String, String> sWatchNextProgramProjectionMap; 150 private static boolean sInitialized; 151 152 static { 153 sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH); 154 sUriMatcher.addURI(TvContract.AUTHORITY, "channel", MATCH_CHANNEL); 155 sUriMatcher.addURI(TvContract.AUTHORITY, "channel/#", MATCH_CHANNEL_ID); 156 sUriMatcher.addURI(TvContract.AUTHORITY, "channel/#/logo", MATCH_CHANNEL_ID_LOGO); 157 sUriMatcher.addURI(TvContract.AUTHORITY, "passthrough/*", MATCH_PASSTHROUGH_ID); 158 sUriMatcher.addURI(TvContract.AUTHORITY, "program", MATCH_PROGRAM); 159 sUriMatcher.addURI(TvContract.AUTHORITY, "program/#", MATCH_PROGRAM_ID); 160 sUriMatcher.addURI(TvContract.AUTHORITY, "watched_program", MATCH_WATCHED_PROGRAM); 161 sUriMatcher.addURI(TvContract.AUTHORITY, "watched_program/#", MATCH_WATCHED_PROGRAM_ID); 162 sUriMatcher.addURI(TvContract.AUTHORITY, "recorded_program", MATCH_RECORDED_PROGRAM); 163 sUriMatcher.addURI(TvContract.AUTHORITY, "recorded_program/#", MATCH_RECORDED_PROGRAM_ID); 164 sUriMatcher.addURI(TvContract.AUTHORITY, "preview_program", MATCH_PREVIEW_PROGRAM); 165 sUriMatcher.addURI(TvContract.AUTHORITY, "preview_program/#", MATCH_PREVIEW_PROGRAM_ID); 166 sUriMatcher.addURI(TvContract.AUTHORITY, "watch_next_program", MATCH_WATCH_NEXT_PROGRAM); 167 sUriMatcher.addURI(TvContract.AUTHORITY, "watch_next_program/#", 168 MATCH_WATCH_NEXT_PROGRAM_ID); 169 170 sChannelProjectionMap = new HashMap<>(); 171 sChannelProjectionMap.put(Channels._ID, CHANNELS_TABLE + "." + Channels._ID); 172 sChannelProjectionMap.put(Channels.COLUMN_PACKAGE_NAME, 173 CHANNELS_TABLE + "." + Channels.COLUMN_PACKAGE_NAME); 174 sChannelProjectionMap.put(Channels.COLUMN_INPUT_ID, 175 CHANNELS_TABLE + "." + Channels.COLUMN_INPUT_ID); 176 sChannelProjectionMap.put(Channels.COLUMN_TYPE, 177 CHANNELS_TABLE + "." + Channels.COLUMN_TYPE); 178 sChannelProjectionMap.put(Channels.COLUMN_SERVICE_TYPE, 179 CHANNELS_TABLE + "." + Channels.COLUMN_SERVICE_TYPE); 180 sChannelProjectionMap.put(Channels.COLUMN_ORIGINAL_NETWORK_ID, 181 CHANNELS_TABLE + "." + Channels.COLUMN_ORIGINAL_NETWORK_ID); 182 sChannelProjectionMap.put(Channels.COLUMN_TRANSPORT_STREAM_ID, 183 CHANNELS_TABLE + "." + Channels.COLUMN_TRANSPORT_STREAM_ID); 184 sChannelProjectionMap.put(Channels.COLUMN_SERVICE_ID, 185 CHANNELS_TABLE + "." + Channels.COLUMN_SERVICE_ID); 186 sChannelProjectionMap.put(Channels.COLUMN_DISPLAY_NUMBER, 187 CHANNELS_TABLE + "." + Channels.COLUMN_DISPLAY_NUMBER); 188 sChannelProjectionMap.put(Channels.COLUMN_DISPLAY_NAME, 189 CHANNELS_TABLE + "." + Channels.COLUMN_DISPLAY_NAME); 190 sChannelProjectionMap.put(Channels.COLUMN_NETWORK_AFFILIATION, 191 CHANNELS_TABLE + "." + Channels.COLUMN_NETWORK_AFFILIATION); 192 sChannelProjectionMap.put(Channels.COLUMN_DESCRIPTION, 193 CHANNELS_TABLE + "." + Channels.COLUMN_DESCRIPTION); 194 sChannelProjectionMap.put(Channels.COLUMN_VIDEO_FORMAT, 195 CHANNELS_TABLE + "." + Channels.COLUMN_VIDEO_FORMAT); 196 sChannelProjectionMap.put(Channels.COLUMN_BROWSABLE, 197 CHANNELS_TABLE + "." + Channels.COLUMN_BROWSABLE); 198 sChannelProjectionMap.put(Channels.COLUMN_SEARCHABLE, 199 CHANNELS_TABLE + "." + Channels.COLUMN_SEARCHABLE); 200 sChannelProjectionMap.put(Channels.COLUMN_LOCKED, 201 CHANNELS_TABLE + "." + Channels.COLUMN_LOCKED); 202 sChannelProjectionMap.put(Channels.COLUMN_APP_LINK_ICON_URI, 203 CHANNELS_TABLE + "." + Channels.COLUMN_APP_LINK_ICON_URI); 204 sChannelProjectionMap.put(Channels.COLUMN_APP_LINK_POSTER_ART_URI, 205 CHANNELS_TABLE + "." + Channels.COLUMN_APP_LINK_POSTER_ART_URI); 206 sChannelProjectionMap.put(Channels.COLUMN_APP_LINK_TEXT, 207 CHANNELS_TABLE + "." + Channels.COLUMN_APP_LINK_TEXT); 208 sChannelProjectionMap.put(Channels.COLUMN_APP_LINK_COLOR, 209 CHANNELS_TABLE + "." + Channels.COLUMN_APP_LINK_COLOR); 210 sChannelProjectionMap.put(Channels.COLUMN_APP_LINK_INTENT_URI, 211 CHANNELS_TABLE + "." + Channels.COLUMN_APP_LINK_INTENT_URI); 212 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_DATA, 213 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_DATA); 214 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_FLAG1, 215 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_FLAG1); 216 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_FLAG2, 217 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_FLAG2); 218 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_FLAG3, 219 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_FLAG3); 220 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_FLAG4, 221 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_FLAG4); 222 sChannelProjectionMap.put(Channels.COLUMN_VERSION_NUMBER, 223 CHANNELS_TABLE + "." + Channels.COLUMN_VERSION_NUMBER); 224 sChannelProjectionMap.put(Channels.COLUMN_TRANSIENT, 225 CHANNELS_TABLE + "." + Channels.COLUMN_TRANSIENT); 226 sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_ID, 227 CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_ID); 228 229 sProgramProjectionMap = new HashMap<>(); 230 sProgramProjectionMap.put(Programs._ID, Programs._ID); 231 sProgramProjectionMap.put(Programs.COLUMN_PACKAGE_NAME, Programs.COLUMN_PACKAGE_NAME); 232 sProgramProjectionMap.put(Programs.COLUMN_CHANNEL_ID, Programs.COLUMN_CHANNEL_ID); 233 sProgramProjectionMap.put(Programs.COLUMN_TITLE, Programs.COLUMN_TITLE); 234 // COLUMN_SEASON_NUMBER is deprecated. Return COLUMN_SEASON_DISPLAY_NUMBER instead. 235 sProgramProjectionMap.put(Programs.COLUMN_SEASON_NUMBER, 236 Programs.COLUMN_SEASON_DISPLAY_NUMBER + " AS " + Programs.COLUMN_SEASON_NUMBER); 237 sProgramProjectionMap.put(Programs.COLUMN_SEASON_DISPLAY_NUMBER, 238 Programs.COLUMN_SEASON_DISPLAY_NUMBER); 239 sProgramProjectionMap.put(Programs.COLUMN_SEASON_TITLE, Programs.COLUMN_SEASON_TITLE); 240 // COLUMN_EPISODE_NUMBER is deprecated. Return COLUMN_EPISODE_DISPLAY_NUMBER instead. 241 sProgramProjectionMap.put(Programs.COLUMN_EPISODE_NUMBER, 242 Programs.COLUMN_EPISODE_DISPLAY_NUMBER + " AS " + Programs.COLUMN_EPISODE_NUMBER); 243 sProgramProjectionMap.put(Programs.COLUMN_EPISODE_DISPLAY_NUMBER, 244 Programs.COLUMN_EPISODE_DISPLAY_NUMBER); 245 sProgramProjectionMap.put(Programs.COLUMN_EPISODE_TITLE, Programs.COLUMN_EPISODE_TITLE); 246 sProgramProjectionMap.put(Programs.COLUMN_START_TIME_UTC_MILLIS, 247 Programs.COLUMN_START_TIME_UTC_MILLIS); 248 sProgramProjectionMap.put(Programs.COLUMN_END_TIME_UTC_MILLIS, 249 Programs.COLUMN_END_TIME_UTC_MILLIS); 250 sProgramProjectionMap.put(Programs.COLUMN_BROADCAST_GENRE, Programs.COLUMN_BROADCAST_GENRE); 251 sProgramProjectionMap.put(Programs.COLUMN_CANONICAL_GENRE, Programs.COLUMN_CANONICAL_GENRE); 252 sProgramProjectionMap.put(Programs.COLUMN_SHORT_DESCRIPTION, 253 Programs.COLUMN_SHORT_DESCRIPTION); 254 sProgramProjectionMap.put(Programs.COLUMN_LONG_DESCRIPTION, 255 Programs.COLUMN_LONG_DESCRIPTION); 256 sProgramProjectionMap.put(Programs.COLUMN_VIDEO_WIDTH, Programs.COLUMN_VIDEO_WIDTH); 257 sProgramProjectionMap.put(Programs.COLUMN_VIDEO_HEIGHT, Programs.COLUMN_VIDEO_HEIGHT); 258 sProgramProjectionMap.put(Programs.COLUMN_AUDIO_LANGUAGE, Programs.COLUMN_AUDIO_LANGUAGE); 259 sProgramProjectionMap.put(Programs.COLUMN_CONTENT_RATING, Programs.COLUMN_CONTENT_RATING); 260 sProgramProjectionMap.put(Programs.COLUMN_POSTER_ART_URI, Programs.COLUMN_POSTER_ART_URI); 261 sProgramProjectionMap.put(Programs.COLUMN_THUMBNAIL_URI, Programs.COLUMN_THUMBNAIL_URI); 262 sProgramProjectionMap.put(Programs.COLUMN_SEARCHABLE, Programs.COLUMN_SEARCHABLE); 263 sProgramProjectionMap.put(Programs.COLUMN_RECORDING_PROHIBITED, 264 Programs.COLUMN_RECORDING_PROHIBITED); 265 sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_DATA, 266 Programs.COLUMN_INTERNAL_PROVIDER_DATA); 267 sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_FLAG1, 268 Programs.COLUMN_INTERNAL_PROVIDER_FLAG1); 269 sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_FLAG2, 270 Programs.COLUMN_INTERNAL_PROVIDER_FLAG2); 271 sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_FLAG3, 272 Programs.COLUMN_INTERNAL_PROVIDER_FLAG3); 273 sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_FLAG4, 274 Programs.COLUMN_INTERNAL_PROVIDER_FLAG4); 275 sProgramProjectionMap.put(Programs.COLUMN_VERSION_NUMBER, Programs.COLUMN_VERSION_NUMBER); 276 sProgramProjectionMap.put(Programs.COLUMN_REVIEW_RATING_STYLE, 277 Programs.COLUMN_REVIEW_RATING_STYLE); 278 sProgramProjectionMap.put(Programs.COLUMN_REVIEW_RATING, 279 Programs.COLUMN_REVIEW_RATING); 280 281 sWatchedProgramProjectionMap = new HashMap<>(); 282 sWatchedProgramProjectionMap.put(WatchedPrograms._ID, WatchedPrograms._ID); 283 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS, 284 WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS); 285 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS, 286 WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS); 287 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_CHANNEL_ID, 288 WatchedPrograms.COLUMN_CHANNEL_ID); 289 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_TITLE, 290 WatchedPrograms.COLUMN_TITLE); 291 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS, 292 WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS); 293 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS, 294 WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS); 295 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_DESCRIPTION, 296 WatchedPrograms.COLUMN_DESCRIPTION); 297 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS, 298 WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS); 299 sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN, 300 WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN); 301 sWatchedProgramProjectionMap.put(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED, 302 WATCHED_PROGRAMS_COLUMN_CONSOLIDATED); 303 304 sRecordedProgramProjectionMap = new HashMap<>(); 305 sRecordedProgramProjectionMap.put(RecordedPrograms._ID, RecordedPrograms._ID); 306 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_PACKAGE_NAME, 307 RecordedPrograms.COLUMN_PACKAGE_NAME); 308 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INPUT_ID, 309 RecordedPrograms.COLUMN_INPUT_ID); 310 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_CHANNEL_ID, 311 RecordedPrograms.COLUMN_CHANNEL_ID); 312 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_TITLE, 313 RecordedPrograms.COLUMN_TITLE); 314 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_SEASON_DISPLAY_NUMBER, 315 RecordedPrograms.COLUMN_SEASON_DISPLAY_NUMBER); 316 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_SEASON_TITLE, 317 RecordedPrograms.COLUMN_SEASON_TITLE); 318 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_EPISODE_DISPLAY_NUMBER, 319 RecordedPrograms.COLUMN_EPISODE_DISPLAY_NUMBER); 320 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_EPISODE_TITLE, 321 RecordedPrograms.COLUMN_EPISODE_TITLE); 322 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_START_TIME_UTC_MILLIS, 323 RecordedPrograms.COLUMN_START_TIME_UTC_MILLIS); 324 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_END_TIME_UTC_MILLIS, 325 RecordedPrograms.COLUMN_END_TIME_UTC_MILLIS); 326 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_BROADCAST_GENRE, 327 RecordedPrograms.COLUMN_BROADCAST_GENRE); 328 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_CANONICAL_GENRE, 329 RecordedPrograms.COLUMN_CANONICAL_GENRE); 330 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_SHORT_DESCRIPTION, 331 RecordedPrograms.COLUMN_SHORT_DESCRIPTION); 332 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_LONG_DESCRIPTION, 333 RecordedPrograms.COLUMN_LONG_DESCRIPTION); 334 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_VIDEO_WIDTH, 335 RecordedPrograms.COLUMN_VIDEO_WIDTH); 336 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_VIDEO_HEIGHT, 337 RecordedPrograms.COLUMN_VIDEO_HEIGHT); 338 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_AUDIO_LANGUAGE, 339 RecordedPrograms.COLUMN_AUDIO_LANGUAGE); 340 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_CONTENT_RATING, 341 RecordedPrograms.COLUMN_CONTENT_RATING); 342 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_POSTER_ART_URI, 343 RecordedPrograms.COLUMN_POSTER_ART_URI); 344 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_THUMBNAIL_URI, 345 RecordedPrograms.COLUMN_THUMBNAIL_URI); 346 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_SEARCHABLE, 347 RecordedPrograms.COLUMN_SEARCHABLE); 348 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_RECORDING_DATA_URI, 349 RecordedPrograms.COLUMN_RECORDING_DATA_URI); 350 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_RECORDING_DATA_BYTES, 351 RecordedPrograms.COLUMN_RECORDING_DATA_BYTES); 352 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_RECORDING_DURATION_MILLIS, 353 RecordedPrograms.COLUMN_RECORDING_DURATION_MILLIS); 354 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_RECORDING_EXPIRE_TIME_UTC_MILLIS, 355 RecordedPrograms.COLUMN_RECORDING_EXPIRE_TIME_UTC_MILLIS); 356 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INTERNAL_PROVIDER_DATA, 357 RecordedPrograms.COLUMN_INTERNAL_PROVIDER_DATA); 358 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1, 359 RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1); 360 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2, 361 RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2); 362 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3, 363 RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3); 364 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4, 365 RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4); 366 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_VERSION_NUMBER, 367 RecordedPrograms.COLUMN_VERSION_NUMBER); 368 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_REVIEW_RATING_STYLE, 369 RecordedPrograms.COLUMN_REVIEW_RATING_STYLE); 370 sRecordedProgramProjectionMap.put(RecordedPrograms.COLUMN_REVIEW_RATING, 371 RecordedPrograms.COLUMN_REVIEW_RATING); 372 373 sPreviewProgramProjectionMap = new HashMap<>(); 374 sPreviewProgramProjectionMap.put(PreviewPrograms._ID, PreviewPrograms._ID); 375 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_PACKAGE_NAME, 376 PreviewPrograms.COLUMN_PACKAGE_NAME); 377 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_CHANNEL_ID, 378 PreviewPrograms.COLUMN_CHANNEL_ID); 379 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_TITLE, 380 PreviewPrograms.COLUMN_TITLE); 381 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_SEASON_DISPLAY_NUMBER, 382 PreviewPrograms.COLUMN_SEASON_DISPLAY_NUMBER); 383 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_SEASON_TITLE, 384 PreviewPrograms.COLUMN_SEASON_TITLE); 385 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_EPISODE_DISPLAY_NUMBER, 386 PreviewPrograms.COLUMN_EPISODE_DISPLAY_NUMBER); 387 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_EPISODE_TITLE, 388 PreviewPrograms.COLUMN_EPISODE_TITLE); 389 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_CANONICAL_GENRE, 390 PreviewPrograms.COLUMN_CANONICAL_GENRE); 391 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_SHORT_DESCRIPTION, 392 PreviewPrograms.COLUMN_SHORT_DESCRIPTION); 393 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_LONG_DESCRIPTION, 394 PreviewPrograms.COLUMN_LONG_DESCRIPTION); 395 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_VIDEO_WIDTH, 396 PreviewPrograms.COLUMN_VIDEO_WIDTH); 397 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_VIDEO_HEIGHT, 398 PreviewPrograms.COLUMN_VIDEO_HEIGHT); 399 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_AUDIO_LANGUAGE, 400 PreviewPrograms.COLUMN_AUDIO_LANGUAGE); 401 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_CONTENT_RATING, 402 PreviewPrograms.COLUMN_CONTENT_RATING); 403 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_POSTER_ART_URI, 404 PreviewPrograms.COLUMN_POSTER_ART_URI); 405 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_THUMBNAIL_URI, 406 PreviewPrograms.COLUMN_THUMBNAIL_URI); 407 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_SEARCHABLE, 408 PreviewPrograms.COLUMN_SEARCHABLE); 409 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_DATA, 410 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_DATA); 411 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1, 412 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1); 413 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2, 414 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2); 415 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3, 416 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3); 417 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4, 418 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4); 419 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_VERSION_NUMBER, 420 PreviewPrograms.COLUMN_VERSION_NUMBER); 421 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERNAL_PROVIDER_ID, 422 PreviewPrograms.COLUMN_INTERNAL_PROVIDER_ID); 423 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_PREVIEW_VIDEO_URI, 424 PreviewPrograms.COLUMN_PREVIEW_VIDEO_URI); 425 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS, 426 PreviewPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS); 427 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_DURATION_MILLIS, 428 PreviewPrograms.COLUMN_DURATION_MILLIS); 429 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTENT_URI, 430 PreviewPrograms.COLUMN_INTENT_URI); 431 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_WEIGHT, 432 PreviewPrograms.COLUMN_WEIGHT); 433 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_TRANSIENT, 434 PreviewPrograms.COLUMN_TRANSIENT); 435 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_TYPE, PreviewPrograms.COLUMN_TYPE); 436 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_POSTER_ART_ASPECT_RATIO, 437 PreviewPrograms.COLUMN_POSTER_ART_ASPECT_RATIO); 438 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO, 439 PreviewPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO); 440 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_LOGO_URI, 441 PreviewPrograms.COLUMN_LOGO_URI); 442 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_AVAILABILITY, 443 PreviewPrograms.COLUMN_AVAILABILITY); 444 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_STARTING_PRICE, 445 PreviewPrograms.COLUMN_STARTING_PRICE); 446 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_OFFER_PRICE, 447 PreviewPrograms.COLUMN_OFFER_PRICE); 448 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_RELEASE_DATE, 449 PreviewPrograms.COLUMN_RELEASE_DATE); 450 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_ITEM_COUNT, 451 PreviewPrograms.COLUMN_ITEM_COUNT); 452 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_LIVE, PreviewPrograms.COLUMN_LIVE); 453 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERACTION_TYPE, 454 PreviewPrograms.COLUMN_INTERACTION_TYPE); 455 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_INTERACTION_COUNT, 456 PreviewPrograms.COLUMN_INTERACTION_COUNT); 457 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_AUTHOR, 458 PreviewPrograms.COLUMN_AUTHOR); 459 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_REVIEW_RATING_STYLE, 460 PreviewPrograms.COLUMN_REVIEW_RATING_STYLE); 461 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_REVIEW_RATING, 462 PreviewPrograms.COLUMN_REVIEW_RATING); 463 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_BROWSABLE, 464 PreviewPrograms.COLUMN_BROWSABLE); 465 sPreviewProgramProjectionMap.put(PreviewPrograms.COLUMN_CONTENT_ID, 466 PreviewPrograms.COLUMN_CONTENT_ID); 467 468 sWatchNextProgramProjectionMap = new HashMap<>(); 469 sWatchNextProgramProjectionMap.put(WatchNextPrograms._ID, WatchNextPrograms._ID); 470 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_PACKAGE_NAME, 471 WatchNextPrograms.COLUMN_PACKAGE_NAME); 472 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_TITLE, 473 WatchNextPrograms.COLUMN_TITLE); 474 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_SEASON_DISPLAY_NUMBER, 475 WatchNextPrograms.COLUMN_SEASON_DISPLAY_NUMBER); 476 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_SEASON_TITLE, 477 WatchNextPrograms.COLUMN_SEASON_TITLE); 478 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_EPISODE_DISPLAY_NUMBER, 479 WatchNextPrograms.COLUMN_EPISODE_DISPLAY_NUMBER); 480 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_EPISODE_TITLE, 481 WatchNextPrograms.COLUMN_EPISODE_TITLE); 482 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_CANONICAL_GENRE, 483 WatchNextPrograms.COLUMN_CANONICAL_GENRE); 484 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_SHORT_DESCRIPTION, 485 WatchNextPrograms.COLUMN_SHORT_DESCRIPTION); 486 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_LONG_DESCRIPTION, 487 WatchNextPrograms.COLUMN_LONG_DESCRIPTION); 488 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_VIDEO_WIDTH, 489 WatchNextPrograms.COLUMN_VIDEO_WIDTH); 490 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_VIDEO_HEIGHT, 491 WatchNextPrograms.COLUMN_VIDEO_HEIGHT); 492 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_AUDIO_LANGUAGE, 493 WatchNextPrograms.COLUMN_AUDIO_LANGUAGE); 494 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_CONTENT_RATING, 495 WatchNextPrograms.COLUMN_CONTENT_RATING); 496 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_POSTER_ART_URI, 497 WatchNextPrograms.COLUMN_POSTER_ART_URI); 498 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_THUMBNAIL_URI, 499 WatchNextPrograms.COLUMN_THUMBNAIL_URI); 500 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_SEARCHABLE, 501 WatchNextPrograms.COLUMN_SEARCHABLE); 502 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_DATA, 503 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_DATA); 504 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1, 505 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1); 506 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2, 507 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2); 508 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3, 509 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3); 510 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4, 511 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4); 512 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_VERSION_NUMBER, 513 WatchNextPrograms.COLUMN_VERSION_NUMBER); 514 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID, 515 WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID); 516 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_PREVIEW_VIDEO_URI, 517 WatchNextPrograms.COLUMN_PREVIEW_VIDEO_URI); 518 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS, 519 WatchNextPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS); 520 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_DURATION_MILLIS, 521 WatchNextPrograms.COLUMN_DURATION_MILLIS); 522 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTENT_URI, 523 WatchNextPrograms.COLUMN_INTENT_URI); 524 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_TRANSIENT, 525 WatchNextPrograms.COLUMN_TRANSIENT); 526 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_TYPE, 527 WatchNextPrograms.COLUMN_TYPE); 528 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_WATCH_NEXT_TYPE, 529 WatchNextPrograms.COLUMN_WATCH_NEXT_TYPE); 530 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_POSTER_ART_ASPECT_RATIO, 531 WatchNextPrograms.COLUMN_POSTER_ART_ASPECT_RATIO); 532 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO, 533 WatchNextPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO); 534 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_LOGO_URI, 535 WatchNextPrograms.COLUMN_LOGO_URI); 536 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_AVAILABILITY, 537 WatchNextPrograms.COLUMN_AVAILABILITY); 538 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_STARTING_PRICE, 539 WatchNextPrograms.COLUMN_STARTING_PRICE); 540 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_OFFER_PRICE, 541 WatchNextPrograms.COLUMN_OFFER_PRICE); 542 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_RELEASE_DATE, 543 WatchNextPrograms.COLUMN_RELEASE_DATE); 544 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_ITEM_COUNT, 545 WatchNextPrograms.COLUMN_ITEM_COUNT); 546 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_LIVE, 547 WatchNextPrograms.COLUMN_LIVE); 548 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERACTION_TYPE, 549 WatchNextPrograms.COLUMN_INTERACTION_TYPE); 550 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_INTERACTION_COUNT, 551 WatchNextPrograms.COLUMN_INTERACTION_COUNT); 552 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_AUTHOR, 553 WatchNextPrograms.COLUMN_AUTHOR); 554 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_REVIEW_RATING_STYLE, 555 WatchNextPrograms.COLUMN_REVIEW_RATING_STYLE); 556 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_REVIEW_RATING, 557 WatchNextPrograms.COLUMN_REVIEW_RATING); 558 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_BROWSABLE, 559 WatchNextPrograms.COLUMN_BROWSABLE); 560 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_CONTENT_ID, 561 WatchNextPrograms.COLUMN_CONTENT_ID); 562 sWatchNextProgramProjectionMap.put(WatchNextPrograms.COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS, 563 WatchNextPrograms.COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS); 564 } 565 566 // Mapping from broadcast genre to canonical genre. 567 private static Map<String, String> sGenreMap; 568 569 private static final String PERMISSION_READ_TV_LISTINGS = "android.permission.READ_TV_LISTINGS"; 570 571 private static final String PERMISSION_ACCESS_ALL_EPG_DATA = 572 "com.android.providers.tv.permission.ACCESS_ALL_EPG_DATA"; 573 574 private static final String PERMISSION_ACCESS_WATCHED_PROGRAMS = 575 "com.android.providers.tv.permission.ACCESS_WATCHED_PROGRAMS"; 576 577 private static final String CREATE_RECORDED_PROGRAMS_TABLE_SQL = 578 "CREATE TABLE " + RECORDED_PROGRAMS_TABLE + " (" 579 + RecordedPrograms._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 580 + RecordedPrograms.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 581 + RecordedPrograms.COLUMN_INPUT_ID + " TEXT NOT NULL," 582 + RecordedPrograms.COLUMN_CHANNEL_ID + " INTEGER," 583 + RecordedPrograms.COLUMN_TITLE + " TEXT," 584 + RecordedPrograms.COLUMN_SEASON_DISPLAY_NUMBER + " TEXT," 585 + RecordedPrograms.COLUMN_SEASON_TITLE + " TEXT," 586 + RecordedPrograms.COLUMN_EPISODE_DISPLAY_NUMBER + " TEXT," 587 + RecordedPrograms.COLUMN_EPISODE_TITLE + " TEXT," 588 + RecordedPrograms.COLUMN_START_TIME_UTC_MILLIS + " INTEGER," 589 + RecordedPrograms.COLUMN_END_TIME_UTC_MILLIS + " INTEGER," 590 + RecordedPrograms.COLUMN_BROADCAST_GENRE + " TEXT," 591 + RecordedPrograms.COLUMN_CANONICAL_GENRE + " TEXT," 592 + RecordedPrograms.COLUMN_SHORT_DESCRIPTION + " TEXT," 593 + RecordedPrograms.COLUMN_LONG_DESCRIPTION + " TEXT," 594 + RecordedPrograms.COLUMN_VIDEO_WIDTH + " INTEGER," 595 + RecordedPrograms.COLUMN_VIDEO_HEIGHT + " INTEGER," 596 + RecordedPrograms.COLUMN_AUDIO_LANGUAGE + " TEXT," 597 + RecordedPrograms.COLUMN_CONTENT_RATING + " TEXT," 598 + RecordedPrograms.COLUMN_POSTER_ART_URI + " TEXT," 599 + RecordedPrograms.COLUMN_THUMBNAIL_URI + " TEXT," 600 + RecordedPrograms.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1," 601 + RecordedPrograms.COLUMN_RECORDING_DATA_URI + " TEXT," 602 + RecordedPrograms.COLUMN_RECORDING_DATA_BYTES + " INTEGER," 603 + RecordedPrograms.COLUMN_RECORDING_DURATION_MILLIS + " INTEGER," 604 + RecordedPrograms.COLUMN_RECORDING_EXPIRE_TIME_UTC_MILLIS + " INTEGER," 605 + RecordedPrograms.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB," 606 + RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER," 607 + RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER," 608 + RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER," 609 + RecordedPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER," 610 + RecordedPrograms.COLUMN_VERSION_NUMBER + " INTEGER," 611 + RecordedPrograms.COLUMN_REVIEW_RATING_STYLE + " INTEGER," 612 + RecordedPrograms.COLUMN_REVIEW_RATING + " TEXT," 613 + "FOREIGN KEY(" + RecordedPrograms.COLUMN_CHANNEL_ID + ") " 614 + "REFERENCES " + CHANNELS_TABLE + "(" + Channels._ID + ") " 615 + "ON UPDATE CASCADE ON DELETE SET NULL);"; 616 617 private static final String CREATE_PREVIEW_PROGRAMS_TABLE_SQL = 618 "CREATE TABLE " + PREVIEW_PROGRAMS_TABLE + " (" 619 + PreviewPrograms._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 620 + PreviewPrograms.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 621 + PreviewPrograms.COLUMN_CHANNEL_ID + " INTEGER," 622 + PreviewPrograms.COLUMN_TITLE + " TEXT," 623 + PreviewPrograms.COLUMN_SEASON_DISPLAY_NUMBER + " TEXT," 624 + PreviewPrograms.COLUMN_SEASON_TITLE + " TEXT," 625 + PreviewPrograms.COLUMN_EPISODE_DISPLAY_NUMBER + " TEXT," 626 + PreviewPrograms.COLUMN_EPISODE_TITLE + " TEXT," 627 + PreviewPrograms.COLUMN_CANONICAL_GENRE + " TEXT," 628 + PreviewPrograms.COLUMN_SHORT_DESCRIPTION + " TEXT," 629 + PreviewPrograms.COLUMN_LONG_DESCRIPTION + " TEXT," 630 + PreviewPrograms.COLUMN_VIDEO_WIDTH + " INTEGER," 631 + PreviewPrograms.COLUMN_VIDEO_HEIGHT + " INTEGER," 632 + PreviewPrograms.COLUMN_AUDIO_LANGUAGE + " TEXT," 633 + PreviewPrograms.COLUMN_CONTENT_RATING + " TEXT," 634 + PreviewPrograms.COLUMN_POSTER_ART_URI + " TEXT," 635 + PreviewPrograms.COLUMN_THUMBNAIL_URI + " TEXT," 636 + PreviewPrograms.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1," 637 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB," 638 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER," 639 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER," 640 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER," 641 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER," 642 + PreviewPrograms.COLUMN_VERSION_NUMBER + " INTEGER," 643 + PreviewPrograms.COLUMN_INTERNAL_PROVIDER_ID + " TEXT," 644 + PreviewPrograms.COLUMN_PREVIEW_VIDEO_URI + " TEXT," 645 + PreviewPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS + " INTEGER," 646 + PreviewPrograms.COLUMN_DURATION_MILLIS + " INTEGER," 647 + PreviewPrograms.COLUMN_INTENT_URI + " TEXT," 648 + PreviewPrograms.COLUMN_WEIGHT + " INTEGER," 649 + PreviewPrograms.COLUMN_TRANSIENT + " INTEGER NOT NULL DEFAULT 0," 650 + PreviewPrograms.COLUMN_TYPE + " INTEGER NOT NULL," 651 + PreviewPrograms.COLUMN_POSTER_ART_ASPECT_RATIO + " INTEGER," 652 + PreviewPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO + " INTEGER," 653 + PreviewPrograms.COLUMN_LOGO_URI + " TEXT," 654 + PreviewPrograms.COLUMN_AVAILABILITY + " INTERGER," 655 + PreviewPrograms.COLUMN_STARTING_PRICE + " TEXT," 656 + PreviewPrograms.COLUMN_OFFER_PRICE + " TEXT," 657 + PreviewPrograms.COLUMN_RELEASE_DATE + " TEXT," 658 + PreviewPrograms.COLUMN_ITEM_COUNT + " INTEGER," 659 + PreviewPrograms.COLUMN_LIVE + " INTEGER NOT NULL DEFAULT 0," 660 + PreviewPrograms.COLUMN_INTERACTION_TYPE + " INTEGER," 661 + PreviewPrograms.COLUMN_INTERACTION_COUNT + " INTEGER," 662 + PreviewPrograms.COLUMN_AUTHOR + " TEXT," 663 + PreviewPrograms.COLUMN_REVIEW_RATING_STYLE + " INTEGER," 664 + PreviewPrograms.COLUMN_REVIEW_RATING + " TEXT," 665 + PreviewPrograms.COLUMN_BROWSABLE + " INTEGER NOT NULL DEFAULT 1," 666 + PreviewPrograms.COLUMN_CONTENT_ID + " TEXT," 667 + "FOREIGN KEY(" 668 + PreviewPrograms.COLUMN_CHANNEL_ID + "," + PreviewPrograms.COLUMN_PACKAGE_NAME 669 + ") REFERENCES " + CHANNELS_TABLE + "(" 670 + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME 671 + ") ON UPDATE CASCADE ON DELETE CASCADE" 672 + ");"; 673 private static final String CREATE_PREVIEW_PROGRAMS_PACKAGE_NAME_INDEX_SQL = 674 "CREATE INDEX preview_programs_package_name_index ON " + PREVIEW_PROGRAMS_TABLE 675 + "(" + PreviewPrograms.COLUMN_PACKAGE_NAME + ");"; 676 private static final String CREATE_PREVIEW_PROGRAMS_CHANNEL_ID_INDEX_SQL = 677 "CREATE INDEX preview_programs_id_index ON " + PREVIEW_PROGRAMS_TABLE 678 + "(" + PreviewPrograms.COLUMN_CHANNEL_ID + ");"; 679 private static final String CREATE_WATCH_NEXT_PROGRAMS_TABLE_SQL = 680 "CREATE TABLE " + WATCH_NEXT_PROGRAMS_TABLE + " (" 681 + WatchNextPrograms._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 682 + WatchNextPrograms.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 683 + WatchNextPrograms.COLUMN_TITLE + " TEXT," 684 + WatchNextPrograms.COLUMN_SEASON_DISPLAY_NUMBER + " TEXT," 685 + WatchNextPrograms.COLUMN_SEASON_TITLE + " TEXT," 686 + WatchNextPrograms.COLUMN_EPISODE_DISPLAY_NUMBER + " TEXT," 687 + WatchNextPrograms.COLUMN_EPISODE_TITLE + " TEXT," 688 + WatchNextPrograms.COLUMN_CANONICAL_GENRE + " TEXT," 689 + WatchNextPrograms.COLUMN_SHORT_DESCRIPTION + " TEXT," 690 + WatchNextPrograms.COLUMN_LONG_DESCRIPTION + " TEXT," 691 + WatchNextPrograms.COLUMN_VIDEO_WIDTH + " INTEGER," 692 + WatchNextPrograms.COLUMN_VIDEO_HEIGHT + " INTEGER," 693 + WatchNextPrograms.COLUMN_AUDIO_LANGUAGE + " TEXT," 694 + WatchNextPrograms.COLUMN_CONTENT_RATING + " TEXT," 695 + WatchNextPrograms.COLUMN_POSTER_ART_URI + " TEXT," 696 + WatchNextPrograms.COLUMN_THUMBNAIL_URI + " TEXT," 697 + WatchNextPrograms.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1," 698 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB," 699 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER," 700 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER," 701 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER," 702 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER," 703 + WatchNextPrograms.COLUMN_VERSION_NUMBER + " INTEGER," 704 + WatchNextPrograms.COLUMN_INTERNAL_PROVIDER_ID + " TEXT," 705 + WatchNextPrograms.COLUMN_PREVIEW_VIDEO_URI + " TEXT," 706 + WatchNextPrograms.COLUMN_LAST_PLAYBACK_POSITION_MILLIS + " INTEGER," 707 + WatchNextPrograms.COLUMN_DURATION_MILLIS + " INTEGER," 708 + WatchNextPrograms.COLUMN_INTENT_URI + " TEXT," 709 + WatchNextPrograms.COLUMN_TRANSIENT + " INTEGER NOT NULL DEFAULT 0," 710 + WatchNextPrograms.COLUMN_TYPE + " INTEGER NOT NULL," 711 + WatchNextPrograms.COLUMN_WATCH_NEXT_TYPE + " INTEGER," 712 + WatchNextPrograms.COLUMN_POSTER_ART_ASPECT_RATIO + " INTEGER," 713 + WatchNextPrograms.COLUMN_THUMBNAIL_ASPECT_RATIO + " INTEGER," 714 + WatchNextPrograms.COLUMN_LOGO_URI + " TEXT," 715 + WatchNextPrograms.COLUMN_AVAILABILITY + " INTEGER," 716 + WatchNextPrograms.COLUMN_STARTING_PRICE + " TEXT," 717 + WatchNextPrograms.COLUMN_OFFER_PRICE + " TEXT," 718 + WatchNextPrograms.COLUMN_RELEASE_DATE + " TEXT," 719 + WatchNextPrograms.COLUMN_ITEM_COUNT + " INTEGER," 720 + WatchNextPrograms.COLUMN_LIVE + " INTEGER NOT NULL DEFAULT 0," 721 + WatchNextPrograms.COLUMN_INTERACTION_TYPE + " INTEGER," 722 + WatchNextPrograms.COLUMN_INTERACTION_COUNT + " INTEGER," 723 + WatchNextPrograms.COLUMN_AUTHOR + " TEXT," 724 + WatchNextPrograms.COLUMN_REVIEW_RATING_STYLE + " INTEGER," 725 + WatchNextPrograms.COLUMN_REVIEW_RATING + " TEXT," 726 + WatchNextPrograms.COLUMN_BROWSABLE + " INTEGER NOT NULL DEFAULT 1," 727 + WatchNextPrograms.COLUMN_CONTENT_ID + " TEXT," 728 + WatchNextPrograms.COLUMN_LAST_ENGAGEMENT_TIME_UTC_MILLIS + " INTEGER" 729 + ");"; 730 private static final String CREATE_WATCH_NEXT_PROGRAMS_PACKAGE_NAME_INDEX_SQL = 731 "CREATE INDEX watch_next_programs_package_name_index ON " + WATCH_NEXT_PROGRAMS_TABLE 732 + "(" + WatchNextPrograms.COLUMN_PACKAGE_NAME + ");"; 733 734 static class DatabaseHelper extends SQLiteOpenHelper { 735 private static DatabaseHelper sSingleton = null; 736 private static Context mContext; 737 738 public static synchronized DatabaseHelper getInstance(Context context) { 739 if (sSingleton == null) { 740 sSingleton = new DatabaseHelper(context); 741 } 742 return sSingleton; 743 } 744 745 private DatabaseHelper(Context context) { 746 this(context, DATABASE_NAME, DATABASE_VERSION); 747 } 748 749 @VisibleForTesting 750 DatabaseHelper(Context context, String databaseName, int databaseVersion) { 751 super(context, databaseName, null, databaseVersion); 752 mContext = context; 753 } 754 755 @Override 756 public void onConfigure(SQLiteDatabase db) { 757 db.setForeignKeyConstraintsEnabled(true); 758 } 759 760 @Override 761 public void onCreate(SQLiteDatabase db) { 762 if (DEBUG) { 763 Log.d(TAG, "Creating database"); 764 } 765 // Set up the database schema. 766 db.execSQL("CREATE TABLE " + CHANNELS_TABLE + " (" 767 + Channels._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 768 + Channels.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 769 + Channels.COLUMN_INPUT_ID + " TEXT NOT NULL," 770 + Channels.COLUMN_TYPE + " TEXT NOT NULL DEFAULT '" + Channels.TYPE_OTHER + "'," 771 + Channels.COLUMN_SERVICE_TYPE + " TEXT NOT NULL DEFAULT '" 772 + Channels.SERVICE_TYPE_AUDIO_VIDEO + "'," 773 + Channels.COLUMN_ORIGINAL_NETWORK_ID + " INTEGER NOT NULL DEFAULT 0," 774 + Channels.COLUMN_TRANSPORT_STREAM_ID + " INTEGER NOT NULL DEFAULT 0," 775 + Channels.COLUMN_SERVICE_ID + " INTEGER NOT NULL DEFAULT 0," 776 + Channels.COLUMN_DISPLAY_NUMBER + " TEXT," 777 + Channels.COLUMN_DISPLAY_NAME + " TEXT," 778 + Channels.COLUMN_NETWORK_AFFILIATION + " TEXT," 779 + Channels.COLUMN_DESCRIPTION + " TEXT," 780 + Channels.COLUMN_VIDEO_FORMAT + " TEXT," 781 + Channels.COLUMN_BROWSABLE + " INTEGER NOT NULL DEFAULT 0," 782 + Channels.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1," 783 + Channels.COLUMN_LOCKED + " INTEGER NOT NULL DEFAULT 0," 784 + Channels.COLUMN_APP_LINK_ICON_URI + " TEXT," 785 + Channels.COLUMN_APP_LINK_POSTER_ART_URI + " TEXT," 786 + Channels.COLUMN_APP_LINK_TEXT + " TEXT," 787 + Channels.COLUMN_APP_LINK_COLOR + " INTEGER," 788 + Channels.COLUMN_APP_LINK_INTENT_URI + " TEXT," 789 + Channels.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB," 790 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER," 791 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER," 792 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER," 793 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER," 794 + CHANNELS_COLUMN_LOGO + " BLOB," 795 + Channels.COLUMN_VERSION_NUMBER + " INTEGER," 796 + Channels.COLUMN_TRANSIENT + " INTEGER NOT NULL DEFAULT 0," 797 + Channels.COLUMN_INTERNAL_PROVIDER_ID + " TEXT," 798 // Needed for foreign keys in other tables. 799 + "UNIQUE(" + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME + ")" 800 + ");"); 801 db.execSQL("CREATE TABLE " + PROGRAMS_TABLE + " (" 802 + Programs._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 803 + Programs.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 804 + Programs.COLUMN_CHANNEL_ID + " INTEGER," 805 + Programs.COLUMN_TITLE + " TEXT," 806 + Programs.COLUMN_SEASON_DISPLAY_NUMBER + " TEXT," 807 + Programs.COLUMN_SEASON_TITLE + " TEXT," 808 + Programs.COLUMN_EPISODE_DISPLAY_NUMBER + " TEXT," 809 + Programs.COLUMN_EPISODE_TITLE + " TEXT," 810 + Programs.COLUMN_START_TIME_UTC_MILLIS + " INTEGER," 811 + Programs.COLUMN_END_TIME_UTC_MILLIS + " INTEGER," 812 + Programs.COLUMN_BROADCAST_GENRE + " TEXT," 813 + Programs.COLUMN_CANONICAL_GENRE + " TEXT," 814 + Programs.COLUMN_SHORT_DESCRIPTION + " TEXT," 815 + Programs.COLUMN_LONG_DESCRIPTION + " TEXT," 816 + Programs.COLUMN_VIDEO_WIDTH + " INTEGER," 817 + Programs.COLUMN_VIDEO_HEIGHT + " INTEGER," 818 + Programs.COLUMN_AUDIO_LANGUAGE + " TEXT," 819 + Programs.COLUMN_CONTENT_RATING + " TEXT," 820 + Programs.COLUMN_POSTER_ART_URI + " TEXT," 821 + Programs.COLUMN_THUMBNAIL_URI + " TEXT," 822 + Programs.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1," 823 + Programs.COLUMN_RECORDING_PROHIBITED + " INTEGER NOT NULL DEFAULT 0," 824 + Programs.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB," 825 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER," 826 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER," 827 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER," 828 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER," 829 + Programs.COLUMN_REVIEW_RATING_STYLE + " INTEGER," 830 + Programs.COLUMN_REVIEW_RATING + " TEXT," 831 + Programs.COLUMN_VERSION_NUMBER + " INTEGER," 832 + "FOREIGN KEY(" 833 + Programs.COLUMN_CHANNEL_ID + "," + Programs.COLUMN_PACKAGE_NAME 834 + ") REFERENCES " + CHANNELS_TABLE + "(" 835 + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME 836 + ") ON UPDATE CASCADE ON DELETE CASCADE" 837 + ");"); 838 db.execSQL("CREATE INDEX " + PROGRAMS_TABLE_PACKAGE_NAME_INDEX + " ON " + PROGRAMS_TABLE 839 + "(" + Programs.COLUMN_PACKAGE_NAME + ");"); 840 db.execSQL("CREATE INDEX " + PROGRAMS_TABLE_CHANNEL_ID_INDEX + " ON " + PROGRAMS_TABLE 841 + "(" + Programs.COLUMN_CHANNEL_ID + ");"); 842 db.execSQL("CREATE INDEX " + PROGRAMS_TABLE_START_TIME_INDEX + " ON " + PROGRAMS_TABLE 843 + "(" + Programs.COLUMN_START_TIME_UTC_MILLIS + ");"); 844 db.execSQL("CREATE INDEX " + PROGRAMS_TABLE_END_TIME_INDEX + " ON " + PROGRAMS_TABLE 845 + "(" + Programs.COLUMN_END_TIME_UTC_MILLIS + ");"); 846 db.execSQL("CREATE TABLE " + WATCHED_PROGRAMS_TABLE + " (" 847 + WatchedPrograms._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," 848 + WatchedPrograms.COLUMN_PACKAGE_NAME + " TEXT NOT NULL," 849 + WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS 850 + " INTEGER NOT NULL DEFAULT 0," 851 + WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS 852 + " INTEGER NOT NULL DEFAULT 0," 853 + WatchedPrograms.COLUMN_CHANNEL_ID + " INTEGER," 854 + WatchedPrograms.COLUMN_TITLE + " TEXT," 855 + WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS + " INTEGER," 856 + WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS + " INTEGER," 857 + WatchedPrograms.COLUMN_DESCRIPTION + " TEXT," 858 + WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS + " TEXT," 859 + WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + " TEXT NOT NULL," 860 + WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + " INTEGER NOT NULL DEFAULT 0," 861 + "FOREIGN KEY(" 862 + WatchedPrograms.COLUMN_CHANNEL_ID + "," 863 + WatchedPrograms.COLUMN_PACKAGE_NAME 864 + ") REFERENCES " + CHANNELS_TABLE + "(" 865 + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME 866 + ") ON UPDATE CASCADE ON DELETE CASCADE" 867 + ");"); 868 db.execSQL("CREATE INDEX " + WATCHED_PROGRAMS_TABLE_CHANNEL_ID_INDEX + " ON " 869 + WATCHED_PROGRAMS_TABLE + "(" + WatchedPrograms.COLUMN_CHANNEL_ID + ");"); 870 db.execSQL(CREATE_RECORDED_PROGRAMS_TABLE_SQL); 871 db.execSQL(CREATE_PREVIEW_PROGRAMS_TABLE_SQL); 872 db.execSQL(CREATE_PREVIEW_PROGRAMS_PACKAGE_NAME_INDEX_SQL); 873 db.execSQL(CREATE_PREVIEW_PROGRAMS_CHANNEL_ID_INDEX_SQL); 874 db.execSQL(CREATE_WATCH_NEXT_PROGRAMS_TABLE_SQL); 875 db.execSQL(CREATE_WATCH_NEXT_PROGRAMS_PACKAGE_NAME_INDEX_SQL); 876 } 877 878 @Override 879 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 880 if (oldVersion < 23) { 881 Log.i(TAG, "Upgrading from version " + oldVersion + " to " + newVersion 882 + ", data will be lost!"); 883 db.execSQL("DROP TABLE IF EXISTS " + DELETED_CHANNELS_TABLE); 884 db.execSQL("DROP TABLE IF EXISTS " + WATCHED_PROGRAMS_TABLE); 885 db.execSQL("DROP TABLE IF EXISTS " + PROGRAMS_TABLE); 886 db.execSQL("DROP TABLE IF EXISTS " + CHANNELS_TABLE); 887 888 onCreate(db); 889 return; 890 } 891 892 Log.i(TAG, "Upgrading from version " + oldVersion + " to " + newVersion + "."); 893 if (oldVersion <= 23) { 894 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 895 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER;"); 896 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 897 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER;"); 898 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 899 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER;"); 900 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 901 + Channels.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER;"); 902 } 903 if (oldVersion <= 24) { 904 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 905 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG1 + " INTEGER;"); 906 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 907 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG2 + " INTEGER;"); 908 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 909 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG3 + " INTEGER;"); 910 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 911 + Programs.COLUMN_INTERNAL_PROVIDER_FLAG4 + " INTEGER;"); 912 } 913 if (oldVersion <= 25) { 914 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 915 + Channels.COLUMN_APP_LINK_ICON_URI + " TEXT;"); 916 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 917 + Channels.COLUMN_APP_LINK_POSTER_ART_URI + " TEXT;"); 918 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 919 + Channels.COLUMN_APP_LINK_TEXT + " TEXT;"); 920 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 921 + Channels.COLUMN_APP_LINK_COLOR + " INTEGER;"); 922 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 923 + Channels.COLUMN_APP_LINK_INTENT_URI + " TEXT;"); 924 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 925 + Programs.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1;"); 926 } 927 if (oldVersion <= 28) { 928 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 929 + Programs.COLUMN_SEASON_TITLE + " TEXT;"); 930 migrateIntegerColumnToTextColumn(db, PROGRAMS_TABLE, Programs.COLUMN_SEASON_NUMBER, 931 Programs.COLUMN_SEASON_DISPLAY_NUMBER); 932 migrateIntegerColumnToTextColumn(db, PROGRAMS_TABLE, Programs.COLUMN_EPISODE_NUMBER, 933 Programs.COLUMN_EPISODE_DISPLAY_NUMBER); 934 } 935 if (oldVersion <= 29) { 936 db.execSQL("DROP TABLE IF EXISTS " + RECORDED_PROGRAMS_TABLE); 937 db.execSQL(CREATE_RECORDED_PROGRAMS_TABLE_SQL); 938 } 939 if (oldVersion <= 30) { 940 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 941 + Programs.COLUMN_RECORDING_PROHIBITED + " INTEGER NOT NULL DEFAULT 0;"); 942 } 943 if (oldVersion <= 32) { 944 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 945 + Channels.COLUMN_TRANSIENT + " INTEGER NOT NULL DEFAULT 0;"); 946 db.execSQL("ALTER TABLE " + CHANNELS_TABLE + " ADD " 947 + Channels.COLUMN_INTERNAL_PROVIDER_ID + " TEXT;"); 948 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 949 + Programs.COLUMN_REVIEW_RATING_STYLE + " INTEGER;"); 950 db.execSQL("ALTER TABLE " + PROGRAMS_TABLE + " ADD " 951 + Programs.COLUMN_REVIEW_RATING + " TEXT;"); 952 if (oldVersion > 29) { 953 db.execSQL("ALTER TABLE " + RECORDED_PROGRAMS_TABLE + " ADD " 954 + RecordedPrograms.COLUMN_REVIEW_RATING_STYLE + " INTEGER;"); 955 db.execSQL("ALTER TABLE " + RECORDED_PROGRAMS_TABLE + " ADD " 956 + RecordedPrograms.COLUMN_REVIEW_RATING + " TEXT;"); 957 } 958 } 959 if (oldVersion <= 33) { 960 db.execSQL("DROP TABLE IF EXISTS " + PREVIEW_PROGRAMS_TABLE); 961 db.execSQL("DROP TABLE IF EXISTS " + WATCH_NEXT_PROGRAMS_TABLE); 962 db.execSQL(CREATE_PREVIEW_PROGRAMS_TABLE_SQL); 963 db.execSQL(CREATE_PREVIEW_PROGRAMS_PACKAGE_NAME_INDEX_SQL); 964 db.execSQL(CREATE_PREVIEW_PROGRAMS_CHANNEL_ID_INDEX_SQL); 965 db.execSQL(CREATE_WATCH_NEXT_PROGRAMS_TABLE_SQL); 966 db.execSQL(CREATE_WATCH_NEXT_PROGRAMS_PACKAGE_NAME_INDEX_SQL); 967 } 968 Log.i(TAG, "Upgrading from version " + oldVersion + " to " + newVersion + " is done."); 969 } 970 971 @Override 972 public void onOpen(SQLiteDatabase db) { 973 // Call a static method on the TvProvider because changes to sInitialized must 974 // be guarded by a lock on the class. 975 initOnOpenIfNeeded(mContext, db); 976 } 977 978 private static void migrateIntegerColumnToTextColumn(SQLiteDatabase db, String table, 979 String integerColumn, String textColumn) { 980 db.execSQL("ALTER TABLE " + table + " ADD " + textColumn + " TEXT;"); 981 db.execSQL("UPDATE " + table + " SET " + textColumn + " = CAST(" + integerColumn 982 + " AS TEXT);"); 983 } 984 } 985 986 private DatabaseHelper mOpenHelper; 987 private static SharedPreferences sBlockedPackagesSharedPreference; 988 private static Map<String, Boolean> sBlockedPackages; 989 @VisibleForTesting 990 protected TransientRowHelper mTransientRowHelper; 991 992 private final Handler mLogHandler = new WatchLogHandler(); 993 994 @Override 995 public boolean onCreate() { 996 if (DEBUG) { 997 Log.d(TAG, "Creating TvProvider"); 998 } 999 if (mOpenHelper == null) { 1000 mOpenHelper = DatabaseHelper.getInstance(getContext()); 1001 } 1002 mTransientRowHelper = TransientRowHelper.getInstance(getContext()); 1003 scheduleEpgDataCleanup(); 1004 buildGenreMap(); 1005 1006 // DB operation, which may trigger upgrade, should not happen in onCreate. 1007 new AsyncTask<Void, Void, Void>() { 1008 @Override 1009 protected Void doInBackground(Void... params) { 1010 deleteUnconsolidatedWatchedProgramsRows(); 1011 return null; 1012 } 1013 }.execute(); 1014 return true; 1015 } 1016 1017 @VisibleForTesting 1018 void scheduleEpgDataCleanup() { 1019 Intent intent = new Intent(EpgDataCleanupService.ACTION_CLEAN_UP_EPG_DATA); 1020 intent.setClass(getContext(), EpgDataCleanupService.class); 1021 PendingIntent pendingIntent = PendingIntent.getService( 1022 getContext(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 1023 AlarmManager alarmManager = 1024 (AlarmManager) getContext().getSystemService(Context.ALARM_SERVICE); 1025 alarmManager.setInexactRepeating(AlarmManager.RTC, System.currentTimeMillis(), 1026 AlarmManager.INTERVAL_HALF_DAY, pendingIntent); 1027 } 1028 1029 private void buildGenreMap() { 1030 if (sGenreMap != null) { 1031 return; 1032 } 1033 1034 sGenreMap = new HashMap<>(); 1035 buildGenreMap(R.array.genre_mapping_atsc); 1036 buildGenreMap(R.array.genre_mapping_dvb); 1037 buildGenreMap(R.array.genre_mapping_isdb); 1038 buildGenreMap(R.array.genre_mapping_isdb_br); 1039 } 1040 1041 @SuppressLint("DefaultLocale") 1042 private void buildGenreMap(int id) { 1043 String[] maps = getContext().getResources().getStringArray(id); 1044 for (String map : maps) { 1045 String[] arr = map.split("\\|"); 1046 if (arr.length != 2) { 1047 throw new IllegalArgumentException("Invalid genre mapping : " + map); 1048 } 1049 sGenreMap.put(arr[0].toUpperCase(), arr[1]); 1050 } 1051 } 1052 1053 @VisibleForTesting 1054 String getCallingPackage_() { 1055 return getCallingPackage(); 1056 } 1057 1058 @VisibleForTesting 1059 void setOpenHelper(DatabaseHelper helper) { 1060 mOpenHelper = helper; 1061 } 1062 1063 @Override 1064 public String getType(Uri uri) { 1065 switch (sUriMatcher.match(uri)) { 1066 case MATCH_CHANNEL: 1067 return Channels.CONTENT_TYPE; 1068 case MATCH_CHANNEL_ID: 1069 return Channels.CONTENT_ITEM_TYPE; 1070 case MATCH_CHANNEL_ID_LOGO: 1071 return "image/png"; 1072 case MATCH_PASSTHROUGH_ID: 1073 return Channels.CONTENT_ITEM_TYPE; 1074 case MATCH_PROGRAM: 1075 return Programs.CONTENT_TYPE; 1076 case MATCH_PROGRAM_ID: 1077 return Programs.CONTENT_ITEM_TYPE; 1078 case MATCH_WATCHED_PROGRAM: 1079 return WatchedPrograms.CONTENT_TYPE; 1080 case MATCH_WATCHED_PROGRAM_ID: 1081 return WatchedPrograms.CONTENT_ITEM_TYPE; 1082 case MATCH_RECORDED_PROGRAM: 1083 return RecordedPrograms.CONTENT_TYPE; 1084 case MATCH_RECORDED_PROGRAM_ID: 1085 return RecordedPrograms.CONTENT_ITEM_TYPE; 1086 case MATCH_PREVIEW_PROGRAM: 1087 return PreviewPrograms.CONTENT_TYPE; 1088 case MATCH_PREVIEW_PROGRAM_ID: 1089 return PreviewPrograms.CONTENT_ITEM_TYPE; 1090 case MATCH_WATCH_NEXT_PROGRAM: 1091 return WatchNextPrograms.CONTENT_TYPE; 1092 case MATCH_WATCH_NEXT_PROGRAM_ID: 1093 return WatchNextPrograms.CONTENT_ITEM_TYPE; 1094 default: 1095 throw new IllegalArgumentException("Unknown URI " + uri); 1096 } 1097 } 1098 1099 @Override 1100 public Bundle call(String method, String arg, Bundle extras) { 1101 if (!callerHasAccessAllEpgDataPermission()) { 1102 return null; 1103 } 1104 ensureInitialized(); 1105 Map<String, String> projectionMap; 1106 switch (method) { 1107 case TvContract.METHOD_GET_COLUMNS: 1108 switch (sUriMatcher.match(Uri.parse(arg))) { 1109 case MATCH_CHANNEL: 1110 projectionMap = sChannelProjectionMap; 1111 break; 1112 case MATCH_PROGRAM: 1113 projectionMap = sProgramProjectionMap; 1114 break; 1115 case MATCH_PREVIEW_PROGRAM: 1116 projectionMap = sPreviewProgramProjectionMap; 1117 break; 1118 case MATCH_WATCH_NEXT_PROGRAM: 1119 projectionMap = sWatchNextProgramProjectionMap; 1120 break; 1121 case MATCH_RECORDED_PROGRAM: 1122 projectionMap = sRecordedProgramProjectionMap; 1123 break; 1124 default: 1125 return null; 1126 } 1127 Bundle result = new Bundle(); 1128 result.putStringArray(TvContract.EXTRA_EXISTING_COLUMN_NAMES, 1129 projectionMap.keySet().toArray(new String[projectionMap.size()])); 1130 return result; 1131 case TvContract.METHOD_ADD_COLUMN: 1132 CharSequence columnName = extras.getCharSequence(TvContract.EXTRA_COLUMN_NAME); 1133 CharSequence dataType = extras.getCharSequence(TvContract.EXTRA_DATA_TYPE); 1134 if (TextUtils.isEmpty(columnName) || TextUtils.isEmpty(dataType)) { 1135 return null; 1136 } 1137 CharSequence defaultValue = extras.getCharSequence(TvContract.EXTRA_DEFAULT_VALUE); 1138 try { 1139 defaultValue = TextUtils.isEmpty(defaultValue) ? "" : generateDefaultClause( 1140 dataType.toString(), defaultValue.toString()); 1141 } catch (IllegalArgumentException e) { 1142 return null; 1143 } 1144 String tableName; 1145 switch (sUriMatcher.match(Uri.parse(arg))) { 1146 case MATCH_CHANNEL: 1147 tableName = CHANNELS_TABLE; 1148 projectionMap = sChannelProjectionMap; 1149 break; 1150 case MATCH_PROGRAM: 1151 tableName = PROGRAMS_TABLE; 1152 projectionMap = sProgramProjectionMap; 1153 break; 1154 case MATCH_PREVIEW_PROGRAM: 1155 tableName = PREVIEW_PROGRAMS_TABLE; 1156 projectionMap = sPreviewProgramProjectionMap; 1157 break; 1158 case MATCH_WATCH_NEXT_PROGRAM: 1159 tableName = WATCH_NEXT_PROGRAMS_TABLE; 1160 projectionMap = sWatchNextProgramProjectionMap; 1161 break; 1162 case MATCH_RECORDED_PROGRAM: 1163 tableName = RECORDED_PROGRAMS_TABLE; 1164 projectionMap = sRecordedProgramProjectionMap; 1165 break; 1166 default: 1167 return null; 1168 } 1169 try (SQLiteDatabase db = mOpenHelper.getWritableDatabase()) { 1170 db.execSQL("ALTER TABLE " + tableName + " ADD " 1171 + columnName + " " + dataType + defaultValue + ";"); 1172 projectionMap.put(columnName.toString(), tableName + '.' + columnName); 1173 Bundle returnValue = new Bundle(); 1174 returnValue.putStringArray(TvContract.EXTRA_EXISTING_COLUMN_NAMES, 1175 projectionMap.keySet().toArray(new String[projectionMap.size()])); 1176 return returnValue; 1177 } catch (SQLException e) { 1178 return null; 1179 } 1180 case TvContract.METHOD_GET_BLOCKED_PACKAGES: 1181 Bundle allBlockedPackages = new Bundle(); 1182 allBlockedPackages.putStringArray(TvContract.EXTRA_BLOCKED_PACKAGES, 1183 sBlockedPackages.keySet().toArray(new String[sBlockedPackages.size()])); 1184 return allBlockedPackages; 1185 case TvContract.METHOD_BLOCK_PACKAGE: 1186 String packageNameToBlock = arg; 1187 Bundle blockPackageResult = new Bundle(); 1188 if (!TextUtils.isEmpty(packageNameToBlock)) { 1189 sBlockedPackages.put(packageNameToBlock, true); 1190 if (sBlockedPackagesSharedPreference.edit().putStringSet( 1191 SHARED_PREF_BLOCKED_PACKAGES_KEY, sBlockedPackages.keySet()).commit()) { 1192 String[] channelSelectionArgs = new String[] { 1193 packageNameToBlock, Channels.TYPE_PREVIEW }; 1194 delete(TvContract.Channels.CONTENT_URI, 1195 Channels.COLUMN_PACKAGE_NAME + "=? AND " 1196 + Channels.COLUMN_TYPE + "=?", 1197 channelSelectionArgs); 1198 String[] programsSelectionArgs = new String[] { 1199 packageNameToBlock }; 1200 delete(TvContract.PreviewPrograms.CONTENT_URI, 1201 PreviewPrograms.COLUMN_PACKAGE_NAME + "=?", programsSelectionArgs); 1202 delete(TvContract.WatchNextPrograms.CONTENT_URI, 1203 WatchNextPrograms.COLUMN_PACKAGE_NAME + "=?", 1204 programsSelectionArgs); 1205 blockPackageResult.putInt( 1206 TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_OK); 1207 } else { 1208 Log.e(TAG, "Blocking package " + packageNameToBlock + " failed"); 1209 sBlockedPackages.remove(packageNameToBlock); 1210 blockPackageResult.putInt(TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_ERROR_IO); 1211 } 1212 } else { 1213 blockPackageResult.putInt( 1214 TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_ERROR_INVALID_ARGUMENT); 1215 } 1216 return blockPackageResult; 1217 case TvContract.METHOD_UNBLOCK_PACKAGE: 1218 String packageNameToUnblock = arg; 1219 Bundle unblockPackageResult = new Bundle(); 1220 if (!TextUtils.isEmpty(packageNameToUnblock)) { 1221 sBlockedPackages.remove(packageNameToUnblock); 1222 if (sBlockedPackagesSharedPreference.edit().putStringSet( 1223 SHARED_PREF_BLOCKED_PACKAGES_KEY, sBlockedPackages.keySet()).commit()) { 1224 unblockPackageResult.putInt( 1225 TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_OK); 1226 } else { 1227 Log.e(TAG, "Unblocking package " + packageNameToUnblock + " failed"); 1228 sBlockedPackages.put(packageNameToUnblock, true); 1229 unblockPackageResult.putInt( 1230 TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_ERROR_IO); 1231 } 1232 } else { 1233 unblockPackageResult.putInt( 1234 TvContract.EXTRA_RESULT_CODE, TvContract.RESULT_ERROR_INVALID_ARGUMENT); 1235 } 1236 return unblockPackageResult; 1237 } 1238 return null; 1239 } 1240 1241 @Override 1242 public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, 1243 String sortOrder) { 1244 ensureInitialized(); 1245 mTransientRowHelper.ensureOldTransientRowsDeleted(); 1246 boolean needsToValidateSortOrder = !callerHasAccessAllEpgDataPermission(); 1247 SqlParams params = createSqlParams(OP_QUERY, uri, selection, selectionArgs); 1248 1249 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 1250 queryBuilder.setStrict(needsToValidateSortOrder); 1251 queryBuilder.setTables(params.getTables()); 1252 String orderBy = null; 1253 Map<String, String> projectionMap; 1254 switch (params.getTables()) { 1255 case PROGRAMS_TABLE: 1256 projectionMap = sProgramProjectionMap; 1257 orderBy = DEFAULT_PROGRAMS_SORT_ORDER; 1258 break; 1259 case WATCHED_PROGRAMS_TABLE: 1260 projectionMap = sWatchedProgramProjectionMap; 1261 orderBy = DEFAULT_WATCHED_PROGRAMS_SORT_ORDER; 1262 break; 1263 case RECORDED_PROGRAMS_TABLE: 1264 projectionMap = sRecordedProgramProjectionMap; 1265 break; 1266 case PREVIEW_PROGRAMS_TABLE: 1267 projectionMap = sPreviewProgramProjectionMap; 1268 break; 1269 case WATCH_NEXT_PROGRAMS_TABLE: 1270 projectionMap = sWatchNextProgramProjectionMap; 1271 break; 1272 default: 1273 projectionMap = sChannelProjectionMap; 1274 break; 1275 } 1276 queryBuilder.setProjectionMap(createProjectionMapForQuery(projection, projectionMap)); 1277 if (needsToValidateSortOrder) { 1278 validateSortOrder(sortOrder, projectionMap.keySet()); 1279 } 1280 1281 // Use the default sort order only if no sort order is specified. 1282 if (!TextUtils.isEmpty(sortOrder)) { 1283 orderBy = sortOrder; 1284 } 1285 1286 // Get the database and run the query. 1287 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 1288 Cursor c = queryBuilder.query(db, projection, params.getSelection(), 1289 params.getSelectionArgs(), null, null, orderBy); 1290 1291 // Tell the cursor what URI to watch, so it knows when its source data changes. 1292 c.setNotificationUri(getContext().getContentResolver(), uri); 1293 return c; 1294 } 1295 1296 @Override 1297 public Uri insert(Uri uri, ContentValues values) { 1298 ensureInitialized(); 1299 mTransientRowHelper.ensureOldTransientRowsDeleted(); 1300 switch (sUriMatcher.match(uri)) { 1301 case MATCH_CHANNEL: 1302 // Preview channels are not necessarily associated with TV input service. 1303 // Therefore, we fill a fake ID to meet not null restriction for preview channels. 1304 if (values.get(Channels.COLUMN_INPUT_ID) == null 1305 && Channels.TYPE_PREVIEW.equals(values.get(Channels.COLUMN_TYPE))) { 1306 values.put(Channels.COLUMN_INPUT_ID, EMPTY_STRING); 1307 } 1308 filterContentValues(values, sChannelProjectionMap); 1309 return insertChannel(uri, values); 1310 case MATCH_PROGRAM: 1311 filterContentValues(values, sProgramProjectionMap); 1312 return insertProgram(uri, values); 1313 case MATCH_WATCHED_PROGRAM: 1314 return insertWatchedProgram(uri, values); 1315 case MATCH_RECORDED_PROGRAM: 1316 filterContentValues(values, sRecordedProgramProjectionMap); 1317 return insertRecordedProgram(uri, values); 1318 case MATCH_PREVIEW_PROGRAM: 1319 filterContentValues(values, sPreviewProgramProjectionMap); 1320 return insertPreviewProgram(uri, values); 1321 case MATCH_WATCH_NEXT_PROGRAM: 1322 filterContentValues(values, sWatchNextProgramProjectionMap); 1323 return insertWatchNextProgram(uri, values); 1324 case MATCH_CHANNEL_ID: 1325 case MATCH_CHANNEL_ID_LOGO: 1326 case MATCH_PASSTHROUGH_ID: 1327 case MATCH_PROGRAM_ID: 1328 case MATCH_WATCHED_PROGRAM_ID: 1329 case MATCH_RECORDED_PROGRAM_ID: 1330 case MATCH_PREVIEW_PROGRAM_ID: 1331 throw new UnsupportedOperationException("Cannot insert into that URI: " + uri); 1332 default: 1333 throw new IllegalArgumentException("Unknown URI " + uri); 1334 } 1335 } 1336 1337 private Uri insertChannel(Uri uri, ContentValues values) { 1338 if (TextUtils.equals(values.getAsString(Channels.COLUMN_TYPE), Channels.TYPE_PREVIEW)) { 1339 blockIllegalAccessFromBlockedPackage(); 1340 } 1341 // Mark the owner package of this channel. 1342 values.put(Channels.COLUMN_PACKAGE_NAME, getCallingPackage_()); 1343 blockIllegalAccessToChannelsSystemColumns(values); 1344 1345 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1346 long rowId = db.insert(CHANNELS_TABLE, null, values); 1347 if (rowId > 0) { 1348 Uri channelUri = TvContract.buildChannelUri(rowId); 1349 notifyChange(channelUri); 1350 return channelUri; 1351 } 1352 1353 throw new SQLException("Failed to insert row into " + uri); 1354 } 1355 1356 private Uri insertProgram(Uri uri, ContentValues values) { 1357 if (!callerHasAccessAllEpgDataPermission() || 1358 !values.containsKey(Programs.COLUMN_PACKAGE_NAME)) { 1359 // Mark the owner package of this program. System app with a proper permission may 1360 // change the owner of the program. 1361 values.put(Programs.COLUMN_PACKAGE_NAME, getCallingPackage_()); 1362 } 1363 1364 checkAndConvertGenre(values); 1365 checkAndConvertDeprecatedColumns(values); 1366 1367 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1368 long rowId = db.insert(PROGRAMS_TABLE, null, values); 1369 if (rowId > 0) { 1370 Uri programUri = TvContract.buildProgramUri(rowId); 1371 notifyChange(programUri); 1372 return programUri; 1373 } 1374 1375 throw new SQLException("Failed to insert row into " + uri); 1376 } 1377 1378 private Uri insertWatchedProgram(Uri uri, ContentValues values) { 1379 if (DEBUG) { 1380 Log.d(TAG, "insertWatchedProgram(uri=" + uri + ", values={" + values + "})"); 1381 } 1382 Long watchStartTime = values.getAsLong(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS); 1383 Long watchEndTime = values.getAsLong(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS); 1384 // The system sends only two kinds of watch events: 1385 // 1. The user tunes to a new channel. (COLUMN_WATCH_START_TIME_UTC_MILLIS) 1386 // 2. The user stops watching. (COLUMN_WATCH_END_TIME_UTC_MILLIS) 1387 if (watchStartTime != null && watchEndTime == null) { 1388 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1389 long rowId = db.insert(WATCHED_PROGRAMS_TABLE, null, values); 1390 if (rowId > 0) { 1391 mLogHandler.removeMessages(WatchLogHandler.MSG_TRY_CONSOLIDATE_ALL); 1392 mLogHandler.sendEmptyMessageDelayed(WatchLogHandler.MSG_TRY_CONSOLIDATE_ALL, 1393 MAX_PROGRAM_DATA_DELAY_IN_MILLIS); 1394 return TvContract.buildWatchedProgramUri(rowId); 1395 } 1396 Log.w(TAG, "Failed to insert row for " + values + ". Channel does not exist."); 1397 return null; 1398 } else if (watchStartTime == null && watchEndTime != null) { 1399 SomeArgs args = SomeArgs.obtain(); 1400 args.arg1 = values.getAsString(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN); 1401 args.arg2 = watchEndTime; 1402 Message msg = mLogHandler.obtainMessage(WatchLogHandler.MSG_CONSOLIDATE, args); 1403 mLogHandler.sendMessageDelayed(msg, MAX_PROGRAM_DATA_DELAY_IN_MILLIS); 1404 return null; 1405 } 1406 // All the other cases are invalid. 1407 throw new IllegalArgumentException("Only one of COLUMN_WATCH_START_TIME_UTC_MILLIS and" 1408 + " COLUMN_WATCH_END_TIME_UTC_MILLIS should be specified"); 1409 } 1410 1411 private Uri insertRecordedProgram(Uri uri, ContentValues values) { 1412 // Mark the owner package of this program. 1413 values.put(Programs.COLUMN_PACKAGE_NAME, getCallingPackage_()); 1414 1415 checkAndConvertGenre(values); 1416 1417 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1418 long rowId = db.insert(RECORDED_PROGRAMS_TABLE, null, values); 1419 if (rowId > 0) { 1420 Uri recordedProgramUri = TvContract.buildRecordedProgramUri(rowId); 1421 notifyChange(recordedProgramUri); 1422 return recordedProgramUri; 1423 } 1424 1425 throw new SQLException("Failed to insert row into " + uri); 1426 } 1427 1428 private Uri insertPreviewProgram(Uri uri, ContentValues values) { 1429 if (!values.containsKey(PreviewPrograms.COLUMN_TYPE)) { 1430 throw new IllegalArgumentException("Missing the required column: " + 1431 PreviewPrograms.COLUMN_TYPE); 1432 } 1433 blockIllegalAccessFromBlockedPackage(); 1434 // Mark the owner package of this program. 1435 values.put(Programs.COLUMN_PACKAGE_NAME, getCallingPackage_()); 1436 blockIllegalAccessToPreviewProgramsSystemColumns(values); 1437 1438 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1439 long rowId = db.insert(PREVIEW_PROGRAMS_TABLE, null, values); 1440 if (rowId > 0) { 1441 Uri previewProgramUri = TvContract.buildPreviewProgramUri(rowId); 1442 notifyChange(previewProgramUri); 1443 return previewProgramUri; 1444 } 1445 1446 throw new SQLException("Failed to insert row into " + uri); 1447 } 1448 1449 private Uri insertWatchNextProgram(Uri uri, ContentValues values) { 1450 if (!values.containsKey(WatchNextPrograms.COLUMN_TYPE)) { 1451 throw new IllegalArgumentException("Missing the required column: " + 1452 WatchNextPrograms.COLUMN_TYPE); 1453 } 1454 blockIllegalAccessFromBlockedPackage(); 1455 if (!callerHasAccessAllEpgDataPermission() || 1456 !values.containsKey(Programs.COLUMN_PACKAGE_NAME)) { 1457 // Mark the owner package of this program. System app with a proper permission may 1458 // change the owner of the program. 1459 values.put(Programs.COLUMN_PACKAGE_NAME, getCallingPackage_()); 1460 } 1461 blockIllegalAccessToPreviewProgramsSystemColumns(values); 1462 1463 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1464 long rowId = db.insert(WATCH_NEXT_PROGRAMS_TABLE, null, values); 1465 if (rowId > 0) { 1466 Uri watchNextProgramUri = TvContract.buildWatchNextProgramUri(rowId); 1467 notifyChange(watchNextProgramUri); 1468 return watchNextProgramUri; 1469 } 1470 1471 throw new SQLException("Failed to insert row into " + uri); 1472 } 1473 1474 @Override 1475 public int delete(Uri uri, String selection, String[] selectionArgs) { 1476 mTransientRowHelper.ensureOldTransientRowsDeleted(); 1477 SqlParams params = createSqlParams(OP_DELETE, uri, selection, selectionArgs); 1478 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1479 int count; 1480 switch (sUriMatcher.match(uri)) { 1481 case MATCH_CHANNEL_ID_LOGO: 1482 ContentValues values = new ContentValues(); 1483 values.putNull(CHANNELS_COLUMN_LOGO); 1484 count = db.update(params.getTables(), values, params.getSelection(), 1485 params.getSelectionArgs()); 1486 break; 1487 case MATCH_CHANNEL: 1488 case MATCH_PROGRAM: 1489 case MATCH_WATCHED_PROGRAM: 1490 case MATCH_RECORDED_PROGRAM: 1491 case MATCH_PREVIEW_PROGRAM: 1492 case MATCH_WATCH_NEXT_PROGRAM: 1493 case MATCH_CHANNEL_ID: 1494 case MATCH_PASSTHROUGH_ID: 1495 case MATCH_PROGRAM_ID: 1496 case MATCH_WATCHED_PROGRAM_ID: 1497 case MATCH_RECORDED_PROGRAM_ID: 1498 case MATCH_PREVIEW_PROGRAM_ID: 1499 case MATCH_WATCH_NEXT_PROGRAM_ID: 1500 count = db.delete(params.getTables(), params.getSelection(), 1501 params.getSelectionArgs()); 1502 break; 1503 default: 1504 throw new IllegalArgumentException("Unknown URI " + uri); 1505 } 1506 if (count > 0) { 1507 notifyChange(uri); 1508 } 1509 return count; 1510 } 1511 1512 @Override 1513 public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { 1514 mTransientRowHelper.ensureOldTransientRowsDeleted(); 1515 SqlParams params = createSqlParams(OP_UPDATE, uri, selection, selectionArgs); 1516 blockIllegalAccessToIdAndPackageName(uri, values); 1517 boolean containImmutableColumn = false; 1518 if (params.getTables().equals(CHANNELS_TABLE)) { 1519 filterContentValues(values, sChannelProjectionMap); 1520 containImmutableColumn = disallowModifyChannelType(values, params); 1521 if (containImmutableColumn && sUriMatcher.match(uri) != MATCH_CHANNEL_ID) { 1522 Log.i(TAG, "Updating failed. Attempt to change immutable column for channels."); 1523 return 0; 1524 } 1525 blockIllegalAccessToChannelsSystemColumns(values); 1526 } else if (params.getTables().equals(PROGRAMS_TABLE)) { 1527 filterContentValues(values, sProgramProjectionMap); 1528 checkAndConvertGenre(values); 1529 checkAndConvertDeprecatedColumns(values); 1530 } else if (params.getTables().equals(RECORDED_PROGRAMS_TABLE)) { 1531 filterContentValues(values, sRecordedProgramProjectionMap); 1532 checkAndConvertGenre(values); 1533 } else if (params.getTables().equals(PREVIEW_PROGRAMS_TABLE)) { 1534 filterContentValues(values, sPreviewProgramProjectionMap); 1535 containImmutableColumn = disallowModifyChannelId(values, params); 1536 if (containImmutableColumn && PreviewPrograms.CONTENT_URI.equals(uri)) { 1537 Log.i(TAG, "Updating failed. Attempt to change unmodifiable column for " 1538 + "preview programs."); 1539 return 0; 1540 } 1541 blockIllegalAccessToPreviewProgramsSystemColumns(values); 1542 } else if (params.getTables().equals(WATCH_NEXT_PROGRAMS_TABLE)) { 1543 filterContentValues(values, sWatchNextProgramProjectionMap); 1544 blockIllegalAccessToPreviewProgramsSystemColumns(values); 1545 } 1546 if (values.size() == 0) { 1547 // All values may be filtered out, no need to update 1548 return 0; 1549 } 1550 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1551 int count = db.update(params.getTables(), values, params.getSelection(), 1552 params.getSelectionArgs()); 1553 if (count > 0) { 1554 notifyChange(uri); 1555 } else if (containImmutableColumn) { 1556 Log.i(TAG, "Updating failed. The item may not exist or attempt to change " 1557 + "immutable column."); 1558 } 1559 return count; 1560 } 1561 1562 private synchronized void ensureInitialized() { 1563 if (!sInitialized) { 1564 // Database is not accessed before and the projection maps and the blocked package list 1565 // are not updated yet. Gets database here to make it initialized. 1566 mOpenHelper.getReadableDatabase(); 1567 } 1568 } 1569 1570 private static synchronized void initOnOpenIfNeeded(Context context, SQLiteDatabase db) { 1571 if (!sInitialized) { 1572 updateProjectionMap(db, CHANNELS_TABLE, sChannelProjectionMap); 1573 updateProjectionMap(db, PROGRAMS_TABLE, sProgramProjectionMap); 1574 updateProjectionMap(db, WATCHED_PROGRAMS_TABLE, sWatchedProgramProjectionMap); 1575 updateProjectionMap(db, RECORDED_PROGRAMS_TABLE, sRecordedProgramProjectionMap); 1576 updateProjectionMap(db, PREVIEW_PROGRAMS_TABLE, sPreviewProgramProjectionMap); 1577 updateProjectionMap(db, WATCH_NEXT_PROGRAMS_TABLE, sWatchNextProgramProjectionMap); 1578 sBlockedPackagesSharedPreference = PreferenceManager.getDefaultSharedPreferences( 1579 context); 1580 sBlockedPackages = new ConcurrentHashMap<>(); 1581 for (String packageName : sBlockedPackagesSharedPreference.getStringSet( 1582 SHARED_PREF_BLOCKED_PACKAGES_KEY, new HashSet<>())) { 1583 sBlockedPackages.put(packageName, true); 1584 } 1585 sInitialized = true; 1586 } 1587 } 1588 1589 private static void updateProjectionMap(SQLiteDatabase db, String tableName, 1590 Map<String, String> projectionMap) { 1591 try(Cursor cursor = db.rawQuery("SELECT * FROM " + tableName + " LIMIT 0", null)) { 1592 for (String columnName : cursor.getColumnNames()) { 1593 if (!projectionMap.containsKey(columnName)) { 1594 projectionMap.put(columnName, tableName + '.' + columnName); 1595 } 1596 } 1597 } 1598 } 1599 1600 private Map<String, String> createProjectionMapForQuery(String[] projection, 1601 Map<String, String> projectionMap) { 1602 if (projection == null) { 1603 return projectionMap; 1604 } 1605 Map<String, String> columnProjectionMap = new HashMap<>(); 1606 for (String columnName : projection) { 1607 // Value NULL will be provided if the requested column does not exist in the database. 1608 columnProjectionMap.put(columnName, 1609 projectionMap.getOrDefault(columnName, "NULL as " + columnName)); 1610 } 1611 return columnProjectionMap; 1612 } 1613 1614 private void filterContentValues(ContentValues values, Map<String, String> projectionMap) { 1615 Iterator<String> iter = values.keySet().iterator(); 1616 while (iter.hasNext()) { 1617 String columnName = iter.next(); 1618 if (!projectionMap.containsKey(columnName)) { 1619 iter.remove(); 1620 } 1621 } 1622 } 1623 1624 private SqlParams createSqlParams(String operation, Uri uri, String selection, 1625 String[] selectionArgs) { 1626 int match = sUriMatcher.match(uri); 1627 SqlParams params = new SqlParams(null, selection, selectionArgs); 1628 1629 // Control access to EPG data (excluding watched programs) when the caller doesn't have all 1630 // access. 1631 String prefix = match == MATCH_CHANNEL ? CHANNELS_TABLE + "." : ""; 1632 if (!callerHasAccessAllEpgDataPermission() 1633 && match != MATCH_WATCHED_PROGRAM && match != MATCH_WATCHED_PROGRAM_ID) { 1634 if (!TextUtils.isEmpty(selection)) { 1635 throw new SecurityException("Selection not allowed for " + uri); 1636 } 1637 // Limit the operation only to the data that the calling package owns except for when 1638 // the caller tries to read TV listings and has the appropriate permission. 1639 if (operation.equals(OP_QUERY) && callerHasReadTvListingsPermission()) { 1640 params.setWhere(prefix + BaseTvColumns.COLUMN_PACKAGE_NAME + "=? OR " 1641 + Channels.COLUMN_SEARCHABLE + "=?", getCallingPackage_(), "1"); 1642 } else { 1643 params.setWhere(prefix + BaseTvColumns.COLUMN_PACKAGE_NAME + "=?", 1644 getCallingPackage_()); 1645 } 1646 } 1647 String packageName = uri.getQueryParameter(TvContract.PARAM_PACKAGE); 1648 if (packageName != null) { 1649 params.appendWhere(prefix + BaseTvColumns.COLUMN_PACKAGE_NAME + "=?", packageName); 1650 } 1651 1652 switch (match) { 1653 case MATCH_CHANNEL: 1654 String genre = uri.getQueryParameter(TvContract.PARAM_CANONICAL_GENRE); 1655 if (genre == null) { 1656 params.setTables(CHANNELS_TABLE); 1657 } else { 1658 if (!operation.equals(OP_QUERY)) { 1659 throw new SecurityException(capitalize(operation) 1660 + " not allowed for " + uri); 1661 } 1662 if (!Genres.isCanonical(genre)) { 1663 throw new IllegalArgumentException("Not a canonical genre : " + genre); 1664 } 1665 params.setTables(CHANNELS_TABLE_INNER_JOIN_PROGRAMS_TABLE); 1666 String curTime = String.valueOf(System.currentTimeMillis()); 1667 params.appendWhere("LIKE(?, " + Programs.COLUMN_CANONICAL_GENRE + ") AND " 1668 + Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND " 1669 + Programs.COLUMN_END_TIME_UTC_MILLIS + ">=?", 1670 "%" + genre + "%", curTime, curTime); 1671 } 1672 String inputId = uri.getQueryParameter(TvContract.PARAM_INPUT); 1673 if (inputId != null) { 1674 params.appendWhere(Channels.COLUMN_INPUT_ID + "=?", inputId); 1675 } 1676 boolean browsableOnly = uri.getBooleanQueryParameter( 1677 TvContract.PARAM_BROWSABLE_ONLY, false); 1678 if (browsableOnly) { 1679 params.appendWhere(Channels.COLUMN_BROWSABLE + "=1"); 1680 } 1681 String preview = uri.getQueryParameter(TvContract.PARAM_PREVIEW); 1682 if (preview != null) { 1683 String previewSelection = Channels.COLUMN_TYPE 1684 + (preview.equals(String.valueOf(true)) ? "=?" : "!=?"); 1685 params.appendWhere(previewSelection, Channels.TYPE_PREVIEW); 1686 } 1687 break; 1688 case MATCH_CHANNEL_ID: 1689 params.setTables(CHANNELS_TABLE); 1690 params.appendWhere(Channels._ID + "=?", uri.getLastPathSegment()); 1691 break; 1692 case MATCH_PROGRAM: 1693 params.setTables(PROGRAMS_TABLE); 1694 String paramChannelId = uri.getQueryParameter(TvContract.PARAM_CHANNEL); 1695 if (paramChannelId != null) { 1696 String channelId = String.valueOf(Long.parseLong(paramChannelId)); 1697 params.appendWhere(Programs.COLUMN_CHANNEL_ID + "=?", channelId); 1698 } 1699 String paramStartTime = uri.getQueryParameter(TvContract.PARAM_START_TIME); 1700 String paramEndTime = uri.getQueryParameter(TvContract.PARAM_END_TIME); 1701 if (paramStartTime != null && paramEndTime != null) { 1702 String startTime = String.valueOf(Long.parseLong(paramStartTime)); 1703 String endTime = String.valueOf(Long.parseLong(paramEndTime)); 1704 params.appendWhere(Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND " 1705 + Programs.COLUMN_END_TIME_UTC_MILLIS + ">=? AND ?<=?", endTime, 1706 startTime, startTime, endTime); 1707 } 1708 break; 1709 case MATCH_PROGRAM_ID: 1710 params.setTables(PROGRAMS_TABLE); 1711 params.appendWhere(Programs._ID + "=?", uri.getLastPathSegment()); 1712 break; 1713 case MATCH_WATCHED_PROGRAM: 1714 if (!callerHasAccessWatchedProgramsPermission()) { 1715 throw new SecurityException("Access not allowed for " + uri); 1716 } 1717 params.setTables(WATCHED_PROGRAMS_TABLE); 1718 params.appendWhere(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=?", "1"); 1719 break; 1720 case MATCH_WATCHED_PROGRAM_ID: 1721 if (!callerHasAccessWatchedProgramsPermission()) { 1722 throw new SecurityException("Access not allowed for " + uri); 1723 } 1724 params.setTables(WATCHED_PROGRAMS_TABLE); 1725 params.appendWhere(WatchedPrograms._ID + "=?", uri.getLastPathSegment()); 1726 params.appendWhere(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=?", "1"); 1727 break; 1728 case MATCH_RECORDED_PROGRAM_ID: 1729 params.appendWhere(RecordedPrograms._ID + "=?", uri.getLastPathSegment()); 1730 // fall-through 1731 case MATCH_RECORDED_PROGRAM: 1732 params.setTables(RECORDED_PROGRAMS_TABLE); 1733 paramChannelId = uri.getQueryParameter(TvContract.PARAM_CHANNEL); 1734 if (paramChannelId != null) { 1735 String channelId = String.valueOf(Long.parseLong(paramChannelId)); 1736 params.appendWhere(Programs.COLUMN_CHANNEL_ID + "=?", channelId); 1737 } 1738 break; 1739 case MATCH_PREVIEW_PROGRAM_ID: 1740 params.appendWhere(PreviewPrograms._ID + "=?", uri.getLastPathSegment()); 1741 // fall-through 1742 case MATCH_PREVIEW_PROGRAM: 1743 params.setTables(PREVIEW_PROGRAMS_TABLE); 1744 paramChannelId = uri.getQueryParameter(TvContract.PARAM_CHANNEL); 1745 if (paramChannelId != null) { 1746 String channelId = String.valueOf(Long.parseLong(paramChannelId)); 1747 params.appendWhere(PreviewPrograms.COLUMN_CHANNEL_ID + "=?", channelId); 1748 } 1749 break; 1750 case MATCH_WATCH_NEXT_PROGRAM_ID: 1751 params.appendWhere(WatchNextPrograms._ID + "=?", uri.getLastPathSegment()); 1752 // fall-through 1753 case MATCH_WATCH_NEXT_PROGRAM: 1754 params.setTables(WATCH_NEXT_PROGRAMS_TABLE); 1755 break; 1756 case MATCH_CHANNEL_ID_LOGO: 1757 if (operation.equals(OP_DELETE)) { 1758 params.setTables(CHANNELS_TABLE); 1759 params.appendWhere(Channels._ID + "=?", uri.getPathSegments().get(1)); 1760 break; 1761 } 1762 // fall-through 1763 case MATCH_PASSTHROUGH_ID: 1764 throw new UnsupportedOperationException(operation + " not permmitted on " + uri); 1765 default: 1766 throw new IllegalArgumentException("Unknown URI " + uri); 1767 } 1768 return params; 1769 } 1770 1771 private static String generateDefaultClause(String dataType, String defaultValue) 1772 throws IllegalArgumentException { 1773 String defaultValueString = " DEFAULT "; 1774 switch (dataType.toLowerCase()) { 1775 case "integer": 1776 return defaultValueString + Integer.parseInt(defaultValue); 1777 case "real": 1778 return defaultValueString + Double.parseDouble(defaultValue); 1779 case "text": 1780 case "blob": 1781 return defaultValueString + DatabaseUtils.sqlEscapeString(defaultValue); 1782 default: 1783 throw new IllegalArgumentException("Illegal data type \"" + dataType 1784 + "\" with default value: " + defaultValue); 1785 } 1786 } 1787 1788 private static String capitalize(String str) { 1789 return Character.toUpperCase(str.charAt(0)) + str.substring(1); 1790 } 1791 1792 @SuppressLint("DefaultLocale") 1793 private void checkAndConvertGenre(ContentValues values) { 1794 String canonicalGenres = values.getAsString(Programs.COLUMN_CANONICAL_GENRE); 1795 1796 if (!TextUtils.isEmpty(canonicalGenres)) { 1797 // Check if the canonical genres are valid. If not, clear them. 1798 String[] genres = Genres.decode(canonicalGenres); 1799 for (String genre : genres) { 1800 if (!Genres.isCanonical(genre)) { 1801 values.putNull(Programs.COLUMN_CANONICAL_GENRE); 1802 canonicalGenres = null; 1803 break; 1804 } 1805 } 1806 } 1807 1808 if (TextUtils.isEmpty(canonicalGenres)) { 1809 // If the canonical genre is not set, try to map the broadcast genre to the canonical 1810 // genre. 1811 String broadcastGenres = values.getAsString(Programs.COLUMN_BROADCAST_GENRE); 1812 if (!TextUtils.isEmpty(broadcastGenres)) { 1813 Set<String> genreSet = new HashSet<>(); 1814 String[] genres = Genres.decode(broadcastGenres); 1815 for (String genre : genres) { 1816 String canonicalGenre = sGenreMap.get(genre.toUpperCase()); 1817 if (Genres.isCanonical(canonicalGenre)) { 1818 genreSet.add(canonicalGenre); 1819 } 1820 } 1821 if (genreSet.size() > 0) { 1822 values.put(Programs.COLUMN_CANONICAL_GENRE, 1823 Genres.encode(genreSet.toArray(new String[genreSet.size()]))); 1824 } 1825 } 1826 } 1827 } 1828 1829 private void checkAndConvertDeprecatedColumns(ContentValues values) { 1830 if (values.containsKey(Programs.COLUMN_SEASON_NUMBER)) { 1831 if (!values.containsKey(Programs.COLUMN_SEASON_DISPLAY_NUMBER)) { 1832 values.put(Programs.COLUMN_SEASON_DISPLAY_NUMBER, values.getAsInteger( 1833 Programs.COLUMN_SEASON_NUMBER)); 1834 } 1835 values.remove(Programs.COLUMN_SEASON_NUMBER); 1836 } 1837 if (values.containsKey(Programs.COLUMN_EPISODE_NUMBER)) { 1838 if (!values.containsKey(Programs.COLUMN_EPISODE_DISPLAY_NUMBER)) { 1839 values.put(Programs.COLUMN_EPISODE_DISPLAY_NUMBER, values.getAsInteger( 1840 Programs.COLUMN_EPISODE_NUMBER)); 1841 } 1842 values.remove(Programs.COLUMN_EPISODE_NUMBER); 1843 } 1844 } 1845 1846 // We might have more than one thread trying to make its way through applyBatch() so the 1847 // notification coalescing needs to be thread-local to work correctly. 1848 private final ThreadLocal<Set<Uri>> mTLBatchNotifications = new ThreadLocal<>(); 1849 1850 private Set<Uri> getBatchNotificationsSet() { 1851 return mTLBatchNotifications.get(); 1852 } 1853 1854 private void setBatchNotificationsSet(Set<Uri> batchNotifications) { 1855 mTLBatchNotifications.set(batchNotifications); 1856 } 1857 1858 @Override 1859 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) 1860 throws OperationApplicationException { 1861 setBatchNotificationsSet(new HashSet<Uri>()); 1862 Context context = getContext(); 1863 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1864 db.beginTransaction(); 1865 try { 1866 ContentProviderResult[] results = super.applyBatch(operations); 1867 db.setTransactionSuccessful(); 1868 return results; 1869 } finally { 1870 db.endTransaction(); 1871 final Set<Uri> notifications = getBatchNotificationsSet(); 1872 setBatchNotificationsSet(null); 1873 for (final Uri uri : notifications) { 1874 context.getContentResolver().notifyChange(uri, null); 1875 } 1876 } 1877 } 1878 1879 @Override 1880 public int bulkInsert(Uri uri, ContentValues[] values) { 1881 setBatchNotificationsSet(new HashSet<Uri>()); 1882 Context context = getContext(); 1883 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 1884 db.beginTransaction(); 1885 try { 1886 int result = super.bulkInsert(uri, values); 1887 db.setTransactionSuccessful(); 1888 return result; 1889 } finally { 1890 db.endTransaction(); 1891 final Set<Uri> notifications = getBatchNotificationsSet(); 1892 setBatchNotificationsSet(null); 1893 for (final Uri notificationUri : notifications) { 1894 context.getContentResolver().notifyChange(notificationUri, null); 1895 } 1896 } 1897 } 1898 1899 private void notifyChange(Uri uri) { 1900 final Set<Uri> batchNotifications = getBatchNotificationsSet(); 1901 if (batchNotifications != null) { 1902 batchNotifications.add(uri); 1903 } else { 1904 getContext().getContentResolver().notifyChange(uri, null); 1905 } 1906 } 1907 1908 private boolean callerHasReadTvListingsPermission() { 1909 return getContext().checkCallingOrSelfPermission(PERMISSION_READ_TV_LISTINGS) 1910 == PackageManager.PERMISSION_GRANTED; 1911 } 1912 1913 private boolean callerHasAccessAllEpgDataPermission() { 1914 return getContext().checkCallingOrSelfPermission(PERMISSION_ACCESS_ALL_EPG_DATA) 1915 == PackageManager.PERMISSION_GRANTED; 1916 } 1917 1918 private boolean callerHasAccessWatchedProgramsPermission() { 1919 return getContext().checkCallingOrSelfPermission(PERMISSION_ACCESS_WATCHED_PROGRAMS) 1920 == PackageManager.PERMISSION_GRANTED; 1921 } 1922 1923 private boolean callerHasModifyParentalControlsPermission() { 1924 return getContext().checkCallingOrSelfPermission( 1925 android.Manifest.permission.MODIFY_PARENTAL_CONTROLS) 1926 == PackageManager.PERMISSION_GRANTED; 1927 } 1928 1929 private void blockIllegalAccessToIdAndPackageName(Uri uri, ContentValues values) { 1930 if (values.containsKey(BaseColumns._ID)) { 1931 int match = sUriMatcher.match(uri); 1932 switch (match) { 1933 case MATCH_CHANNEL_ID: 1934 case MATCH_PROGRAM_ID: 1935 case MATCH_PREVIEW_PROGRAM_ID: 1936 case MATCH_RECORDED_PROGRAM_ID: 1937 case MATCH_WATCH_NEXT_PROGRAM_ID: 1938 case MATCH_WATCHED_PROGRAM_ID: 1939 if (TextUtils.equals(values.getAsString(BaseColumns._ID), 1940 uri.getLastPathSegment())) { 1941 break; 1942 } 1943 default: 1944 throw new IllegalArgumentException("Not allowed to change ID."); 1945 } 1946 } 1947 if (values.containsKey(BaseTvColumns.COLUMN_PACKAGE_NAME) 1948 && !callerHasAccessAllEpgDataPermission() && !TextUtils.equals(values.getAsString( 1949 BaseTvColumns.COLUMN_PACKAGE_NAME), getCallingPackage_())) { 1950 throw new SecurityException("Not allowed to change package name."); 1951 } 1952 } 1953 1954 private void blockIllegalAccessToChannelsSystemColumns(ContentValues values) { 1955 if (values.containsKey(Channels.COLUMN_LOCKED) 1956 && !callerHasModifyParentalControlsPermission()) { 1957 throw new SecurityException("Not allowed to access Channels.COLUMN_LOCKED"); 1958 } 1959 Boolean hasAccessAllEpgDataPermission = null; 1960 if (values.containsKey(Channels.COLUMN_BROWSABLE)) { 1961 hasAccessAllEpgDataPermission = callerHasAccessAllEpgDataPermission(); 1962 if (!hasAccessAllEpgDataPermission) { 1963 throw new SecurityException("Not allowed to access Channels.COLUMN_BROWSABLE"); 1964 } 1965 } 1966 } 1967 1968 private void blockIllegalAccessToPreviewProgramsSystemColumns(ContentValues values) { 1969 if (values.containsKey(PreviewPrograms.COLUMN_BROWSABLE) 1970 && !callerHasAccessAllEpgDataPermission()) { 1971 throw new SecurityException("Not allowed to access Programs.COLUMN_BROWSABLE"); 1972 } 1973 } 1974 1975 private void blockIllegalAccessFromBlockedPackage() { 1976 String callingPackageName = getCallingPackage_(); 1977 if (sBlockedPackages.containsKey(callingPackageName)) { 1978 throw new SecurityException( 1979 "Not allowed to access " + TvContract.AUTHORITY + ", " 1980 + callingPackageName + " is blocked"); 1981 } 1982 } 1983 1984 private boolean disallowModifyChannelType(ContentValues values, SqlParams params) { 1985 if (values.containsKey(Channels.COLUMN_TYPE)) { 1986 params.appendWhere(Channels.COLUMN_TYPE + "=?", 1987 values.getAsString(Channels.COLUMN_TYPE)); 1988 return true; 1989 } 1990 return false; 1991 } 1992 1993 private boolean disallowModifyChannelId(ContentValues values, SqlParams params) { 1994 if (values.containsKey(PreviewPrograms.COLUMN_CHANNEL_ID)) { 1995 params.appendWhere(PreviewPrograms.COLUMN_CHANNEL_ID + "=?", 1996 values.getAsString(PreviewPrograms.COLUMN_CHANNEL_ID)); 1997 return true; 1998 } 1999 return false; 2000 } 2001 2002 @Override 2003 public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException { 2004 switch (sUriMatcher.match(uri)) { 2005 case MATCH_CHANNEL_ID_LOGO: 2006 return openLogoFile(uri, mode); 2007 default: 2008 throw new FileNotFoundException(uri.toString()); 2009 } 2010 } 2011 2012 private ParcelFileDescriptor openLogoFile(Uri uri, String mode) throws FileNotFoundException { 2013 long channelId = Long.parseLong(uri.getPathSegments().get(1)); 2014 2015 SqlParams params = new SqlParams(CHANNELS_TABLE, Channels._ID + "=?", 2016 String.valueOf(channelId)); 2017 if (!callerHasAccessAllEpgDataPermission()) { 2018 if (callerHasReadTvListingsPermission()) { 2019 params.appendWhere(Channels.COLUMN_PACKAGE_NAME + "=? OR " 2020 + Channels.COLUMN_SEARCHABLE + "=?", getCallingPackage_(), "1"); 2021 } else { 2022 params.appendWhere(Channels.COLUMN_PACKAGE_NAME + "=?", getCallingPackage_()); 2023 } 2024 } 2025 2026 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2027 queryBuilder.setTables(params.getTables()); 2028 2029 // We don't write the database here. 2030 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 2031 if (mode.equals("r")) { 2032 String sql = queryBuilder.buildQuery(new String[] { CHANNELS_COLUMN_LOGO }, 2033 params.getSelection(), null, null, null, null); 2034 ParcelFileDescriptor fd = DatabaseUtils.blobFileDescriptorForQuery( 2035 db, sql, params.getSelectionArgs()); 2036 if (fd == null) { 2037 throw new FileNotFoundException(uri.toString()); 2038 } 2039 return fd; 2040 } else { 2041 try (Cursor cursor = queryBuilder.query(db, new String[] { Channels._ID }, 2042 params.getSelection(), params.getSelectionArgs(), null, null, null)) { 2043 if (cursor.getCount() < 1) { 2044 // Fails early if corresponding channel does not exist. 2045 // PipeMonitor may still fail to update DB later. 2046 throw new FileNotFoundException(uri.toString()); 2047 } 2048 } 2049 2050 try { 2051 ParcelFileDescriptor[] pipeFds = ParcelFileDescriptor.createPipe(); 2052 PipeMonitor pipeMonitor = new PipeMonitor(pipeFds[0], channelId, params); 2053 pipeMonitor.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); 2054 return pipeFds[1]; 2055 } catch (IOException ioe) { 2056 FileNotFoundException fne = new FileNotFoundException(uri.toString()); 2057 fne.initCause(ioe); 2058 throw fne; 2059 } 2060 } 2061 } 2062 2063 /** 2064 * Validates the sort order based on the given field set. 2065 * 2066 * @throws IllegalArgumentException if there is any unknown field. 2067 */ 2068 @SuppressLint("DefaultLocale") 2069 private static void validateSortOrder(String sortOrder, Set<String> possibleFields) { 2070 if (TextUtils.isEmpty(sortOrder) || possibleFields.isEmpty()) { 2071 return; 2072 } 2073 String[] orders = sortOrder.split(","); 2074 for (String order : orders) { 2075 String field = order.replaceAll("\\s+", " ").trim().toLowerCase().replace(" asc", "") 2076 .replace(" desc", ""); 2077 if (!possibleFields.contains(field)) { 2078 throw new IllegalArgumentException("Illegal field in sort order " + order); 2079 } 2080 } 2081 } 2082 2083 private class PipeMonitor extends AsyncTask<Void, Void, Void> { 2084 private final ParcelFileDescriptor mPfd; 2085 private final long mChannelId; 2086 private final SqlParams mParams; 2087 2088 private PipeMonitor(ParcelFileDescriptor pfd, long channelId, SqlParams params) { 2089 mPfd = pfd; 2090 mChannelId = channelId; 2091 mParams = params; 2092 } 2093 2094 @Override 2095 protected Void doInBackground(Void... params) { 2096 AutoCloseInputStream is = new AutoCloseInputStream(mPfd); 2097 ByteArrayOutputStream baos = null; 2098 int count = 0; 2099 try { 2100 Bitmap bitmap = BitmapFactory.decodeStream(is); 2101 if (bitmap == null) { 2102 Log.e(TAG, "Failed to decode logo image for channel ID " + mChannelId); 2103 return null; 2104 } 2105 2106 float scaleFactor = Math.min(1f, ((float) MAX_LOGO_IMAGE_SIZE) / 2107 Math.max(bitmap.getWidth(), bitmap.getHeight())); 2108 if (scaleFactor < 1f) { 2109 bitmap = Bitmap.createScaledBitmap(bitmap, 2110 (int) (bitmap.getWidth() * scaleFactor), 2111 (int) (bitmap.getHeight() * scaleFactor), false); 2112 } 2113 2114 baos = new ByteArrayOutputStream(); 2115 bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos); 2116 byte[] bytes = baos.toByteArray(); 2117 2118 ContentValues values = new ContentValues(); 2119 values.put(CHANNELS_COLUMN_LOGO, bytes); 2120 2121 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 2122 count = db.update(mParams.getTables(), values, mParams.getSelection(), 2123 mParams.getSelectionArgs()); 2124 if (count > 0) { 2125 Uri uri = TvContract.buildChannelLogoUri(mChannelId); 2126 notifyChange(uri); 2127 } 2128 } finally { 2129 if (count == 0) { 2130 try { 2131 mPfd.closeWithError("Failed to write logo for channel ID " + mChannelId); 2132 } catch (IOException ioe) { 2133 Log.e(TAG, "Failed to close pipe", ioe); 2134 } 2135 } 2136 IoUtils.closeQuietly(baos); 2137 IoUtils.closeQuietly(is); 2138 } 2139 return null; 2140 } 2141 } 2142 2143 private void deleteUnconsolidatedWatchedProgramsRows() { 2144 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 2145 db.delete(WATCHED_PROGRAMS_TABLE, WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0", null); 2146 } 2147 2148 @SuppressLint("HandlerLeak") 2149 private final class WatchLogHandler extends Handler { 2150 private static final int MSG_CONSOLIDATE = 1; 2151 private static final int MSG_TRY_CONSOLIDATE_ALL = 2; 2152 2153 @Override 2154 public void handleMessage(Message msg) { 2155 switch (msg.what) { 2156 case MSG_CONSOLIDATE: { 2157 SomeArgs args = (SomeArgs) msg.obj; 2158 String sessionToken = (String) args.arg1; 2159 long watchEndTime = (long) args.arg2; 2160 onConsolidate(sessionToken, watchEndTime); 2161 args.recycle(); 2162 return; 2163 } 2164 case MSG_TRY_CONSOLIDATE_ALL: { 2165 onTryConsolidateAll(); 2166 return; 2167 } 2168 default: { 2169 Log.w(TAG, "Unhandled message code: " + msg.what); 2170 return; 2171 } 2172 } 2173 } 2174 2175 // Consolidates all WatchedPrograms rows for a given session with watch end time information 2176 // of the most recent log entry. After this method is called, it is guaranteed that there 2177 // remain consolidated rows only for that session. 2178 private void onConsolidate(String sessionToken, long watchEndTime) { 2179 if (DEBUG) { 2180 Log.d(TAG, "onConsolidate(sessionToken=" + sessionToken + ", watchEndTime=" 2181 + watchEndTime + ")"); 2182 } 2183 2184 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2185 queryBuilder.setTables(WATCHED_PROGRAMS_TABLE); 2186 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 2187 2188 // Pick up the last row with the same session token. 2189 String[] projection = { 2190 WatchedPrograms._ID, 2191 WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS, 2192 WatchedPrograms.COLUMN_CHANNEL_ID 2193 }; 2194 String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=? AND " 2195 + WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + "=?"; 2196 String[] selectionArgs = { 2197 "0", 2198 sessionToken 2199 }; 2200 String sortOrder = WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC"; 2201 2202 int consolidatedRowCount = 0; 2203 try (Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null, 2204 null, sortOrder)) { 2205 long oldWatchStartTime = watchEndTime; 2206 while (cursor != null && cursor.moveToNext()) { 2207 long id = cursor.getLong(0); 2208 long watchStartTime = cursor.getLong(1); 2209 long channelId = cursor.getLong(2); 2210 consolidatedRowCount += consolidateRow(id, watchStartTime, oldWatchStartTime, 2211 channelId, false); 2212 oldWatchStartTime = watchStartTime; 2213 } 2214 } 2215 if (consolidatedRowCount > 0) { 2216 deleteUnsearchable(); 2217 } 2218 } 2219 2220 // Tries to consolidate all WatchedPrograms rows regardless of the session. After this 2221 // method is called, it is guaranteed that we have at most one unconsolidated log entry per 2222 // session that represents the user's ongoing watch activity. 2223 // Also, this method automatically schedules the next consolidation if there still remains 2224 // an unconsolidated entry. 2225 private void onTryConsolidateAll() { 2226 if (DEBUG) { 2227 Log.d(TAG, "onTryConsolidateAll()"); 2228 } 2229 2230 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2231 queryBuilder.setTables(WATCHED_PROGRAMS_TABLE); 2232 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 2233 2234 // Pick up all unconsolidated rows grouped by session. The most recent log entry goes on 2235 // top. 2236 String[] projection = { 2237 WatchedPrograms._ID, 2238 WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS, 2239 WatchedPrograms.COLUMN_CHANNEL_ID, 2240 WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN 2241 }; 2242 String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0"; 2243 String sortOrder = WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + " DESC," 2244 + WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC"; 2245 2246 int consolidatedRowCount = 0; 2247 try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null, 2248 sortOrder)) { 2249 long oldWatchStartTime = 0; 2250 String oldSessionToken = null; 2251 while (cursor != null && cursor.moveToNext()) { 2252 long id = cursor.getLong(0); 2253 long watchStartTime = cursor.getLong(1); 2254 long channelId = cursor.getLong(2); 2255 String sessionToken = cursor.getString(3); 2256 2257 if (!sessionToken.equals(oldSessionToken)) { 2258 // The most recent log entry for the current session, which may be still 2259 // active. Just go through a dry run with the current time to see if this 2260 // entry can be split into multiple rows. 2261 consolidatedRowCount += consolidateRow(id, watchStartTime, 2262 System.currentTimeMillis(), channelId, true); 2263 oldSessionToken = sessionToken; 2264 } else { 2265 // The later entries after the most recent one all fall into here. We now 2266 // know that this watch activity ended exactly at the same time when the 2267 // next activity started. 2268 consolidatedRowCount += consolidateRow(id, watchStartTime, 2269 oldWatchStartTime, channelId, false); 2270 } 2271 oldWatchStartTime = watchStartTime; 2272 } 2273 } 2274 if (consolidatedRowCount > 0) { 2275 deleteUnsearchable(); 2276 } 2277 scheduleConsolidationIfNeeded(); 2278 } 2279 2280 // Consolidates a WatchedPrograms row. 2281 // A row is 'consolidated' if and only if the following information is complete: 2282 // 1. WatchedPrograms.COLUMN_CHANNEL_ID 2283 // 2. WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS 2284 // 3. WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS 2285 // where COLUMN_WATCH_START_TIME_UTC_MILLIS <= COLUMN_WATCH_END_TIME_UTC_MILLIS. 2286 // This is the minimal but useful enough set of information to comprise the user's watch 2287 // history. (The program data are considered optional although we do try to fill them while 2288 // consolidating the row.) It is guaranteed that the target row is either consolidated or 2289 // deleted after this method is called. 2290 // Set {@code dryRun} to {@code true} if you think it's necessary to split the row without 2291 // consolidating the most recent row because the user stayed on the same channel for a very 2292 // long time. 2293 // This method returns the number of consolidated rows, which can be 0 or more. 2294 private int consolidateRow( 2295 long id, long watchStartTime, long watchEndTime, long channelId, boolean dryRun) { 2296 if (DEBUG) { 2297 Log.d(TAG, "consolidateRow(id=" + id + ", watchStartTime=" + watchStartTime 2298 + ", watchEndTime=" + watchEndTime + ", channelId=" + channelId 2299 + ", dryRun=" + dryRun + ")"); 2300 } 2301 2302 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 2303 2304 if (watchStartTime > watchEndTime) { 2305 Log.e(TAG, "watchEndTime cannot be less than watchStartTime"); 2306 db.delete(WATCHED_PROGRAMS_TABLE, WatchedPrograms._ID + "=" + String.valueOf(id), 2307 null); 2308 return 0; 2309 } 2310 2311 ContentValues values = getProgramValues(channelId, watchStartTime); 2312 Long endTime = values.getAsLong(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS); 2313 boolean needsToSplit = endTime != null && endTime < watchEndTime; 2314 2315 values.put(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS, 2316 String.valueOf(watchStartTime)); 2317 if (!dryRun || needsToSplit) { 2318 values.put(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS, 2319 String.valueOf(needsToSplit ? endTime : watchEndTime)); 2320 values.put(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED, "1"); 2321 db.update(WATCHED_PROGRAMS_TABLE, values, 2322 WatchedPrograms._ID + "=" + String.valueOf(id), null); 2323 // Treat the watched program is inserted when WATCHED_PROGRAMS_COLUMN_CONSOLIDATED 2324 // becomes 1. 2325 notifyChange(TvContract.buildWatchedProgramUri(id)); 2326 } else { 2327 db.update(WATCHED_PROGRAMS_TABLE, values, 2328 WatchedPrograms._ID + "=" + String.valueOf(id), null); 2329 } 2330 int count = dryRun ? 0 : 1; 2331 if (needsToSplit) { 2332 // This means that the program ended before the user stops watching the current 2333 // channel. In this case we duplicate the log entry as many as the number of 2334 // programs watched on the same channel. Here the end time of the current program 2335 // becomes the new watch start time of the next program. 2336 long duplicatedId = duplicateRow(id); 2337 if (duplicatedId > 0) { 2338 count += consolidateRow(duplicatedId, endTime, watchEndTime, channelId, dryRun); 2339 } 2340 } 2341 return count; 2342 } 2343 2344 // Deletes the log entries from unsearchable channels. Note that only consolidated log 2345 // entries are safe to delete. 2346 private void deleteUnsearchable() { 2347 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 2348 String deleteWhere = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=1 AND " 2349 + WatchedPrograms.COLUMN_CHANNEL_ID + " IN (SELECT " + Channels._ID 2350 + " FROM " + CHANNELS_TABLE + " WHERE " + Channels.COLUMN_SEARCHABLE + "=0)"; 2351 db.delete(WATCHED_PROGRAMS_TABLE, deleteWhere, null); 2352 } 2353 2354 private void scheduleConsolidationIfNeeded() { 2355 if (DEBUG) { 2356 Log.d(TAG, "scheduleConsolidationIfNeeded()"); 2357 } 2358 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2359 queryBuilder.setTables(WATCHED_PROGRAMS_TABLE); 2360 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 2361 2362 // Pick up all unconsolidated rows. 2363 String[] projection = { 2364 WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS, 2365 WatchedPrograms.COLUMN_CHANNEL_ID, 2366 }; 2367 String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0"; 2368 2369 try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null, 2370 null)) { 2371 // Find the earliest time that any of the currently watching programs ends and 2372 // schedule the next consolidation at that time. 2373 long minEndTime = Long.MAX_VALUE; 2374 while (cursor != null && cursor.moveToNext()) { 2375 long watchStartTime = cursor.getLong(0); 2376 long channelId = cursor.getLong(1); 2377 ContentValues values = getProgramValues(channelId, watchStartTime); 2378 Long endTime = values.getAsLong(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS); 2379 2380 if (endTime != null && endTime < minEndTime 2381 && endTime > System.currentTimeMillis()) { 2382 minEndTime = endTime; 2383 } 2384 } 2385 if (minEndTime != Long.MAX_VALUE) { 2386 sendEmptyMessageAtTime(MSG_TRY_CONSOLIDATE_ALL, minEndTime); 2387 if (DEBUG) { 2388 CharSequence minEndTimeStr = DateUtils.getRelativeTimeSpanString( 2389 minEndTime, System.currentTimeMillis(), DateUtils.SECOND_IN_MILLIS); 2390 Log.d(TAG, "onTryConsolidateAll() scheduled " + minEndTimeStr); 2391 } 2392 } 2393 } 2394 } 2395 2396 // Returns non-null ContentValues of the program data that the user watched on the channel 2397 // {@code channelId} at the time {@code time}. 2398 private ContentValues getProgramValues(long channelId, long time) { 2399 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2400 queryBuilder.setTables(PROGRAMS_TABLE); 2401 SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 2402 2403 String[] projection = { 2404 Programs.COLUMN_TITLE, 2405 Programs.COLUMN_START_TIME_UTC_MILLIS, 2406 Programs.COLUMN_END_TIME_UTC_MILLIS, 2407 Programs.COLUMN_SHORT_DESCRIPTION 2408 }; 2409 String selection = Programs.COLUMN_CHANNEL_ID + "=? AND " 2410 + Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND " 2411 + Programs.COLUMN_END_TIME_UTC_MILLIS + ">?"; 2412 String[] selectionArgs = { 2413 String.valueOf(channelId), 2414 String.valueOf(time), 2415 String.valueOf(time) 2416 }; 2417 String sortOrder = Programs.COLUMN_START_TIME_UTC_MILLIS + " ASC"; 2418 2419 try (Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null, 2420 null, sortOrder)) { 2421 ContentValues values = new ContentValues(); 2422 if (cursor != null && cursor.moveToNext()) { 2423 values.put(WatchedPrograms.COLUMN_TITLE, cursor.getString(0)); 2424 values.put(WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS, cursor.getLong(1)); 2425 values.put(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS, cursor.getLong(2)); 2426 values.put(WatchedPrograms.COLUMN_DESCRIPTION, cursor.getString(3)); 2427 } 2428 return values; 2429 } 2430 } 2431 2432 // Duplicates the WatchedPrograms row with a given ID and returns the ID of the duplicated 2433 // row. Returns -1 if failed. 2434 private long duplicateRow(long id) { 2435 if (DEBUG) { 2436 Log.d(TAG, "duplicateRow(" + id + ")"); 2437 } 2438 2439 SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder(); 2440 queryBuilder.setTables(WATCHED_PROGRAMS_TABLE); 2441 SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 2442 2443 String[] projection = { 2444 WatchedPrograms.COLUMN_PACKAGE_NAME, 2445 WatchedPrograms.COLUMN_CHANNEL_ID, 2446 WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN 2447 }; 2448 String selection = WatchedPrograms._ID + "=" + String.valueOf(id); 2449 2450 try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null, 2451 null)) { 2452 long rowId = -1; 2453 if (cursor != null && cursor.moveToNext()) { 2454 ContentValues values = new ContentValues(); 2455 values.put(WatchedPrograms.COLUMN_PACKAGE_NAME, cursor.getString(0)); 2456 values.put(WatchedPrograms.COLUMN_CHANNEL_ID, cursor.getLong(1)); 2457 values.put(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN, cursor.getString(2)); 2458 rowId = db.insert(WATCHED_PROGRAMS_TABLE, null, values); 2459 } 2460 return rowId; 2461 } 2462 } 2463 } 2464} 2465