xref: /packages/providers/TvProvider/src/com/android/providers/tv/TvProvider.java

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.providers.tv;

import android.annotation.SuppressLint;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.ContentProvider;
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.OperationApplicationException;
import android.content.UriMatcher;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.database.DatabaseUtils;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteQueryBuilder;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.tv.TvContract;
import android.media.tv.TvContract.BaseTvColumns;
import android.media.tv.TvContract.Channels;
import android.media.tv.TvContract.Programs;
import android.media.tv.TvContract.Programs.Genres;
import android.media.tv.TvContract.WatchedPrograms;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.ParcelFileDescriptor.AutoCloseInputStream;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.util.Log;

import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.os.SomeArgs;
import com.android.providers.tv.util.SqlParams;
import com.google.android.collect.Sets;

import libcore.io.IoUtils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * TV content provider. The contract between this provider and applications is defined in
 * {@link android.media.tv.TvContract}.
 */
public class TvProvider extends ContentProvider {
    private static final boolean DEBUG = false;
    private static final String TAG = "TvProvider";

    // Operation names for createSqlParams().
    private static final String OP_QUERY = "query";
    private static final String OP_UPDATE = "update";
    private static final String OP_DELETE = "delete";

    private static final int DATABASE_VERSION = 21;
    private static final String DATABASE_NAME = "tv.db";
    private static final String CHANNELS_TABLE = "channels";
    private static final String PROGRAMS_TABLE = "programs";
    private static final String WATCHED_PROGRAMS_TABLE = "watched_programs";
    // This table stores deleted channels, so that when the same channel is added back,
    // TvProvider can restore the locked & browsable state.
    private static final String DELETED_CHANNELS_TABLE = "deleted_channels";
    private static final String DEFAULT_CHANNELS_SORT_ORDER = Channels.COLUMN_DISPLAY_NUMBER
            + " ASC";
    private static final String DEFAULT_PROGRAMS_SORT_ORDER = Programs.COLUMN_START_TIME_UTC_MILLIS
            + " ASC";
    private static final String DEFAULT_WATCHED_PROGRAMS_SORT_ORDER =
            WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC";
    private static final String CHANNELS_TABLE_INNER_JOIN_PROGRAMS_TABLE = CHANNELS_TABLE
            + " INNER JOIN " + PROGRAMS_TABLE
            + " ON (" + CHANNELS_TABLE + "." + Channels._ID + "="
            + PROGRAMS_TABLE + "." + Programs.COLUMN_CHANNEL_ID + ")";

    private static final UriMatcher sUriMatcher;
    private static final int MATCH_CHANNEL = 1;
    private static final int MATCH_CHANNEL_ID = 2;
    private static final int MATCH_CHANNEL_ID_LOGO = 3;
    private static final int MATCH_PASSTHROUGH_ID = 4;
    private static final int MATCH_PROGRAM = 5;
    private static final int MATCH_PROGRAM_ID = 6;
    private static final int MATCH_WATCHED_PROGRAM = 7;
    private static final int MATCH_WATCHED_PROGRAM_ID = 8;

    private static final String CHANNELS_COLUMN_LOGO = "logo";
    private static final int MAX_LOGO_IMAGE_SIZE = 256;

    // The internal column in the watched programs table to indicate whether the current log entry
    // is consolidated or not. Unconsolidated entries may have columns with missing data.
    private static final String WATCHED_PROGRAMS_COLUMN_CONSOLIDATED = "consolidated";

    private static final long MAX_PROGRAM_DATA_DELAY_IN_MILLIS = 10 * 1000; // 10 seconds

    private static Map<String, String> sChannelProjectionMap;
    private static Map<String, String> sProgramProjectionMap;
    private static Map<String, String> sWatchedProgramProjectionMap;

    static {
        sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        sUriMatcher.addURI(TvContract.AUTHORITY, "channel", MATCH_CHANNEL);
        sUriMatcher.addURI(TvContract.AUTHORITY, "channel/#", MATCH_CHANNEL_ID);
        sUriMatcher.addURI(TvContract.AUTHORITY, "channel/#/logo", MATCH_CHANNEL_ID_LOGO);
        sUriMatcher.addURI(TvContract.AUTHORITY, "passthrough/*", MATCH_PASSTHROUGH_ID);
        sUriMatcher.addURI(TvContract.AUTHORITY, "program", MATCH_PROGRAM);
        sUriMatcher.addURI(TvContract.AUTHORITY, "program/#", MATCH_PROGRAM_ID);
        sUriMatcher.addURI(TvContract.AUTHORITY, "watched_program", MATCH_WATCHED_PROGRAM);
        sUriMatcher.addURI(TvContract.AUTHORITY, "watched_program/#", MATCH_WATCHED_PROGRAM_ID);

        sChannelProjectionMap = new HashMap<String, String>();
        sChannelProjectionMap.put(Channels._ID, CHANNELS_TABLE + "." + Channels._ID);
        sChannelProjectionMap.put(Channels.COLUMN_PACKAGE_NAME,
                CHANNELS_TABLE + "." + Channels.COLUMN_PACKAGE_NAME);
        sChannelProjectionMap.put(Channels.COLUMN_INPUT_ID,
                CHANNELS_TABLE + "." + Channels.COLUMN_INPUT_ID);
        sChannelProjectionMap.put(Channels.COLUMN_TYPE,
                CHANNELS_TABLE + "." + Channels.COLUMN_TYPE);
        sChannelProjectionMap.put(Channels.COLUMN_SERVICE_TYPE,
                CHANNELS_TABLE + "." + Channels.COLUMN_SERVICE_TYPE);
        sChannelProjectionMap.put(Channels.COLUMN_ORIGINAL_NETWORK_ID,
                CHANNELS_TABLE + "." + Channels.COLUMN_ORIGINAL_NETWORK_ID);
        sChannelProjectionMap.put(Channels.COLUMN_TRANSPORT_STREAM_ID,
                CHANNELS_TABLE + "." + Channels.COLUMN_TRANSPORT_STREAM_ID);
        sChannelProjectionMap.put(Channels.COLUMN_SERVICE_ID,
                CHANNELS_TABLE + "." + Channels.COLUMN_SERVICE_ID);
        sChannelProjectionMap.put(Channels.COLUMN_DISPLAY_NUMBER,
                CHANNELS_TABLE + "." + Channels.COLUMN_DISPLAY_NUMBER);
        sChannelProjectionMap.put(Channels.COLUMN_DISPLAY_NAME,
                CHANNELS_TABLE + "." + Channels.COLUMN_DISPLAY_NAME);
        sChannelProjectionMap.put(Channels.COLUMN_NETWORK_AFFILIATION,
                CHANNELS_TABLE + "." + Channels.COLUMN_NETWORK_AFFILIATION);
        sChannelProjectionMap.put(Channels.COLUMN_DESCRIPTION,
                CHANNELS_TABLE + "." + Channels.COLUMN_DESCRIPTION);
        sChannelProjectionMap.put(Channels.COLUMN_VIDEO_FORMAT,
                CHANNELS_TABLE + "." + Channels.COLUMN_VIDEO_FORMAT);
        sChannelProjectionMap.put(Channels.COLUMN_BROWSABLE,
                CHANNELS_TABLE + "." + Channels.COLUMN_BROWSABLE);
        sChannelProjectionMap.put(Channels.COLUMN_SEARCHABLE,
                CHANNELS_TABLE + "." + Channels.COLUMN_SEARCHABLE);
        sChannelProjectionMap.put(Channels.COLUMN_LOCKED,
                CHANNELS_TABLE + "." + Channels.COLUMN_LOCKED);
        sChannelProjectionMap.put(Channels.COLUMN_INTERNAL_PROVIDER_DATA,
                CHANNELS_TABLE + "." + Channels.COLUMN_INTERNAL_PROVIDER_DATA);
        sChannelProjectionMap.put(Channels.COLUMN_VERSION_NUMBER,
                CHANNELS_TABLE + "." + Channels.COLUMN_VERSION_NUMBER);

        sProgramProjectionMap = new HashMap<String, String>();
        sProgramProjectionMap.put(Programs._ID, Programs._ID);
        sProgramProjectionMap.put(Programs.COLUMN_PACKAGE_NAME, Programs.COLUMN_PACKAGE_NAME);
        sProgramProjectionMap.put(Programs.COLUMN_CHANNEL_ID, Programs.COLUMN_CHANNEL_ID);
        sProgramProjectionMap.put(Programs.COLUMN_TITLE, Programs.COLUMN_TITLE);
        sProgramProjectionMap.put(Programs.COLUMN_SEASON_NUMBER, Programs.COLUMN_SEASON_NUMBER);
        sProgramProjectionMap.put(Programs.COLUMN_EPISODE_NUMBER, Programs.COLUMN_EPISODE_NUMBER);
        sProgramProjectionMap.put(Programs.COLUMN_EPISODE_TITLE, Programs.COLUMN_EPISODE_TITLE);
        sProgramProjectionMap.put(Programs.COLUMN_START_TIME_UTC_MILLIS,
                Programs.COLUMN_START_TIME_UTC_MILLIS);
        sProgramProjectionMap.put(Programs.COLUMN_END_TIME_UTC_MILLIS,
                Programs.COLUMN_END_TIME_UTC_MILLIS);
        sProgramProjectionMap.put(Programs.COLUMN_BROADCAST_GENRE, Programs.COLUMN_BROADCAST_GENRE);
        sProgramProjectionMap.put(Programs.COLUMN_CANONICAL_GENRE, Programs.COLUMN_CANONICAL_GENRE);
        sProgramProjectionMap.put(Programs.COLUMN_SHORT_DESCRIPTION,
                Programs.COLUMN_SHORT_DESCRIPTION);
        sProgramProjectionMap.put(Programs.COLUMN_LONG_DESCRIPTION,
                Programs.COLUMN_LONG_DESCRIPTION);
        sProgramProjectionMap.put(Programs.COLUMN_VIDEO_WIDTH, Programs.COLUMN_VIDEO_WIDTH);
        sProgramProjectionMap.put(Programs.COLUMN_VIDEO_HEIGHT, Programs.COLUMN_VIDEO_HEIGHT);
        sProgramProjectionMap.put(Programs.COLUMN_AUDIO_LANGUAGE, Programs.COLUMN_AUDIO_LANGUAGE);
        sProgramProjectionMap.put(Programs.COLUMN_CONTENT_RATING, Programs.COLUMN_CONTENT_RATING);
        sProgramProjectionMap.put(Programs.COLUMN_POSTER_ART_URI, Programs.COLUMN_POSTER_ART_URI);
        sProgramProjectionMap.put(Programs.COLUMN_THUMBNAIL_URI, Programs.COLUMN_THUMBNAIL_URI);
        sProgramProjectionMap.put(Programs.COLUMN_INTERNAL_PROVIDER_DATA,
                Programs.COLUMN_INTERNAL_PROVIDER_DATA);
        sProgramProjectionMap.put(Programs.COLUMN_VERSION_NUMBER, Programs.COLUMN_VERSION_NUMBER);

        sWatchedProgramProjectionMap = new HashMap<String, String>();
        sWatchedProgramProjectionMap.put(WatchedPrograms._ID, WatchedPrograms._ID);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS,
                WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS,
                WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_CHANNEL_ID,
                WatchedPrograms.COLUMN_CHANNEL_ID);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_TITLE,
                WatchedPrograms.COLUMN_TITLE);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS,
                WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS,
                WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_DESCRIPTION,
                WatchedPrograms.COLUMN_DESCRIPTION);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS,
                WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS);
        sWatchedProgramProjectionMap.put(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN,
                WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN);
        sWatchedProgramProjectionMap.put(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED,
                WATCHED_PROGRAMS_COLUMN_CONSOLIDATED);
    }

    // Mapping from broadcast genre to canonical genre.
    private static Map<String, String> sGenreMap;

    private static final String PERMISSION_ACCESS_ALL_EPG_DATA =
            "com.android.providers.tv.permission.ACCESS_ALL_EPG_DATA";

    private static final String PERMISSION_ACCESS_WATCHED_PROGRAMS =
            "com.android.providers.tv.permission.ACCESS_WATCHED_PROGRAMS";

    private static class DatabaseHelper extends SQLiteOpenHelper {
        private final Context mContext;

        DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
            mContext = context;
        }

        @Override
        public void onConfigure(SQLiteDatabase db) {
            db.setForeignKeyConstraintsEnabled(true);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            if (DEBUG) {
                Log.d(TAG, "Creating database");
            }
            // Set up the database schema.
            db.execSQL("CREATE TABLE " + CHANNELS_TABLE + " ("
                    + Channels._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
                    + Channels.COLUMN_PACKAGE_NAME + " TEXT NOT NULL,"
                    + Channels.COLUMN_INPUT_ID + " TEXT NOT NULL,"
                    + Channels.COLUMN_TYPE + " TEXT NOT NULL DEFAULT '" + Channels.TYPE_OTHER + "',"
                    + Channels.COLUMN_SERVICE_TYPE + " TEXT NOT NULL DEFAULT '"
                    + Channels.SERVICE_TYPE_AUDIO_VIDEO + "',"
                    + Channels.COLUMN_ORIGINAL_NETWORK_ID + " INTEGER NOT NULL DEFAULT 0,"
                    + Channels.COLUMN_TRANSPORT_STREAM_ID + " INTEGER NOT NULL DEFAULT 0,"
                    + Channels.COLUMN_SERVICE_ID + " INTEGER NOT NULL DEFAULT 0,"
                    + Channels.COLUMN_DISPLAY_NUMBER + " TEXT,"
                    + Channels.COLUMN_DISPLAY_NAME + " TEXT,"
                    + Channels.COLUMN_NETWORK_AFFILIATION + " TEXT,"
                    + Channels.COLUMN_DESCRIPTION + " TEXT,"
                    + Channels.COLUMN_VIDEO_FORMAT + " TEXT,"
                    + Channels.COLUMN_BROWSABLE + " INTEGER NOT NULL DEFAULT 0,"
                    + Channels.COLUMN_SEARCHABLE + " INTEGER NOT NULL DEFAULT 1,"
                    + Channels.COLUMN_LOCKED + " INTEGER NOT NULL DEFAULT 0,"
                    + Channels.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB,"
                    + CHANNELS_COLUMN_LOGO + " BLOB,"
                    + Channels.COLUMN_VERSION_NUMBER + " INTEGER,"
                    + "UNIQUE(" + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME + "),"
                    + "UNIQUE(" + Channels.COLUMN_INPUT_ID + ","
                            + Channels.COLUMN_ORIGINAL_NETWORK_ID + ","
                            + Channels.COLUMN_TRANSPORT_STREAM_ID + ","
                            + Channels.COLUMN_SERVICE_ID + ")"
                    + ");");
            db.execSQL("CREATE TABLE " + PROGRAMS_TABLE + " ("
                    + Programs._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
                    + Programs.COLUMN_PACKAGE_NAME + " TEXT NOT NULL,"
                    + Programs.COLUMN_CHANNEL_ID + " INTEGER,"
                    + Programs.COLUMN_TITLE + " TEXT,"
                    + Programs.COLUMN_SEASON_NUMBER + " INTEGER,"
                    + Programs.COLUMN_EPISODE_NUMBER + " INTEGER,"
                    + Programs.COLUMN_EPISODE_TITLE + " TEXT,"
                    + Programs.COLUMN_START_TIME_UTC_MILLIS + " INTEGER,"
                    + Programs.COLUMN_END_TIME_UTC_MILLIS + " INTEGER,"
                    + Programs.COLUMN_BROADCAST_GENRE + " TEXT,"
                    + Programs.COLUMN_CANONICAL_GENRE + " TEXT,"
                    + Programs.COLUMN_SHORT_DESCRIPTION + " TEXT,"
                    + Programs.COLUMN_LONG_DESCRIPTION + " TEXT,"
                    + Programs.COLUMN_VIDEO_WIDTH + " INTEGER,"
                    + Programs.COLUMN_VIDEO_HEIGHT + " INTEGER,"
                    + Programs.COLUMN_AUDIO_LANGUAGE + " TEXT,"
                    + Programs.COLUMN_CONTENT_RATING + " TEXT,"
                    + Programs.COLUMN_POSTER_ART_URI + " TEXT,"
                    + Programs.COLUMN_THUMBNAIL_URI + " TEXT,"
                    + Programs.COLUMN_INTERNAL_PROVIDER_DATA + " BLOB,"
                    + Programs.COLUMN_VERSION_NUMBER + " INTEGER,"
                    + "FOREIGN KEY("
                            + Programs.COLUMN_CHANNEL_ID + "," + Programs.COLUMN_PACKAGE_NAME
                            + ") REFERENCES " + CHANNELS_TABLE + "("
                            + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME
                            + ") ON UPDATE CASCADE ON DELETE CASCADE"
                    + ");");
            db.execSQL("CREATE TABLE " + WATCHED_PROGRAMS_TABLE + " ("
                    + WatchedPrograms._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
                    + WatchedPrograms.COLUMN_PACKAGE_NAME + " TEXT NOT NULL,"
                    + WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS
                    + " INTEGER NOT NULL DEFAULT 0,"
                    + WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS
                    + " INTEGER NOT NULL DEFAULT 0,"
                    + WatchedPrograms.COLUMN_CHANNEL_ID + " INTEGER,"
                    + WatchedPrograms.COLUMN_TITLE + " TEXT,"
                    + WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS + " INTEGER,"
                    + WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS + " INTEGER,"
                    + WatchedPrograms.COLUMN_DESCRIPTION + " TEXT,"
                    + WatchedPrograms.COLUMN_INTERNAL_TUNE_PARAMS + " TEXT,"
                    + WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + " TEXT NOT NULL,"
                    + WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + " INTEGER NOT NULL DEFAULT 0,"
                    + "FOREIGN KEY("
                            + WatchedPrograms.COLUMN_CHANNEL_ID + ","
                            + WatchedPrograms.COLUMN_PACKAGE_NAME
                            + ") REFERENCES " + CHANNELS_TABLE + "("
                            + Channels._ID + "," + Channels.COLUMN_PACKAGE_NAME
                            + ") ON UPDATE CASCADE ON DELETE CASCADE"
                    + ");");
            db.execSQL("CREATE TABLE " + DELETED_CHANNELS_TABLE + " ("
                    + Channels.COLUMN_INPUT_ID + " TEXT NOT NULL,"
                    + Channels.COLUMN_ORIGINAL_NETWORK_ID + " INTEGER NOT NULL,"
                    + Channels.COLUMN_TRANSPORT_STREAM_ID + " INTEGER NOT NULL,"
                    + Channels.COLUMN_SERVICE_ID + " INTEGER NOT NULL,"
                    + Channels.COLUMN_LOCKED + " INTEGER NOT NULL,"
                    + Channels.COLUMN_BROWSABLE + " INTEGER NOT NULL,"
                    + "UNIQUE(" + Channels.COLUMN_INPUT_ID + ","
                    + Channels.COLUMN_ORIGINAL_NETWORK_ID + ","
                    + Channels.COLUMN_TRANSPORT_STREAM_ID + "," + Channels.COLUMN_SERVICE_ID + ")"
                    + ");");
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            if (DEBUG) {
                Log.d(TAG, "Upgrading database from " + oldVersion + " to " + newVersion);
            }

            // Default upgrade case.
            db.execSQL("DROP TABLE IF EXISTS " + DELETED_CHANNELS_TABLE);
            db.execSQL("DROP TABLE IF EXISTS " + WATCHED_PROGRAMS_TABLE);
            db.execSQL("DROP TABLE IF EXISTS " + PROGRAMS_TABLE);
            db.execSQL("DROP TABLE IF EXISTS " + CHANNELS_TABLE);

            // Clear legacy logo directory
            File logoPath = new File(mContext.getFilesDir(), "logo");
            if (logoPath.exists()) {
                for (File file : logoPath.listFiles()) {
                    file.delete();
                }
                logoPath.delete();
            }

            onCreate(db);
        }
    }

    private DatabaseHelper mOpenHelper;

    private final Handler mLogHandler = new WatchLogHandler();

    @Override
    public boolean onCreate() {
        if (DEBUG) {
            Log.d(TAG, "Creating TvProvider");
        }
        mOpenHelper = new DatabaseHelper(getContext());
        deleteUnconsolidatedWatchedProgramsRows();
        scheduleEpgDataCleanup();
        buildGenreMap();
        return true;
    }

    @VisibleForTesting
    void scheduleEpgDataCleanup() {
        Intent intent = new Intent(EpgDataCleanupService.ACTION_CLEAN_UP_EPG_DATA);
        intent.setClass(getContext(), EpgDataCleanupService.class);
        PendingIntent pendingIntent = PendingIntent.getService(
                getContext(), 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
        AlarmManager alarmManager =
                (AlarmManager) getContext().getSystemService(Context.ALARM_SERVICE);
        alarmManager.setInexactRepeating(AlarmManager.RTC, System.currentTimeMillis(),
                AlarmManager.INTERVAL_HALF_DAY, pendingIntent);
    }

    private void buildGenreMap() {
        if (sGenreMap != null) {
            return;
        }

        sGenreMap = new HashMap<String, String>();
        buildGenreMap(R.array.genre_mapping_atsc);
        buildGenreMap(R.array.genre_mapping_dvb);
        buildGenreMap(R.array.genre_mapping_isdb);
    }

    @SuppressLint("DefaultLocale")
    private void buildGenreMap(int id) {
        String[] maps = getContext().getResources().getStringArray(id);
        for (String map : maps) {
            String[] arr = map.split("\\|");
            if (arr.length != 2) {
                throw new IllegalArgumentException("Invalid genre mapping : " + map);
            }
            sGenreMap.put(arr[0].toUpperCase(), arr[1]);
        }
    }

    @VisibleForTesting
    String getCallingPackage_() {
        return getCallingPackage();
    }

    @Override
    public String getType(Uri uri) {
        switch (sUriMatcher.match(uri)) {
            case MATCH_CHANNEL:
                return Channels.CONTENT_TYPE;
            case MATCH_CHANNEL_ID:
                return Channels.CONTENT_ITEM_TYPE;
            case MATCH_CHANNEL_ID_LOGO:
                return "image/png";
            case MATCH_PASSTHROUGH_ID:
                return Channels.CONTENT_ITEM_TYPE;
            case MATCH_PROGRAM:
                return Programs.CONTENT_TYPE;
            case MATCH_PROGRAM_ID:
                return Programs.CONTENT_ITEM_TYPE;
            case MATCH_WATCHED_PROGRAM:
                return WatchedPrograms.CONTENT_TYPE;
            case MATCH_WATCHED_PROGRAM_ID:
                return WatchedPrograms.CONTENT_ITEM_TYPE;
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
            String sortOrder) {
        if (needsToLimitPackage(uri) && !TextUtils.isEmpty(sortOrder)) {
            throw new SecurityException("Sort order not allowed for " + uri);
        }
        SqlParams params = createSqlParams(OP_QUERY, uri, selection, selectionArgs);

        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
        queryBuilder.setTables(params.getTables());
        String orderBy;
        if (params.getTables().equals(PROGRAMS_TABLE)) {
            queryBuilder.setProjectionMap(sProgramProjectionMap);
            orderBy = DEFAULT_PROGRAMS_SORT_ORDER;
        } else if (params.getTables().equals(WATCHED_PROGRAMS_TABLE)) {
            queryBuilder.setProjectionMap(sWatchedProgramProjectionMap);
            orderBy = DEFAULT_WATCHED_PROGRAMS_SORT_ORDER;
        } else {
            queryBuilder.setProjectionMap(sChannelProjectionMap);
            orderBy = DEFAULT_CHANNELS_SORT_ORDER;
        }

        // Use the default sort order only if no sort order is specified.
        if (!TextUtils.isEmpty(sortOrder)) {
            orderBy = sortOrder;
        }

        // Get the database and run the query.
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        Cursor c = queryBuilder.query(db, projection, params.getSelection(),
                params.getSelectionArgs(), null, null, orderBy);

        // Tell the cursor what URI to watch, so it knows when its source data changes.
        c.setNotificationUri(getContext().getContentResolver(), uri);
        return c;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        switch (sUriMatcher.match(uri)) {
            case MATCH_CHANNEL:
                return insertChannel(uri, values);
            case MATCH_PROGRAM:
                return insertProgram(uri, values);
            case MATCH_WATCHED_PROGRAM:
                return insertWatchedProgram(uri, values);
            case MATCH_CHANNEL_ID:
            case MATCH_CHANNEL_ID_LOGO:
            case MATCH_PASSTHROUGH_ID:
            case MATCH_PROGRAM_ID:
            case MATCH_WATCHED_PROGRAM_ID:
                throw new UnsupportedOperationException("Cannot insert into that URI: " + uri);
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }

    private static void restoreChannelState(SQLiteDatabase db, ContentValues values) {
        String inputId = values.getAsString(Channels.COLUMN_INPUT_ID);
        Integer onid = values.getAsInteger(Channels.COLUMN_ORIGINAL_NETWORK_ID);
        Integer tsid = values.getAsInteger(Channels.COLUMN_TRANSPORT_STREAM_ID);
        Integer serviceId = values.getAsInteger(Channels.COLUMN_SERVICE_ID);
        if (onid == null) { onid = 0; }
        if (tsid == null) { tsid = 0; }
        if (serviceId == null) { serviceId = 0; }

        SqlParams params = new SqlParams(DELETED_CHANNELS_TABLE,
                "(" + Channels.COLUMN_INPUT_ID + "=?) AND ("
                + Channels.COLUMN_ORIGINAL_NETWORK_ID + "=?) AND ("
                + Channels.COLUMN_TRANSPORT_STREAM_ID + "=?) AND ("
                + Channels.COLUMN_SERVICE_ID + "=?)",
                inputId, Integer.toString(onid), Integer.toString(tsid),
                Integer.toString(serviceId));

        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
        queryBuilder.setTables(params.getTables());
        final String[] projection = { Channels.COLUMN_LOCKED, Channels.COLUMN_BROWSABLE };
        try (Cursor cursor = queryBuilder.query(db, projection, params.getSelection(),
                params.getSelectionArgs(), null, null, null)) {
            if (cursor != null && cursor.moveToNext()) {
                if (!values.containsKey(Channels.COLUMN_LOCKED)) {
                    values.put(Channels.COLUMN_LOCKED, cursor.getInt(0));
                }
                if (!values.containsKey(Channels.COLUMN_BROWSABLE)) {
                    values.put(Channels.COLUMN_BROWSABLE, cursor.getInt(1));
                }
                db.delete(params.getTables(), params.getSelection(), params.getSelectionArgs());
            }
        }
    }

    private Uri insertChannel(Uri uri, ContentValues values) {
        // Mark the owner package of this channel.
        values.put(Channels.COLUMN_PACKAGE_NAME, getCallingPackage_());

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        restoreChannelState(db, values);
        long rowId = db.insert(CHANNELS_TABLE, null, values);
        if (rowId > 0) {
            Uri channelUri = TvContract.buildChannelUri(rowId);
            notifyChange(channelUri);
            return channelUri;
        }

        throw new SQLException("Failed to insert row into " + uri);
    }

    private Uri insertProgram(Uri uri, ContentValues values) {
        // Mark the owner package of this program.
        values.put(Programs.COLUMN_PACKAGE_NAME, getCallingPackage_());

        checkAndConvertGenre(values);

        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        long rowId = db.insert(PROGRAMS_TABLE, null, values);
        if (rowId > 0) {
            Uri programUri = TvContract.buildProgramUri(rowId);
            notifyChange(programUri);
            return programUri;
        }

        throw new SQLException("Failed to insert row into " + uri);
    }

    private Uri insertWatchedProgram(Uri uri, ContentValues values) {
        if (DEBUG) {
            Log.d(TAG, "insertWatchedProgram(uri=" + uri + ", values={" + values + "})");
        }
        Long watchStartTime = values.getAsLong(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS);
        Long watchEndTime = values.getAsLong(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS);
        // The system sends only two kinds of watch events:
        // 1. The user tunes to a new channel. (COLUMN_WATCH_START_TIME_UTC_MILLIS)
        // 2. The user stops watching. (COLUMN_WATCH_END_TIME_UTC_MILLIS)
        if (watchStartTime != null && watchEndTime == null) {
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            long rowId = db.insert(WATCHED_PROGRAMS_TABLE, null, values);
            if (rowId > 0) {
                mLogHandler.removeMessages(WatchLogHandler.MSG_TRY_CONSOLIDATE_ALL);
                mLogHandler.sendEmptyMessageDelayed(WatchLogHandler.MSG_TRY_CONSOLIDATE_ALL,
                        MAX_PROGRAM_DATA_DELAY_IN_MILLIS);
                return TvContract.buildWatchedProgramUri(rowId);
            }
            throw new SQLException("Failed to insert row into " + uri);
        } else if (watchStartTime == null && watchEndTime != null) {
            SomeArgs args = SomeArgs.obtain();
            args.arg1 = values.getAsString(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN);
            args.arg2 = watchEndTime;
            Message msg = mLogHandler.obtainMessage(WatchLogHandler.MSG_CONSOLIDATE, args);
            mLogHandler.sendMessageDelayed(msg, MAX_PROGRAM_DATA_DELAY_IN_MILLIS);
            return null;
        }
        // All the other cases are invalid.
        throw new IllegalArgumentException("Only one of COLUMN_WATCH_START_TIME_UTC_MILLIS and"
                + " COLUMN_WATCH_END_TIME_UTC_MILLIS should be specified");
    }

    private static void storeChannelStates(SqlParams params, SQLiteDatabase db) {
        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
        queryBuilder.setTables(params.getTables());
        try (Cursor cursor = queryBuilder.query(db,
                new String[] { Channels.COLUMN_INPUT_ID, Channels.COLUMN_ORIGINAL_NETWORK_ID,
                Channels.COLUMN_TRANSPORT_STREAM_ID, Channels.COLUMN_SERVICE_ID,
                Channels.COLUMN_LOCKED, Channels.COLUMN_BROWSABLE },
                params.getSelection(), params.getSelectionArgs(), null, null, null)) {
            ContentValues values = new ContentValues();
            while (cursor != null && cursor.moveToNext()) {
                values.put(Channels.COLUMN_INPUT_ID, cursor.getString(0));
                values.put(Channels.COLUMN_ORIGINAL_NETWORK_ID, cursor.getInt(1));
                values.put(Channels.COLUMN_TRANSPORT_STREAM_ID, cursor.getInt(2));
                values.put(Channels.COLUMN_SERVICE_ID, cursor.getInt(3));
                values.put(Channels.COLUMN_LOCKED, cursor.getInt(4));
                values.put(Channels.COLUMN_BROWSABLE, cursor.getInt(5));
                db.insert(DELETED_CHANNELS_TABLE, null, values);
            }
        }
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        SqlParams params = createSqlParams(OP_DELETE, uri, selection, selectionArgs);
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        if (params.getTables().equals(CHANNELS_TABLE)) {
            storeChannelStates(params, db);
        }
        int count = db.delete(params.getTables(), params.getSelection(), params.getSelectionArgs());
        if (count > 0) {
            notifyChange(uri);
        }
        return count;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        SqlParams params = createSqlParams(OP_UPDATE, uri, selection, selectionArgs);
        if (params.getTables().equals(CHANNELS_TABLE)) {
            if (values.containsKey(Channels.COLUMN_LOCKED)
                    && !callerHasModifyParentalControlsPermission()) {
                throw new SecurityException("Not allowed to modify Channels.COLUMN_LOCKED");
            }
        } else if (params.getTables().equals(PROGRAMS_TABLE)) {
            checkAndConvertGenre(values);
        }
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        int count = db.update(params.getTables(), values, params.getSelection(),
                params.getSelectionArgs());
        if (count > 0) {
            notifyChange(uri);
        }
        return count;
    }

    private SqlParams createSqlParams(String operation, Uri uri, String selection,
            String[] selectionArgs) {
        SqlParams params = new SqlParams(null, selection, selectionArgs);
        if (needsToLimitPackage(uri)) {
            if (!TextUtils.isEmpty(selection)) {
                throw new SecurityException("Selection not allowed for " + uri);
            }
            params.setWhere(BaseTvColumns.COLUMN_PACKAGE_NAME + "=?", getCallingPackage_());
        }
        switch (sUriMatcher.match(uri)) {
            case MATCH_CHANNEL:
                String genre = uri.getQueryParameter(TvContract.PARAM_CANONICAL_GENRE);
                if (genre == null) {
                    params.setTables(CHANNELS_TABLE);
                } else {
                    if (!operation.equals(OP_QUERY)) {
                        throw new SecurityException(capitalize(operation)
                                + " not allowed for " + uri);
                    }
                    if (!Genres.isCanonical(genre)) {
                        throw new IllegalArgumentException("Not a canonical genre : " + genre);
                    }
                    params.setTables(CHANNELS_TABLE_INNER_JOIN_PROGRAMS_TABLE);
                    String curTime = String.valueOf(System.currentTimeMillis());
                    params.appendWhere("LIKE(?, " + Programs.COLUMN_CANONICAL_GENRE + ") AND "
                            + Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND "
                            + Programs.COLUMN_END_TIME_UTC_MILLIS + ">=?",
                            "%" + genre + "%", curTime, curTime);
                }
                String inputId = uri.getQueryParameter(TvContract.PARAM_INPUT);
                if (inputId != null) {
                    params.appendWhere(Channels.COLUMN_INPUT_ID + "=?", inputId);
                }
                boolean browsableOnly = uri.getBooleanQueryParameter(
                        TvContract.PARAM_BROWSABLE_ONLY, false);
                if (browsableOnly) {
                    params.appendWhere(Channels.COLUMN_BROWSABLE + "=1");
                }
                break;
            case MATCH_CHANNEL_ID:
                params.setTables(CHANNELS_TABLE);
                params.appendWhere(Channels._ID + "=?", uri.getLastPathSegment());
                break;
            case MATCH_PROGRAM:
                params.setTables(PROGRAMS_TABLE);
                String paramChannelId = uri.getQueryParameter(TvContract.PARAM_CHANNEL);
                if (paramChannelId != null) {
                    String channelId = String.valueOf(Long.parseLong(paramChannelId));
                    params.appendWhere(Programs.COLUMN_CHANNEL_ID + "=?", channelId);
                }
                String paramStartTime = uri.getQueryParameter(TvContract.PARAM_START_TIME);
                String paramEndTime = uri.getQueryParameter(TvContract.PARAM_END_TIME);
                if (paramStartTime != null && paramEndTime != null) {
                    String startTime = String.valueOf(Long.parseLong(paramStartTime));
                    String endTime = String.valueOf(Long.parseLong(paramEndTime));
                    params.appendWhere(Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND "
                            + Programs.COLUMN_END_TIME_UTC_MILLIS + ">=?", endTime, startTime);
                }
                break;
            case MATCH_PROGRAM_ID:
                params.setTables(PROGRAMS_TABLE);
                params.appendWhere(Programs._ID + "=?", uri.getLastPathSegment());
                break;
            case MATCH_WATCHED_PROGRAM:
                params.setTables(WATCHED_PROGRAMS_TABLE);
                params.appendWhere(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=?", "1");
                break;
            case MATCH_WATCHED_PROGRAM_ID:
                params.setTables(WATCHED_PROGRAMS_TABLE);
                params.appendWhere(WatchedPrograms._ID + "=?", uri.getLastPathSegment());
                params.appendWhere(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=?", "1");
                break;
            case MATCH_CHANNEL_ID_LOGO:
            case MATCH_PASSTHROUGH_ID:
                throw new UnsupportedOperationException("Cannot " + operation + " that URI: "
                        + uri);
            default:
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        return params;
    }

    private static String capitalize(String str) {
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }

    @SuppressLint("DefaultLocale")
    private void checkAndConvertGenre(ContentValues values) {
        String canonicalGenres = values.getAsString(Programs.COLUMN_CANONICAL_GENRE);

        if (!TextUtils.isEmpty(canonicalGenres)) {
            // Check if the canonical genres are valid. If not, clear them.
            String[] genres = Genres.decode(canonicalGenres);
            for (String genre : genres) {
                if (!Genres.isCanonical(genre)) {
                    values.putNull(Programs.COLUMN_CANONICAL_GENRE);
                    canonicalGenres = null;
                    break;
                }
            }
        }

        if (TextUtils.isEmpty(canonicalGenres)) {
            // If the canonical genre is not set, try to map the broadcast genre to the canonical
            // genre.
            String broadcastGenres = values.getAsString(Programs.COLUMN_BROADCAST_GENRE);
            if (!TextUtils.isEmpty(broadcastGenres)) {
                Set<String> genreSet = new HashSet<String>();
                String[] genres = Genres.decode(broadcastGenres);
                for (String genre : genres) {
                    String canonicalGenre = sGenreMap.get(genre.toUpperCase());
                    if (Genres.isCanonical(canonicalGenre)) {
                        genreSet.add(canonicalGenre);
                    }
                }
                if (genreSet.size() > 0) {
                    values.put(Programs.COLUMN_CANONICAL_GENRE,
                            Genres.encode(genreSet.toArray(new String[0])));
                }
            }
        }
    }

    // We might have more than one thread trying to make its way through applyBatch() so the
    // notification coalescing needs to be thread-local to work correctly.
    private final ThreadLocal<Set<Uri>> mTLBatchNotifications =
            new ThreadLocal<Set<Uri>>();

    private Set<Uri> getBatchNotificationsSet() {
        return mTLBatchNotifications.get();
    }

    private void setBatchNotificationsSet(Set<Uri> batchNotifications) {
        mTLBatchNotifications.set(batchNotifications);
    }

    @Override
    public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
            throws OperationApplicationException {
        setBatchNotificationsSet(Sets.<Uri>newHashSet());
        Context context = getContext();
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        db.beginTransaction();
        try {
            ContentProviderResult[] results = super.applyBatch(operations);
            db.setTransactionSuccessful();
            return results;
        } finally {
            db.endTransaction();
            final Set<Uri> notifications = getBatchNotificationsSet();
            setBatchNotificationsSet(null);
            for (final Uri uri : notifications) {
                context.getContentResolver().notifyChange(uri, null);
            }
        }
    }

    private void notifyChange(Uri uri) {
        final Set<Uri> batchNotifications = getBatchNotificationsSet();
        if (batchNotifications != null) {
            batchNotifications.add(uri);
        } else {
            getContext().getContentResolver().notifyChange(uri, null);
        }
    }

    // When an application tries to create/read/update/delete channel or program data, we need to
    // ensure that such an access is limited to the data entries it owns, unless it has the full
    // access permission.
    // Note that the user's watch log is treated with more caution and we should block any access
    // from an application that doesn't have the proper permission.
    private boolean needsToLimitPackage(Uri uri) {
        int match = sUriMatcher.match(uri);
        if (match == MATCH_WATCHED_PROGRAM || match == MATCH_WATCHED_PROGRAM_ID) {
            if (!callerHasAccessWatchedProgramsPermission()) {
                throw new SecurityException("Access not allowed for " + uri);
            }
        }
        return !callerHasAccessAllEpgDataPermission();
    }

    private boolean callerHasAccessAllEpgDataPermission() {
        return getContext().checkCallingOrSelfPermission(PERMISSION_ACCESS_ALL_EPG_DATA)
                == PackageManager.PERMISSION_GRANTED;
    }

    private boolean callerHasAccessWatchedProgramsPermission() {
        return getContext().checkCallingOrSelfPermission(PERMISSION_ACCESS_WATCHED_PROGRAMS)
                == PackageManager.PERMISSION_GRANTED;
    }

    private boolean callerHasModifyParentalControlsPermission() {
        return getContext().checkCallingOrSelfPermission(
                android.Manifest.permission.MODIFY_PARENTAL_CONTROLS)
                == PackageManager.PERMISSION_GRANTED;
    }

    @Override
    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
        switch (sUriMatcher.match(uri)) {
            case MATCH_CHANNEL_ID_LOGO:
                return openLogoFile(uri, mode);
            default:
                throw new FileNotFoundException(uri.toString());
        }
    }

    private ParcelFileDescriptor openLogoFile(Uri uri, String mode) throws FileNotFoundException {
        long channelId = Long.parseLong(uri.getPathSegments().get(1));

        SqlParams params = new SqlParams(CHANNELS_TABLE, Channels._ID + "=?",
                String.valueOf(channelId));
        if (!callerHasAccessAllEpgDataPermission()) {
            params.appendWhere(Channels.COLUMN_PACKAGE_NAME + "=?", getCallingPackage_());
        }

        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
        queryBuilder.setTables(params.getTables());

        // We don't write the database here.
        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
        if (mode.equals("r")) {
            String sql = queryBuilder.buildQuery(new String[] { CHANNELS_COLUMN_LOGO },
                    params.getSelection(), null, null, null, null);
            return DatabaseUtils.blobFileDescriptorForQuery(db, sql, params.getSelectionArgs());
        } else {
            try (Cursor cursor = queryBuilder.query(db, new String[] { Channels._ID },
                    params.getSelection(), params.getSelectionArgs(), null, null, null)) {
                if (cursor.getCount() < 1) {
                    // Fails early if corresponding channel does not exist.
                    // PipeMonitor may still fail to update DB later.
                    throw new FileNotFoundException(uri.toString());
                }
            }

            try {
                ParcelFileDescriptor[] pipeFds = ParcelFileDescriptor.createPipe();
                PipeMonitor pipeMonitor = new PipeMonitor(pipeFds[0], channelId, params);
                pipeMonitor.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
                return pipeFds[1];
            } catch (IOException ioe) {
                FileNotFoundException fne = new FileNotFoundException(uri.toString());
                fne.initCause(ioe);
                throw fne;
            }
        }
    }

    private class PipeMonitor extends AsyncTask<Void, Void, Void> {
        private final ParcelFileDescriptor mPfd;
        private final long mChannelId;
        private final SqlParams mParams;

        private PipeMonitor(ParcelFileDescriptor pfd, long channelId, SqlParams params) {
            mPfd = pfd;
            mChannelId = channelId;
            mParams = params;
        }

        @Override
        protected Void doInBackground(Void... params) {
            AutoCloseInputStream is = new AutoCloseInputStream(mPfd);
            ByteArrayOutputStream baos = null;
            int count = 0;
            try {
                Bitmap bitmap = BitmapFactory.decodeStream(is);
                if (bitmap == null) {
                    Log.e(TAG, "Failed to decode logo image for channel ID " + mChannelId);
                    return null;
                }

                float scaleFactor = Math.min(1f, ((float) MAX_LOGO_IMAGE_SIZE) /
                        Math.max(bitmap.getWidth(), bitmap.getHeight()));
                if (scaleFactor < 1f) {
                    bitmap = Bitmap.createScaledBitmap(bitmap,
                            (int) (bitmap.getWidth() * scaleFactor),
                            (int) (bitmap.getHeight() * scaleFactor), false);
                }

                baos = new ByteArrayOutputStream();
                bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
                byte[] bytes = baos.toByteArray();

                ContentValues values = new ContentValues();
                values.put(CHANNELS_COLUMN_LOGO, bytes);

                SQLiteDatabase db = mOpenHelper.getWritableDatabase();
                count = db.update(mParams.getTables(), values, mParams.getSelection(),
                        mParams.getSelectionArgs());
                if (count > 0) {
                    Uri uri = TvContract.buildChannelLogoUri(mChannelId);
                    notifyChange(uri);
                }
            } finally {
                if (count == 0) {
                    try {
                        mPfd.closeWithError("Failed to write logo for channel ID " + mChannelId);
                    } catch (IOException ioe) {
                        Log.e(TAG, "Failed to close pipe", ioe);
                    }
                }
                IoUtils.closeQuietly(baos);
                IoUtils.closeQuietly(is);
            }
            return null;
        }
    }

    private final void deleteUnconsolidatedWatchedProgramsRows() {
        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
        db.delete(WATCHED_PROGRAMS_TABLE, WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0", null);
    }

    private final class WatchLogHandler extends Handler {
        private static final int MSG_CONSOLIDATE = 1;
        private static final int MSG_TRY_CONSOLIDATE_ALL = 2;

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_CONSOLIDATE: {
                    SomeArgs args = (SomeArgs) msg.obj;
                    String sessionToken = (String) args.arg1;
                    long watchEndTime = (long) args.arg2;
                    onConsolidate(sessionToken, watchEndTime);
                    args.recycle();
                    return;
                }
                case MSG_TRY_CONSOLIDATE_ALL: {
                    onTryConsolidateAll();
                    return;
                }
                default: {
                    Log.w(TAG, "Unhandled message code: " + msg.what);
                    return;
                }
            }
        }

        // Consolidates all WatchedPrograms rows for a given session with watch end time information
        // of the most recent log entry. After this method is called, it is guaranteed that there
        // remain consolidated rows only for that session.
        private final void onConsolidate(String sessionToken, long watchEndTime) {
            if (DEBUG) {
                Log.d(TAG, "onConsolidate(sessionToken=" + sessionToken + ", watchEndTime="
                        + watchEndTime + ")");
            }

            SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
            queryBuilder.setTables(WATCHED_PROGRAMS_TABLE);
            SQLiteDatabase db = mOpenHelper.getReadableDatabase();

            // Pick up the last row with the same session token.
            String[] projection = {
                    WatchedPrograms._ID,
                    WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS,
                    WatchedPrograms.COLUMN_CHANNEL_ID
            };
            String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=? AND "
                    + WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + "=?";
            String[] selectionArgs = {
                    "0",
                    sessionToken
            };
            String sortOrder = WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC";

            int consolidatedRowCount = 0;
            try (Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null,
                    null, sortOrder)) {
                long oldWatchStartTime = watchEndTime;
                while (cursor != null && cursor.moveToNext()) {
                    long id = cursor.getLong(0);
                    long watchStartTime = cursor.getLong(1);
                    long channelId = cursor.getLong(2);
                    consolidatedRowCount += consolidateRow(id, watchStartTime, oldWatchStartTime,
                            channelId, false);
                    oldWatchStartTime = watchStartTime;
                }
            }
            if (consolidatedRowCount > 0) {
                deleteUnsearchable();
            }
        }

        // Tries to consolidate all WatchedPrograms rows regardless of the session. After this
        // method is called, it is guaranteed that we have at most one unconsolidated log entry per
        // session that represents the user's ongoing watch activity.
        // Also, this method automatically schedules the next consolidation if there still remains
        // an unconsolidated entry.
        private final void onTryConsolidateAll() {
            if (DEBUG) {
                Log.d(TAG, "onTryConsolidateAll()");
            }

            SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
            queryBuilder.setTables(WATCHED_PROGRAMS_TABLE);
            SQLiteDatabase db = mOpenHelper.getReadableDatabase();

            // Pick up all unconsolidated rows grouped by session. The most recent log entry goes on
            // top.
            String[] projection = {
                    WatchedPrograms._ID,
                    WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS,
                    WatchedPrograms.COLUMN_CHANNEL_ID,
                    WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN
            };
            String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0";
            String sortOrder = WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN + " DESC,"
                    + WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + " DESC";

            int consolidatedRowCount = 0;
            try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null,
                    sortOrder)) {
                long oldWatchStartTime = 0;
                String oldSessionToken = null;
                while (cursor != null && cursor.moveToNext()) {
                    long id = cursor.getLong(0);
                    long watchStartTime = cursor.getLong(1);
                    long channelId = cursor.getLong(2);
                    String sessionToken = cursor.getString(3);

                    if (!sessionToken.equals(oldSessionToken)) {
                        // The most recent log entry for the current session, which may be still
                        // active. Just go through a dry run with the current time to see if this
                        // entry can be split into multiple rows.
                        consolidatedRowCount += consolidateRow(id, watchStartTime,
                                System.currentTimeMillis(), channelId, true);
                        oldSessionToken = sessionToken;
                    } else {
                        // The later entries after the most recent one all fall into here. We now
                        // know that this watch activity ended exactly at the same time when the
                        // next activity started.
                        consolidatedRowCount += consolidateRow(id, watchStartTime,
                                oldWatchStartTime, channelId, false);
                    }
                    oldWatchStartTime = watchStartTime;
                }
            }
            if (consolidatedRowCount > 0) {
                deleteUnsearchable();
            }
            scheduleConsolidationIfNeeded();
        }

        // Consolidates a WatchedPrograms row.
        // A row is 'consolidated' if and only if the following information is complete:
        // 1. WatchedPrograms.COLUMN_CHANNEL_ID
        // 2. WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS
        // 3. WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS
        // where COLUMN_WATCH_START_TIME_UTC_MILLIS <= COLUMN_WATCH_END_TIME_UTC_MILLIS.
        // This is the minimal but useful enough set of information to comprise the user's watch
        // history. (The program data are considered optional although we do try to fill them while
        // consolidating the row.) It is guaranteed that the target row is either consolidated or
        // deleted after this method is called.
        // Set {@code dryRun} to {@code true} if you think it's necessary to split the row without
        // consolidating the most recent row because the user stayed on the same channel for a very
        // long time.
        // This method returns the number of consolidated rows, which can be 0 or more.
        private final int consolidateRow(long id, long watchStartTime, long watchEndTime,
                long channelId, boolean dryRun) {
            if (DEBUG) {
                Log.d(TAG, "consolidateRow(id=" + id + ", watchStartTime=" + watchStartTime
                        + ", watchEndTime=" + watchEndTime + ", channelId=" + channelId
                        + ", dryRun=" + dryRun + ")");
            }

            SQLiteDatabase db = mOpenHelper.getWritableDatabase();

            if (watchStartTime > watchEndTime) {
                Log.e(TAG, "watchEndTime cannot be less than watchStartTime");
                db.delete(WATCHED_PROGRAMS_TABLE, WatchedPrograms._ID + "=" + String.valueOf(id),
                        null);
                return 0;
            }

            ContentValues values = getProgramValues(channelId, watchStartTime);
            Long endTime = values.getAsLong(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS);
            boolean needsToSplit = endTime != null && endTime < watchEndTime;

            values.put(WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS,
                    String.valueOf(watchStartTime));
            if (!dryRun || needsToSplit) {
                values.put(WatchedPrograms.COLUMN_WATCH_END_TIME_UTC_MILLIS,
                        String.valueOf(needsToSplit ? endTime : watchEndTime));
                values.put(WATCHED_PROGRAMS_COLUMN_CONSOLIDATED, "1");
                db.update(WATCHED_PROGRAMS_TABLE, values,
                        WatchedPrograms._ID + "=" + String.valueOf(id), null);
                // Treat the watched program is inserted when WATCHED_PROGRAMS_COLUMN_CONSOLIDATED
                // becomes 1.
                notifyChange(TvContract.buildWatchedProgramUri(id));
            } else {
                db.update(WATCHED_PROGRAMS_TABLE, values,
                        WatchedPrograms._ID + "=" + String.valueOf(id), null);
            }
            int count = dryRun ? 0 : 1;
            if (needsToSplit) {
                // This means that the program ended before the user stops watching the current
                // channel. In this case we duplicate the log entry as many as the number of
                // programs watched on the same channel. Here the end time of the current program
                // becomes the new watch start time of the next program.
                long duplicatedId = duplicateRow(id);
                if (duplicatedId > 0) {
                    count += consolidateRow(duplicatedId, endTime, watchEndTime, channelId, dryRun);
                }
            }
            return count;
        }

        // Deletes the log entries from unsearchable channels. Note that only consolidated log
        // entries are safe to delete.
        private final void deleteUnsearchable() {
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();
            String deleteWhere = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=1 AND "
                    + WatchedPrograms.COLUMN_CHANNEL_ID + " IN (SELECT " + Channels._ID
                    + " FROM " + CHANNELS_TABLE + " WHERE " + Channels.COLUMN_SEARCHABLE + "=0)";
            db.delete(WATCHED_PROGRAMS_TABLE, deleteWhere, null);
        }

        private final void scheduleConsolidationIfNeeded() {
            if (DEBUG) {
                Log.d(TAG, "scheduleConsolidationIfNeeded()");
            }
            SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
            queryBuilder.setTables(WATCHED_PROGRAMS_TABLE);
            SQLiteDatabase db = mOpenHelper.getReadableDatabase();

            // Pick up all unconsolidated rows.
            String[] projection = {
                    WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS,
                    WatchedPrograms.COLUMN_CHANNEL_ID,
            };
            String selection = WATCHED_PROGRAMS_COLUMN_CONSOLIDATED + "=0";

            try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null,
                    null)) {
                // Find the earliest time that any of the currently watching programs ends and
                // schedule the next consolidation at that time.
                long minEndTime = Long.MAX_VALUE;
                while (cursor != null && cursor.moveToNext()) {
                    long watchStartTime = cursor.getLong(0);
                    long channelId = cursor.getLong(1);
                    ContentValues values = getProgramValues(channelId, watchStartTime);
                    Long endTime = values.getAsLong(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS);

                    if (endTime != null && endTime < minEndTime
                            && endTime > System.currentTimeMillis()) {
                        minEndTime = endTime;
                    }
                }
                if (minEndTime != Long.MAX_VALUE) {
                    sendEmptyMessageAtTime(MSG_TRY_CONSOLIDATE_ALL, minEndTime);
                    if (DEBUG) {
                        CharSequence minEndTimeStr = DateUtils.getRelativeTimeSpanString(
                                minEndTime, System.currentTimeMillis(), DateUtils.SECOND_IN_MILLIS);
                        Log.d(TAG, "onTryConsolidateAll() scheduled " + minEndTimeStr);
                    }
                }
            }
        }

        // Returns non-null ContentValues of the program data that the user watched on the channel
        // {@code channelId} at the time {@code time}.
        private final ContentValues getProgramValues(long channelId, long time) {
            SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
            queryBuilder.setTables(PROGRAMS_TABLE);
            SQLiteDatabase db = mOpenHelper.getReadableDatabase();

            String[] projection = {
                    Programs.COLUMN_TITLE,
                    Programs.COLUMN_START_TIME_UTC_MILLIS,
                    Programs.COLUMN_END_TIME_UTC_MILLIS,
                    Programs.COLUMN_SHORT_DESCRIPTION
            };
            String selection = Programs.COLUMN_CHANNEL_ID + "=? AND "
                    + Programs.COLUMN_START_TIME_UTC_MILLIS + "<=? AND "
                    + Programs.COLUMN_END_TIME_UTC_MILLIS + ">?";
            String[] selectionArgs = {
                    String.valueOf(channelId),
                    String.valueOf(time),
                    String.valueOf(time)
            };
            String sortOrder = Programs.COLUMN_START_TIME_UTC_MILLIS + " ASC";

            try (Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null,
                    null, sortOrder)) {
                ContentValues values = new ContentValues();
                if (cursor != null && cursor.moveToNext()) {
                    values.put(WatchedPrograms.COLUMN_TITLE, cursor.getString(0));
                    values.put(WatchedPrograms.COLUMN_START_TIME_UTC_MILLIS, cursor.getLong(1));
                    values.put(WatchedPrograms.COLUMN_END_TIME_UTC_MILLIS, cursor.getLong(2));
                    values.put(WatchedPrograms.COLUMN_DESCRIPTION, cursor.getString(3));
                }
                return values;
            }
        }

        // Duplicates the WatchedPrograms row with a given ID and returns the ID of the duplicated
        // row. Returns -1 if failed.
        private final long duplicateRow(long id) {
            if (DEBUG) {
                Log.d(TAG, "duplicateRow(" + id + ")");
            }

            SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
            queryBuilder.setTables(WATCHED_PROGRAMS_TABLE);
            SQLiteDatabase db = mOpenHelper.getWritableDatabase();

            String[] projection = {
                    WatchedPrograms.COLUMN_PACKAGE_NAME,
                    WatchedPrograms.COLUMN_CHANNEL_ID,
                    WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN
            };
            String selection = WatchedPrograms._ID + "=" + String.valueOf(id);

            try (Cursor cursor = queryBuilder.query(db, projection, selection, null, null, null,
                    null)) {
                long rowId = -1;
                if (cursor != null && cursor.moveToNext()) {
                    ContentValues values = new ContentValues();
                    values.put(WatchedPrograms.COLUMN_PACKAGE_NAME, cursor.getString(0));
                    values.put(WatchedPrograms.COLUMN_CHANNEL_ID, cursor.getLong(1));
                    values.put(WatchedPrograms.COLUMN_INTERNAL_SESSION_TOKEN, cursor.getString(2));
                    rowId = db.insert(WATCHED_PROGRAMS_TABLE, null, values);
                }
                return rowId;
            }
        }
    }
}