<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2013 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>
    <!-- Name for the default system route prior to Jellybean. [CHAR LIMIT=30] -->
    <string name="mr_system_route_name">System</string>

    <!-- Name for the user route category created when publishing routes to the system in Jellybean and above. [CHAR LIMIT=30] -->
    <string name="mr_user_route_category_name">Devices</string>

    <!-- String to be shown as a tooltip of MediaRouteButton
        Cast is the standard android verb for sending content to a remote device. [CHAR LIMIT=50] -->
    <string name="mr_button_content_description">Cast</string>

    <!-- Content description of a MediaRouteButton for accessibility support when no remote device is connected.
        Cast is the standard android verb for sending content to a remote device. [CHAR LIMIT=NONE] -->
    <string name="mr_cast_button_disconnected">Cast. Disconnected</string>

    <!-- Content description of a MediaRouteButton for accessibility support while connecting to a remote device.
        Cast is the standard android verb for sending content to a remote device. [CHAR LIMIT=NONE] -->
    <string name="mr_cast_button_connecting">Cast. Connecting</string>

    <!-- Content description of a MediaRouteButton for accessibility support when a remote device is connected.
        Cast is the standard android verb for sending content to a remote device. [CHAR LIMIT=NONE] -->
    <string name="mr_cast_button_connected">Cast. Connected</string>

    <!-- Title of the media route chooser dialog. [CHAR LIMIT=30] -->
    <string name="mr_chooser_title">Cast to</string>

    <!-- Placeholder text to show when no devices have been found. [CHAR LIMIT=50] -->
    <string name="mr_chooser_searching">Finding devices</string>

    <!-- Placeholder text to show when looking for devices. [CHAR LIMIT=50] -->
    <string name="mr_chooser_looking_for_devices">Looking for devices...</string>

    <!-- Button to disconnect from a media route.  [CHAR LIMIT=30] -->
    <string name="mr_controller_disconnect">Disconnect</string>

    <!-- Button to stop playback and disconnect from a media route. [CHAR LIMIT=32] -->
    <string name="mr_controller_stop_casting">Stop casting</string>

    <!-- Content description for accessibility (not shown on the screen): dialog close button. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_close_description">Close</string>

    <!-- Content description for accessibility (not shown on the screen): media play button. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_play">Play</string>

    <!-- Content description for accessibility (not shown on the screen): media pause button. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_pause">Pause</string>

    <!-- Content description for accessibility (not shown on the screen): media stop button. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_stop">Stop</string>

    <!-- Content description for accessibility (not shown on the screen): group expand button. Pressing button shows group members of a selected route group. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_expand_group">Expand</string>

    <!-- Content description for accessibility (not shown on the screen): group collapse button. Pressing button hides group members of a selected route group. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_collapse_group">Collapse</string>

    <!-- Content description for accessibility (not shown on the screen): album art button. Clicking on the album art takes user to a predefined activity per media app. [CHAR LIMIT=50] -->
    <string name="mr_controller_album_art">Album art</string>

    <!-- Content description for accessibility (not shown on the screen): volume slider. [CHAR LIMIT=NONE] -->
    <string name="mr_controller_volume_slider">Volume slider</string>

    <!-- Placeholder text to show when no media have been selected for playback. [CHAR LIMIT=50] -->
    <string name="mr_controller_no_media_selected">No media selected</string>

    <!-- Placeholder text to show when no title/description have been found for a given song/video. [CHAR LIMIT=50] -->
    <string name="mr_controller_no_info_available">No info available</string>

    <!-- Placeholder text indicating that the user is currently casting screen. [CHAR LIMIT=50] -->
    <string name="mr_controller_casting_screen">Casting screen</string>

    <!-- The default name of a group route in dynamic controller dialog
          when it is not set by media route provider [CHAR LIMIT=50] -->
    <string name="mr_dialog_default_group_name">Group</string>

    <!-- Section header text of groupable route section in dialog [CHAR LIMIT=50] -->
    <string name="mr_dialog_groupable_header">Add a device</string>

    <!-- Section header text of transferable route section in dialog [CHAR LIMIT=50] -->
    <string name="mr_dialog_transferable_header">Play on a group</string>

    <!-- Placeholder text for cast dialog title view [CHAR LIMIT=50] -->
    <string name="mr_cast_dialog_title_view_placeholder">No info available</string>

    <!-- Title of the media route chooser dialog when zero routes have been found after searching. [CHAR_LIMIT=NONE] -->
    <string name="mr_chooser_zero_routes_found_title">No devices available</string>

    <!-- Text displayed to hint making sure device and cast device are connected to the same Wi-Fi. [CHAR_LIMIT=NONE] -->
    <string name="mr_chooser_wifi_warning_description">Make sure the other device is on the same Wi-Fi network as this %s</string>

    <!-- Text displayed to link the user to the support article. [CHAR_LIMIT=NONE] -->
    <string name="mr_chooser_wifi_learn_more"><a href="https://support.google.com/chromecast/?p=trouble-finding-devices">Learn more</a></string>
    <string name="ic_media_route_learn_more_accessibility">Learn how to cast</string>

    <!-- Text displayed representing different form factors of devices. [CHAR_LIMIT=NONE] -->
    <string name="mr_device_form_factor_phone">phone</string>
    <string name="mr_device_form_factor_tablet">tablet</string>
    <string name="mr_device_form_factor_tv">tv</string>
    <string name="mr_device_form_factor_watch">watch</string>
    <string name="mr_device_form_factor_car">car</string>
    <string name="mr_device_form_factor_unknown">device</string>
</resources>
