<?Xm 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">
    <!-- Name of this application. It appears in TV app UI, as one of available TV inputs. -->
    <string name="bt_app_name">TV Tuner</string>
    <!-- Name of this application when one uses USB tuner. It appears in TV app UI, as one of
         available TV inputs. -->
    <string name="ut_app_name">USB TV Tuner</string>
    <!-- Title for an action which turns a feature on [CHAR LIMIT=30] -->
    <string name="ut_setup_on">On</string>
    <!-- Title for an action which turns a feature off [CHAR LIMIT=30] -->
    <string name="ut_setup_off">Off</string>
    <!-- Message shown when the scanning process is being canceled by a user and the scanning
         process needs the time to wait to finish the processing -->
    <string name="ut_setup_cancel">Please wait to finish processing</string>
    <!-- Message that asks a user to select the type of signal to be used for input among
         the choices like terrestrial, cable, or satellite -->
    <string name="ut_select_channel_map">Select your channel source</string>
    <!-- Message that indicates TV input signal is lost due to physical disconnection or bad
         reception -->
    <string name="ut_no_signal">No Signal</string>
    <!-- Message that says TV failed to change to a channel (or tune) -->
    <string name="ut_fail_to_tune">Failed to tune to <xliff:g id="channel_name">%s</xliff:g></string>
    <!-- Message that says TV failed to change(or tune) to a channel which has no title -->
    <string name="ut_fail_to_tune_to_unknown_channel">Failed to tune</string>
    <!-- Message shown when the scanned channels became invalid due to incompatible changes
         found across application versions, hence a user is required to rescan the channels -->
    <string name="ut_rescan_needed">Tuner software has been recently updated. Please re-scan the
        channels.</string>
    <!-- Message that says audio of the current channel is not available due to surround sound
         of TV device disabled -->
    <string name="ut_surround_sound_disabled">Enable surround sound in system sound settings to enable audio</string>
    <!-- Usb Tuner setup common UI breadcrumb -->
    <string name="ut_setup_breadcrumb">Channel tuner setup</string>
    <!-- Title for TV Tuner main setup menu when no channel exists -->
    <string name="bt_setup_new_title">TV Tuner setup</string>
    <!-- Title for USB tuner main setup menu when no channel exists -->
    <string name="ut_setup_new_title">USB channel tuner setup</string>
    <!-- Description for TV tuner main setup menu when no channel exists -->
    <string name="bt_setup_new_description">Verify your TV is connected to a TV signal
        source.\n\nIf using an over-the-air antenna, you may need to adjust its placement or
        direction to receive the most channels. For best results, place it high and near a
        window.</string>
    <!-- Description for USB tuner main setup menu when no channel exists -->
    <string name="ut_setup_new_description">Verify the USB tuner is plugged in and connected
        to a TV signal source.\n\nIf using an over-the-air antenna, you may need to adjust its
        placement or direction to receive the most channels. For best results,
        place it high and near a window.</string>
    <!-- Menu items for USB tuner main setup menu when no channel exists -->
    <string-array name="ut_setup_new_choices">
        <!-- Continue setup -->
        <item>Continue</item>
        <!-- Exit setup -->
        <item>Not now</item>
    </string-array>
    <!-- Title for tuner main setup menu when channel exists already -->
    <string name="bt_setup_again_title">Rerun channel setup?</string>
    <!-- Description for TV tuner main setup menu when channel exists already -->
    <string name="bt_setup_again_description">This will remove the channels found from the TV
        tuner and scan for new channels again.\n\nVerify your TV is connected to a TV signal
        source.\n\nIf using an over-the-air antenna, you may need to adjust its placement or
        direction to receive the most channels. For best results, place it high and near a
        window.</string>
    <!-- Description for USB tuner main setup menu when channel exists already -->
    <string name="ut_setup_again_description">This will remove the channels found from the USB
        tuner and scan for new channels again.\n\nVerify the USB tuner is plugged in and connected
        to a TV signal source.\n\nIf using an over-the-air antenna, you may need to adjust its
        placement or direction to receive the most channels. For best results, place it high and
        near a window.</string>
    <!-- Menu items for USB tuner main setup menu when channel exists already -->
    <string-array name="ut_setup_again_choices">
        <!-- Continue setup -->
        <item>Continue</item>
        <!-- Exit setup -->
        <item>Cancel</item>
    </string-array>
    <!-- Title for connection type selection menu -->
    <string name="ut_connection_title">Select the connection type</string>
    <!-- Description for connection type selection menu -->
    <string name="ut_connection_description">Choose Antenna if there is an external antenna
        connected to the tuner. Choose Cable if your channels come from a cable service provider.
        If you are not sure, both types will be scanned, but this may take longer.</string>
    <!-- Menu items for connection type selection menu -->
    <string-array name="ut_connection_choices">
        <!-- Signal coming from the antenna that carries over-the-air, terrestrial channels -->
        <item>Antenna</item>
        <!-- Signal for cable television channels -->
        <item>Cable</item>
        <!-- Not sure what type of connection is provided for channel scanning -->
        <item>Not sure</item>
        <item translatable="false">Development only</item>
    </string-array>
    <!-- Title for channel scanning menu. Use this title with built-in tuners -->
    <string name="bt_channel_scan">TV tuner setup</string>
    <!-- Title for channel scanning menu. Use this title with USB tuners -->
    <string name="ut_channel_scan">USB channel tuner setup</string>
    <!-- Message that says channel is not yet scanned during channel scanning process -->
    <string name="ut_channel_scan_time">This may take several minutes</string>
    <!-- Message that says Tuner is not available -->
    <string name="ut_channel_scan_tuner_unavailable">Tuner is temporarily not available or already
        used by recording.</string>
    <!-- Message that says channels are found during channel scanning process -->
    <plurals name="ut_channel_scan_message">
        <item quantity="one">%1$d channel found</item>
        <item quantity="other">%1$d channels found</item>
    </plurals>
    <!-- Title for a button which will stop channel scanning process -->
    <string name="ut_stop_channel_scan">STOP CHANNEL SCAN</string>
    <!-- Title for channel scanning result menu when channels were found -->
    <plurals name="ut_result_found_title">
        <item quantity="one">%1$d channel found</item>
        <item quantity="other">%1$d channels found</item>
    </plurals>
    <!-- Description for channel scanning result menu when channels were found -->
    <plurals name="ut_result_found_description">
        <item quantity="one">Nice! %1$d channel was found during the channel scan.
            If this doesn’t seem right, try adjusting the antenna position and scan again.</item>
        <item quantity="other">Nice! %1$d channels were found during the channel scan.
            If this doesn’t seem right, try adjusting the antenna position and scan again.</item>
    </plurals>
    <!-- Menu items for channel scanning result menu when channels were found -->
    <string-array name="ut_result_found_choices">
        <item>Done</item>
        <item>Scan again</item>
    </string-array>
    <!-- Title for channel scanning result menu when no channel was found -->
    <string name="ut_result_not_found_title">No Channels found</string>
    <!-- Description for channel scanning result menu when no channel was found -->
    <string name="bt_result_not_found_description">The scan did not find any channels. Verify
        your TV is connected to a TV signal source.\n\nIf using an over-the-air antenna, adjust
        its placement or direction. For best results, place it high and near a window and scan
        again.</string>
    <!-- Description for channel scanning result menu when no channel was found -->
    <string name="ut_result_not_found_description">The scan did not find any channels. Verify the
        USB tuner is plugged in and connected to a TV signal source.\n\nIf using an over-the-air
        antenna, adjust its placement or direction. For best results, place it high and near a
        window and scan again.</string>
    <!-- Menu items for channel scanning result menu when no channel was found -->
    <string-array name="ut_result_not_found_choices">
        <item>Scan again</item>
        <item>Done</item>
    </string-array>

    <!-- Recommendation card of USB channel tuner setup strings. -->
    <!-- Content title of the recommendation card to launch the setup application of
         USB tuner TV input for scanning channels. This text is shown only when the card is
         focused. -->
    <string name="ut_setup_recommendation_card_focused_title">Scan for TV channels</string>
    <!-- Content text and info of the recommendation card to launch the setup application of
         built-in tuner TV input for scanning channels. -->
    <string name="bt_setup_recommendation_card_title">TV Tuner setup</string>
    <!-- Content text and info of the recommendation card to launch the setup application of
         USB tuner TV input for scanning channels. -->
    <string name="ut_setup_recommendation_card_title">USB TV Tuner setup</string>

    <!-- Message when usb tuner device is unplugged. [CHAR LIMIT=NONE] -->
    <string name="msg_usb_device_detached">USB TV tuner disconnected.</string>
</resources>
