Skip to content

Most visited

Recently visited


Supporting Content Recording

TV input services let the user pause and resume channel playback via time-shifting APIs. Android 7.0 expands on time-shifting by letting the user save multiple recorded sessions.

Users can schedule recordings in advance, or start a recording as they watch a program. Once the system has saved a recording, the user can browse, manage, and play back the recording using the system TV app.

If you want to provide recording functionality for your TV input service, you must indicate to the system that your app supports recording, implement the ability to record programs, handle and communicate any errors that occur during recording, and manage your recorded sessions.

Indicating Support for Recording

To tell the system that your TV input service supports recording, set the android:canRecord attribute in your service metadata XML file to true:

<tv-input xmlns:android=""
  android:setupActivity="com.example.sampletvinput.SampleTvInputSetupActivity" />

For more information on the service metadata file, see Declare Your TV Input Service in the Manifest.

Alternatively, you can indicate recording support in your code using these steps:

  1. In your TV input service onCreate() method, create a new TvInputInfo object using the TvInputInfo.Builder class.
  2. When creating the new TvInputInfo object, call setCanRecord(true) before calling build() to indicate your service supports recording.
  3. Register your TvInputInfo object with the system by calling TvInputManager.updateTvInputInfo().

Recording a Session

After your TV input service registers that it supports recording functionality, the system calls your TvInputService.onCreateRecordingSession() method when it needs to access your app's recording implementation. Implement your own TvInputService.RecordingSession subclass and return it when the onCreateRecordingSession() callback fires. This subclass is responsible for switching to the correct channel data, recording the requested data, and communicating recording status and errors to the system.

When the system calls RecordingSession.onTune(), passing in a channel URI, tune to the channel that the URI specifies. Notify the system that your app has tuned to the desired channel by calling notifyTuned() or, if your app could not tune to the proper channel, call notifyError().

The system next invokes the RecordingSession.onStartRecording() callback. Your app must start recording immediately. When the system invokes this callback, it may provide a URI that contains information about the program that is about to be recorded. When the recording is done, you'll copy this data to the RecordedPrograms data table.

Finally, the system calls RecordingSession.onStopRecording(). At this point, your app must stop recording immediately. You also need to create an entry in the RecordedPrograms table. This entry should include the recorded session data URI in the RecordedPrograms.COLUMN_RECORDING_DATA_URI column, and any program information that the system provided in the initial call to onStartRecording().

For more details on how to access the RecordedPrograms table see Managing Recorded Sessions.

Handling Recording Errors

If an error occurs during recording, resulting in unusable recorded data, notify the system by calling notifyError(). Similarly, you can call notifyError() after a recording session is created to let the system know that your app can no longer record sessions.

If an error occurs during recording, but you'd like to provide a partial recording to users for playback, call notifyRecordingStopped() to enable the system to use the partial session.

Managing Recorded Sessions

The system maintains information for all recorded sessions from all recording-capable channel apps in the RecordedPrograms content provider table. This information is accessible via the RecordedPrograms content recording URIs. Use content provider APIs to read, add, and delete entries from this table.

For more information on working with content provider data see Content Provider Basics.

Best Practices

TV devices may have limited storage, so use your best judgment when allocating storage to save recorded sessions. Use RecordingCallback.onError(RECORDING_ERROR_INSUFFICIENT_SPACE) when there isn't enough space to save a recorded session.

When the user initiates recording, you should start recording data as soon as possible. To facilitate this, complete any up-front time-consuming tasks, like accessing and allocating storage space, when the system invokes the onCreateRecordingSession() callback. Doing so lets you start recording immediately when the onStartRecording() callback fires.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields


Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience. (April 2018 — Developer Survey)