<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ 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.
  -->

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="font" translatable="false">sans-serif</string>
    <string name="light_font" translatable="false">sans-serif-light</string>
    <string name="thin_font" translatable="false">sans-serif-thin</string>
    <string name="condensed_font" translatable="false">sans-serif-condensed</string>

    <string name="option_item_text_font" translatable="false">@string/condensed_font</string>
    <string name="option_item_secondary_text_font" translatable="false">@string/condensed_font</string>

    <string name="option_item_divider_font" translatable="false">@string/condensed_font</string>

    <!-- Name of application [CHAR LIMIT=NONE] -->
    <string name="app_name" translatable="false">Live TV</string>

    <!-- Title of an application permission, listed so the user can choose
        whether they want to allow the application to do this. -->
    <string name="permlab_receiveInputEvent" translatable="false">receive input events from <xliff:g id="app_name">Live TV</xliff:g>  app</string>
    <!-- Description of an application permission, listed so the user can choose
        whether they want to allow the application to do this. -->
    <string name="permdesc_receiveInputEvent" translatable="false">Allows the app to receive input events from <xliff:g id="app_name">Live TV</xliff:g>  app</string>
    <!-- Title of an application permission, listed so the user can choose
        whether they want to allow the application to do this. -->
    <string name="permlab_customizeTvApp" translatable="false">customize <xliff:g id="app_name">Live TV</xliff:g>  app</string>
    <!-- Description of an application permission, listed so the user can choose
        whether they want to allow the application to do this. -->
    <string name="permdesc_customizeTvApp" translatable="false">Allows the app to customize <xliff:g id="app_name">Live TV</xliff:g>  app</string>

    <!-- Program information, mainly used for channel banner and program guide. -->
    <eat-comment />
    <!-- Mark for closed caption when a program has closed caption tracks -->
    <string name="closed_caption" translatable="false">CC</string>
    <!-- Mark indicating that the current program has ultra-high-definition video. -->
    <string name="video_definition_level_ultra_hd" translatable="false">Ultra HD</string>
    <!-- Mark indicating that the current program has full-high-definition video. -->
    <string name="video_definition_level_full_hd" translatable="false">Full HD</string>
    <!-- Mark indicating that the current program has high-definition video. -->
    <string name="video_definition_level_hd" translatable="false">HD</string>
    <!-- Mark indicating that the current program has standard-definition video.  -->
    <string name="video_definition_level_sd" translatable="false">SD</string>
    <!-- Mark indicating that the current program has only one audio channel (mono).
         [CHAR LIMIT=8] -->
    <string name="audio_channel_mono">mono</string>
    <!-- Mark indicating that the current program has two audio channels (stereo).
         [CHAR LIMIT=8] -->
    <string name="audio_channel_stereo">stereo</string>
    <!-- Mark indicating that the current program has 5.1 surround audio channels. -->
    <string name="audio_channel_5_1" translatable="false">5.1</string>
    <!-- Mark indicating that the current program has 7.1 surround audio channels. -->
    <string name="audio_channel_7_1" translatable="false">7.1</string>

    <!-- Title of the play controls row in the main menu.
         The play means a playback of video and audio. [CHAR LIMIT=NONE] -->
    <string name="menu_title_play_controls">Play controls</string>
    <!-- Title of the channels row in the main menu. [CHAR LIMIT=NONE] -->
    <string name="menu_title_channels">Channels</string>
    <!-- Title of the TV option row in the main menu. [CHAR LIMIT=NONE] -->
    <string name="menu_title_options">TV options</string>

    <!-- Play speed of 2X, 3X, 4X, 5X -->
    <string name="play_controls_speed" translatable="false">%1$dX</string>
    <!-- Message when the trick play is not available [CHAR LIMIT=NONE] -->
    <string name="play_controls_unavailable">Play controls unavailable for this channel</string>
    <!-- Description of the Play Pause button on the play controls. -->
    <string name="play_controls_description_play_pause">Play or pause</string>
    <!-- Description of the Fast Forward button on the play controls. -->
    <string name="play_controls_description_fast_forward">Fast forward</string>
    <!-- Description of the Rewind button on the play controls. -->
    <string name="play_controls_description_fast_rewind">Rewind</string>
    <!-- Description of the Next button on the play controls. -->
    <string name="play_controls_description_skip_next">Next</string>
    <!-- Description of the Previous button on the play controls. -->
    <string name="play_controls_description_skip_previous">Previous</string>

    <!-- Label of Program guide item in the channel list row. [CHAR LIMIT=23] -->
    <string name="channels_item_program_guide">Program guide</string>
    <!-- Label of the item in the "channel menu" that changes the current TV channel in the "up"
         direction, to the next larger channel number. [CHAR LIMIT=23] -->
    <string name="channels_item_up">Channel up</string>
    <!-- Label of the item in the "channel menu" that changes the current TV channel in the "down"
         direction, to the next smaller channel number. [CHAR LIMIT=23] -->
    <string name="channels_item_down">Channel down</string>
    <!-- Label of setup item in the channel list row. The item is shown only
         when new inputs are installed. [CHAR LIMIT=23] -->
    <string name="channels_item_setup">New channels available</string>
    <!-- Label of the app link card used for Google analytics. -->
    <string name="channels_item_app_link" translatable="false">App link</string>
    <!-- Label of app link card for launching app in the channel list row. [CHAR LIMIT=NONE] -->
    <string name="channels_item_app_link_app_launcher">Open <xliff:g id="app_name" example="YouTube">%1$s</xliff:g></string>

    <!-- Label of "Closed captions" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_closed_caption">Closed captions</string>
    <!-- Label of "Display mode" item in the TV option row. Inside display mode,
         there are three items: Full, Normal, Zoom. [CHAR LIMIT=17] -->
    <string name="options_item_display_mode">Display mode</string>
    <!-- Label of "PIP (Picture in picture)" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_pip">PIP</string>
    <!-- Label of "Multi audio" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_multi_audio">Multi-audio</string>
    <!-- Label of "Get more channels" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_more_channels">Get more channels</string>
    <!-- Label of "Developer Options" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_developer" translatable="false">Developer options</string>
    <!-- Label of "Settings" item in the TV option row. [CHAR LIMIT=17] -->
    <string name="options_item_settings">Settings</string>

    <!-- Label of a unified input for tuner type inputs. [CHAR LIMIT=30] -->
    <string name="input_long_label_for_tuner">TV (antenna/cable)</string>

    <!-- Default program name when there is no program title. [CHAR LIMIT=30] -->
    <string name="no_program_information">No program information</string>

    <!-- Program title for no information. [CHAR LIMIT=23] -->
    <string name="program_title_for_no_information">No information</string>
    <!-- Program title for blocked channel [CHAR LIMIT=23] -->
    <string name="program_title_for_blocked_channel">Blocked channel</string>

    <!-- Default string for unknown language used in "Multi Audio" options. [CHAR LIMIT=30] -->
    <string name="multi_audio_unknown_language">Unknown language</string>

    <!-- Default string for unknown language used in "Closed Caption" options. [CHAR LIMIT=30] -->
    <string name="closed_caption_unknown_language">Closed captions <xliff:g id="unknown_language_index" example="1">%1$d</xliff:g></string>

    <!-- Inside "Closed captions" option side panel -->
    <eat-comment />
    <!-- Title of "Closed captions" option. [CHAR LIMIT=30] -->
    <string name="side_panel_title_closed_caption">Closed captions</string>
    <!-- Label of an option item for Closed Caption "off" [CHAR LIMIT=30] -->
    <string name="closed_caption_option_item_off">Off</string>
    <!-- Label of an option item to launch system closed caption settings [CHAR LIMIT=30] -->
    <string name="closed_caption_system_settings">Customize formatting</string>
    <!-- Description for "System Caption Settings" option [CHAR LIMIT=NONE] -->
    <string name="closed_caption_system_settings_description">Set system-wide preferences for closed captions</string>

    <!-- Inside "Display Mode" option side panel -->
    <eat-comment />
    <!-- Title of "Display Mode" option. It has three items: Normal, Full, Zoom. [CHAR LIMIT=30]-->
    <string name="side_panel_title_display_mode">Display mode</string>

    <!-- Inside "Multi Audio" option side panel -->
    <eat-comment />
    <!-- Title of "Multi-Audio" option. [CHAR LIMIT=30] -->
    <string name="side_panel_title_multi_audio">Multi-audio</string>
    <!-- Format of "Multi-Audio" item. E.g.) English (stereo) -->
    <string name="multi_audio_display_string_with_channel" translatable="false">%1$s (%2$s)</string>
    <!-- Label of audio track with one audio channel [CHAR LIMIT=30] -->
    <string name="multi_audio_channel_mono">mono</string>
    <!-- Label of audio track with two audio channels [CHAR LIMIT=30] -->
    <string name="multi_audio_channel_stereo">stereo</string>
    <!-- Label of audio track with six audio channels [CHAR LIMIT=30] -->
    <string name="multi_audio_channel_surround_6">5.1 surround</string>
    <!-- Label of audio track with eight audio channels [CHAR LIMIT=30] -->
    <string name="multi_audio_channel_surround_8">7.1 surround</string>
    <!-- Label of audio track with other audio channels than 1, 2, 6, and 8 [CHAR LIMIT=30] -->
    <string name="multi_audio_channel_suffix"><xliff:g id="audio_channel_count" example="5">%d</xliff:g> channels</string>

    <!-- Inside "Edit Channels for a specific input" option side panel -->
    <eat-comment />
    <!-- Title of "Edit channels" option. [CHAR LIMIT=30] -->
    <string name="side_panel_title_edit_channels_for_an_input">Customize channel list</string>
    <!-- Label of "Select group" item to make all channels of a group enabled. The group can
         be a channel source or video quality like HD or SD. [CHAR LIMIT=30] -->
    <string name="edit_channels_item_select_group">Select group</string>
    <!-- Label of "Deselect group" item to make all channels of a group disabled. The group can
         be a channel source or video quality like HD or SD. [CHAR LIMIT=30] -->
    <string name="edit_channels_item_deselect_group">Deselect group</string>
    <!-- Label of "Group by" item to regroup channels [CHAR LIMIT=30] -->
    <string name="edit_channels_item_group_by">Group by</string>
    <!-- Type of grouping by channel source [CHAR LIMIT=30] -->
    <string name="edit_channels_group_by_sources">Channel source</string>
    <!-- Type of grouping by video quality [CHAR LIMIT=30] -->
    <string name="edit_channels_group_by_hd_sd">HD/SD</string>
    <!-- Subheader of HD channel group [CHAR LIMIT=30] -->
    <string name="edit_channels_group_divider_for_hd">HD</string>
    <!-- Subheader of SD channel group [CHAR LIMIT=40] -->
    <string name="edit_channels_group_divider_for_sd">SD</string>
    <!-- Title of "Group by" side panel to set grouping type [CHAR LIMIT=30] -->
    <string name="side_panel_title_group_by">Group by</string>

    <!-- Inside full EPG -->
    <eat-comment />
    <!-- Description in the TV guide when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="program_guide_content_locked">This program is blocked</string>
    <!-- Description in the TV guide when the current content is unrated and it's restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="program_guide_content_locked_unrated">This program is unrated</string>
    <!-- Description in the TV guide with the rating when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="program_guide_content_locked_format">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g></string>

    <!-- Message when a channel item is clicked for channel auto-scan, but the input doesn't
         have auto-scan function. [CHAR LIMIT=NONE] -->
    <string name="msg_no_setup_activity">The input doesn\'t support auto-scan</string>
    <!-- Error message when Live TV app cannnot launch auto-scan activity due to the wrong information
         from the input. [CHAR LIMIT=NONE] -->
    <string name="msg_unable_to_start_setup_activity">Unable to start auto-scan for \'<xliff:g id="tv_input" example="Built-in Tuner">%s</xliff:g>\'</string>
    <!-- Error message when Live TV app cannnot launch the system-wide preferences for closed captions. [CHAR LIMIT=NONE] -->
    <string name="msg_unable_to_start_system_captioning_settings">Unable to start the system-wide preferences for closed captions.</string>
    <!-- Message after some channels are added. [CHAR LIMIT=NONE] -->
    <plurals name="msg_channel_added">
        <item quantity="one">%1$d channel added</item>
        <item quantity="other">%1$d channels added</item>
    </plurals>
    <!-- Message after no channel is added after setting up an input. [CHAR LIMIT=NONE] -->
    <string name="msg_no_channel_added">No channels added</string>

    <!-- Parental control -->
    <eat-comment />
    <!-- Title of "Parental Contrals" option. [CHAR LIMIT=30] -->
    <string name="menu_parental_controls">Parental controls</string>
    <!-- Label in On state of On/Off switch for "Parental Contrals" option. [CHAR LIMIT=30] -->
    <string name="option_toggle_parental_controls_on">On</string>
    <!-- Label in Off state of On/Off switch for "Parental Contrals" option. [CHAR LIMIT=30] -->
    <string name="option_toggle_parental_controls_off">Off</string>
    <!-- Item and title of "Channels blocked" option. This option provides an interface for parents
         to block/unblock channels that are not suitable for their children. [CHAR LIMIT=30] -->
    <string name="option_channels_locked">Channels blocked</string>
    <!-- Label of an item to lock all channels. [CHAR LIMIT=30] -->
    <string name="option_channels_lock_all">Block all</string>
    <!-- Label of an item to unlock all channels. [CHAR LIMIT=30] -->
    <string name="option_channels_unlock_all">Unblock all</string>
    <!-- Subheader below a divider to separate hidden channels from visible channels. Visible
         channels appear first in the list and this divider comes, followed by hidden channels.
         [CHAR LIMIT=30] -->
    <string name="option_channels_subheader_hidden">Hidden channels</string>
    <!-- Item and title of "Program restrictions" option. It has two items: Rating Systems
         and Ratings [CHAR LIMIT=30] -->
    <string name="option_program_restrictions">Program restrictions</string>
    <string name="option_change_pin">Change PIN</string>
    <!-- Item and title of "Rating Systems" option. In this option, a user can choose the rating
         system per country listed [CHAR LIMIT=30] -->
    <string name="option_country_rating_systems">Rating systems</string>
    <!-- Item and title of "Rating Systems" option. In this option, after choosing a rating system,
         a user selects the actual rating to be restricted. [CHAR LIMIT=30] -->
    <string name="option_ratings">Ratings</string>
    <!-- Label of an item to show all rating systems in the system. [CHAR LIMIT=30] -->
    <string name="option_see_all_rating_systems">See all rating systems</string>
    <!-- Display country name for rating systems used in multiple countries.
         [CHAR LIMIT=30] -->
    <string name="other_countries">Other countries</string>

    <!-- Description below "Channel Locked" item when there is no locked channel.
         [CHAR LIMIT=NONE] -->
    <string name="option_no_locked_channel">None</string>
    <!-- Description below "Program Restrictions" item when there is no locked channel.
         [CHAR LIMIT=NONE] -->
    <string name="option_no_enabled_rating_system">None</string>

    <!-- Display name of unrated rating -->
    <string name="unrated_rating_name">Unrated</string>

    <!-- Label of an item to block unrated programs. [CHAR LIMIT=30] -->
    <string name="option_block_unrated_programs">Block unrated programs</string>

    <!-- Label of an item not to select any restriction. [CHAR LIMIT=30] -->
    <string name="option_rating_none">None</string>
    <!-- Label of an item to select high restriction. [CHAR LIMIT=30] -->
    <string name="option_rating_high">High restrictions</string>
    <!-- Label of an item to select medium restriction. [CHAR LIMIT=30] -->
    <string name="option_rating_medium">Medium restrictions</string>
    <!-- Label of an item to select low restriction. [CHAR LIMIT=30] -->
    <string name="option_rating_low">Low restrictions</string>
    <!-- Label of an item to select custom restriction. In the restriction, a user
         can finely tune the restriction with rating details. [CHAR LIMIT=30] -->
    <string name="option_rating_custom">Custom</string>

    <!-- The description used for high restrictions. [CHAR LIMIT=NONE] -->
    <string name="option_rating_high_description">Content suitable for children</string>
    <!-- The description used for medium restrictions. [CHAR LIMIT=NONE] -->
    <string name="option_rating_medium_description">Content suitable for older children</string>
    <!-- The description used for low restrictions. [CHAR LIMIT=NONE] -->
    <string name="option_rating_low_description">Content suitable for teens</string>
    <!-- The description used for custom restrictions. [CHAR LIMIT=NONE] -->
    <string name="option_rating_custom_description">Manual restrictions</string>

    <!-- Attribution text shown at the end of the 'Ratings' menu. It indicates where those rating
         descriptions come from. [CHAR LIMIT=NONE] -->
    <string name="option_attribution">Sources for rating descriptions</string>

    <!-- Title of the menu where the user can select sub-ratings settings. Sub-ratings can be added
         to the basic rating to let parents know additional information about the TV program such as
         drug, violence, nudity, sex and coarse language. [CHAR LIMIT=30] -->
    <string name="option_subrating_title">%1$s and sub-ratings</string>
    <!-- Header of the divider in the sub-ratings menu. Sub-ratings can be added to the basic rating
         to let parents know additional information about the TV program such as drug, violence,
         nudity, sex and coarse language. [CHAR LIMIT=30] -->
    <string name="option_subrating_header">Sub-ratings</string>

    <!-- PIN UX -->
    <eat-comment />
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock channel.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_unlock_channel">Enter your PIN to watch this channel</string>
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock program.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_unlock_program">Enter your PIN to watch this program</string>
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock DVR playback.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_unlock_dvr">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g>. Enter your PIN to watch this program</string>
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock unrated DVR playback.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_unlock_dvr_unrated">This program is unrated. Enter your PIN to watch this program</string>
    <!-- Title of PIN dialog when an user tries to change Parental control setting.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_pin">Enter your PIN</string>
    <!-- Title of PIN dialog when an user is asked to set a PIN for the first time.
         [CHAR LIMIT=NONE] -->
    <string name="pin_enter_create_pin">To set parental controls, create a PIN</string>
    <!-- Title of PIN dialog when an user is asked to change PIN [CHAR LIMIT=NONE] -->
    <string name="pin_enter_new_pin">Enter new PIN</string>
    <!-- Title of PIN dialog when an user is asked to set a PIN. [CHAR LIMIT=NONE] -->
    <string name="pin_enter_again">Confirm your PIN</string>
    <!-- Title of PIN dialog when an user is about to change older PIN. [CHAR LIMIT=NONE] -->
    <string name="pin_enter_old_pin">Enter your current PIN</string>
    <!-- Message shown in the dialog when the user entered the wrong. [CHAR LIMIT=NONE] -->
    <plurals name="pin_enter_countdown">
        <item quantity="one">You entered the wrong PIN 5 times.\nTry again in <xliff:g id="remaining_seconds" example="1">%1$d</xliff:g> second.</item>
        <item quantity="other">You entered the wrong PIN 5 times.\nTry again in <xliff:g id="remaining_seconds" example="60">%1$d</xliff:g> seconds.</item>
    </plurals>
    <!-- Toast message when an user entered wrong PIN. [CHAR LIMIT=NONE] -->
    <string name="pin_toast_wrong">That PIN was wrong. Try again.</string>
    <!-- Toast message when an user couldn't pass the PIN confirmation. [CHAR LIMIT=NONE] -->
    <string name="pin_toast_not_match">Try again, PIN doesn\'t match</string>

    <!-- menu for "Settings" option -->
    <eat-comment />
    <!--  Title of "Settings" option. [CHAR LIMIT=30] -->
    <string name="side_panel_title_settings">Settings</string>
    <!-- Label of "Customize channels list" item to select and deselect channels.
         [CHAR LIMIT=30] -->
    <string name="settings_channel_source_item_customize_channels">Customize channel list</string>
    <!-- Description of "Customize channels list" item. [CHAR LIMIT=NONE] -->
    <string name="settings_channel_source_item_customize_channels_description">Choose channels for your program guide</string>
    <!-- Label of "Channel sources" item to setup channels. [CHAR LIMIT=30] -->
    <string name="settings_channel_source_item_setup">Channel sources</string>
    <!-- Description of "Channel sources" item only when new inputs are available.
         [CHAR LIMIT=NONE] -->
    <string name="settings_channel_source_item_setup_new_inputs">New channels available</string>
    <!-- Label of "Parental controls" item. [CHAR LIMIT=30] -->
    <string name="settings_parental_controls">Parental controls</string>
    <!-- Label of "Timeshift" item. Record while watching so you can pause or rewind live
         programs.-->
    <string name="settings_trickplay">Timeshift</string>
    <!-- Description of "Timeshift" item. This explains what is 'Timeshift' to users. Also warns of
         the effect of enabling the option. -->
    <string name="settings_trickplay_description">Record while watching so you can pause or rewind live programs.\nWarning: This may decrease the life of the internal storage by the intensive use of the storage.</string>
    <!-- Menu item to show licenses for open source code used in the app [CHAR LIMIT=35] -->
    <string name="settings_menu_licenses">Open source licenses</string>
    <!-- Menu item to send feedback [CHAR LIMIT=30] -->
    <string name="settings_send_feedback">Send feedback</string>
    <!-- Menu item that shows the application version(eg 1.2.03-final) as a second line below this title [CHAR LIMIT=35] -->
    <string name="settings_menu_version">Version</string>

    <!-- opt out preferences -->
    <eat-comment />

    <!-- TunableTvView -->
    <eat-comment />
    <!-- Description on the locked screen when current channel is locked by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_channel_locked">To watch this channel, press Right and enter your PIN</string>
    <!-- Description on the locked screen when current channel is locked by parental control and talk back is turned on.
        "press select" refers to a button on the remote.  [CHAR LIMIT=NONE] -->
    <string name="tvview_channel_locked_talkback">To watch this channel, press select and enter your PIN</string>
    <!-- Description on the locked screen when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked">To watch this program, press Right and enter your PIN</string>
    <!-- Description on the locked screen when the rating of the current content is restricted by parental control and talk back is turned on.
     "press select" refers to a button on the remote.[CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_talkback">To watch this program, press select and enter your PIN</string>
    <!-- Description on the locked screen when the current content is unrated and it's restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_unrated">This program is unrated.\nTo watch this program, press Right and enter your PIN</string>
    <!-- Description on the locked screen when the current content is unrated and it's restricted by parental control and talk back is turned on.
    "press select" refers to a button on the remote.[CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_unrated_talkback">This program is unrated.\nTo watch this program, press select and enter your PIN</string>
    <!-- Description on the locked screen with the rating when the rating of the current content is restricted by parental control and talk back is turned on. [CHAR LIMIT=NONE]
     "press select" refers to a button on the remote.-->
    <string name="tvview_content_locked_format_talkback">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g>.\nTo watch this program, press select and enter your PIN.</string>
    <!-- Description on the locked screen with the rating when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_format">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g>.\nTo watch this program, press Right and enter your PIN.</string>
    <!-- Description on the locked screen when current channel is locked by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_channel_locked_no_permission">To watch this channel, use the default Live TV app.</string>
    <!-- Description on the locked screen when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_no_permission">To watch this program, use the default Live TV app.</string>
    <!-- Description on the locked screen when the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_unrated_no_permission">This program is unrated.\nTo watch this program, use the default Live TV app.</string>
    <!-- Description on the locked screen with the rating when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="tvview_content_locked_format_no_permission">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g>.\nTo watch this program, use the default Live TV app.</string>

    <!-- Description on the locked screen when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="shrunken_tvview_content_locked">Program is blocked</string>
    <!-- Description on the locked screen with the rating when the current content is unrated and it's restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="shrunken_tvview_content_locked_unrated">This program is unrated</string>
    <!-- Description on the locked screen with the rating when the rating of the current content is restricted by parental control. [CHAR LIMIT=NONE] -->
    <string name="shrunken_tvview_content_locked_format">This program is rated <xliff:g id="rating" example="TV_MA">%1$s</xliff:g></string>

    <!-- The text message which is shown when the current program is audio only one.
         i.e. The program doesn't have a video. [CHAR LIMIT=NONE] -->
    <string name="tvview_msg_audio_only">Audio only</string>
    <!-- Message displayed when current channel's signal is too weak to use. [CHAR LIMIT=NONE] -->
    <string name="tvview_msg_weak_signal">Weak signal</string>
    <!-- The text message which is shown when the internet connection fails.
         This message is shown at the center of the screen. [CHAR LIMIT=NONE] -->
    <string name="tvview_msg_no_internet_connection">No internet connection</string>
    <!-- The text message which is shown when the tune fails due to no available tuners.
         This message is shown at the center of the screen. [CHAR LIMIT=NONE] -->
    <plurals name="tvview_msg_input_no_resource">
        <item quantity="one">This channel can\'t be played until <xliff:g id="end_time" example="9:30 PM">%1$s</xliff:g> because another channel is being recorded.
\n\nPress Right to adjust recording schedule.</item>
        <item quantity="other">This channel can\'t be played until <xliff:g id="end_time" example="9:30 PM">%1$s</xliff:g> because other channels are being recorded.
\n\nPress Right to adjust recording schedule.</item>
    </plurals>

    <!-- Channel Banner -->
    <eat-comment />
    <!-- The text used when there is no program title. [CHAR LIMIT=NONE] -->
    <string name="channel_banner_no_title">No title</string>
    <!-- The text used when a channel is locked and program title needs to be hidden. [CHAR LIMIT=NONE] -->
    <string name="channel_banner_locked_channel_title">Channel blocked</string>

    <!-- Setup Sources Fragment -->
    <eat-comment />
    <!-- Category name for the newly installed channel sources(inputs).-->
    <string name="setup_category_new">New</string>
    <!-- Category name for the installed channel sources(inputs). -->
    <string name="setup_category_done">Sources</string>
    <!-- Description of an input to describe its channel count. [CHAR LIMIT=40] -->
    <plurals name="setup_input_channels">
        <item quantity="one">%1$d channel</item>
        <item quantity="other">%1$d channels</item>
    </plurals>
    <!-- Description of an input with 0 channels. [CHAR LIMIT=40] -->
    <string name="setup_input_no_channels">No channels available</string>
    <!-- Description of newly installed inputs. [CHAR LIMIT=40] -->
    <string name="setup_input_new">New</string>
    <!-- Description of an input which was installed but not setup yet. [CHAR LIMIT=40] -->
    <string name="setup_input_setup_now">Not set up</string>
    <!-- Title for the link to the online store to get more channel sources. -->
    <string name="setup_store_action_title">Get more sources</string>
    <!-- Description for the link to the online store to get more channel sources. -->
    <string name="setup_store_action_description">Browse apps that offer live channels</string>

    <!-- New Sources Fragment -->
    <eat-comment />
    <!-- Title for the new sources fragment -->
    <string name="new_sources_title">New channel sources available</string>
    <!-- Description for the new sources fragment -->
    <string name="new_sources_description">New channel sources have channels to offer.\nSet them up now, or do this later in the channel sources setting.</string>
    <!-- String for the "Set up now" action -->
    <string name="new_sources_action_setup">Set up now</string>
    <!-- String for the "skip" action -->
    <string name="new_sources_action_skip">Ok, got it</string>

    <!-- Intro dialog -->
    <eat-comment />
    <string name="intro_title">@string/app_name</string>
    <!-- Description of Intro Dialog [CHAR LIMIT=NONE] -->
    <string name="intro_description"><b>Press SELECT</b> to access the TV menu.</string>

    <!-- Toast messages -->
    <eat-comment />
    <!-- Error message when there is no TV input. [CHAR LIMIT=NONE] -->
    <string name="msg_no_input">No TV input found</string>
    <!-- Error message when a specific TV input isn't installed. [CHAR LIMIT=NONE] -->
    <string name="msg_no_specific_input">Cannot find the TV input</string>
    <!-- Error message when the selected TV input is a tuner type TV input, not a pass-through type
         input. Tuner type inputs such as built-in tuner, external usb tuner, network tuner or
         virtual IPTV tuner provide live channels to tune to. As opposed to tuner type input,
         pass-through type inputs such as HDMI, component, S-video, DVI or display port merely pass
         the source video through to the display and don't provide ability to tune to a specific
         channel unless the user directly controls the external source device (e.g. game console,
         DVD player, settop box, etc) that is connected to the TV. [CHAR LIMIT=NONE] -->
    <string name="msg_not_passthrough_input">Tuner type not suitable. Please launch <xliff:g id="app_name">Live TV</xliff:g>  app for tuner type TV input.</string>
    <!-- Error message when tune is failed. [CHAR LIMIT=NONE] -->
    <string name="msg_tune_failed">Tune failed</string>
    <!-- Error message when the user attempts an action (select TIS setup-activity, app-link,
         custom options, etc.) and no application was found that could perform the action.
         [CHAR LIMIT=NONE] -->
    <string name="msg_missing_app">No app was found to handle this action.</string>
    <!-- Message when all channels are hidden. [CHAR LIMIT=NONE] -->
    <string name="msg_all_channels_hidden">All source channels are hidden.\nSelect at least one channel to watch.</string>
    <!-- Message displayed when availability is changed by unknown reason. [CHAR LIMIT=NONE] -->
    <string name="msg_channel_unavailable_unknown">The video is unexpectedly unavailable</string>
    <!-- Message to notify the different use of Back Button: Home Button(To exit) Back button
         (commands for external device)  [CHAR LIMIT=NONE] -->
    <string name="msg_back_key_guide">BACK key is for connected device. Press HOME button to exit.</string>
    <!-- Error message when a user denied to grant READ_TV_LISTING permission. [CHAR LIMIT=NONE] -->
    <string name="msg_read_tv_listing_permission_denied"><xliff:g id="app_name">Live TV</xliff:g>  needs permission to read the TV listings.</string>

    <!-- Strings for debug or not to be shown to users -->
    <eat-comment />
    <!-- Debug Options -->
    <string name="menu_developer_options" translatable="false">Developer options</string>
    <string name="dev_item_watch_history" translatable="false">Watch history</string>
    <string name="dev_item_dvr_history" translatable="false">DVR history</string>
    <string name="dev_item_fetch_epg" translatable="false">Fetch program guide</string>
    <string name="dev_item_store_ts_on" translatable="false">Store TS for debugging: On</string>
    <string name="dev_item_store_ts_off" translatable="false">Store TS for debugging: Off</string>
    <string name="dev_item_store_ts_description" translatable="false">Store some TS data before exceptions/crash for debugging.</string>
    <string name="dev_item_show_performance_monitor_log" translatable="false">Show performance log</string>

    <!-- The state of the schedules which is in DVR history. -->
    <string name="dvr_history_dialog_state_fail" translatable="false">[Fail]</string>
    <string name="dvr_history_dialog_state_success" translatable="false">[Success]</string>
    <string name="dvr_history_dialog_state_clip" translatable="false">[Clip]</string>

    <!-- Title of Recently watched dialog. It is used for debug purpose. -->
    <string name="recently_watched" translatable="false">Recently watched</string>

    <!-- Title of DVR history dialog. -->
    <string name="dvr_history_dialog_title" translatable="false">DVR history</string>

    <!-- Display name of DVR recording service's notification channel. -->
    <string name="dvr_notification_channel_name" translatable="false"><xliff:g id="app_name">Live TV</xliff:g>  DVR</string>
    <!-- Content title of DVR recording service's notification. -->
    <string name="dvr_notification_content_title" translatable="false"><xliff:g id="app_name">Live TV</xliff:g>  DVR</string>
    <!-- Content text of DVR recording service's notification during recording. -->
    <string name="dvr_notification_content_text_recording" translatable="false"><xliff:g id="app_name">Live TV</xliff:g>  are recording.</string>
    <!-- Content text of DVR recording service's notification during updating schedules. -->
    <string name="dvr_notification_content_text_loading" translatable="false"><xliff:g id="app_name">Live TV</xliff:g>  are updating recording schedules.</string>

    <!-- Default content title of tuner installing notifications. -->
    <string name="tuner_install_notification_content_title" translatable="false">Install <xliff:g id="tuner_package" example="Tuner package">%s</xliff:g></string>
    <!-- Default application name for tuner installing notifications. -->
    <string name="tuner_install_default_application_name" translatable="false">Tuner Package</string>
    <!-- Default content text of tuner installing notifications. -->
    <string name="tuner_install_notification_content_text" translatable="false">Install tuner package to watch tuner channels.</string>

    <!-- EPG Search strings. -->
    <!-- Remove translatable="false" once UI is finalized -->
    <string name="search_result_no_result" translatable="false">No result</string>
    <string name="search_result_title" translatable="false">Search results</string>

    <!-- Onboarding experience. -->
    <eat-comment />
    <!-- Text for the channel sources screen in onboarding. -->
    <string name="setup_sources_text">Set up your sources</string>
    <!-- Description for channel sources screen in onboarding. -->
    <string name="setup_sources_description">Live channels combines the experience of traditional TV channels with streaming channels provided by apps.
\n\nGet started by setting up the channel sources already installed. Or browse the online store for more apps that offer live channels.</string>

    <!-- Menu item label to start DVR manager UI. -->
    <string name="channels_item_dvr">Recordings &amp; schedules</string>
    <!-- Menu item label to start recording of the current channel. -->
    <string name="channels_item_record_start" translatable="false">Start recording</string>
    <!-- Menu item label to stop recording of the current channel. -->
    <string name="channels_item_record_stop" translatable="false">Stop recording</string>

    <!-- The action to record the current channel for 10 minutes. [CHAR LIMIT=30] -->
    <string name="recording_start_dialog_10_min_duration">10 minutes</string>
    <!-- The action to record the current channel for 30 minutes. [CHAR LIMIT=30] -->
    <string name="recording_start_dialog_30_min_duration">30 minutes</string>
    <!-- The action to record the current channel for 1 hour. [CHAR LIMIT=30] -->
    <string name="recording_start_dialog_1_hour_duration">1 hour</string>
    <!-- The action to record the current channel for 3 hours. [CHAR LIMIT=30] -->
    <string name="recording_start_dialog_3_hours_duration">3 hours</string>

    <!--TODO(DVR): decide if translation needed Name of DVR service [CHAR LIMIT=NONE]  -->
    <string name="dvr_service_name" translatable="false">DVR Service</string>

    <!-- DVR Menu strings. -->
    <eat-comment />
    <!-- Row label of lists of scheduled recording in DVR menu. -->
    <!-- Header of DVR tab label for recently recorded programs list [CHAR LIMIT=20] -->
    <string name="dvr_main_recent">Recent</string>
    <!-- Header of DVR tab label for recording scheduled list [CHAR LIMIT=20] -->
    <string name="dvr_main_scheduled">Scheduled</string>
    <!-- Header of DVR tab label for recordings lists of TV series [CHAR LIMIT=20] -->
    <string name="dvr_main_series">Series</string>
    <!-- Header of DVR tab label for recorded programs list without any genre [CHAR LIMIT=20] -->
    <string name="dvr_main_others">Others</string>
    <!-- Toast message that the current channel cannot be recorded. -->
    <string name="dvr_msg_cannot_record_channel">The channel cannot be recorded.</string>
    <!-- Toast message that the current program cannot be recorded. -->
    <string name="dvr_msg_cannot_record_program">The program cannot be recorded.</string>
    <!-- Toast message that a new recording schedule has been created from the user action. -->
    <string name="dvr_msg_program_scheduled"><xliff:g id="programName" example="Big bang theory">%1$s</xliff:g> has been scheduled to be recorded</string>
    <!-- Toast message that a new recording schedule of the current program has been created
         from the user action. -->
    <string name="dvr_msg_current_program_scheduled">Recording <xliff:g id="programName" example="Big bang theory">%1$s</xliff:g> from now to <xliff:g id="endTime" example="12:30 PM">%2$s</xliff:g></string>
    <!-- Description of a card view to show Recording (DVR) history.[CHAR LIMIT=25]-->
    <string name="dvr_history_card_view_title">Recording History</string>
    <!-- Description of a card view to show full list of scheduled recordings. [CHAR LIMIT=25] -->
    <string name="dvr_full_schedule_card_view_title">Full schedule</string>
    <!-- Description of failed recordings. [CHAR LIMIT=25] -->
    <string name="dvr_recording_failed">Recording Failed.</string>
    <!-- Description of failed recordings. [CHAR LIMIT=25] -->
    <string name="dvr_recording_failed_no_period">Recording Failed</string>
    <!-- Description of recording conflicts. [CHAR LIMIT=25] -->
    <string name="dvr_recording_conflict">Recording Conflict</string>
    <!-- Description of how many following days the schedule list will show. [CHAR LIMIT=25] -->
    <plurals name="dvr_full_schedule_card_view_content">
        <item quantity="one">Next %1$d day</item>
        <item quantity="other">Next %1$d days</item>
    </plurals>
    <!-- Description of recording card views for recorded programs' length. [CHAR LIMIT=15] -->
    <plurals name="dvr_program_duration">
        <item quantity="one">%1$d minute</item>
        <item quantity="other">%1$d minutes</item>
    </plurals>
    <!-- Description of recording card views for number of new recorded programs [CHAR LIMIT=32] -->
    <plurals name="dvr_count_new_recordings">
        <item quantity="one">%1$d new recording</item>
        <item quantity="other">%1$d new recordings</item>
    </plurals>
    <!-- Description of recording card views for number of recorded programs [CHAR LIMIT=32] -->
    <plurals name="dvr_count_recordings">
        <item quantity="one">%1$d recording</item>
        <item quantity="other">%1$d recordings</item>
    </plurals>
    <!-- Description of recording card views for number of scheduled recordings [CHAR LIMIT=32] -->
    <plurals name="dvr_count_scheduled_recordings">
        <item quantity="one">%1$d recording scheduled</item>
        <item quantity="other">%1$d recordings scheduled</item>
    </plurals>


    <!-- DVR detailed page -->
    <eat-comment />
    <!-- Button label to schedule a recording. -->
    <string name="dvr_detail_schedule_recording">Schedule recording</string>
    <!-- Button label to cancel the recording schedule. -->
    <string name="dvr_detail_cancel_recording">Cancel recording</string>
    <!-- Button label to stop the current recording. -->
    <string name="dvr_detail_stop_recording">Stop recording</string>
    <!-- Button label to play recorded programs from beginning.
         Displayed when there's no watched history available. [CHAR LIMIT=15] -->
    <string name="dvr_detail_watch">Watch</string>
    <!-- Button label to play recorded programs from beginning. [CHAR LIMIT=25] -->
    <string name="dvr_detail_play_from_beginning">Play from beginning</string>
    <!-- Button label to play recorded programs from last watched position. [CHAR LIMIT=20] -->
    <string name="dvr_detail_resume_play">Resume playing</string>
    <!-- Button label to remove a recorded program in a recording details page [CHAR LIMIT=20] -->
    <string name="dvr_detail_delete">Delete</string>
    <!-- Button label to remove a recorded program in a series recording details page
         [CHAR LIMIT=30] -->
    <string name="dvr_detail_series_delete">Delete recordings</string>
    <!-- Button label to resume playback of a recorded program [CHAR LIMIT=20] -->
    <string name="dvr_detail_series_resume">Resume</string>
    <!-- Row label to show the season number of series recordings [CHAR LIMIT=20] -->
    <string name="dvr_detail_series_season_title">Season <xliff:g id="season_number">%1$s</xliff:g></string>
    <!-- Button label to open full schedule list page [CHAR LIMIT=15] -->
    <string name="dvr_detail_view_schedule">View schedule</string>
    <!-- Text label to indicate there's more text in the details description [CHAR LIMIT=20] -->
    <string name="dvr_detail_read_more">Read more</string>
    <!-- Description of failed recordings caused by system failures. -->
    <string name="dvr_recording_failed_system_failure">System failure. (Error code: <xliff:g id="errorCode" example="0">%1$d</xliff:g>)</string>
    <!-- Description of failed recordings when they are not started correctly. -->
    <string name="dvr_recording_failed_not_started">Recording was not started. Please check the antenna and hard drive connections (if any).</string>
    <!-- Description of failed recordings when required resource is busy. -->
    <string name="dvr_recording_failed_resource_busy">Failed to tune to the channel. Possible causes: weak signal, poor antenna connection, or recording conflict.</string>
    <!-- Description of failed recordings when the input is unavailable. -->
    <string name="dvr_recording_failed_input_unavailable"><xliff:g id="inputId" example="com.example.partnersupportsampletvinput/.SampleTvInputService">%1$s</xliff:g> unavailable.</string>
    <!-- Description of failed recordings when the input doesn't support recording. -->
    <string name="dvr_recording_failed_input_dvr_unsupported">Recording of this channel is not supported.</string>
    <!-- Description of failed recordings when the space is insufficient. -->
    <string name="dvr_recording_failed_insufficient_space">Insufficient space. Please connect an external storage device or delete some existing recordings.</string>


    <!-- DVR series settings -->
    <eat-comment />
    <!-- Title of DVR series deletion [CHAR LIMIT=25] -->
    <string name="dvr_series_deletion_title">Delete recordings</string>
    <!-- Description of DVR series deletion. -->
    <string name="dvr_series_deletion_description">Select the episodes you would like to delete. They can\'t be recovered once deleted.</string>
    <!-- Toast message of no recordings can be deleted [CHAR LIMIT=40] -->
    <string name="dvr_series_deletion_no_recordings">There\'re no recordings to delete.</string>
    <!-- Button label to select all watched episodes of the given series [CHAR LIMIT=35] -->
    <string name="dvr_series_select_watched">Select watched episodes</string>
    <!-- Button label to select all episodes of the given series [CHAR LIMIT=35] -->
    <string name="dvr_series_select_all">Select all episodes</string>
    <!-- Button label to deselect all episodes of the given series [CHAR LIMIT=35] -->
    <string name="dvr_series_deselect_all">Deselect all episodes</string>
    <!-- Description of recording's watched position in minutes. -->
    <string name="dvr_series_watched_info_minutes"><xliff:g id="watched">%1$d</xliff:g> of <xliff:g id="duration">%2$d</xliff:g> minutes watched</string>
    <!-- Description of recording's watched position in seconds. -->
    <string name="dvr_series_watched_info_seconds"><xliff:g id="watched">%1$d</xliff:g> of <xliff:g id="duration">%2$d</xliff:g> seconds watched</string>
    <!-- Description of never watched recordings [CHAR LIMIT=25] -->
    <string name="dvr_series_never_watched">Never watched</string>
    <!-- Message after recorded episodes are deleted. -->
    <plurals name="dvr_msg_episodes_deleted">
        <item quantity="one">%1$d of %2$d episode is deleted</item>
        <item quantity="other">%1$d of %2$d episodes are deleted</item>
    </plurals>
    <!-- Title of DVR series settings -->
    <string name="dvr_series_settings_title" translatable="false">Recording settings</string>
    <!-- Item label to change priority of TV series for DVR -->
    <string name="dvr_series_settings_priority">Priority</string>
    <!-- Item description when the current series has the height proirty among scheduled
         TV series. -->
    <string name="dvr_series_settings_priority_highest">Highest</string>
    <!-- Item description when the current series has the lowest proirty among scheduled
         TV series. -->
    <string name="dvr_series_settings_priority_lowest">Lowest</string>
    <!-- Item description of the priority rank of the current series among all scheduled
         TV series. -->
    <string name="dvr_series_settings_priority_rank">No. <xliff:g id="rank">%1$d</xliff:g></string>
    <!-- Item label to specify channel which will be recorded for TV series recording -->
    <string name="dvr_series_settings_channels">Channels</string>
    <!-- Sub item label to record TV series from any channel. c.f., a user can
         specify a channel like CNN -->
    <string name="dvr_series_settings_channels_all">Any</string>
    <!-- Title of priority settings fragment -->
    <string name="dvr_priority_title">Choose priority</string>
    <!-- Description of priority settings fragment -->
    <string name="dvr_priority_description">When there are too many programs to be recorded at the same time, only the ones with higher priorities will be recorded.</string>
    <!-- Button lable in priority settings fragment to save the current settings -->
    <string name="dvr_priority_button_action_save">Save</string>
    <!-- Button label in priority settings fragment for one-time recordings -->
    <string name="dvr_priority_action_one_time_recording">One-time recordings have the highest priority</string>

    <!-- DVR epg strings -->
    <eat-comment />
    <string name="dvr_action_delete_schedule" translatable="false">Delete schedule</string>
    <string name="dvr_action_record_program" translatable="false">Record program</string>
    <!-- The action to forget DVR storage which is missing currently. invoke android internal storage settings activity. -->
    <string name="dvr_action_error_storage_settings" translatable="false">Open storage settings</string>
    <!-- The action to stop recording. [CHAR LIMIT=10] -->
    <string name="dvr_action_stop">Stop</string>
    <!-- The action to open the activity which shows all the schedules.[CHAR LIMIT=32] -->
    <string name="dvr_action_view_schedules">View recording schedule</string>
    <!-- The action to make the recording schedule for only this program(episode).
         [CHAR LIMIT=30] -->
    <string name="dvr_action_record_episode">This single program</string>
    <!-- The description for the action "dvr_action_record_episode" to show the recording duration
         which starts now and ends at the end of the program.
         [CHAR LIMIT=30] -->
    <string name="dvr_action_record_episode_from_now_description">now - <xliff:g id="endTime" example="11:30">%1$s</xliff:g></string>
    <!-- The action to make the recording schedule for the series (i.e. all the episodes). The
         ellipsis(&#8230) means that there will be a next setup page for the series recording.
         [CHAR LIMIT=30] -->
    <string name="dvr_action_record_series">Entire series&#8230;</string>
    <!-- The title of the action to create a schedule for the program even though there are some
         problems. [CHAR LIMIT=32] -->
    <string name="dvr_action_record_anyway">Schedule anyway</string>
    <!-- The title of the action to record this program instead of the other. This happens when the
         user tries to record a program while there is a existing schedule with the same episode
         as the program. [CHAR LIMIT=35] -->
    <string name="dvr_action_record_instead">Record this one instead</string>
    <!-- The title of the action to cancel to create the new schedule. This happens when the user
         created a schedule while there is a existing schedule with the same episode as the program.
         This action cancels the new schedule. [CHAR LIMIT=32] -->
    <string name="dvr_action_record_cancel">Cancel this recording</string>
    <!-- The title of the action to show the details of the recorded program. [CHAR LIMIT=32] -->
    <string name="dvr_action_watch_now">Watch now</string>
    <!-- The title of the action to open the DVR library to delete some recorded programs. [CHAR LIMIT=32] -->
    <string name="dvr_action_delete_recordings">Delete recordings&#8230;</string>
    <!-- Dvr label in epg to indicate the program is recordable. [CHAR LIMIT=30] -->
    <string name="dvr_epg_program_recordable">Recordable</string>
    <!-- Dvr label in epg to indicate the program is scheduled to be recorded. [CHAR LIMIT=30] -->
    <string name="dvr_epg_program_recording_scheduled">Recording scheduled</string>
    <!-- Dvr label in epg to indicate the program has a conflicted scheduled recording. [CHAR LIMIT=30] -->
    <string name="dvr_epg_program_recording_conflict">Recording conflict</string>
    <!-- Dvr label in epg to indicate the program is recording now. [CHAR LIMIT=30] -->
    <string name="dvr_epg_program_recording_in_progress">Recording</string>
    <!-- Dvr label in epg to indicate the recording of the program has been failed. [CHAR LIMIT=30] -->
    <string name="dvr_epg_program_recording_failed">Recording failed</string>
    <string name="dvr_epg_program_icon_text" translatable="false">DVR</string>
    <string name="dvr_epg_channel_watch_conflict_dialog_title" translatable="false">Upcoming schedules</string>
    <string name="dvr_epg_channel_watch_conflict_dialog_description" translatable="false">The programs will not be recorded if you keep watching this channel. Cancel the recordings, or current channel will be blocked when the recording starts.</string>
    <!-- A popup message which informs that Live TV is reading program information. -->
    <string name="dvr_series_progress_message_reading_programs">Reading programs</string>
    <!-- Dialog action which let user view the recent recordings. -->
    <string name="dvr_error_insufficient_space_action_view_recent_recordings">View recent recordings</string>
    <!-- Dialog title which means there is one recording doesn't complete. -->
    <string name="dvr_error_insufficient_space_title_one_recording">The recording of <xliff:g id="programName" example="Friends">%1$s</xliff:g> is incomplete.</string>
    <!-- Dialog title which means there are two recordings don't complete. -->
    <string name="dvr_error_insufficient_space_title_two_recordings">The recordings of <xliff:g id="programName_1" example="Friends">%1$s</xliff:g> and <xliff:g id="programName_2" example="Friends">%2$s</xliff:g> are incomplete.</string>
    <!-- Dialog title which means there are three or more recordings don't complete.-->
    <string name="dvr_error_insufficient_space_title_three_or_more_recordings">The recordings of <xliff:g id="programName_1" example="Friends">%1$s</xliff:g>, <xliff:g id="programName_2" example="Friends">%2$s</xliff:g> and <xliff:g id="programName_3" example="Friends">%3$s</xliff:g> are incomplete.</string>
    <!-- Description which means there is one recording didn't complete due to no sufficient space.
         -->
    <string name="dvr_error_insufficient_space_description_one_recording">The recording of <xliff:g id="programName" example="Friends">%1$s</xliff:g> didn\'t complete due to insufficient storage.</string>
    <!-- Description which means there are two recordings didn't complete due to no sufficient
         space. -->
    <string name="dvr_error_insufficient_space_description_two_recordings">The recordings of <xliff:g id="programName_1" example="Friends">%1$s</xliff:g> and <xliff:g id="programName_2" example="Friends">%2$s</xliff:g> didn\'t complete due to insufficient storage.</string>
    <!-- Description which means there are three or more recordings didn't complete due to no
         sufficient space.-->
    <string name="dvr_error_insufficient_space_description_three_or_more_recordings">The recordings of <xliff:g id="programName_1" example="Friends">%1$s</xliff:g>, <xliff:g id="programName_2" example="Friends">%2$s</xliff:g> and <xliff:g id="programName_3" example="Friends">%3$s</xliff:g> didn\'t complete due to insufficient storage.</string>
    <!-- Dialog title which will be shown when the current storage is too small for DVR. -->
    <string name="dvr_error_small_sized_storage_title">More storage needed</string>
    <!-- Dialog description which will be shown when the current storage is too small for DVR. -->
    <string name="dvr_error_small_sized_storage_description">You will be able to record programs. However there is not enough storage on your device to start recording. Please connect an external drive that is <xliff:g id="storage_size" example="10GB">%1$d</xliff:g>GB or larger and follow the steps to format it as device storage.</string>
    <!-- Dialog title which will be shown when there is no free space on the current storage for DVR. -->
    <string name="dvr_error_no_free_space_title">Not enough storage</string>
    <!-- Dialog description which will be shown when there is no free space on the current storage for DVR. -->
    <string name="dvr_error_no_free_space_description">This program will not be recorded because there is not enough storage. Try deleting some existing recordings.</string>
    <!-- Dialog title which will be shown when the current DVR storage is not accessible. -->
    <string name="dvr_error_missing_storage_title">Missing storage</string>
    <!-- Dialog description which will be shown when the current DVR storage is not accessible. -->
    <string name="dvr_error_missing_storage_description" translatable="false">Some of the storage used for recording is missing. Please connect the external drive you used before to re-enable recording. Alternately, you can forget the storage in the storage settings, if it\'s no longer available.</string>
    <!-- The recording being requested to play is not existent in storage. It may be deleted. -->
    <string name="dvr_toast_recording_deleted" translatable="false">The recording seems to be deleted.</string>

    <!-- DVR half sized dialogs -->
    <eat-comment />
    <!-- The title of the stop recording dialog which asks the user whether to stop recording of the
         current channel or not. -->
    <string name="dvr_stop_recording_dialog_title">Stop recording?</string>
    <!-- The description of the stop recording dialog which asks the user whether to stop recording
         of the current channel or not. -->
    <string name="dvr_stop_recording_dialog_description">The recorded content will be saved.</string>
    <!-- The description of the stop recording dialog which asks the user whether to stop the
        current recording to start another conflict schedule. -->
    <string name="dvr_stop_recording_dialog_description_on_conflict">The recording of <xliff:g id="programName" example="Friends">%1$s</xliff:g> will be stopped because it conflicts with this program. The recorded content will be saved.</string>
    <!--The title of the dialog to notify the user that the new schedule conflicts with others. -->
    <string name="dvr_program_conflict_dialog_title">Recording scheduled but has conflicts</string>
    <!--The title of the dialog to notify the user that the recording of the current channel
        conflicts with other schedules. -->
    <string name="dvr_channel_conflict_dialog_title">Recording has started but has conflicts</string>
    <!-- The message which says that the new recording schedule has been created. -->
    <string name="dvr_program_conflict_dialog_description_prefix"><xliff:g id="programName" example="Friends">%1$s</xliff:g> will be recorded.</string>
    <!-- The message which says that the recording of the current channel has been started. -->
    <string name="dvr_channel_conflict_dialog_description_prefix"><xliff:g id="channelName" example="KQED">%1$s</xliff:g> is being recorded.</string>
    <!--The description of the dialog to notify the user that the new recording schedule conflicts
        with another schedule. In this case the old schedule will be clipped or not be recorded.
        "Clipped" means that only a part of the program is recorded. -->
    <string name="dvr_program_conflict_dialog_description_1">Some parts of <xliff:g id="conflictProgramName" example="Friends">%1$s</xliff:g> will not be recorded.</string>
    <!--The description of the dialog to notify the user that the new recording schedule conflicts
        with two other schedule. In this case the old schedule will be clipped or not be recorded.
        "Clipped" means that only a part of the program is recorded. -->
    <string name="dvr_program_conflict_dialog_description_2">Some parts of <xliff:g id="conflictProgramName_1" example="Friends">%1$s</xliff:g> and <xliff:g id="conflictProgramName_2" example="Friends">%2$s</xliff:g> will not be recorded.</string>
    <!--The description of the dialog to notify the user that the new recording schedule conflicts
        with another schedules. In this case the old schedule will be clipped or not be recorded.
        "Clipped" means that only a part of the program is recorded. -->
    <string name="dvr_program_conflict_dialog_description_3">Some parts of <xliff:g id="conflictProgramName_1" example="Friends">%1$s</xliff:g>, <xliff:g id="conflictProgramName_2" example="Friends">%2$s</xliff:g> and one more schedule will not be recorded.</string>
    <!--The description of the dialog to notify the user that the new recording schedule conflicts
        with more than two schedules. In this case the old schedule will be clipped or not be
        recorded. "Clipped" means that only a part of the program is recorded. Note that this string
        is used only when the quantity is greater than one. -->
    <plurals name="dvr_program_conflict_dialog_description_many">
        <item quantity="one">Some parts of <xliff:g id="conflictProgramName_1" example="Friends">%1$s</xliff:g>, <xliff:g id="conflictProgramName_2" example="Friends">%2$s</xliff:g> and %3$d more schedule will not be recorded.</item>
        <item quantity="other">Some parts of <xliff:g id="conflictProgramName_1" example="Friends">%1$s</xliff:g>, <xliff:g id="conflictProgramName_2" example="Friends">%2$s</xliff:g> and %3$d more schedules will not be recorded.</item>
    </plurals>
    <!-- The title of the DVR schedule dialog which asks the user whether he/she want to make the
         one-time recording or series recording. -->
    <string name="dvr_schedule_dialog_title">What would you like to record?</string>
    <!-- The title of the DVR channel recording dialog which asks the user how long he/she wants
         record the current channel. -->
    <string name="dvr_channel_record_duration_dialog_title">How long would you like to record?</string>
    <!-- The title of the dialog which notifies the user that a schedule which is the same episode
         as this program has already been created. -->
    <string name="dvr_already_scheduled_dialog_title">Already scheduled</string>
    <!-- The description of the dialog which notifies the user that a schedule which is the same
         episode as this program has already been created. -->
    <string name="dvr_already_scheduled_dialog_description">The same program has already been scheduled to be recorded at <xliff:g id="programStartTime" example="7:30 AM on Jun 27.">%1$s</xliff:g>.</string>
    <!-- The title of the dialog which notifies the user that the same episode as the program has
         already been recorded. -->
    <string name="dvr_already_recorded_dialog_title">Already recorded</string>
    <!-- The description of the dialog which notifies the user that the same episode as the program
         has already been recorded. -->
    <string name="dvr_already_recorded_dialog_description">This program has already been recorded. It’s available in the DVR library.</string>
    <!-- The title of dialog that notifies the user the series recording has been scheduled. -->
    <string name="dvr_series_recording_dialog_title">Series recording scheduled</string>
    <!-- The description of the dialog which notifies how many schedules have been added for the
         series. -->
    <plurals name="dvr_series_scheduled_no_conflict">
        <item quantity="one"><xliff:g id="numberOfRecordings" example="1">%1$d</xliff:g> recording has been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>.</item>
        <item quantity="other"><xliff:g id="numberOfRecordings" example="5">%1$d</xliff:g> recordings have been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>.</item>
    </plurals>
    <!-- The description of the dialog which notifies how many schedules have been added for the
         series. But some episodes of this series won't be recorded due to conflict with
         other schedules. -->
    <plurals name="dvr_series_recording_scheduled_only_this_series_conflict">
        <item quantity="one"><xliff:g id="numberOfRecordings" example="1">%1$d</xliff:g> recording has been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. It will not be recorded due to conflicts.</item>
        <item quantity="other"><xliff:g id="numberOfRecordings" example="5">%1$d</xliff:g> recordings have been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. <xliff:g id="numberOfConflictRecordings" example="2">%3$d</xliff:g> of them will not be recorded due to conflicts.</item>
    </plurals>
    <!-- The description of the dialog which notifies how many schedules have been added for the
         series. But some episodes of this and other series won't be recorded due to the episodes
         of this series conflict with other schedules and the episodes of other series conflict
         with this series. -->
    <plurals name="dvr_series_scheduled_this_and_other_series_conflict">
        <item quantity="one"><xliff:g id="numberOfRecordings" example="1">%1$d</xliff:g> recording has been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. <xliff:g id="numberOfConflictEpisodes" example="1">%3$d</xliff:g> episodes of this series and other series will not be recorded due to conflicts.</item>
        <item quantity="other"><xliff:g id="numberOfRecordings" example="5">%1$d</xliff:g> recordings have been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. <xliff:g id="numberOfConflictEpisodes" example="2">%3$d</xliff:g> episodes of this series and other series will not be recorded due to conflicts.</item>
    </plurals>
    <!-- The description of the dialog which notifies how many schedules have been added for the
         series. But only 1 episode of other series won't be recorded due to conflict
         with this series. -->
    <plurals name="dvr_series_scheduled_only_other_series_one_conflict">
        <item quantity="one"><xliff:g id="numberOfRecordings" example="1">%1$d</xliff:g> recording has been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. 1 episode of other series will not be recorded due to conflicts.</item>
        <item quantity="other"><xliff:g id="numberOfRecordings" example="5">%1$d</xliff:g> recordings have been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. 1 episode of other series will not be recorded due to conflicts.</item>
    </plurals>
    <!-- The description of the dialog which notifies how many schedules have been added for the
         series. But some episodes of other series won't be recorded due to conflict with this
         series. -->
    <plurals name="dvr_series_scheduled_only_other_series_many_conflicts">
        <item quantity="one"><xliff:g id="numberOfRecordings" example="1">%1$d</xliff:g> recording has been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. <xliff:g id="numberOfConflictEpisodes" example="1">%3$d</xliff:g> episodes of other series will not be recorded due to conflicts.</item>
        <item quantity="other"><xliff:g id="numberOfRecordings" example="5">%1$d</xliff:g> recordings have been scheduled for <xliff:g id="seriesName" example="Friends">%2$s</xliff:g>. <xliff:g id="numberOfConflictEpisodes" example="2">%3$d</xliff:g> episodes of other series will not be recorded due to conflicts.</item>
    </plurals>

    <!-- DVR playback strings -->
    <eat-comment />
    <!-- DVR playback activity's warning about the recorded program is not found. -->
    <string name="dvr_program_not_found">Recorded program not found.</string>
    <!-- Label used in DVR playback activity as the header of the row of related recordings. [CHAR LIMIT=32] -->
    <string name="dvr_playback_related_recordings">Related recordings</string>

    <!-- DVR channel banner strings -->
    <eat-comment />
    <string name="dvr_recording_till_format" translatable="false">Recording till <xliff:g id="recordingEndTime" example="9:00pm">%1$s</xliff:g></string>

    <!-- DVR schedule list strings -->
    <eat-comment/>
    <!-- Description of list's header about how many recordings in the recording list. -->
    <plurals name="dvr_schedules_section_subtitle">
        <item quantity="one">%1$d recording</item>
        <item quantity="other">%1$d recordings</item>
    </plurals>
    <!-- Separator between program name and channel name. -->
    <string name="dvr_schedules_information_separator">&#160;/&#160;</string>
    <!-- Description of which recording has been removed. -->
    <string name="dvr_schedules_deletion_info"><xliff:g id="programName" example="Big bang theory">%1$s</xliff:g> removed from recording schedule</string>
    <!-- Description of the schedule will be partially recorded, because of no available tuner
         for recording. [CHAR LIMIT=60] -->
    <string name="dvr_schedules_tuner_conflict_will_be_partially_recorded">Will be partially recorded due to tuner conflicts.</string>
    <!-- Description of the schedule will not be recorded, because of no available tuner for
         recording. [CHAR LIMIT=60] -->
    <string name="dvr_schedules_tuner_conflict_will_not_be_recorded_info">Won\'t be recorded due to tuner conflicts.</string>
    <!-- Description of no schedule recording for now, and ask user to schedule recordings from
         the program guide. -->
    <string name="dvr_schedules_empty_state">There are no recordings scheduled yet.\nYou can schedule recordings from the program guide.</string>
    <!-- Description of no recording history for now, and ask user to schedule recordings from
         the program guide. -->
    <string name="dvr_history_empty_state">There is no recording history.\nYou can schedule recordings from the program guide.</string>
    <!-- Description of schedule list header about how many recordings conflict. -->
    <plurals name="dvr_series_schedules_header_description">
        <item quantity="one">%1$d recording conflict</item>
        <item quantity="other">%1$d recording conflicts</item>
    </plurals>
    <!-- Button label of settings for DVR series recordings [CHAR LIMIT=25] -->
    <string name="dvr_series_schedules_settings">Series settings</string>
    <!-- Button label of the action which starts creating schedules for the series automatically.[CHAR LIMIT=32] -->
    <string name="dvr_series_schedules_start">Start series recording</string>
    <!-- Button label of the action which stops creating schedules for the series automatically. [CHAR LIMIT=32]-->
    <string name="dvr_series_schedules_stop">Stop series recording</string>
    <!-- The title of asking user whether to stop creating schedules. -->
    <string name="dvr_series_schedules_stop_dialog_title">Stop series recording?</string>
    <!-- The description of asking user whether to stop creating schedules for the series. -->
    <string name="dvr_series_schedules_stop_dialog_description">Recorded episodes will remain available in the DVR library.</string>
    <!-- Action to stop creating the schedules for the series. -->
    <string name="dvr_series_schedules_stop_dialog_action_stop">Stop</string>
     <!-- Description of no episodes in stopped series recording. -->
    <string name="dvr_series_schedules_stopped_empty_state">No episodes are on air now.</string>
    <!-- Description of no episodes in series recording, and the episodes will be recorded once
         they are available. -->
    <string name="dvr_series_schedules_empty_state">No episodes are available.\nThey will be recorded once they are available.</string>
    <!-- Tag of schedules header focus view. -->
    <string name="dvr_schedules_header_focus_view" translatable="false">DvrSchedulesHeaderFocusView</string>
    <!-- Tag of schedules item focus view. -->
    <string name="dvr_schedules_item_focus_view" translatable="false">DvrSchedulesItemFocusView</string>
    <!-- Description of recordings' duration in minutes. [CHAR LIMIT=25] -->
    <plurals name="dvr_schedules_recording_duration">
        <item quantity="one">(%1$d minute) </item>
        <item quantity="other">(%1$d minutes)</item>
    </plurals>

    <!-- DVR history list strings -->
    <!-- Short description of failed recordings. -->
    <string name="dvr_recording_failed_short">Failed.</string>
    <!-- Short description of failed recordings when they are not started correctly. -->
    <string name="dvr_recording_failed_not_started_short">Failed to start recording.</string>
    <!-- Short description of failed recordings when required resource is busy. -->
    <string name="dvr_recording_failed_resource_busy_short">Failed to tune to the channel.</string>
    <!-- Short description of failed recordings when the input is unavailable. -->
    <string name="dvr_recording_failed_input_unavailable_short"><xliff:g id="inputId" example="com.example.partnersupportsampletvinput/.SampleTvInputService">%1$s</xliff:g> unavailable.</string>
    <!-- Short description of failed recordings when the input doesn't support recording. -->
    <string name="dvr_recording_failed_input_dvr_unsupported_short">Recording not supported.</string>
    <!-- Short description of failed recordings when the space is insufficient. -->
    <string name="dvr_recording_failed_insufficient_space_short">Insufficient space.</string>

    <!-- DVR date related strings -->
    <eat-comment/>
    <!-- Date text to represent today. -->
    <string name="dvr_date_today">Today</string>
    <!-- Date text to represent tomorrow. -->
    <string name="dvr_date_tomorrow">Tomorrow</string>
    <!-- Date text to represent yesterday. -->
    <string name="dvr_date_yesterday">Yesterday</string>
    <!-- Date text to represent time with today like 8 - 9 AM today -->
    <string name="dvr_date_today_time"><xliff:g id="time_range" example="10:00 am - 11:00 am">%1$s</xliff:g> today</string>
    <!-- Date text to represent time with today like 8 - 9 AM tomorrow -->
    <string name="dvr_date_tomorrow_time"><xliff:g id="time_range" example="10:00 am - 11:00 am">%1$s</xliff:g> tomorrow</string>

    <!-- Program Guide Strings -->
    <eat-comment/>
    <!-- Text that goes after a Critic Score to indicate that it's a score -->
    <string name="program_guide_critic_score">Score</string>

    <!-- Preview Channel Name -->
    <eat-comment/>
    <!-- Name for recorded programs preview channel -->
    <string name="recorded_programs_preview_channel">Recorded Programs</string>
</resources>
