<?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 tuners. It appears in TV app UI, as one of
         available TV inputs. -->
    <string name="ut_app_name">USB TV Tuner</string>
    <!-- Name of this application when one uses network tuners. It appears in TV app UI, as one of
         available TV inputs. -->
    <string name="nt_app_name">Network TV Tuner (BETA)</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 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>
    <!-- Message that says audio of the current channel is not available due to AC3 passthrough is not usable -->
    <string name="audio_passthrough_not_supported">Cannot play audio. Please try another TV</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>
    <!-- Title for network tuner main setup menu when no channel exists -->
    <string name="nt_setup_new_title">Network 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>
    <!-- Description for network tuner main setup menu when no channel exists -->
    <string name="nt_setup_new_description">Verify the network tuner is powered on 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>
    <!-- Description for network tuner main setup menu when channel exists already -->
    <string name="nt_setup_again_description">This will remove the channels found from the network
        tuner and scan for new channels again.\n\nVerify the network tuner is powered on 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>
    <!-- Title for channel scanning menu. Use this title with network tuners -->
    <string name="nt_channel_scan">Network 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 with USB tuners-->
    <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>
    <!-- Description for channel scanning result menu when no channel was found with network
         tuners -->
    <string name="nt_result_not_found_description">The scan did not find any channels. Verify the
        network tuner is powered on 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>

    <!-- Notification of USB channel tuner setup strings. -->
    <!-- Name of notification channel which is for tuner setup. -->
    <string name="ut_setup_notification_channel_name" translatable="false">USB tuner set up</string>
    <!-- Content title of the notification to launch the setup application of
         USB tuner TV input for scanning channels. -->
    <string name="ut_setup_notification_content_title">Scan for TV channels</string>
    <!-- Content text and info of the notification to launch the setup application of
         built-in tuner TV input for scanning channels. -->
    <string name="bt_setup_notification_content_text">TV Tuner setup</string>
    <!-- Content text and info of the notification to launch the setup application of
         USB tuner TV input for scanning channels. -->
    <string name="ut_setup_notification_content_text">USB TV Tuner setup</string>
    <!-- Content text and info of the notification to launch the setup application of
         network tuner TV input for scanning channels. -->
    <string name="nt_setup_notification_content_text">Network TV Tuner setup</string>

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