<?xml version="1.0" encoding="utf-8"?>
<!--
/*
* Copyright (C) 2008 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">
    <!-- General -->
    <skip />

    <!-- URI used to import old favorites. [DO NOT TRANSLATE] -->
    <string name="old_launcher_provider_uri" translatable="false">content://com.android.launcher2.settings/favorites?notify=true</string>

    <!-- Permission to receive the com.android.launcher3.action.LAUNCH intent -->
    <string name="receive_launch_broadcasts_permission" translatable="false">com.android.launcher3.permission.RECEIVE_LAUNCH_BROADCASTS</string>

    <!-- Permission to receive the com.android.launcher3.action.FIRST_LOAD_COMPLETE intent -->
    <string name="receive_first_load_broadcast_permission" translatable="false">com.android.launcher3.permission.RECEIVE_FIRST_LOAD_BROADCAST</string>

    <!-- Application name -->
    <string name="application_name">Launcher3</string>
    <!-- Accessibility-facing application name -->
    <string name="home">Home</string>
    <!-- Name for all applications running as this uid. -->
    <string name="uid_name">Android Core Apps</string>
    <!-- Default folder name -->
    <string name="folder_name"></string>
    <!-- Displayed when user selects a shortcut for an app that was uninstalled [CHAR_LIMIT=none]-->
    <string name="activity_not_found">App isn\'t installed.</string>
    <!-- Displayed when user selects a shortcut for an app that is current not available [CHAR_LIMIT=none]-->
    <string name="activity_not_available">App isn\'t available</string>
    <!-- SafeMode shortcut error string -->
    <string name="safemode_shortcut_error">Downloaded app disabled in Safe mode</string>
    <!-- SafeMode widget error string -->
    <string name="safemode_widget_error">Widgets disabled in Safe mode</string>
    <!--  Labels for the tabs in the customize drawer -->
    <string name="widgets_tab_label">Widgets</string>

    <string name="widget_adder">Widgets</string>

    <string name="toggle_weight_watcher">Show Mem</string>

    <!-- AppsCustomize pane -->
    <!-- Message to tell the user to press and hold on a widget to add it [CHAR_LIMIT=50] -->
    <string name="long_press_widget_to_add">Touch &amp; hold to pick up a widget.</string>
    <!-- The format string for the dimensions of a widget in the drawer -->
    <!-- There is a special version of this format string for Farsi -->
    <string name="widget_dims_format">%1$d \u00d7 %2$d</string>

    <!-- External-drop widget pick label format string [CHAR_LIMIT=25] -->
    <string name="external_drop_widget_pick_format" translatable="false">%1$s (%2$d \u00d7 %3$d)</string>
    <!-- External-drop widget error string.  This is the error that is shown
         when you drag and item into the homescreen and it is unable to fit,
         or an error is encountered. [CHAR_LIMIT=50] -->
    <string name="external_drop_widget_error">Couldn\'t drop item on this Home screen.</string>
    <!-- External-drop widget pick title.  This is shown as the title of the
         dialog which allows you to pick which widgets to handle a particular
         drop if there are multiple choices. [CHAR_LIMIT=35] -->
    <string name="external_drop_widget_pick_title">Choose widget to create</string>

    <!-- Folders -->
    <skip />
    <!-- Label of Folder name field in Rename folder dialog box -->
    <string name="rename_folder_label">Folder name</string>
    <!-- Title of dialog box -->
    <string name="rename_folder_title">Rename folder</string>
    <!-- Buttons in Rename folder dialog box -->
    <string name="rename_action">OK</string>
    <!-- Buttons in Rename folder dialog box -->
    <string name="cancel_action">Cancel</string>

    <!-- Shortcuts -->
    <skip />
    <!-- Title of dialog box -->
    <string name="menu_item_add_item">Add to Home screen</string>
    <!-- Options in "Add to Home" dialog box; Title of the group containing the list of all apps -->
    <string name="group_applications">Apps</string>
    <!-- Options in "Add to Home" dialog box; Title of the group containing the list of all shortcut
s -->
    <string name="group_shortcuts">Shortcuts</string>
    <!-- Options in "Add to Home" dialog box; Title of the group containing the list of all widgets/gadgets -->
    <string name="group_widgets">Widgets</string>
    <!-- Error message when user has filled all their home screens -->
    <string name="completely_out_of_space">No more room on your Home screens.</string>
    <!-- Error message when user has filled a home screen -->
    <string name="out_of_space">No more room on this Home screen.</string>
    <!-- Error message when user has filled the hotseat -->
    <string name="hotseat_out_of_space">No more room in the Favorites tray</string>
    <!-- Error message when user tries to drop an invalid item on the hotseat -->
    <string name="invalid_hotseat_item">This widget is too large for the Favorites tray</string>
    <!-- Message displayed when a shortcut is created by an external application -->
    <string name="shortcut_installed">Shortcut \"<xliff:g id="name" example="Browser">%s</xliff:g>\" created.</string>
    <!-- Message displayed when a shortcut is uninstalled by an external application -->
    <string name="shortcut_uninstalled">Shortcut \"<xliff:g id="name" example="Browser">%s</xliff:g>\" was removed.</string>
    <!-- Message displayed when an external application attemps to create a shortcut that already exists -->
    <string name="shortcut_duplicate">Shortcut \"<xliff:g id="name" example="Browser">%s</xliff:g>\" already exists.</string>

    <!-- Title of dialog when user is selecting shortcut to add to homescreen -->
    <string name="title_select_shortcut">Choose shortcut</string>
    <!-- Title of dialog when user is selecting an application to add to homescreen -->
    <string name="title_select_application">Choose app</string>

    <!-- All applications label -->
    <string name="all_apps_button_label">Apps</string>
    <!-- Label for button in all applications label to go back home (to the workspace / desktop)
         for accessibilty (spoken when the button gets focus). -->
    <string name="all_apps_home_button_label">Home</string>
    <!-- Label for trash icon in All Apps. The icon/widget will become completely unavailable on the
         device. [CHAR_LIMIT=30]-->
    <string name="delete_zone_label_all_apps">Uninstall</string>

    <!-- Label for delete drop target. [CHAR_LIMIT=20] -->
    <string name="delete_target_label">Remove</string>
    <!-- Label for uninstall drop target. [CHAR_LIMIT=20]-->
    <string name="delete_target_uninstall_label">Uninstall</string>
    <!-- Label for the info icon. [CHAR_LIMIT=20] -->
    <string name="info_target_label">App info</string>

    <!-- Accessibility: AllApps button -->
    <string name="accessibility_all_apps_button">Apps</string>
    <!-- Accessibility: Delete button -->
    <string name="accessibility_delete_button">Remove</string>

    <!-- Label for trash icon in All Apps, when an updated system app is selected. The update will
         be uninstalled. [CHAR_LIMIT=30] -->
    <string name="delete_zone_label_all_apps_system_app">Uninstall update</string>

    <!-- URL pointing to help text. If empty, no link to help will be created [DO NOT TRANSLATE] -->
    <string name="help_url" translatable="false"></string>

    <!--  Strings for the contextual action bar (CAB) in All Apps -->
    <skip />
    <!-- Describes the button for uninstalling the currently selected application.
         Text is not displayed, but provided for accessibility. [CHAR_LIMIT=none] -->
    <string name="cab_menu_delete_app">Uninstall app</string>
    <!-- Describes the button for getting details/info about currently selected application.
         Text is not displayed, but provided for accessibility. [CHAR_LIMIT=none] -->
    <string name="cab_menu_app_info">App details</string>
    <!-- Appears in the CAB when an app is selected in All Apps or Customize mode. [CHAR_LIMIT=50] -->
    <string name="cab_app_selection_text">1 app selected</string>
    <!-- Appears in the CAB when a widget is selected in Customize mode. [CHAR_LIMIT=50] -->
    <string name="cab_widget_selection_text">1 widget selected</string>
    <!-- Appears in the CAB when a folder is selected in Customize mode. [CHAR_LIMIT=50] -->
    <string name="cab_folder_selection_text">1 folder selected</string>
    <!-- Appears in the CAB when a shortcut is selected in Customize mode. [CHAR_LIMIT=50] -->
    <string name="cab_shortcut_selection_text">1 shortcut selected</string>

    <!-- Permissions: -->
    <skip />
    <!-- Permission short label -->
    <string name="permlab_install_shortcut">install shortcuts</string>
    <!-- Permission description -->
    <string name="permdesc_install_shortcut">Allows an app to add
        shortcuts without user intervention.</string>
    <!-- Permission short label -->
    <string name="permlab_uninstall_shortcut">uninstall shortcuts</string>
    <!-- Permission description -->
    <string name="permdesc_uninstall_shortcut">Allows the app to remove
        shortcuts without user intervention.</string>
    <!-- Permission short label -->
    <string name="permlab_read_settings">read Home settings and shortcuts</string>
    <!-- Permission description -->
    <string name="permdesc_read_settings">Allows the app to read the settings and
        shortcuts in Home.</string>
    <!-- Permission short label -->
    <string name="permlab_write_settings">write Home settings and shortcuts</string>
    <!-- Permission description -->
    <string name="permdesc_write_settings">Allows the app to change the settings and
        shortcuts in Home.</string>

    <!-- Widgets: -->
    <skip />    

    <!-- Text to show user in place of a gadget when we can't display it properly -->
    <string name="gadget_error_text">Problem loading widget</string>

    <!-- Text to show user in place of a gadget when it is not yet initialized. -->
    <string name="gadget_setup_text">Setup</string>

    <!-- Text to inform the user that they can't uninstall a system application -->
    <string name="uninstall_system_app_text">This is a system app and can\'t be uninstalled.</string>

    <!-- Title of the Android Dreams (screensaver) module -->
    <string name="dream_name">Rocket Launcher</string>

    <!-- Default folder title -->
    <string name="folder_hint_text">Unnamed Folder</string>

    <!-- Accessibility -->
    <skip />

    <!-- The format string for Workspace descriptions [CHAR_LIMIT=none] -->
    <string name="workspace_description_format">Home screen %1$d</string>

    <!-- The format string for default page scroll text [CHAR_LIMIT=none] -->
    <string name="default_scroll_format">Page %1$d of %2$d</string>
    <!-- The format string for Workspace page scroll text [CHAR_LIMIT=none] -->
    <string name="workspace_scroll_format">Home screen %1$d of %2$d</string>
    <!-- The format string for AppsCustomize Apps page scroll text [CHAR_LIMIT=none] -->
    <string name="apps_customize_apps_scroll_format">Apps page %1$d of %2$d</string>
    <!-- The format string for AppsCustomize Apps page scroll text [CHAR_LIMIT=none] -->
    <string name="apps_customize_widgets_scroll_format">Widgets page %1$d of %2$d</string>

    <!-- Clings -->
    <!-- The title text for the workspace cling [CHAR_LIMIT=30] -->
    <string name="first_run_cling_title">Welcome</string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=60] -->
    <string name="first_run_cling_description">Make yourself at home.</string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=60] -->
    <string name="first_run_cling_custom_content_hint"></string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=60] -->
    <string name="first_run_cling_search_bar_hint"></string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=60] -->
    <string name="first_run_cling_create_screens_hint">Create more screens for apps and folders</string>
    <!-- The title text for the migration cling [CHAR_LIMIT=30] -->
    <string name="migration_cling_title">Copy your app icons</string>
    <!-- The description of what migration does [CHAR_LIMIT=70] -->
    <string name="migration_cling_description">Import icons and folders from your old Home screens?</string>
    <!-- The description of the button to migrate apps from another launcher [CHAR_LIMIT=30] -->
    <string name="migration_cling_copy_apps">COPY ICONS</string>
    <!-- The description of the button to use the default launcher layout [CHAR_LIMIT=30] -->
    <string name="migration_cling_use_default">START FRESH</string>
    <!-- The title text for the workspace cling [CHAR_LIMIT=30] -->
    <string name="workspace_cling_title">Organize your space</string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=70] -->
    <string name="workspace_cling_move_item">Touch &amp; hold background to manage wallpaper, widgets and settings.</string>
    <!-- The title text for workspace longpress action [CHAR_LIMIT=40] -->
    <string name="workspace_cling_longpress_title">Wallpapers, widgets, &amp; settings</string>
    <!-- The description of how to use the workspace [CHAR_LIMIT=70] -->
    <string name="workspace_cling_longpress_description">Touch &amp; hold background to customize</string>
    <!-- The description of the button to dismiss the cling [CHAR_LIMIT=30] -->
    <string name="workspace_cling_longpress_dismiss">GOT IT</string>
    <!-- The title text for the Folder cling [CHAR_LIMIT=30] -->
    <string name="folder_cling_title">Here\'s a folder</string>
    <!-- The description of how to create a folder [CHAR_LIMIT=70] -->
    <string name="folder_cling_create_folder">To create one like this, touch &amp; hold an app, then move it over another.</string>
    <!-- The text on the button to dismiss a cling [CHAR_LIMIT=30] -->
    <string name="cling_dismiss">OK</string>
    <!-- Error message on dummy custom cling layout [DO NOT TRANSLATE] -->
    <string name="dummy_custom_cling_error_message">Error: custom workspace layout passed in but custom cling was not overwritten</string>

    <!-- Folder accessibility -->
    <!-- The format string for when a folder is opened, speaks the dimensions -->
    <string name="folder_opened">Folder opened, <xliff:g id="width" example="5">%1$d</xliff:g> by <xliff:g id="height" example="3">%2$d</xliff:g></string>
    <!-- Instruction that clicking outside will close folder -->
    <string name="folder_tap_to_close">Touch to close folder</string>
    <!-- Instruction that clicking outside will commit folder rename -->
    <string name="folder_tap_to_rename">Touch to save rename</string>
    <!-- Indication that folder closed -->
    <string name="folder_closed">Folder closed</string>
    <!-- Folder renamed format -->
    <string name="folder_renamed">Folder renamed to <xliff:g id="name" example="Games">%1$s</xliff:g></string>
    <!-- Folder name format -->
    <string name="folder_name_format">Folder: <xliff:g id="name" example="Games">%1$s</xliff:g></string>

    <!-- Debug-only activity name. [DO NOT TRANSLATE] -->
    <string name="debug_memory_activity">* HPROF</string>

    <!-- Strings for the customization mode -->
    <!-- Text for widget add button -->
    <string name="widget_button_text">Widgets</string>
    <!-- Text for wallpaper change button -->
    <string name="wallpaper_button_text">Wallpapers</string>
    <!-- Text for settings button -->
    <string name="settings_button_text">Settings</string>

    <!-- Label on an icon that references an uninstalled package, that is going to be installed at some point. [CHAR_LIMIT=15] -->
    <string name="package_state_enqueued">Waiting</string>
    <!-- Label on an icon that references an uninstalled package, that is currently being downloaded. [CHAR_LIMIT=15] -->
    <string name="package_state_downloading">Downloading</string>
    <!-- Label on an icon that references an uninstalled package, that is currently being installed. [CHAR_LIMIT=15] -->
    <string name="package_state_installing">Installing</string>
    <!-- Label on an icon that references an uninstalled package, for which we have no information about when it might be installed. [CHAR_LIMIT=15] -->
    <string name="package_state_unknown">Unknown</string>
    <!-- Label on an icon that references an uninstalled package, for which restore from market has failed. [CHAR_LIMIT=15] -->
    <string name="package_state_error">Not restored</string>

    <!-- Button for abandoned promises dialog, that removes all abandoned promise icons. -->
    <string name="abandoned_clean_all">Remove All</string>
    <!-- Button for abandoned promises dialog, to removes this abandoned promise icon. -->
    <string name="abandoned_clean_this">Remove</string>
    <!-- Button for abandoned promise dialog, to search in the market for the missing package. -->
    <string name="abandoned_search">Search</string>
    <!-- Title for abandoned promise dialog. -->
    <string name="abandoned_promises_title">This app is not installed</string>
    <!-- Explanation for abandoned promise dialog. "The first 'it' refers to the shortcut icon.
    The second "it" refers to the app. -->
    <string name="abandoned_promise_explanation">The app for this icon isn\'t installed.
        You can remove it, or search for the app and install it manually.
    </string>

<!-- Strings for accessibility actions -->
    <!-- Accessibility action to add an app to workspace. [CHAR_LIMIT=30] -->
    <string name="action_add_to_workspace">Add To Workspace</string>

    <!-- Accessibility confirmation for item added to workspace -->
    <string name="item_added_to_workspace">Item added to workspace</string>

    <!-- Accessibility confirmation for item removed-->
    <string name="item_removed_from_workspace">Item removed from workspace</string>

    <!-- Accessibility action to move an item on the workspace. [CHAR_LIMIT=30] -->
    <string name="action_move">Move Item</string>

    <!-- Accessibility description to move item to empty cell. -->
    <string name="move_to_empty_cell">Move to empty cell <xliff:g id="number" example="1">%1$s</xliff:g>, <xliff:g id="number" example="1">%2$s</xliff:g></string>

    <!-- Accessibility confirmation for item move -->
    <string name="item_moved">Item moved</string>

    <!-- Accessibility description to move item into an existing folder. -->
    <string name="add_to_folder">Add to folder: <xliff:g id="name" example="Games">%1$s</xliff:g></string>

    <!-- Accessibility confirmation for item added to folder-->
    <string name="added_to_folder">Item added to folder</string>

    <!-- Accessibility description to create folder with another item. -->
    <string name="create_folder_with">Create folder with: <xliff:g id="name" example="Game">%1$s</xliff:g></string>

    <!-- Accessibility confirmation for folder created -->
    <string name="folder_created">Folder created</string>

</resources>
