1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* 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.app.IntentService;
import android.content.Intent;
import android.database.Cursor;
import android.media.tv.TvContract.Programs;
import android.media.tv.TvContract.WatchedPrograms;
import android.text.format.DateUtils;
import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
import java.util.concurrent.TimeUnit;
/**
* A service that cleans up EPG data.
*/
public class EpgDataCleanupService extends IntentService {
private static final boolean DEBUG = true;
private static final String TAG = "EpgDataCleanupService";
static final String ACTION_CLEAN_UP_EPG_DATA =
"com.android.providers.tv.intent.CLEAN_UP_EPG_DATA";
public EpgDataCleanupService() {
super("EpgDataCleanupService");
}
@Override
protected void onHandleIntent(Intent intent) {
if (DEBUG) {
Log.d(TAG, "Received intent: " + intent);
}
final String action = intent.getAction();
if (!ACTION_CLEAN_UP_EPG_DATA.equals(action)) {
return;
}
long nowMillis = System.currentTimeMillis();
int maxProgramAgeInDays = getResources().getInteger(R.integer.max_program_age_in_days);
if (maxProgramAgeInDays > 0) {
clearOldPrograms(nowMillis - TimeUnit.DAYS.toMillis(maxProgramAgeInDays));
}
int maxWatchedProgramAgeInDays =
getResources().getInteger(R.integer.max_watched_program_age_in_days);
if (maxWatchedProgramAgeInDays > 0) {
clearOldWatchHistory(nowMillis - TimeUnit.DAYS.toMillis(maxWatchedProgramAgeInDays));
}
int maxWatchedProgramEntryCount =
getResources().getInteger(R.integer.max_watched_program_entry_count);
if (maxWatchedProgramEntryCount > 0) {
clearOverflowWatchHistory(maxWatchedProgramEntryCount);
}
}
/**
* Clear program info that ended before {@code maxEndTimeMillis}.
*/
@VisibleForTesting
void clearOldPrograms(long maxEndTimeMillis) {
int deleteCount = getContentResolver().delete(
Programs.CONTENT_URI,
Programs.COLUMN_END_TIME_UTC_MILLIS + "<?",
new String[] { String.valueOf(maxEndTimeMillis) });
if (DEBUG && deleteCount > 0) {
Log.d(TAG, "Deleted " + deleteCount + " programs"
+ " (reason: ended before "
+ DateUtils.getRelativeTimeSpanString(this, maxEndTimeMillis) + ")");
}
}
/**
* Clear watch history whose watch started before {@code maxStartTimeMillis}.
* In theory, history entry for currently watching program can be deleted
* (e.g., have been watching since before {@code maxStartTimeMillis}).
*/
@VisibleForTesting
void clearOldWatchHistory(long maxStartTimeMillis) {
int deleteCount = getContentResolver().delete(
WatchedPrograms.CONTENT_URI,
WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + "<?",
new String[] { String.valueOf(maxStartTimeMillis) });
if (DEBUG && deleteCount > 0) {
Log.d(TAG, "Deleted " + deleteCount + " watched programs"
+ " (reason: started before "
+ DateUtils.getRelativeTimeSpanString(this, maxStartTimeMillis) + ")");
}
}
/**
* Clear watch history except last {@code maxEntryCount} entries.
* "Last" here is based on watch start time, and so, in theory, history entry for program
* that user was watching until recent reboot can be deleted earlier than other entries
* which ended before.
*/
@VisibleForTesting
void clearOverflowWatchHistory(int maxEntryCount) {
Cursor cursor = getContentResolver().query(
WatchedPrograms.CONTENT_URI,
new String[] { WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS }, null, null,
WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS);
if (cursor == null) {
Log.e(TAG, "Failed to query watched program");
return;
}
int totalCount;
long maxStartTimeMillis;
try {
totalCount = cursor.getCount();
int overflowCount = totalCount - maxEntryCount;
if (overflowCount <= 0) {
return;
}
if (!cursor.moveToPosition(overflowCount - 1)) {
Log.e(TAG, "Failed to query watched program");
return;
}
maxStartTimeMillis = cursor.getLong(0);
} finally {
cursor.close();
}
int deleteCount = getContentResolver().delete(
WatchedPrograms.CONTENT_URI,
WatchedPrograms.COLUMN_WATCH_START_TIME_UTC_MILLIS + "<?",
new String[] { String.valueOf(maxStartTimeMillis + 1) });
if (DEBUG && deleteCount > 0) {
Log.d(TAG, "Deleted " + deleteCount + " of " + totalCount + " watched programs"
+ " (reason: entry count > " + maxEntryCount + ")");
}
}
}
|
