| /* |
| * Copyright (C) 2015 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.tv.dvr.data; |
| |
| import android.annotation.TargetApi; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.os.Build; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.support.annotation.IntDef; |
| import android.support.annotation.Nullable; |
| import android.text.TextUtils; |
| import android.util.Range; |
| import com.android.tv.R; |
| import com.android.tv.TvSingletons; |
| import com.android.tv.common.SoftPreconditions; |
| import com.android.tv.common.util.CommonUtils; |
| import com.android.tv.data.Program; |
| import com.android.tv.data.api.Channel; |
| import com.android.tv.dvr.DvrScheduleManager; |
| import com.android.tv.dvr.provider.DvrContract.Schedules; |
| import com.android.tv.util.CompositeComparator; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.Collection; |
| import java.util.Comparator; |
| import java.util.Objects; |
| |
| /** A data class for one recording contents. */ |
| @TargetApi(Build.VERSION_CODES.N) |
| @SuppressWarnings("AndroidApiChecker") // TODO(b/32513850) remove when error prone is updated |
| public final class ScheduledRecording implements Parcelable { |
| private static final String TAG = "ScheduledRecording"; |
| |
| /** Indicates that the ID is not assigned yet. */ |
| public static final long ID_NOT_SET = 0; |
| |
| /** The default priority of the recording. */ |
| public static final long DEFAULT_PRIORITY = Long.MAX_VALUE >> 1; |
| |
| /** Compares the start time in ascending order. */ |
| public static final Comparator<ScheduledRecording> START_TIME_COMPARATOR = |
| new Comparator<ScheduledRecording>() { |
| @Override |
| public int compare(ScheduledRecording lhs, ScheduledRecording rhs) { |
| return Long.compare(lhs.mStartTimeMs, rhs.mStartTimeMs); |
| } |
| }; |
| |
| /** Compares the end time in ascending order. */ |
| public static final Comparator<ScheduledRecording> END_TIME_COMPARATOR = |
| new Comparator<ScheduledRecording>() { |
| @Override |
| public int compare(ScheduledRecording lhs, ScheduledRecording rhs) { |
| return Long.compare(lhs.mEndTimeMs, rhs.mEndTimeMs); |
| } |
| }; |
| |
| /** Compares ID in ascending order. The schedule with the larger ID was created later. */ |
| public static final Comparator<ScheduledRecording> ID_COMPARATOR = |
| new Comparator<ScheduledRecording>() { |
| @Override |
| public int compare(ScheduledRecording lhs, ScheduledRecording rhs) { |
| return Long.compare(lhs.mId, rhs.mId); |
| } |
| }; |
| |
| /** Compares the priority in ascending order. */ |
| public static final Comparator<ScheduledRecording> PRIORITY_COMPARATOR = |
| new Comparator<ScheduledRecording>() { |
| @Override |
| public int compare(ScheduledRecording lhs, ScheduledRecording rhs) { |
| return Long.compare(lhs.mPriority, rhs.mPriority); |
| } |
| }; |
| |
| /** |
| * Compares start time in ascending order and then priority in descending order and then ID in |
| * descending order. |
| */ |
| public static final Comparator<ScheduledRecording> START_TIME_THEN_PRIORITY_THEN_ID_COMPARATOR = |
| new CompositeComparator<>( |
| START_TIME_COMPARATOR, |
| PRIORITY_COMPARATOR.reversed(), |
| ID_COMPARATOR.reversed()); |
| |
| /** Builds scheduled recordings from programs. */ |
| public static Builder builder(String inputId, Program p) { |
| return new Builder() |
| .setInputId(inputId) |
| .setChannelId(p.getChannelId()) |
| .setStartTimeMs(p.getStartTimeUtcMillis()) |
| .setEndTimeMs(p.getEndTimeUtcMillis()) |
| .setProgramId(p.getId()) |
| .setProgramTitle(p.getTitle()) |
| .setSeasonNumber(p.getSeasonNumber()) |
| .setEpisodeNumber(p.getEpisodeNumber()) |
| .setEpisodeTitle(p.getEpisodeTitle()) |
| .setProgramDescription(p.getDescription()) |
| .setProgramLongDescription(p.getLongDescription()) |
| .setProgramPosterArtUri(p.getPosterArtUri()) |
| .setProgramThumbnailUri(p.getThumbnailUri()) |
| .setType(TYPE_PROGRAM); |
| } |
| |
| public static Builder builder(String inputId, long channelId, long startTime, long endTime) { |
| return new Builder() |
| .setInputId(inputId) |
| .setChannelId(channelId) |
| .setStartTimeMs(startTime) |
| .setEndTimeMs(endTime) |
| .setType(TYPE_TIMED); |
| } |
| |
| /** Creates a new Builder with the values set from the {@link RecordedProgram}. */ |
| public static Builder builder(RecordedProgram p) { |
| boolean isProgramRecording = !TextUtils.isEmpty(p.getTitle()); |
| return new Builder() |
| .setInputId(p.getInputId()) |
| .setChannelId(p.getChannelId()) |
| .setType(isProgramRecording ? TYPE_PROGRAM : TYPE_TIMED) |
| .setStartTimeMs(p.getStartTimeUtcMillis()) |
| .setEndTimeMs(p.getEndTimeUtcMillis()) |
| .setProgramTitle(p.getTitle()) |
| .setSeasonNumber(p.getSeasonNumber()) |
| .setEpisodeNumber(p.getEpisodeNumber()) |
| .setEpisodeTitle(p.getEpisodeTitle()) |
| .setProgramDescription(p.getDescription()) |
| .setProgramLongDescription(p.getLongDescription()) |
| .setProgramPosterArtUri(p.getPosterArtUri()) |
| .setProgramThumbnailUri(p.getThumbnailUri()) |
| .setState(STATE_RECORDING_FINISHED) |
| .setRecordedProgramId(p.getId()); |
| } |
| |
| public static final class Builder { |
| private long mId = ID_NOT_SET; |
| private long mPriority = DvrScheduleManager.DEFAULT_PRIORITY; |
| private String mInputId; |
| private long mChannelId; |
| private long mProgramId = ID_NOT_SET; |
| private String mProgramTitle; |
| private @RecordingType int mType; |
| private long mStartTimeMs; |
| private long mEndTimeMs; |
| private String mSeasonNumber; |
| private String mEpisodeNumber; |
| private String mEpisodeTitle; |
| private String mProgramDescription; |
| private String mProgramLongDescription; |
| private String mProgramPosterArtUri; |
| private String mProgramThumbnailUri; |
| private @RecordingState int mState; |
| private long mSeriesRecordingId = ID_NOT_SET; |
| private Long mRecodedProgramId; |
| private Integer mFailedReason; |
| |
| private Builder() {} |
| |
| public Builder setId(long id) { |
| mId = id; |
| return this; |
| } |
| |
| public Builder setPriority(long priority) { |
| mPriority = priority; |
| return this; |
| } |
| |
| public Builder setInputId(String inputId) { |
| mInputId = inputId; |
| return this; |
| } |
| |
| public Builder setChannelId(long channelId) { |
| mChannelId = channelId; |
| return this; |
| } |
| |
| public Builder setProgramId(long programId) { |
| mProgramId = programId; |
| return this; |
| } |
| |
| public Builder setProgramTitle(String programTitle) { |
| mProgramTitle = programTitle; |
| return this; |
| } |
| |
| private Builder setType(@RecordingType int type) { |
| mType = type; |
| return this; |
| } |
| |
| public Builder setStartTimeMs(long startTimeMs) { |
| mStartTimeMs = startTimeMs; |
| return this; |
| } |
| |
| public Builder setEndTimeMs(long endTimeMs) { |
| mEndTimeMs = endTimeMs; |
| return this; |
| } |
| |
| public Builder setSeasonNumber(String seasonNumber) { |
| mSeasonNumber = seasonNumber; |
| return this; |
| } |
| |
| public Builder setEpisodeNumber(String episodeNumber) { |
| mEpisodeNumber = episodeNumber; |
| return this; |
| } |
| |
| public Builder setEpisodeTitle(String episodeTitle) { |
| mEpisodeTitle = episodeTitle; |
| return this; |
| } |
| |
| public Builder setProgramDescription(String description) { |
| mProgramDescription = description; |
| return this; |
| } |
| |
| public Builder setProgramLongDescription(String longDescription) { |
| mProgramLongDescription = longDescription; |
| return this; |
| } |
| |
| public Builder setProgramPosterArtUri(String programPosterArtUri) { |
| mProgramPosterArtUri = programPosterArtUri; |
| return this; |
| } |
| |
| public Builder setProgramThumbnailUri(String programThumbnailUri) { |
| mProgramThumbnailUri = programThumbnailUri; |
| return this; |
| } |
| |
| public Builder setState(@RecordingState int state) { |
| mState = state; |
| return this; |
| } |
| |
| public Builder setSeriesRecordingId(long seriesRecordingId) { |
| mSeriesRecordingId = seriesRecordingId; |
| return this; |
| } |
| |
| public Builder setRecordedProgramId(Long recordedProgramId) { |
| mRecodedProgramId = recordedProgramId; |
| return this; |
| } |
| |
| public Builder setFailedReason(Integer reason) { |
| mFailedReason = reason; |
| return this; |
| } |
| |
| public ScheduledRecording build() { |
| return new ScheduledRecording( |
| mId, |
| mPriority, |
| mInputId, |
| mChannelId, |
| mProgramId, |
| mProgramTitle, |
| mType, |
| mStartTimeMs, |
| mEndTimeMs, |
| mSeasonNumber, |
| mEpisodeNumber, |
| mEpisodeTitle, |
| mProgramDescription, |
| mProgramLongDescription, |
| mProgramPosterArtUri, |
| mProgramThumbnailUri, |
| mState, |
| mSeriesRecordingId, |
| mRecodedProgramId, |
| mFailedReason); |
| } |
| } |
| |
| /** Creates {@link Builder} object from the given original {@code Recording}. */ |
| public static Builder buildFrom(ScheduledRecording orig) { |
| return new Builder() |
| .setId(orig.mId) |
| .setInputId(orig.mInputId) |
| .setChannelId(orig.mChannelId) |
| .setEndTimeMs(orig.mEndTimeMs) |
| .setSeriesRecordingId(orig.mSeriesRecordingId) |
| .setPriority(orig.mPriority) |
| .setProgramId(orig.mProgramId) |
| .setProgramTitle(orig.mProgramTitle) |
| .setStartTimeMs(orig.mStartTimeMs) |
| .setSeasonNumber(orig.getSeasonNumber()) |
| .setEpisodeNumber(orig.getEpisodeNumber()) |
| .setEpisodeTitle(orig.getEpisodeTitle()) |
| .setProgramDescription(orig.getProgramDescription()) |
| .setProgramLongDescription(orig.getProgramLongDescription()) |
| .setProgramPosterArtUri(orig.getProgramPosterArtUri()) |
| .setProgramThumbnailUri(orig.getProgramThumbnailUri()) |
| .setState(orig.mState) |
| .setFailedReason(orig.getFailedReason()) |
| .setType(orig.mType); |
| } |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({ |
| STATE_RECORDING_NOT_STARTED, |
| STATE_RECORDING_IN_PROGRESS, |
| STATE_RECORDING_FINISHED, |
| STATE_RECORDING_FAILED, |
| STATE_RECORDING_CLIPPED, |
| STATE_RECORDING_DELETED, |
| STATE_RECORDING_CANCELED |
| }) |
| public @interface RecordingState {} |
| |
| public static final int STATE_RECORDING_NOT_STARTED = 0; |
| public static final int STATE_RECORDING_IN_PROGRESS = 1; |
| public static final int STATE_RECORDING_FINISHED = 2; |
| public static final int STATE_RECORDING_FAILED = 3; |
| public static final int STATE_RECORDING_CLIPPED = 4; |
| public static final int STATE_RECORDING_DELETED = 5; |
| public static final int STATE_RECORDING_CANCELED = 6; |
| |
| /** The reasons of failed recordings */ |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({ |
| FAILED_REASON_OTHER, |
| FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED, |
| FAILED_REASON_NOT_FINISHED, |
| FAILED_REASON_SCHEDULER_STOPPED, |
| FAILED_REASON_INVALID_CHANNEL, |
| FAILED_REASON_MESSAGE_NOT_SENT, |
| FAILED_REASON_CONNECTION_FAILED, |
| FAILED_REASON_RESOURCE_BUSY, |
| FAILED_REASON_INPUT_UNAVAILABLE, |
| FAILED_REASON_INPUT_DVR_UNSUPPORTED, |
| FAILED_REASON_INSUFFICIENT_SPACE |
| }) |
| public @interface RecordingFailedReason {} |
| |
| public static final int FAILED_REASON_OTHER = 0; |
| public static final int FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED = 1; |
| public static final int FAILED_REASON_NOT_FINISHED = 2; |
| public static final int FAILED_REASON_SCHEDULER_STOPPED = 3; |
| public static final int FAILED_REASON_INVALID_CHANNEL = 4; |
| public static final int FAILED_REASON_MESSAGE_NOT_SENT = 5; |
| public static final int FAILED_REASON_CONNECTION_FAILED = 6; |
| public static final int FAILED_REASON_RESOURCE_BUSY = 7; |
| // For the following reasons, show advice to users |
| public static final int FAILED_REASON_INPUT_UNAVAILABLE = 8; |
| public static final int FAILED_REASON_INPUT_DVR_UNSUPPORTED = 9; |
| public static final int FAILED_REASON_INSUFFICIENT_SPACE = 10; |
| |
| @Retention(RetentionPolicy.SOURCE) |
| @IntDef({TYPE_TIMED, TYPE_PROGRAM}) |
| public @interface RecordingType {} |
| /** Record with given time range. */ |
| public static final int TYPE_TIMED = 1; |
| /** Record with a given program. */ |
| public static final int TYPE_PROGRAM = 2; |
| |
| @RecordingType private final int mType; |
| |
| /** |
| * Use this projection if you want to create {@link ScheduledRecording} object using {@link |
| * #fromCursor}. |
| */ |
| public static final String[] PROJECTION = { |
| // Columns must match what is read in #fromCursor |
| Schedules._ID, |
| Schedules.COLUMN_PRIORITY, |
| Schedules.COLUMN_TYPE, |
| Schedules.COLUMN_INPUT_ID, |
| Schedules.COLUMN_CHANNEL_ID, |
| Schedules.COLUMN_PROGRAM_ID, |
| Schedules.COLUMN_PROGRAM_TITLE, |
| Schedules.COLUMN_START_TIME_UTC_MILLIS, |
| Schedules.COLUMN_END_TIME_UTC_MILLIS, |
| Schedules.COLUMN_SEASON_NUMBER, |
| Schedules.COLUMN_EPISODE_NUMBER, |
| Schedules.COLUMN_EPISODE_TITLE, |
| Schedules.COLUMN_PROGRAM_DESCRIPTION, |
| Schedules.COLUMN_PROGRAM_LONG_DESCRIPTION, |
| Schedules.COLUMN_PROGRAM_POST_ART_URI, |
| Schedules.COLUMN_PROGRAM_THUMBNAIL_URI, |
| Schedules.COLUMN_STATE, |
| Schedules.COLUMN_FAILED_REASON, |
| Schedules.COLUMN_SERIES_RECORDING_ID |
| }; |
| |
| /** Creates {@link ScheduledRecording} object from the given {@link Cursor}. */ |
| public static ScheduledRecording fromCursor(Cursor c) { |
| int index = -1; |
| return new Builder() |
| .setId(c.getLong(++index)) |
| .setPriority(c.getLong(++index)) |
| .setType(recordingType(c.getString(++index))) |
| .setInputId(c.getString(++index)) |
| .setChannelId(c.getLong(++index)) |
| .setProgramId(c.getLong(++index)) |
| .setProgramTitle(c.getString(++index)) |
| .setStartTimeMs(c.getLong(++index)) |
| .setEndTimeMs(c.getLong(++index)) |
| .setSeasonNumber(c.getString(++index)) |
| .setEpisodeNumber(c.getString(++index)) |
| .setEpisodeTitle(c.getString(++index)) |
| .setProgramDescription(c.getString(++index)) |
| .setProgramLongDescription(c.getString(++index)) |
| .setProgramPosterArtUri(c.getString(++index)) |
| .setProgramThumbnailUri(c.getString(++index)) |
| .setState(recordingState(c.getString(++index))) |
| .setFailedReason(recordingFailedReason(c.getString(++index))) |
| .setSeriesRecordingId(c.getLong(++index)) |
| .build(); |
| } |
| |
| public static ContentValues toContentValues(ScheduledRecording r) { |
| ContentValues values = new ContentValues(); |
| if (r.getId() != ID_NOT_SET) { |
| values.put(Schedules._ID, r.getId()); |
| } |
| values.put(Schedules.COLUMN_INPUT_ID, r.getInputId()); |
| values.put(Schedules.COLUMN_CHANNEL_ID, r.getChannelId()); |
| values.put(Schedules.COLUMN_PROGRAM_ID, r.getProgramId()); |
| values.put(Schedules.COLUMN_PROGRAM_TITLE, r.getProgramTitle()); |
| values.put(Schedules.COLUMN_PRIORITY, r.getPriority()); |
| values.put(Schedules.COLUMN_START_TIME_UTC_MILLIS, r.getStartTimeMs()); |
| values.put(Schedules.COLUMN_END_TIME_UTC_MILLIS, r.getEndTimeMs()); |
| values.put(Schedules.COLUMN_SEASON_NUMBER, r.getSeasonNumber()); |
| values.put(Schedules.COLUMN_EPISODE_NUMBER, r.getEpisodeNumber()); |
| values.put(Schedules.COLUMN_EPISODE_TITLE, r.getEpisodeTitle()); |
| values.put(Schedules.COLUMN_PROGRAM_DESCRIPTION, r.getProgramDescription()); |
| values.put(Schedules.COLUMN_PROGRAM_LONG_DESCRIPTION, r.getProgramLongDescription()); |
| values.put(Schedules.COLUMN_PROGRAM_POST_ART_URI, r.getProgramPosterArtUri()); |
| values.put(Schedules.COLUMN_PROGRAM_THUMBNAIL_URI, r.getProgramThumbnailUri()); |
| values.put(Schedules.COLUMN_STATE, recordingState(r.getState())); |
| values.put(Schedules.COLUMN_FAILED_REASON, recordingFailedReason(r.getFailedReason())); |
| values.put(Schedules.COLUMN_TYPE, recordingType(r.getType())); |
| if (r.getSeriesRecordingId() != ID_NOT_SET) { |
| values.put(Schedules.COLUMN_SERIES_RECORDING_ID, r.getSeriesRecordingId()); |
| } else { |
| values.putNull(Schedules.COLUMN_SERIES_RECORDING_ID); |
| } |
| return values; |
| } |
| |
| public static ScheduledRecording fromParcel(Parcel in) { |
| return new Builder() |
| .setId(in.readLong()) |
| .setPriority(in.readLong()) |
| .setInputId(in.readString()) |
| .setChannelId(in.readLong()) |
| .setProgramId(in.readLong()) |
| .setProgramTitle(in.readString()) |
| .setType(in.readInt()) |
| .setStartTimeMs(in.readLong()) |
| .setEndTimeMs(in.readLong()) |
| .setSeasonNumber(in.readString()) |
| .setEpisodeNumber(in.readString()) |
| .setEpisodeTitle(in.readString()) |
| .setProgramDescription(in.readString()) |
| .setProgramLongDescription(in.readString()) |
| .setProgramPosterArtUri(in.readString()) |
| .setProgramThumbnailUri(in.readString()) |
| .setState(in.readInt()) |
| .setFailedReason(recordingFailedReason(in.readString())) |
| .setSeriesRecordingId(in.readLong()) |
| .build(); |
| } |
| |
| public static final Parcelable.Creator<ScheduledRecording> CREATOR = |
| new Parcelable.Creator<ScheduledRecording>() { |
| @Override |
| public ScheduledRecording createFromParcel(Parcel in) { |
| return ScheduledRecording.fromParcel(in); |
| } |
| |
| @Override |
| public ScheduledRecording[] newArray(int size) { |
| return new ScheduledRecording[size]; |
| } |
| }; |
| |
| /** The ID internal to Live TV */ |
| private long mId; |
| |
| /** |
| * The priority of this recording. |
| * |
| * <p>The highest number is recorded first. If there is a tie in priority then the higher id |
| * wins. |
| */ |
| private final long mPriority; |
| |
| private final String mInputId; |
| private final long mChannelId; |
| /** Optional id of the associated program. */ |
| private final long mProgramId; |
| |
| private final String mProgramTitle; |
| |
| private final long mStartTimeMs; |
| private final long mEndTimeMs; |
| private final String mSeasonNumber; |
| private final String mEpisodeNumber; |
| private final String mEpisodeTitle; |
| private final String mProgramDescription; |
| private final String mProgramLongDescription; |
| private final String mProgramPosterArtUri; |
| private final String mProgramThumbnailUri; |
| @RecordingState private final int mState; |
| private final long mSeriesRecordingId; |
| private final Long mRecordedProgramId; |
| private final Integer mFailedReason; |
| |
| private ScheduledRecording( |
| long id, |
| long priority, |
| String inputId, |
| long channelId, |
| long programId, |
| String programTitle, |
| @RecordingType int type, |
| long startTime, |
| long endTime, |
| String seasonNumber, |
| String episodeNumber, |
| String episodeTitle, |
| String programDescription, |
| String programLongDescription, |
| String programPosterArtUri, |
| String programThumbnailUri, |
| @RecordingState int state, |
| long seriesRecordingId, |
| Long recordedProgramId, |
| Integer failedReason) { |
| mId = id; |
| mPriority = priority; |
| mInputId = inputId; |
| mChannelId = channelId; |
| mProgramId = programId; |
| mProgramTitle = programTitle; |
| mType = type; |
| mStartTimeMs = startTime; |
| mEndTimeMs = endTime; |
| mSeasonNumber = seasonNumber; |
| mEpisodeNumber = episodeNumber; |
| mEpisodeTitle = episodeTitle; |
| mProgramDescription = programDescription; |
| mProgramLongDescription = programLongDescription; |
| mProgramPosterArtUri = programPosterArtUri; |
| mProgramThumbnailUri = programThumbnailUri; |
| mState = state; |
| mSeriesRecordingId = seriesRecordingId; |
| mRecordedProgramId = recordedProgramId; |
| mFailedReason = failedReason; |
| } |
| |
| /** |
| * Returns recording schedule type. The possible types are {@link #TYPE_PROGRAM} and {@link |
| * #TYPE_TIMED}. |
| */ |
| @RecordingType |
| public int getType() { |
| return mType; |
| } |
| |
| /** Returns schedules' input id. */ |
| public String getInputId() { |
| return mInputId; |
| } |
| |
| /** Returns recorded {@link Channel}. */ |
| public long getChannelId() { |
| return mChannelId; |
| } |
| |
| /** Return the optional program id */ |
| public long getProgramId() { |
| return mProgramId; |
| } |
| |
| /** Return the optional program Title */ |
| public String getProgramTitle() { |
| return mProgramTitle; |
| } |
| |
| /** Returns started time. */ |
| public long getStartTimeMs() { |
| return mStartTimeMs; |
| } |
| |
| /** Returns ended time. */ |
| public long getEndTimeMs() { |
| return mEndTimeMs; |
| } |
| |
| /** Returns the season number. */ |
| public String getSeasonNumber() { |
| return mSeasonNumber; |
| } |
| |
| /** Returns the episode number. */ |
| public String getEpisodeNumber() { |
| return mEpisodeNumber; |
| } |
| |
| /** Returns the episode title. */ |
| public String getEpisodeTitle() { |
| return mEpisodeTitle; |
| } |
| |
| /** Returns the description of program. */ |
| public String getProgramDescription() { |
| return mProgramDescription; |
| } |
| |
| /** Returns the long description of program. */ |
| public String getProgramLongDescription() { |
| return mProgramLongDescription; |
| } |
| |
| /** Returns the poster uri of program. */ |
| public String getProgramPosterArtUri() { |
| return mProgramPosterArtUri; |
| } |
| |
| /** Returns the thumb nail uri of program. */ |
| public String getProgramThumbnailUri() { |
| return mProgramThumbnailUri; |
| } |
| |
| /** Returns duration. */ |
| public long getDuration() { |
| return mEndTimeMs - mStartTimeMs; |
| } |
| |
| /** |
| * Returns the state. The possible states are {@link #STATE_RECORDING_NOT_STARTED}, {@link |
| * #STATE_RECORDING_IN_PROGRESS}, {@link #STATE_RECORDING_FINISHED}, {@link |
| * #STATE_RECORDING_FAILED}, {@link #STATE_RECORDING_CLIPPED} and {@link |
| * #STATE_RECORDING_DELETED}. |
| */ |
| @RecordingState |
| public int getState() { |
| return mState; |
| } |
| |
| /** Returns the ID of the {@link SeriesRecording} including this schedule. */ |
| public long getSeriesRecordingId() { |
| return mSeriesRecordingId; |
| } |
| |
| /** Returns the ID of the corresponding {@link RecordedProgram}. */ |
| @Nullable |
| public Long getRecordedProgramId() { |
| return mRecordedProgramId; |
| } |
| |
| /** Returns the failed reason of the {@link ScheduledRecording}. */ |
| @Nullable @RecordingFailedReason |
| public Integer getFailedReason() { |
| return mFailedReason; |
| } |
| |
| public long getId() { |
| return mId; |
| } |
| |
| /** Sets the ID; */ |
| public void setId(long id) { |
| mId = id; |
| } |
| |
| public long getPriority() { |
| return mPriority; |
| } |
| |
| /** Returns season number, episode number and episode title for display. */ |
| public String getEpisodeDisplayTitle(Context context) { |
| if (!TextUtils.isEmpty(mEpisodeNumber)) { |
| String episodeTitle = mEpisodeTitle == null ? "" : mEpisodeTitle; |
| if (TextUtils.equals(mSeasonNumber, "0")) { |
| // Do not show "S0: ". |
| return String.format( |
| context.getResources() |
| .getString(R.string.display_episode_title_format_no_season_number), |
| mEpisodeNumber, |
| episodeTitle); |
| } else { |
| return String.format( |
| context.getResources().getString(R.string.display_episode_title_format), |
| mSeasonNumber, |
| mEpisodeNumber, |
| episodeTitle); |
| } |
| } |
| return mEpisodeTitle; |
| } |
| |
| /** |
| * Returns the program's display title, if the program title is not null, returns program title. |
| * Otherwise returns the channel name. |
| */ |
| public String getProgramDisplayTitle(Context context) { |
| if (!TextUtils.isEmpty(mProgramTitle)) { |
| return mProgramTitle; |
| } |
| Channel channel = |
| TvSingletons.getSingletons(context).getChannelDataManager().getChannel(mChannelId); |
| return channel != null |
| ? channel.getDisplayName() |
| : context.getString(R.string.no_program_information); |
| } |
| |
| /** Converts a string to a @RecordingType int, defaulting to {@link #TYPE_TIMED}. */ |
| private static @RecordingType int recordingType(String type) { |
| switch (type) { |
| case Schedules.TYPE_TIMED: |
| return TYPE_TIMED; |
| case Schedules.TYPE_PROGRAM: |
| return TYPE_PROGRAM; |
| default: |
| SoftPreconditions.checkArgument(false, TAG, "Unknown recording type %s", type); |
| return TYPE_TIMED; |
| } |
| } |
| |
| /** Converts a @RecordingType int to a string, defaulting to {@link Schedules#TYPE_TIMED}. */ |
| private static String recordingType(@RecordingType int type) { |
| switch (type) { |
| case TYPE_TIMED: |
| return Schedules.TYPE_TIMED; |
| case TYPE_PROGRAM: |
| return Schedules.TYPE_PROGRAM; |
| default: |
| SoftPreconditions.checkArgument(false, TAG, "Unknown recording type %s", type); |
| return Schedules.TYPE_TIMED; |
| } |
| } |
| |
| /** |
| * Converts a string to a @RecordingState int, defaulting to {@link |
| * #STATE_RECORDING_NOT_STARTED}. |
| */ |
| private static @RecordingState int recordingState(String state) { |
| switch (state) { |
| case Schedules.STATE_RECORDING_NOT_STARTED: |
| return STATE_RECORDING_NOT_STARTED; |
| case Schedules.STATE_RECORDING_IN_PROGRESS: |
| return STATE_RECORDING_IN_PROGRESS; |
| case Schedules.STATE_RECORDING_FINISHED: |
| return STATE_RECORDING_FINISHED; |
| case Schedules.STATE_RECORDING_FAILED: |
| return STATE_RECORDING_FAILED; |
| case Schedules.STATE_RECORDING_CLIPPED: |
| return STATE_RECORDING_CLIPPED; |
| case Schedules.STATE_RECORDING_DELETED: |
| return STATE_RECORDING_DELETED; |
| case Schedules.STATE_RECORDING_CANCELED: |
| return STATE_RECORDING_CANCELED; |
| default: |
| SoftPreconditions.checkArgument(false, TAG, "Unknown recording state %s", state); |
| return STATE_RECORDING_NOT_STARTED; |
| } |
| } |
| |
| /** |
| * Converts a @RecordingState int to string, defaulting to {@link |
| * Schedules#STATE_RECORDING_NOT_STARTED}. |
| */ |
| private static String recordingState(@RecordingState int state) { |
| switch (state) { |
| case STATE_RECORDING_NOT_STARTED: |
| return Schedules.STATE_RECORDING_NOT_STARTED; |
| case STATE_RECORDING_IN_PROGRESS: |
| return Schedules.STATE_RECORDING_IN_PROGRESS; |
| case STATE_RECORDING_FINISHED: |
| return Schedules.STATE_RECORDING_FINISHED; |
| case STATE_RECORDING_FAILED: |
| return Schedules.STATE_RECORDING_FAILED; |
| case STATE_RECORDING_CLIPPED: |
| return Schedules.STATE_RECORDING_CLIPPED; |
| case STATE_RECORDING_DELETED: |
| return Schedules.STATE_RECORDING_DELETED; |
| case STATE_RECORDING_CANCELED: |
| return Schedules.STATE_RECORDING_CANCELED; |
| default: |
| SoftPreconditions.checkArgument(false, TAG, "Unknown recording state %s", state); |
| return Schedules.STATE_RECORDING_NOT_STARTED; |
| } |
| } |
| |
| /** |
| * Converts a string to a failed reason integer, defaulting to {@link |
| * #FAILED_REASON_OTHER}. |
| */ |
| private static Integer recordingFailedReason(String reason) { |
| if (TextUtils.isEmpty(reason)) { |
| return null; |
| } |
| switch (reason) { |
| case Schedules.FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED: |
| return FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED; |
| case Schedules.FAILED_REASON_NOT_FINISHED: |
| return FAILED_REASON_NOT_FINISHED; |
| case Schedules.FAILED_REASON_SCHEDULER_STOPPED: |
| return FAILED_REASON_SCHEDULER_STOPPED; |
| case Schedules.FAILED_REASON_INVALID_CHANNEL: |
| return FAILED_REASON_INVALID_CHANNEL; |
| case Schedules.FAILED_REASON_MESSAGE_NOT_SENT: |
| return FAILED_REASON_MESSAGE_NOT_SENT; |
| case Schedules.FAILED_REASON_CONNECTION_FAILED: |
| return FAILED_REASON_CONNECTION_FAILED; |
| case Schedules.FAILED_REASON_RESOURCE_BUSY: |
| return FAILED_REASON_RESOURCE_BUSY; |
| case Schedules.FAILED_REASON_INPUT_UNAVAILABLE: |
| return FAILED_REASON_INPUT_UNAVAILABLE; |
| case Schedules.FAILED_REASON_INPUT_DVR_UNSUPPORTED: |
| return FAILED_REASON_INPUT_DVR_UNSUPPORTED; |
| case Schedules.FAILED_REASON_INSUFFICIENT_SPACE: |
| return FAILED_REASON_INSUFFICIENT_SPACE; |
| case Schedules.FAILED_REASON_OTHER: |
| default: |
| return FAILED_REASON_OTHER; |
| } |
| } |
| |
| /** |
| * Converts a failed reason integer to string, defaulting to {@link |
| * Schedules#FAILED_REASON_OTHER}. |
| */ |
| private static String recordingFailedReason(Integer reason) { |
| if (reason == null) { |
| return null; |
| } |
| switch (reason) { |
| case FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED: |
| return Schedules.FAILED_REASON_PROGRAM_ENDED_BEFORE_RECORDING_STARTED; |
| case FAILED_REASON_NOT_FINISHED: |
| return Schedules.FAILED_REASON_NOT_FINISHED; |
| case FAILED_REASON_SCHEDULER_STOPPED: |
| return Schedules.FAILED_REASON_SCHEDULER_STOPPED; |
| case FAILED_REASON_INVALID_CHANNEL: |
| return Schedules.FAILED_REASON_INVALID_CHANNEL; |
| case FAILED_REASON_MESSAGE_NOT_SENT: |
| return Schedules.FAILED_REASON_MESSAGE_NOT_SENT; |
| case FAILED_REASON_CONNECTION_FAILED: |
| return Schedules.FAILED_REASON_CONNECTION_FAILED; |
| case FAILED_REASON_RESOURCE_BUSY: |
| return Schedules.FAILED_REASON_RESOURCE_BUSY; |
| case FAILED_REASON_INPUT_UNAVAILABLE: |
| return Schedules.FAILED_REASON_INPUT_UNAVAILABLE; |
| case FAILED_REASON_INPUT_DVR_UNSUPPORTED: |
| return Schedules.FAILED_REASON_INPUT_DVR_UNSUPPORTED; |
| case FAILED_REASON_INSUFFICIENT_SPACE: |
| return Schedules.FAILED_REASON_INSUFFICIENT_SPACE; |
| case FAILED_REASON_OTHER: // fall through |
| default: |
| return Schedules.FAILED_REASON_OTHER; |
| } |
| } |
| |
| /** Checks if the {@code period} overlaps with the recording time. */ |
| public boolean isOverLapping(Range<Long> period) { |
| return mStartTimeMs < period.getUpper() && mEndTimeMs > period.getLower(); |
| } |
| |
| /** Checks if the {@code schedule} overlaps with this schedule. */ |
| public boolean isOverLapping(ScheduledRecording schedule) { |
| return mStartTimeMs < schedule.getEndTimeMs() && mEndTimeMs > schedule.getStartTimeMs(); |
| } |
| |
| @Override |
| public String toString() { |
| return "ScheduledRecording[" |
| + mId |
| + "]" |
| + "(inputId=" |
| + mInputId |
| + ",channelId=" |
| + mChannelId |
| + ",programId=" |
| + mProgramId |
| + ",programTitle=" |
| + mProgramTitle |
| + ",type=" |
| + mType |
| + ",startTime=" |
| + CommonUtils.toIsoDateTimeString(mStartTimeMs) |
| + "(" |
| + mStartTimeMs |
| + ")" |
| + ",endTime=" |
| + CommonUtils.toIsoDateTimeString(mEndTimeMs) |
| + "(" |
| + mEndTimeMs |
| + ")" |
| + ",seasonNumber=" |
| + mSeasonNumber |
| + ",episodeNumber=" |
| + mEpisodeNumber |
| + ",episodeTitle=" |
| + mEpisodeTitle |
| + ",programDescription=" |
| + mProgramDescription |
| + ",programLongDescription=" |
| + mProgramLongDescription |
| + ",programPosterArtUri=" |
| + mProgramPosterArtUri |
| + ",programThumbnailUri=" |
| + mProgramThumbnailUri |
| + ",state=" |
| + mState |
| + ",failedReason=" |
| + mFailedReason |
| + ",priority=" |
| + mPriority |
| + ",seriesRecordingId=" |
| + mSeriesRecordingId |
| + ")"; |
| } |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel out, int paramInt) { |
| out.writeLong(mId); |
| out.writeLong(mPriority); |
| out.writeString(mInputId); |
| out.writeLong(mChannelId); |
| out.writeLong(mProgramId); |
| out.writeString(mProgramTitle); |
| out.writeInt(mType); |
| out.writeLong(mStartTimeMs); |
| out.writeLong(mEndTimeMs); |
| out.writeString(mSeasonNumber); |
| out.writeString(mEpisodeNumber); |
| out.writeString(mEpisodeTitle); |
| out.writeString(mProgramDescription); |
| out.writeString(mProgramLongDescription); |
| out.writeString(mProgramPosterArtUri); |
| out.writeString(mProgramThumbnailUri); |
| out.writeInt(mState); |
| out.writeString(recordingFailedReason(mFailedReason)); |
| out.writeLong(mSeriesRecordingId); |
| } |
| |
| /** Returns {@code true} if the recording is not started yet, otherwise @{code false}. */ |
| public boolean isNotStarted() { |
| return mState == STATE_RECORDING_NOT_STARTED; |
| } |
| |
| /** Returns {@code true} if the recording is in progress, otherwise @{code false}. */ |
| public boolean isInProgress() { |
| return mState == STATE_RECORDING_IN_PROGRESS; |
| } |
| |
| /** Returns {@code true} if the recording is finished, otherwise @{code false}. */ |
| public boolean isFinished() { |
| return mState == STATE_RECORDING_FINISHED; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (!(obj instanceof ScheduledRecording)) { |
| return false; |
| } |
| ScheduledRecording r = (ScheduledRecording) obj; |
| return mId == r.mId |
| && mPriority == r.mPriority |
| && mChannelId == r.mChannelId |
| && mProgramId == r.mProgramId |
| && Objects.equals(mProgramTitle, r.mProgramTitle) |
| && mType == r.mType |
| && mStartTimeMs == r.mStartTimeMs |
| && mEndTimeMs == r.mEndTimeMs |
| && Objects.equals(mSeasonNumber, r.mSeasonNumber) |
| && Objects.equals(mEpisodeNumber, r.mEpisodeNumber) |
| && Objects.equals(mEpisodeTitle, r.mEpisodeTitle) |
| && Objects.equals(mProgramDescription, r.getProgramDescription()) |
| && Objects.equals(mProgramLongDescription, r.getProgramLongDescription()) |
| && Objects.equals(mProgramPosterArtUri, r.getProgramPosterArtUri()) |
| && Objects.equals(mProgramThumbnailUri, r.getProgramThumbnailUri()) |
| && mState == r.mState |
| && Objects.equals(mFailedReason, r.mFailedReason) |
| && mSeriesRecordingId == r.mSeriesRecordingId; |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash( |
| mId, |
| mPriority, |
| mChannelId, |
| mProgramId, |
| mProgramTitle, |
| mType, |
| mStartTimeMs, |
| mEndTimeMs, |
| mSeasonNumber, |
| mEpisodeNumber, |
| mEpisodeTitle, |
| mProgramDescription, |
| mProgramLongDescription, |
| mProgramPosterArtUri, |
| mProgramThumbnailUri, |
| mState, |
| mFailedReason, |
| mSeriesRecordingId); |
| } |
| |
| /** Returns an array containing all of the elements in the list. */ |
| public static ScheduledRecording[] toArray(Collection<ScheduledRecording> schedules) { |
| return schedules.toArray(new ScheduledRecording[schedules.size()]); |
| } |
| } |
