<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 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">
    <!-- [CHAR LIMIT=60] -->
    <string name="app_name">Permission controller</string>

    <!-- [CHAR LIMIT=15] -->
    <string name="ok">OK</string>

    <!-- Keyword in the Settings app's search functionality that can be used to find links to the permissions management screens [CHAR LIMIT=none] -->
    <string name="permission_search_keyword">permissions</string>

    <!-- Button label for generic cancel action [CHAR LIMIT=20] -->
    <string name="cancel">Cancel</string>

    <!-- Button label for back action [CHAR LIMIT=20] -->
    <string name="back">Back</string>

    <!-- Button label for uninstall or disable actions [CHAR LIMIT=none] -->
    <string name="uninstall_or_disable">Uninstall or disable</string>

    <!--  [CHAR LIMIT=30] -->
    <string name="app_not_found_dlg_title">App not found</string>

    <!-- Title for the dialog button to deny a permission grant. [CHAR LIMIT=20] -->
    <string name="grant_dialog_button_deny">Don\u2019t allow</string>

    <!-- Title for the dialog button to always deny a permission grant from now on. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_deny_and_dont_ask_again">Don\u2019t allow \u0026 don\u2019t ask again</string>

    <!-- Title for the dialog button to deny a change from foreground to background permission grant. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_no_upgrade">Keep \u201cWhile the app is in use\u201d</string>

    <!-- Title for the dialog button to deny a change from one-time to background permission grant. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_no_upgrade_one_time">Keep \u201cOnly this time\u201d</string>

    <!-- Title for the dialog button to get more info about a permission. [CHAR LIMIT=15] -->
    <string name="grant_dialog_button_more_info">More info</string>

    <!-- Title for the dialog button to deny a permission grant despite a warning of implications. [CHAR LIMIT=30] -->
    <string name="grant_dialog_button_deny_anyway">Don\u2019t allow anyway</string>

    <!-- Alternative dialog button to deny a permission, but phrased as dismissing the dialog. Currently only used in automotive. [CHAR LIMIT=20] -->
    <string name="grant_dialog_button_dismiss">Dismiss</string>

    <!-- Template for the current permission from the total number of permissions. [CHAR LIMIT=100] -->
    <string name="current_permission_template">
        <xliff:g id="current_permission_index" example="1">%1$s</xliff:g> of
        <xliff:g id="permission_count" example="2">%2$s</xliff:g></string>

    <!-- Template for the warning message when an app requests a permission. [CHAR LIMIT=100] -->
    <string name="permission_warning_template">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to
        <xliff:g id="action" example="do something">%2$s</xliff:g>?</string>

    <!-- Template for the warning message when an app requests the permission to access a
    resource even while in the background (i.e. always). [CHAR LIMIT=100] -->
    <string name="permission_add_background_warning_template">Always allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to
        <xliff:g id="action" example="do something">%2$s</xliff:g>?</string>

    <!-- Radio button shown for permissions that can be granted either only while the app is in
    foreground or always. If this button is selected the app only gets the permission while in
    foreground [CHAR LIMIT=50] -->
    <string name="allow_permission_foreground_only">Only while using app</string>

    <!-- Radio button shown for permissions that can be granted either only while the app is in
    foreground or always. If this button is selected the app always gets the permission (while in
    foreground _and_ while in background) [CHAR LIMIT=50] -->
    <string name="allow_permission_always">Always</string>

    <!-- Radio button shown for permissions that can be granted either only while the app is in
    foreground or always. If this button is selected the app does not get the permission and the
    permissions will always be denied from now on [CHAR LIMIT=50] -->
    <string name="deny_permission_deny_and_dont_ask_again">Don\u2019t allow and don\u2019t ask again</string>

    <!-- Template for the message how many permissions are disabled. [CHAR LIMIT=30] -->
    <string name="permission_revoked_count"><xliff:g id="count" example="2">%1$d</xliff:g> disabled</string>

    <!-- Message that all permissions are disabled. [CHAR LIMIT=30]  -->
    <string name="permission_revoked_all">all disabled</string>

    <!-- Message that no permissions are disabled. [CHAR LIMIT=30]  -->
    <string name="permission_revoked_none">none disabled</string>

    <!-- Title for the dialog button to allow a permission grant. [CHAR LIMIT=15]  -->
    <string name="grant_dialog_button_allow">Allow</string>

    <!-- Title for the dialog button to allow a permission grant when you can also only allow in the foreground. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_allow_always">Allow all the time</string>

    <!-- Title for the dialog button to allow a permission grant only when the app is in the foreground. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_allow_foreground">While using the app</string>

    <!-- Title for the dialog button to change to precise location. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_change_to_precise_location">Change to precise location</string>

    <!-- Title for the dialog button to keep approximate location. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_keey_approximate_location">Keep approximate location</string>

    <!-- Title for the dialog button to allow a permission grant temporarily in teh foreground. [CHAR LIMIT=60] -->
    <string name="grant_dialog_button_allow_one_time">Only this time</string>

    <!-- Title for the dialog button to allow a change from foreground to background permission grant. [CHAR LIMIT=60]  -->
    <string name="grant_dialog_button_allow_background">Allow all the time</string>

    <!-- Title for the dialog button to allow a permission grant for all files. [CHAR LIMIT=60]  -->
    <string name="grant_dialog_button_allow_all_files">Allow management of all files</string>

    <!-- Title for the dialog button to allow a permission grant for media files only. [CHAR LIMIT=60]  -->
    <string name="grant_dialog_button_allow_media_only">Allow access to media files</string>

    <!-- Breadcrumb for page of managing application permissions [CHAR LIMIT=50] -->
    <string name="app_permissions_breadcrumb">Apps</string>

    <!-- Title for page of managing application permissions [CHAR LIMIT=30] -->
    <string name="app_permissions">App permissions</string>

    <!-- Title for the page of manage unused apps [CHAR LIMIT=30] -->
    <string name="unused_apps">Unused apps</string>

    <!-- Label when there are no unused apps [CHAR LIMIT=30] -->
    <string name="no_unused_apps">No unused apps</string>

    <!-- Label when there are zero unused apps [CHAR LIMIT=30] -->
    <string name="zero_unused_apps">0 unused apps</string>

    <!-- [CHAR LIMIT=30] Manage applications, label for option to disable app -->
    <string name="app_disable_dlg_positive">Disable app</string>

    <!-- [CHAR LIMIT=NONE] Manage applications, text for dialog when disabling apps -->
    <string name="app_disable_dlg_text">If you disable this app, Android and other apps may no longer function as intended. Keep in mind, you can\u2019t delete this app since it came pre-installed on your device. By disabling, you turn this app off and hide it on your device.</string>

    <!-- Title for page of managing application permissions [CHAR LIMIT=30] -->
    <string name="app_permission_manager">Permission manager</string>

    <!-- Checkbox that allows user to not be questioned about this permission
         request again [CHAR LIMIT=30] -->
    <string name="never_ask_again">Don\'t ask again</string>

    <!-- Label when app requests no permissions [CHAR LIMIT=30] -->
    <string name="no_permissions">No permissions</string>

    <!-- Label for button that leads to more permissions [CHAR LIMIT=40] -->
    <string name="additional_permissions">Additional permissions</string>

    <!-- Accessibility label for button opening the app-info when clicked [CHAR LIMIT=none] -->
    <string name="app_permissions_info_button_label">Open app info</string>

    <!-- Description of how many more permissions to view on next page [CHAR LIMIT=30] -->
    <plurals name="additional_permissions_more">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> more</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$d</xliff:g> more</item>
    </plurals>

    <!-- Warning for turning off permissions on older apps [CHAR LIMIT=none] -->
    <string name="old_sdk_deny_warning">This app was designed for an older version of Android. Denying permission may cause it to no longer function as intended.</string>

    <!-- The default description of a permission, i.e. what it does.  [CHAR LIMIT=40] -->
    <string name="default_permission_description">perform an unknown action</string>

    <!-- Summary of number of apps currently granted a single permission [CHAR LIMIT=45] -->
   <string name="app_permissions_group_summary"><xliff:g id="count" example="10">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$d</xliff:g> apps allowed</string>

    <!-- Summary of number of apps currently granted a single permission [CHAR LIMIT=45] -->
    <string name="app_permissions_group_summary2"><xliff:g id="count" example="10">%1$d</xliff:g>/<xliff:g id="count" example="10">%2$d</xliff:g> apps allowed</string>

   <!-- [CHAR LIMIT=NONE] Menu for manage permissions to control whether system apps are shown -->
   <string name="menu_show_system">Show system</string>
   <!-- [CHAR LIMIT=NONE] Menu for manage permissions to control whether system apps are hidden -->
   <string name="menu_hide_system">Hide system</string>

    <!-- FAB text of permission usage fragment [CHAR LIMIT=30] -->
    <string name="manage_permission">Manage permission</string>

   <!-- [CHAR LIMIT=NONE] Label when no apps requesting this permission -->
   <string name="no_apps">No apps</string>

   <!-- [CHAR LIMIT=30] Title of button that leads to location settings -->
   <string name="location_settings">Location Settings</string>

   <!-- [CHAR LIMIT=NONE] Warning about how this app cannot have location permission disabled -->
   <string name="location_warning"><xliff:g id="app_name" example="Package Installer">%1$s</xliff:g> is a provider of location services for this device. Location access can be modified from location settings.</string>

   <!-- [CHAR LIMIT=NONE] Warning message when turning off permission for system apps -->
   <string name="system_warning">If you deny this permission, basic features of your device may no longer function as intended.</string>

    <!-- [CHAR LIMIT=NONE] Warning message when turning off permission for an app managing a companion device -->
    <string name="cdm_profile_revoke_warning">If you deny this permission, some features of your device managed by this app may no longer function as intended.</string>

   <!-- [CHAR LIMIT=NONE] Summary of a permission switch when it's enforced by policy -->
   <string name="permission_summary_enforced_by_policy">Enforced by policy</string>

   <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is denied by policy -->
   <string name="permission_summary_disabled_by_policy_background_only">Background access disabled by policy</string>

   <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is enabled by policy -->
   <string name="permission_summary_enabled_by_policy_background_only">Background access enabled by policy</string>

   <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is enabled by policy -->
   <string name="permission_summary_enabled_by_policy_foreground_only">Foreground access enabled by policy</string>

    <!-- [CHAR LIMIT=60] Summary of a permission switch when it's enforced by an administrator -->
   <string name="permission_summary_enforced_by_admin">Controlled by admin</string>

    <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is denied by an admin -->
    <string name="permission_summary_disabled_by_admin_background_only">Background access disabled by admin</string>

    <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is enabled an admin -->
    <string name="permission_summary_enabled_by_admin_background_only">Background access enabled by admin</string>

    <!-- [CHAR LIMIT=60] Summary of a permission switch when the background access is enabled an admin -->
    <string name="permission_summary_enabled_by_admin_foreground_only">Foreground access enabled by admin</string>

    <!-- [CHAR LIMIT=60] Summary of a permission switch when the access is enabled by the system -->
    <string name="permission_summary_enabled_system_fixed">Device requires this permission to operate</string>

    <string-array name="background_access_chooser_dialog_choices">
       <item>@string/permission_access_always</item>
       <item>@string/permission_access_only_foreground</item>
       <item>@string/permission_access_never</item>
   </string-array>

   <!-- [CHAR LIMIT=60] App can always (when app is in foreground or background) access the resource protected by the permission -->
   <string name="permission_access_always">Allow all the time</string>

   <!-- [CHAR LIMIT=60] App can only access the resource protected by the permission while app is in foreground -->
   <string name="permission_access_only_foreground">Allow only while using the app</string>

   <!-- [CHAR LIMIT=60] App can never access the resource protected by the permission (Not while app is in foregound and not while app is in background) -->
   <string name="permission_access_never">Don\u2019t allow</string>

    <!-- Text displayed until loading is done [CHAR LIMIT=50] -->
   <string name="loading">Loading\u2026</string>

   <!-- [CHAR LIMIT=45] Title of all permissions settings -->
   <string name="all_permissions">All permissions</string>
   <!-- [CHAR LIMIT=45] Group of permissions granted to app automatically when installed. -->
   <string name="other_permissions">Other app capabilities</string>

   <!-- Title of the permission dialog for accessibility purposes- spoken to the user. [CHAR LIMIT=none] -->
   <string name="permission_request_title">Permission request</string>

    <!-- Title for the dialog that warns the user they need to turn off screen overlays
         before permissions can be changed. [CHAR LIMIT=NONE] -->
   <string name="screen_overlay_title">Screen overlay detected</string>

   <!-- Message for the dialog that warns the user they need to turn off screen overlays
        before permissions can be changed. The "Settings > Apps" conveys to the user to
        go to Settings and click on apps, this may need updates in RTL languages. [CHAR LIMIT=NONE] -->
   <string name="screen_overlay_message">To change this permission setting, you first have to turn off the screen overlay from Settings \u003e Apps</string>

    <!-- Button for the dialog that warns the user they need to turn off screen overlays
         before permissions can be changed. [CHAR LIMIT=NONE] -->
    <string name="screen_overlay_button">Open settings</string>

    <!-- Title of dialog telling users that Install/Uninstall action is not supported on Android Wear. [CHAR LIMIT=30] -->
    <string name="wear_not_allowed_dlg_title">Android Wear</string>
    <!-- Title of dialog telling users that Install/Uninstall action is not supported on Android Wear. [CHAR LIMIT=none] -->
    <string name="wear_not_allowed_dlg_text">Install/Uninstall actions not supported on Wear.</string>

    <!-- Review of runtime permissions for legacy apps -->

    <!-- Template for the screen title when app permissions are reviewed on install. [CHAR LIMIT=none] -->
    <string name="permission_review_title_template_install">Choose what to allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access</string>

    <!-- Template for the screen title when app permissions are reviewed on update. [CHAR LIMIT=none] -->
    <string name="permission_review_title_template_update">
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> has been updated.
        Choose what to allow this app to access.</string>

    <!-- Title for the dialog button to cancel the detailed permission review. [CHAR LIMIT=15] -->
    <string name="review_button_cancel">Cancel</string>

    <!-- Title for the dialog button to continue accepting the detailed permission review. [CHAR LIMIT=15] -->
    <string name="review_button_continue">Continue</string>

    <!-- Title for the category listing the new permissions used by an app. [CHAR LIMIT=30] -->
    <string name="new_permissions_category">New permissions</string>

    <!-- Title for the category listing the current permissions used by an app. [CHAR LIMIT=30] -->
    <string name="current_permissions_category">Current permissions</string>

    <!-- Message that the app to be installed is being staged [CHAR LIMIT=50] -->
    <string name="message_staging">Staging app&#8230;</string>

    <!-- Placeholder for an app name when it is unknown [CHAR LIMIT=50] -->
    <string name="app_name_unknown">Unknown</string>

    <!-- Help URL, application permissions [DO NOT TRANSLATE] -->
    <string name="help_app_permissions" translatable="false"></string>

    <!-- Title for permission usage [CHAR LIMIT=30] -->
    <string name="permission_usage_title">Privacy dashboard</string>

    <!-- Title for permission group usage [CHAR LIMIT=30] -->
    <string name="permission_group_usage_title"><xliff:g id="permgroup" example="Location">%1$s</xliff:g> usage</string>

    <!-- Title for permission usage advanced info [CHAR LIMIT=30] -->
    <string name="perm_usage_adv_info_title">See other permissions</string>

    <!-- Summary for permission usage advanced info for 2 items [CHAR LIMIT=60] -->
    <string name="perm_usage_adv_info_summary_2_items"><xliff:g id="permgroup" example="Location">%1$s</xliff:g>,\u0020<xliff:g id="permgroup" example="Location">%2$s</xliff:g></string>

    <!-- Summary for permission usage advanced info for 3 or more items [CHAR LIMIT=60] -->
    <string name="perm_usage_adv_info_summary_more_items"><xliff:g id="permgroup" example="Location">%1$s</xliff:g>,\u0020<xliff:g id="permgroup" example="Location">%2$s</xliff:g>, and\u0020<xliff:g id="num" example="7">%3$s</xliff:g> more</string>

    <!-- Subtitle for permission group usage [CHAR LIMIT=100] -->
    <string name="permission_group_usage_subtitle">Timeline of when apps used your <xliff:g id="permgroup" example="Location">%1$s</xliff:g> in the past 24 hours</string>

    <!-- Subtitle for access time list dialog [CHAR LIMIT=100] -->
    <string name="permission_usage_access_dialog_subtitle">When this app used your <xliff:g id="permgroup" example="Location">%1$s</xliff:g> permission</string>

    <!-- Link text for intent out to location provider [CHAR LIMIT=20] -->
    <string name="permission_usage_access_dialog_learn_more">Learn more</string>

    <!-- Label which separates a proxy app name (an app which uses apermission on behalf of another app), and a usage duration, with a bullet point [CHAR LIMIT=NONE]-->
    <string name="permission_usage_duration_and_proxy"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> \u2022 <xliff:g id="truncated_time" example="1 hr 20min">%2$s</xliff:g></string>

    <!-- Duration used for a permission in days -->
    <plurals name="duration_used_days">
        <item quantity="one">1 day</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> days</item>
    </plurals>

    <!-- Duration used for a permission in hours -->
    <plurals name="duration_used_hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> hours</item>
    </plurals>

    <!-- Duration used for a permission in minutes -->
    <plurals name="duration_used_minutes">
        <item quantity="one">1 min</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> mins</item>
    </plurals>

    <!-- Duration used for a permission in seconds -->
    <plurals name="duration_used_seconds">
        <item quantity="one">1 sec</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> secs</item>
    </plurals>


    <!-- Summary for showing a single permission access and the number of accesses [CHAR LIMIT=80] -->
    <plurals name="permission_usage_summary">
        <item quantity="one">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> access</item>
        <item quantity="other">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> accesses</item>
    </plurals>

    <!-- Summary for showing a single permission access and the number of accesses, including those in the background [CHAR LIMIT=80] -->
    <plurals name="permission_usage_summary_background">
        <item quantity="one">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> access (<xliff:g id="num" example="7">%3$s</xliff:g> in background)</item>
        <item quantity="other">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> accesses (<xliff:g id="num" example="7">%3$s</xliff:g> in background)</item>
    </plurals>

    <!-- Summary for showing a single permission access and the number of accesses [CHAR LIMIT=120] -->
    <plurals name="permission_usage_summary_duration">
        <item quantity="one">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> access\nDuration: <xliff:g id="time" example="2 hours">%3$s</xliff:g></item>
        <item quantity="other">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> accesses\nDuration: <xliff:g id="time" example="2 hours">%3$s</xliff:g></item>
    </plurals>

    <!-- Summary for showing a single permission access and the number of accesses, including those in the background [CHAR LIMIT=120] -->
    <plurals name="permission_usage_summary_background_duration">
        <item quantity="one">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> access (<xliff:g id="num" example="7">%3$s</xliff:g> in background)\nDuration: <xliff:g id="time" example="2 hours">%3$s</xliff:g></item>
        <item quantity="other">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\n<xliff:g id="num" example="42">%2$s</xliff:g> accesses (<xliff:g id="num" example="7">%3$s</xliff:g> in background)\nDuration: <xliff:g id="time" example="2 hours">%3$s</xliff:g></item>
    </plurals>

    <!-- Summary for showing a single permission access and the time of the last access when it was in the background [CHAR LIMIT=80] -->
    <string name="permission_usage_summary_background">Last access: <xliff:g id="time" example="12:10 PM">%1$s</xliff:g>\nLast accessed in the background</string>

    <!-- Description for showing permission accesses with any permission [CHAR LIMIT=30] -->
    <string name="permission_usage_any_permission">Any permission</string>

    <!-- Description for showing permission accesses accessed any time [CHAR LIMIT=30] -->
    <string name="permission_usage_any_time">Any time</string>

    <!-- Description for showing permissions accessed in the last 7 days [CHAR LIMIT=30] -->
    <string name="permission_usage_last_7_days">Last 7 days</string>

    <!-- Description for showing permissions accessed in the last day [CHAR LIMIT=30] -->
    <string name="permission_usage_last_day">Last 24 hours</string>

    <!-- Description for showing permissions accessed in the last hour [CHAR LIMIT=30] -->
    <string name="permission_usage_last_hour">Last 1 hour</string>

    <!-- Description for showing permissions accessed in the last 15 minutes [CHAR LIMIT=30] -->
    <string name="permission_usage_last_15_minutes">Last 15 minutes</string>

    <!-- Description for showing permissions accessed in the last minute [CHAR LIMIT=30] -->
    <string name="permission_usage_last_minute">Last 1 minute</string>

    <!-- Label when no apps have used the requested permissions [CHAR LIMIT=30] -->
    <string name="no_permission_usages">No permission usages</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_any_time">Most recent access at any time</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_last_7_days">Most recent access in last 7 days</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_last_day">Most recent access in last 24 hours</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_last_hour">Most recent access in last 1 hour</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_last_15_minutes">Most recent access in last 15 minutes</string>

    <!-- Label for the title of the list of permission usages that shows which apps used which permissions[CHAR LIMIT=50] -->
    <string name="permission_usage_list_title_last_minute">Most recent access in last 1 minute</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_any_time">Permission usage at any time</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_last_7_days">Permission usage in last 7 days</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_last_day">Permission usage in last 24 hours</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_last_hour">Permission usage in last 1 hour</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_last_15_minutes">Permission usage in last 15 minutes</string>

    <!-- Label for the title of the permission bar chart showing how often the most common permissions are used [CHAR LIMIT=50] -->
    <string name="permission_usage_bar_chart_title_last_minute">Permission usage in last 1 minute</string>

    <!-- Label for the bars on the chart that shows how many apps have used various permissions [CHAR LIMIT=10] -->
    <plurals name="permission_usage_bar_label">
        <item quantity="one">1 app</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> apps</item>
    </plurals>

    <!-- Summary text if a permission usage is not used [CHAR LIMIT=60] -->
    <string name="permission_usage_preference_summary_not_used">Not used in past 24 hours</string>

    <!-- Label for the permission usage preference that shows how many apps have used various permissions [CHAR LIMIT=50] -->
    <plurals name="permission_usage_preference_label">
        <item quantity="one">Used by 1 app</item>
        <item quantity="other">Used by <xliff:g id="number" example="7">%1$d</xliff:g> apps</item>
    </plurals>

    <!-- Label for the button to bring the user to view the details of recent permission accesses [CHAR LIMIT=42] -->
    <string name="permission_usage_view_details">See all in Dashboard</string>

    <!-- DO NOT TRANSLATE Summary placeholder -->
    <string name="summary_placeholder" translatable="false">&#160;</string>

    <!-- Label for filtered view that shows permission usages of a single permission [CHAR LIMIT=40] -->
    <string name="app_permission_usage_filter_label">Filtered by: <xliff:g id="perm" example="Location">%1$s</xliff:g> </string>

    <!-- Label for the text that removes the filter by permission to view all usages [CHAR LIMIT=none] -->
    <string name="app_permission_usage_remove_filter">Remove filter</string>

    <!-- Label for the title of the dialog allowing filtering by permissions [CHAR LIMIT=none] -->
    <string name="filter_by_title">Filter by</string>

    <!-- Label for the menu item allowing filtering by permissions [CHAR LIMIT=none] -->
    <string name="filter_by_permissions">Filter by permissions</string>

    <!-- Label for the menu item allowing filtering by time [CHAR LIMIT=none] -->
    <string name="filter_by_time">Filter by time</string>

    <!-- Label for sorting usages by the number of permissions used [CHAR LIMIT=30] -->
    <string name="sort_spinner_most_permissions">Most permissions</string>

    <!-- Label for sorting usages by the number of accesses [CHAR LIMIT=30] -->
    <string name="sort_spinner_most_accesses">Most accesses</string>

    <!-- Label for sorting usages by the most recent accesses [CHAR LIMIT=30] -->
    <string name="sort_spinner_recent">Recent</string>

    <!-- Label for sorting usages by which app used a permission most recently [CHAR LIMIT=30] -->
    <string name="sort_by_app">Sort by app usage</string>

    <!-- Label for sorting usages by access time [CHAR LIMIT=30] -->
    <string name="sort_by_time">Sort by time</string>

    <!-- Separator for a list of items. Include spaces before and after if needed [CHAR LIMIT=10] -->
    <string name="item_separator">,\u0020</string>

    <!-- Label for refreshing the list of permission usages. [CHAR LIMIT=30] -->
    <string name="permission_usage_refresh">Refresh</string>

    <!-- Subtitle for showing how many apps have accessed a given permission [CHAR LIMIT=20] -->
    <plurals name="permission_usage_permission_filter_subtitle">
        <item quantity="one">1 app</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> apps</item>
    </plurals>

    <!-- Label for the title of permission history. [CHAR LIMIT=20] -->
    <string name="permission_history_title">Permission history</string>

    <!-- Label for the category title of permission history of today. [CHAR LIMIT=20] -->
    <string name="permission_history_category_today">Today</string>

    <!-- Label for the category title of permission history of yesterday. [CHAR LIMIT=20] -->
    <string name="permission_history_category_yesterday">Yesterday</string>

    <!-- Help URL, permission usage [DO NOT TRANSLATE] -->
    <string name="help_permission_usage" translatable="false"></string>

    <!-- Title for permission usage [CHAR LIMIT=30] -->
    <string name="app_permission_usage_title">App permissions usage</string>

    <!-- Summary for an app's use of a permission [CHAR LIMIT=none] -->
    <string name="app_permission_usage_summary">Access: <xliff:g id="num" example="2">%1$s</xliff:g> times. Total duration: <xliff:g id="duration" example="2 hours">%2$s</xliff:g>. Last used <xliff:g id="time" example="2 hours">%3$s</xliff:g> ago.</string>

    <!-- Summary for an app's use of a permission without duration [CHAR LIMIT=none] -->
    <string name="app_permission_usage_summary_no_duration">Access: <xliff:g id="num" example="2">%1$s</xliff:g> times. Last used <xliff:g id="time" example="2 hours">%2$s</xliff:g> ago.</string>

    <!-- Title for the dialog button to allow a permission grant when you cannot only allow in the foreground. [CHAR LIMIT=60] -->
    <string name="app_permission_button_allow">Allow</string>

    <!-- Title for the dialog button to allow a storage permission grant for all files [CHAR LIMIT=60] -->
    <string name="app_permission_button_allow_all_files">Allow management of all files</string>

    <!-- Title for the dialog button to allow a storage permission grant for media files only [CHAR LIMIT=60] -->
    <string name="app_permission_button_allow_media_only">Allow access to media only</string>

    <!-- Title for the dialog button to allow a permission grant when you can also only allow in the foreground. [CHAR LIMIT=60] -->
    <string name="app_permission_button_allow_always">Allow all the time</string>

    <!-- Title for the dialog button to allow a permission grant only when the app is in the foreground. [CHAR LIMIT=60] -->
    <string name="app_permission_button_allow_foreground">Allow only while using the app</string>

    <!-- Title for the dialog button to require an app to ask for a permission next time they need it. [CHAR LIMIT=60] -->
    <string name="app_permission_button_ask">Ask every time</string>

    <!-- Title for the dialog button to deny with prejudice a permission grant. [CHAR LIMIT=60] -->
    <string name="app_permission_button_deny">Don\u2019t allow</string>

    <!-- Content description for precise location image. [CHAR LIMIT=50] -->
    <string name="precise_image_description">Precise location</string>

    <!-- Content description for approximate location image. [CHAR LIMIT=50] -->
    <string name="approximate_image_description">Approximate location</string>

    <!-- Title for location accuracy switch in location settings. [CHAR LIMIT=60] -->
    <string name="app_permission_location_accuracy">Use precise location</string>

    <!-- Subtitle for location accuracy switch in location settings. [CHAR LIMIT=none] -->
    <string name="app_permission_location_accuracy_subtitle">When precise location is off, apps can access your approximate location</string>

    <!-- Title for app permission [CHAR LIMIT=30] -->
    <string name="app_permission_title"><xliff:g id="perm" example="location">%1$s</xliff:g> permission</string>

    <!-- Description for showing an app's permission [CHAR LIMIT=60] -->
    <string name="app_permission_header"><xliff:g id="perm" example="location">%1$s</xliff:g> access for this app</string>

    <!-- Text for linking to the page that shows an app's permissions [CHAR LIMIT=none] -->
    <string name="app_permission_footer_app_permissions_link">See all <xliff:g id="app" example="Maps">%1$s</xliff:g> permissions</string>

    <!-- Text for linking to the page that shows the apps with a given permission [CHAR LIMIT=none] -->
    <string name="app_permission_footer_permission_apps_link">See all apps with this permission</string>

    <!-- Label for the assistant mic display switch [CHAR LIMIT=60] -->
    <string name="assistant_mic_label">Show assistant microphone usage</string>

    <!-- Label for the auto revoke switch on pre-S devices [CHAR LIMIT=60] -->
    <string name="auto_revoke_label">Remove permissions if app isn\u2019t used</string>

    <!-- Label for the hibernation / auto revoke switch on S+ devices [CHAR LIMIT=40] -->
    <string name="unused_apps_label">Remove permissions and free up space</string>

    <!-- Summary for stating that permissions will be removed [CHAR LIMIT=none] -->
    <string name="auto_revoke_summary">To protect your data, permissions for this app will be removed if the app is unused for a few months.</string>

    <!-- Summary for stating that permissions will be removed, which includes a list of permissions which will be removed [CHAR LIMIT=none] -->
    <string name="auto_revoke_summary_with_permissions">To protect your data, if the app is unused for a few months, the following permissions will be removed: <xliff:g id="perms" example="location, contacts, and phone">%1$s</xliff:g></string>

    <!-- Summary for the screen that shows all apps that have had permissions removed [CHAR LIMIT=none] -->
    <string name="auto_revoked_apps_page_summary">To protect your data, permissions have been removed from apps that you haven\u2019t used in a few months.</string>

    <!-- Message which tells users to open an app to grant permissions [CHAR LIMIT=none]-->
    <string name="auto_revoke_open_app_message">If you want to allow permissions again, open the app.</string>

    <!-- Summary for stating that auto revoke is disabled for the current app [CHAR LIMIT=none] -->
    <string name="auto_revoke_disabled">Automatic removal is currently disabled for this app.</string>

    <!-- Summary for stating that no permission groups that are granted and auto revocable[CHAR LIMIT=none] -->
    <string name="auto_revocable_permissions_none">No auto revocable permissions are currently granted</string>

    <!-- Summary for stating that one permission will be auto revoked[CHAR LIMIT=none] -->
    <string name="auto_revocable_permissions_one"><xliff:g id="perm" example="location">%1$s</xliff:g> permission will be removed.</string>

    <!-- Summary for stating that two permissions will be auto revoked[CHAR LIMIT=none] -->
    <string name="auto_revocable_permissions_two"><xliff:g id="perm" example="location">%1$s</xliff:g> and <xliff:g id="perm" example="contacts">%2$s</xliff:g> permissions will be removed.</string>

    <!-- Summary for stating that more than two permissions will be auto revoked[CHAR LIMIT=none] -->
    <string name="auto_revocable_permissions_many">Permissions that will be removed: <xliff:g id="perms" example="location, contacts, and phone">%1$s</xliff:g>.</string>

    <!-- Title for a page where users can manage whether or not they want Android to automatically remove permissions [CHAR LIMIT=40] -->
    <string name="auto_manage_title">Manage permissions automatically</string>

    <!-- Label for an "off" button [CHAR LIMIT=30] -->
    <string name="off">Off</string>

    <!-- Summary describing the permissions that have been removed from an app, when one permission is removed [CHAR LIMIT=none] -->
    <string name="auto_revoked_app_summary_one"><xliff:g id="permission_name" example="Location">%s</xliff:g> permission removed</string>

    <!-- Summary describing the permissions that have been removed from an app, when two permissions are removed [CHAR LIMIT=none] -->
    <string name="auto_revoked_app_summary_two"><xliff:g id="permission_name" example="Camera">%1$s</xliff:g> and <xliff:g id="permission_name" example="Contacts">%2$s</xliff:g> permissions removed</string>

    <!-- Summary describing the permissions that have been removed from an app, when more than two permissions are removed [CHAR LIMIT=none] -->
    <string name="auto_revoked_app_summary_many"><xliff:g id="permission_name" example="Microphone">%1$s</xliff:g> and <xliff:g id="number" example="2">%2$s</xliff:g> other permissions removed</string>

    <!-- The title of a page showing unused apps that have been hibernated [CHAR LIMIT=60]-->
    <string name="unused_apps_page_title">Unused apps</string>

    <!-- Summary for the screen that shows all unused apps that have been hibernated [CHAR LIMIT=none] -->
    <string name="unused_apps_page_summary">If an app is unused for a few months:\n\n\u2022 Permissions are removed to protect your data\n\u2022 Notifications are stopped to save battery\n\u2022 Temporary files are removed to free up space\n\nTo allow permissions and notifications again, open the app.</string>

    <!-- Title for a category of apps that were last used several months ago [CHAR LIMIT=none] -->
    <string name="last_opened_category_title">Last opened more than <xliff:g id="number" example="3">%s</xliff:g> months ago</string>

    <!-- Summary for showing when an app was last used [CHAR LIMIT=none] -->
    <string name="last_opened_summary">App last opened on <xliff:g id="date" example="March 12, 2020">%s</xliff:g></string>

    <!-- Summary for showing when an app was last used, shorter version [CHAR LIMIT=none] -->
    <string name="last_opened_summary_short">Last opened <xliff:g id="date" example="March 12, 2020">%s</xliff:g></string>

    <!-- Text that explains that an app has access to all files[CHAR LIMIT=none] -->
    <string name="app_permission_footer_special_file_access">If you allow management of all files, this app can access, modify, and delete any files in common storage on this device or connected storage devices. The app may access files without asking you.</string>

    <!-- Text that explains that an app requests full file access, and links to the settings page[CHAR LIMIT=none] -->
    <string name="special_file_access_dialog">Allow this app to access, modify and delete files on the device, or any connected storage devices? This app may access files without asking you.</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have that permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_generic">Apps with this permission can <xliff:g id="description" example="record audio">%1$s</xliff:g></string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the activity recognition permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_activity_recognition">Apps with this permission can access your physical activity, like walking, biking, driving, step count, and more</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the calendar permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_calendar">Apps with this permission can access your calendar</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the call log permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_call_log">Apps with this permission can read and write phone call log</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the camera permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_camera">Apps with this permission can take pictures and record video</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the contacts permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_contacts">Apps with this permission can access your contacts</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the location permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_location">Apps with this permission can access this device\'s location</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the nearby devices permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_nearby_devices">Apps with this permission can find, connect to, and determine the relative position of nearby devices</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the microphone permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_microphone">Apps with this permission can record audio</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the phone permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_phone">Apps with this permission can make and manage phone calls</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the sensors permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_sensors">Apps with this permission can access sensor data about your vital signs</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the SMS permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_sms">Apps with this permission can send and view SMS messages</string>

    <!-- Label for showing a permission group's description in the header of the list of apps that have the Storage permission [CHAR LIMIT=none] -->
    <string name="permission_description_summary_storage">Apps with this permission can access photos, media, and files on your device</string>

    <!-- Summary for showing the time and/or date of the most recent access of a permission by an app [CHAR LIMIT=60] -->
    <string name="app_permission_most_recent_summary">Last access: <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g></string>

    <!-- Summary for showing the time and/or date of the most recent access of a denied permission by an app [CHAR LIMIT=60] -->
    <string name="app_permission_most_recent_denied_summary">Currently denied / Last access: <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g></string>

    <!-- Summary for showing that a denied app has not accessed a permission. [CHAR LIMIT=60] -->
    <string name="app_permission_never_accessed_summary">Never accessed</string>

    <!-- Summary for showing that an app has not accessed a permission. [CHAR LIMIT=60] -->
    <string name="app_permission_never_accessed_denied_summary">Denied / Never accessed</string>

    <!-- Header for granted permissions/apps [CHAR LIMIT=40] -->
    <string name="allowed_header">Allowed</string>

    <!-- Header for granted apps that can access the permission in the foreground and the background [CHAR LIMIT=40] -->
    <string name="allowed_always_header">Allowed all the time</string>

    <!-- Header for permissions/apps that are granted only when in the foreground [CHAR LIMIT=40] -->
    <string name="allowed_foreground_header">Allowed only while in use</string>

    <!-- Subtitle for scoped storage permissions, showing apps that have access to media files only [CHAR LIMIT=45] -->
    <string name="allowed_storage_scoped">Allowed access to media only</string>

    <!-- Subtitle for full storage permissions, showing apps that have access to all files [CHAR LIMIT=45] -->
    <string name="allowed_storage_full">Allowed to manage all files</string>

    <!-- Header for permissions/apps which need to ask next time they want to use the permission. Note: Permission may or may not be currently granted [CHAR LIMIT=60] -->
    <string name="ask_header">Ask every time</string>

    <!-- Header for denied permissions/apps [CHAR LIMIT=40] -->
    <string name="denied_header">Not allowed</string>

    <!-- Time in days -->
    <plurals name="days">
        <item quantity="one">1 day</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> days</item>
    </plurals>

    <!-- Time in hours -->
    <plurals name="hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> hours</item>
    </plurals>

    <!-- Time in minutes -->
    <plurals name="minutes">
        <item quantity="one">1 minute</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> minutes</item>
    </plurals>

    <!-- Time in seconds -->
    <plurals name="seconds">
        <item quantity="one">1 second</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> seconds</item>
    </plurals>

    <!-- The name of the notification channel containing reminders about permission [CHAR LIMIT=60]-->
    <string name="permission_reminders">Permission reminders</string>

    <!-- The notification title for the notification that a permission auto revoke has happened for one app (outdated) [CHAR LIMIT=60] -->
    <string name="auto_revoke_permission_reminder_notification_title_one">1 unused app</string>

    <!-- The notification title for the notification that a permission auto revoke has happened for more than one app (outdated) [CHAR LIMIT=60] -->
    <string name="auto_revoke_permission_reminder_notification_title_many"><xliff:g id="number_of_apps" example="4">%s</xliff:g> unused apps</string>

    <!-- The notification content for the auto revoke reminder notification (outdated) [CHAR LIMIT=none] -->
    <string name="auto_revoke_permission_reminder_notification_content">Permissions removed to protect your privacy. Tap to review</string>

    <!-- The notification title for the notification that a permission auto revoked has happened [CHAR LIMIT=60] -->
    <string name="auto_revoke_permission_notification_title">Permissions removed for unused apps</string>

    <!-- The notification content for the auto revoke reminder notification [CHAR LIMIT=none] -->
    <string name="auto_revoke_permission_notification_content">Some apps haven\u2019t been used in a few months. Tap to review.</string>

    <!-- The subtitle for the auto revoke reminder notification, including the number of apps [CHAR LIMIT=none] -->
    <plurals name="auto_revoke_permission_notification_content_count">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> app hasn\u2019t been used in a few months. Tap to review</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$d</xliff:g> apps haven\u2019t been used in a few months. Tap to review</item>
    </plurals>

    <!-- The notification title for the notification that app hibernation has happened [CHAR LIMIT=60] -->
    <plurals name="unused_apps_notification_title">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> unused app</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$d</xliff:g> unused apps</item>
    </plurals>

    <!-- The notification content for the hibernation reminder notification [CHAR LIMIT=none] -->
    <string name="unused_apps_notification_content">Permissions and temporary files have been removed and notifications were stopped. Tap to review.</string>

    <!-- The subtitle for the auto revoke settings card [CHAR LIMIT=none] -->
    <string name="auto_revoke_setting_subtitle">Some apps haven\u2019t been used in a few months</string>

    <!-- The subtitle for the auto revoke settings card, including the number of apps [CHAR LIMIT=none] -->
    <plurals name="auto_revoke_setting_subtitle_count">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> app hasn\u2019t been used in a few months</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$d</xliff:g> apps haven\u2019t been used in a few months</item>
    </plurals>

    <!-- The title of the category showing apps with removed permissions [CHAR LIMIT=60] -->
    <string name="permissions_removed_category_title">Removed permissions</string>

    <!-- The title of a page showing apps with removed permissions [CHAR LIMIT=60]-->
    <string name="permission_removed_page_title">Permissions removed</string>

    <!-- The title of the category showing all unused apps [CHAR LIMIT=60]-->
    <string name="all_unused_apps_category_title">All unused apps</string>

    <!-- String stating how many months ago an app was used [CHAR LIMIT=none] -->
    <string name="months_ago"><xliff:g id="count" example="2">%1$d</xliff:g> months ago</string>

    <!-- The summary for the auto revoke preference [CHAR LIMIT=none] -->
    <string name="auto_revoke_preference_summary">Permissions removed to protect your privacy</string>

    <!-- The notification title for background location access reminder notification [CHAR LIMIT=60] -->
    <string name="background_location_access_reminder_notification_title"><xliff:g id="app_name" example="Gmail">%s</xliff:g> got your location in the background</string>

    <!-- The notification content for background location access reminder notification [CHAR LIMIT=none] -->
    <string name="background_location_access_reminder_notification_content">This app can always access your location. Tap to change.</string>

    <!-- The notification title for the notification that a permission auto revoke has happened [CHAR LIMIT=60] -->
    <string name="auto_revoke_after_notification_title">App permissions removed to protect privacy</string>

    <!-- The notification content for the notification that a permission auto revoke has happened for one app [CHAR LIMIT=none] -->
    <string name="auto_revoke_after_notification_content_one"><xliff:g id="app_name" example="Gmail">%s</xliff:g> hasn\u2019t been used in a few months. Tap to review.</string>

    <!-- The notification content for the notification that a permission auto revoke has happened for two apps [CHAR LIMIT=none] -->
    <string name="auto_revoke_after_notification_content_two"><xliff:g id="app_name" example="Gmail">%s</xliff:g> and 1 other app haven\u2019t been used in a few months. Tap to review.</string>

    <!-- The notification content for the notification that a permission auto revoke has happened for more than two apps [CHAR LIMIT=none] -->
    <string name="auto_revoke_after_notification_content_many"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> and <xliff:g id="number_of_apps" example="4">%2$s</xliff:g> other apps haven\u2019t been used in a few months. Tap to review.</string>

    <!-- The notification title for the notification that 1 app is unused [CHAR LIMIT=60] -->
    <string name="auto_revoke_before_notification_title_one">1 app is unused</string>

    <!-- The notification title for the notification that a permission auto revoke has happened [CHAR LIMIT=60] -->
    <string name="auto_revoke_before_notification_title_many"><xliff:g id="number_of_apps" example="4">%s</xliff:g> apps are unused</string>

    <!-- The notification content for the notification that a permission auto revoke has happened for one app [CHAR LIMIT=none] -->
    <string name="auto_revoke_before_notification_content_one">Permissions will be removed to protect your privacy. Tap to review.</string>

    <!-- Title for the unused app screen [CHAR LIMIT=30] -->
    <string name="unused_apps_title">Unused apps</string>

    <!-- Subtitle for the unused app screen, after permissions have been removed [CHAR LIMIT=none] -->
    <string name="unused_apps_subtitle_after">Permissions removed from</string>

    <!-- Subtitle for the unused app screen, before permissions have been removed [CHAR LIMIT=none] -->
    <string name="unused_apps_subtitle_before">Permissions will be removed from</string>

    <!-- Subtitle for an app with unused permissions, listing two permissions [CHAR LIMIT=none] -->
    <string name="unused_permissions_subtitle_two"><xliff:g id="perm_name" example="Location">%1$s</xliff:g> and <xliff:g id="perm_name" example="Contacts">%2$s</xliff:g></string>

    <!-- Subtitle for an app with unused permissions, listing more than two permissions [CHAR LIMIT=none] -->
    <string name="unused_permissions_subtitle_many"><xliff:g id="perm_name" example="Location">%1$s</xliff:g>, <xliff:g id="perm_name" example="Contacts">%2$s</xliff:g>, and <xliff:g id="number_of_permissions" example="4">%3$s</xliff:g> more</string>

    <!-- Summary explaining that permissions for unused apps have be removed [CHAR LIMIT=none] -->
    <string name="unused_app_permissions_removed_summary">To protect your data, permissions have been removed from apps that you haven\u2019t used in a few months</string>

    <!-- Summary explaining that permissions for unused apps have be removed. Has "some apps", instead of "apps" [CHAR LIMIT=none] -->
    <string name="unused_app_permissions_removed_summary_some">To protect your data, permissions have been removed from some apps that you haven\u2019t used in a few months</string>

    <!-- Summary listing that one app is unused [CHAR LIMIT=none] -->
    <string name="one_unused_app_summary">1 app hasen\u2019t been used for a few months</string>

    <!-- Summary listing how many apps are unused [CHAR LIMIT=none] -->
    <string name="num_unused_apps_summary"><xliff:g id="number_of_apps" example="4">%s</xliff:g> apps haven\u2019t been used for a few months</string>

    <!-- Subtitle for the preference that is currently granted only when the app is in the foreground. [CHAR LIMIT=60] -->
    <string name="permission_subtitle_only_in_foreground">Only while app is in use</string>

    <!-- Subtitle for a storage preference that is currently granted for Media files only. [CHAR LIMIT=60] -->
    <string name="permission_subtitle_media_only">Media</string>

    <!-- Subtitle for a storage preference that is currently granted for all files. [CHAR LIMIT=60] -->
    <string name="permission_subtitle_all_files">All Files</string>

    <!-- Subtitle for the preference that the permission is currently always granted. [CHAR LIMIT=60] -->
    <string name="permission_subtitle_background">Allowed all the time</string>

    <!-- Summary for showing the last access text for sensor data permissions for today [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access">Last accessed <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g></string>

    <!-- Summary for showing the last access text for sensor data permissions for yesterday [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_yest">Last accessed yesterday at <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g></string>

    <!-- Summary for showing the last access text for content provider permissions [CHAR LIMIT=70] -->
    <string name="app_perms_content_provider">Accessed in past 24 hours</string>

    <!-- Subtitle for the preference that the permission is currently always granted. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_background">Last accessed <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 Allowed all the time</string>

    <!-- Subtitle for the preference that the permission is currently always granted. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_yest_background">Last accessed yesterday at <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 Allowed all the time</string>

    <!-- Subtitle for the preference that the permission is currently always granted. [CHAR LIMIT=70] -->
    <string name="app_perms_content_provider_background">Accessed in past 24 hours \u2022 Allowed all the time</string>

    <!-- Subtitle for a storage preference that is currently granted for Media files only. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_media_only">Last accessed <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 Media</string>

    <!-- Subtitle for a storage preference that is currently granted for Media files only. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_yest_media_only">Last accessed yesterday at <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 Media</string>

    <!-- Subtitle for a storage preference that is currently granted for Media files only. [CHAR LIMIT=70] -->
    <string name="app_perms_content_provider_media_only">Accessed in past 24 hours \u2022 Media</string>

    <!-- Subtitle for a storage preference that is currently granted for all files. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_all_files">Last accessed <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 All Files</string>

    <!-- Subtitle for a storage preference that is currently granted for all files. [CHAR LIMIT=70] -->
    <string name="app_perms_24h_access_yest_all_files">Last accessed yesterday at <xliff:g id="time_date" example="12:42 PM">%1$s</xliff:g> \u2022 All Files</string>

    <!-- Subtitle for a storage preference that is currently granted for all files. [CHAR LIMIT=70] -->
    <string name="app_perms_content_provider_all_files">Accessed in past 24 hours \u2022 All Files</string>

    <!-- Label when app has been granted no permissions [CHAR LIMIT=none] -->
    <string name="no_permissions_allowed">No permissions allowed</string>

    <!-- Label when app has been denied no permissions [CHAR LIMIT=none] -->
    <string name="no_permissions_denied">No permissions denied</string>

    <!-- Label when no apps have been granted a given permission [CHAR LIMIT=none] -->
    <string name="no_apps_allowed">No apps allowed</string>

    <!-- Label when no apps have ben granted storage access to all files on a devie [CHAR LIMIT=none] -->
    <string name="no_apps_allowed_full">No apps allowed for all files</string>

    <!-- Label when no apps have been granted storage access to media files on a device [CHAR LIMIT=none] -->
    <string name="no_apps_allowed_scoped">No apps allowed for media only</string>

    <!-- Label when no apps have been denied a given permission [CHAR LIMIT=none] -->
    <string name="no_apps_denied">No apps denied</string>

    <!-- Label for the selected permission state for a given permission and application [CHAR LIMIT=30] -->
    <string name="car_permission_selected">Selected</string>

    <!-- Label for button that opens up the Settings [CHAR LIMIT=20] -->
    <string name="settings">Settings</string>

    <!-- Title for the dialog listing the enabled accessibility services when there is only one [CHAR LIMIT=none] -->
    <string name="accessibility_service_dialog_title_single"><xliff:g id="service_name" example="Gmail">%s</xliff:g> has full access to your device</string>

    <!-- Title for the dialog listing the enabled accessibility services when there are more than one [CHAR LIMIT=none] -->
    <string name="accessibility_service_dialog_title_multiple"><xliff:g id="num_services" example="2">%s</xliff:g> accessibility apps have full access to your device</string>

    <!-- Text for the dialog listing the enabled accessibility services when there is only one [CHAR LIMIT=none] -->
    <string name="accessibility_service_dialog_bottom_text_single"><xliff:g id="service_name" example="Gmail">%s</xliff:g> can view your screen, actions, and inputs, perform actions, and control the display.</string>

    <!-- Text for the dialog listing the enabled accessibility services when there are more than one [CHAR LIMIT=none] -->
    <string name="accessibility_service_dialog_bottom_text_multiple">These apps can view your screen, actions, and inputs, perform actions, and control the display.</string>

    <!-- Label for the assistant role. [CHAR LIMIT=30] -->
    <string name="role_assistant_label">Default digital assistant app</string>
    <!-- Short label for the assistant role. [CHAR LIMIT=30] -->
    <string name="role_assistant_short_label">Digital assistant app</string>
    <!-- Description for the assistant role. [CHAR LIMIT=NONE] -->
    <string name="role_assistant_description">Assist apps can help you based on information from the screen you\u2019re viewing. Some apps support both launcher and voice input services to give you integrated assistance.</string>
    <!-- Template for the title when an app requests to become the default assistant app. [CHAR LIMIT=100] -->
    <string name="role_assistant_request_title">Set <xliff:g id="app_name" example="Super Assistant">%1$s</xliff:g> as your default assist app?</string>
    <!-- Description when an app requests to become the default assistant. [CHAR LIMIT=60] -->
    <string name="role_assistant_request_description">Gets access to SMS, call log</string>

    <!-- Label for the browser role. [CHAR LIMIT=30] -->
    <string name="role_browser_label">Default browser app</string>
    <!-- Short label for the browser role. [CHAR LIMIT=30] -->
    <string name="role_browser_short_label">Browser app</string>
    <!-- Description for the browser role. [CHAR LIMIT=NONE] -->
    <string name="role_browser_description">Apps that give you access to the internet and display links that you tap</string>
    <!-- Template for the title when an app requests to become the default browser app. [CHAR LIMIT=100] -->
    <string name="role_browser_request_title">Set <xliff:g id="app_name" example="Super Browser">%1$s</xliff:g> as your default browser app?</string>
    <!-- Description when an app requests to become the default browser app. [CHAR LIMIT=60] -->
    <string name="role_browser_request_description">No permissions needed</string>

    <!-- Label for the dialer role. [CHAR LIMIT=30] -->
    <string name="role_dialer_label">Default phone app</string>
    <!-- Short label for the dialer role. [CHAR LIMIT=30] -->
    <string name="role_dialer_short_label">Phone app</string>
    <!-- Description for the dialer role. [CHAR LIMIT=NONE] -->
    <string name="role_dialer_description">Apps that allow you to make and receive telephone calls on your device</string>
    <!-- Template for the title when an app requests to become the default dialer app. [CHAR LIMIT=100] -->
    <string name="role_dialer_request_title">Set <xliff:g id="app_name" example="Super Phone">%1$s</xliff:g> as your default phone app?</string>
    <!-- Description when an app requests to become the default dialer app. [CHAR LIMIT=60] -->
    <string name="role_dialer_request_description">Gets access to call log, send SMS</string>
    <!-- Search keywords for the dialer role. [CHAR LIMIT=NONE] -->
    <string name="role_dialer_search_keywords">dialer</string>

    <!-- Label for the SMS role. [CHAR LIMIT=30] -->
    <string name="role_sms_label">Default SMS app</string>
    <!-- Short label for the SMS role. [CHAR LIMIT=30] -->
    <string name="role_sms_short_label">SMS app</string>
    <!-- Description for the SMS role. [CHAR LIMIT=NONE] -->
    <string name="role_sms_description">Apps that allow you to use your phone number to send and receive short text messages, photos, videos, and more</string>
    <!-- Template for the title when an app requests to become the default SMS app. [CHAR LIMIT=100] -->
    <string name="role_sms_request_title">Set <xliff:g id="app_name" example="Super SMS">%1$s</xliff:g> as your default SMS app?</string>
    <!-- Description when an app requests to become the default SMS app. [CHAR LIMIT=60] -->
    <string name="role_sms_request_description">Gets access to contacts, SMS, phone</string>
    <!-- Search keywords for the SMS role. [CHAR LIMIT=NONE] -->
    <string name="role_sms_search_keywords">text message, texting, messages, messaging</string>

    <!-- Label for the emergency role. [CHAR LIMIT=30] -->
    <string name="role_emergency_label">Default emergency app</string>
    <!-- Short label for the emergency role. [CHAR LIMIT=30] -->
    <string name="role_emergency_short_label">Emergency app</string>
    <!-- Description for the emergency role. [CHAR LIMIT=NONE] -->
    <string name="role_emergency_description">Apps that allow you to record your medical info and make it accessible to emergency responders; to get alerts about severe weather events and disasters; to notify others when you need help</string>
    <!-- Template for the title when an app requests to become the default emergency app. [CHAR LIMIT=100] -->
    <string name="role_emergency_request_title">Set <xliff:g id="app_name" example="Super Emergency">%1$s</xliff:g> as your default emergency app?</string>
    <!-- Description when an app requests to become the default emergency app. [CHAR LIMIT=60] -->
    <string name="role_emergency_request_description">No permissions needed</string>
    <!-- Search keywords for the emergency role. The word "ICE" here is short for In Case of Emergency, not frozen water. [CHAR LIMIT=NONE] -->
    <string name="role_emergency_search_keywords">ice</string>

    <!-- Label for the home role. [CHAR LIMIT=30] -->
    <string name="role_home_label">Default home app</string>
    <!-- Short label for the home role. [CHAR LIMIT=30] -->
    <string name="role_home_short_label">Home app</string>
    <!-- Description for the home role. [CHAR LIMIT=NONE] -->
    <string name="role_home_description">Apps, often called launchers, that replace the Home screens on your Android device and give you access to the contents and features of your device</string>
    <!-- Template for the title when an app requests to become the default home app. [CHAR LIMIT=100] -->
    <string name="role_home_request_title">Set <xliff:g id="app_name" example="Super Home">%1$s</xliff:g> as your default home app?</string>
    <!-- Description when an app requests to become the default home app. [CHAR LIMIT=60] -->
    <string name="role_home_request_description">No permissions needed</string>
    <!-- Search keywords for the home role. [CHAR LIMIT=NONE] -->
    <string name="role_home_search_keywords">launcher</string>

    <!-- Label for the call redirection role. [CHAR LIMIT=30] -->
    <string name="role_call_redirection_label">Default call redirecting app</string>
    <!-- Short label for the call redirection role. [CHAR LIMIT=30] -->
    <string name="role_call_redirection_short_label">Call redirecting app</string>
    <!-- Description for the call redirection role. [CHAR LIMIT=NONE] -->
    <string name="role_call_redirection_description">Apps that allow you to forward outgoing calls to another phone number</string>
    <!-- Template for the title when an app requests to become the default call redirection app. [CHAR LIMIT=100] -->
    <string name="role_call_redirection_request_title">Set <xliff:g id="app_name" example="Super Call Redirection">%1$s</xliff:g> as your default call redirection app?</string>
    <!-- Description when an app requests to become the default call redirection app. [CHAR LIMIT=60] -->
    <string name="role_call_redirection_request_description">No permissions needed</string>

    <!-- Label for the call screening role. [CHAR LIMIT=45] -->
    <string name="role_call_screening_label">Default caller ID &amp; spam app</string>
    <!-- Short label for the call screening role. [CHAR LIMIT=30] -->
    <string name="role_call_screening_short_label">Caller ID &amp; spam app</string>
    <!-- Description for the call screening role. [CHAR LIMIT=NONE] -->
    <string name="role_call_screening_description">Apps that allow you to identify calls and block spam, robocalls, or unwanted numbers</string>
    <!-- Template for the title when an app requests to become the default call screening app. [CHAR LIMIT=100] -->
    <string name="role_call_screening_request_title">Set <xliff:g id="app_name" example="Super Call Screening">%1$s</xliff:g> as your default caller ID &amp; spam app?</string>
    <!-- Description when an app requests to become the default call screening app. [CHAR LIMIT=60] -->
    <string name="role_call_screening_request_description">No permissions needed</string>

    <!-- Description for the watch profile role. [CHAR LIMIT=NONE] -->
    <string name="role_watch_description"><xliff:g id="app_name" example="Wear">%1$s</xliff:g> will be allowed to interact with your notifications and access your Phone, SMS, Contacts and Calendar permissions.</string>

    <!-- Subtitle for the application that is the current default application [CHAR LIMIT=30] -->
    <string name="request_role_current_default">Current default</string>

    <!-- Label for the checkbox to always deny a role request from an application from now on [CHAR LIMIT=30] -->
    <string name="request_role_dont_ask_again">Don\u2019t ask again</string>

    <!-- Label for the button to set an application as the default application [CHAR LIMIT=20] -->
    <string name="request_role_set_as_default">Set as default</string>

    <!-- Message telling the user that a phone call is currently using the microphone [CHAR LIMIT=none] -->
    <string name="phone_call_uses_microphone">Microphone is used in &lt;b>phone call&lt;/b></string>
    <!-- Message telling the user that a phone call is currently using the microphone and the camera [CHAR LIMIT=none] -->
    <string name="phone_call_uses_microphone_and_camera">Camera and Microphone are used in &lt;b>video call&lt;/b></string>
    <!-- Message telling the user that a phone call is currently using the camera [CHAR LIMIT=none] -->
    <string name="phone_call_uses_camera">Camera is used in &lt;b>video call&lt;/b></string>

    <!-- Message telling the user that a system service is currently using the microphone [CHAR LIMIT=none] -->
    <string name="system_uses_microphone">Microphone is accessed using system service</string>
    <!-- Message telling the user that a system service is currently using the microphone and the camera [CHAR LIMIT=none] -->
    <string name="system_uses_microphone_and_camera">Camera and Microphone are accessed using system service</string>
    <!-- Message telling the user that a system service is currently using the camera [CHAR LIMIT=none] -->
    <string name="system_uses_camera">Camera is accessed using system service</string>

    <!-- Line above a list of other apps and system service that are currently microphone or camera [CHAR LIMIT=60] -->
    <string name="other_use">Other use:</string>

    <!-- Action for accepting the Ongoing usage dialog [CHAR LIMIT=10]-->
    <string name="ongoing_usage_dialog_ok">Got it</string>

    <!-- Title for Ongoing usage dialog title when multiple apps are using app ops [CHAR LIMIT=NONE] -->
    <string name="ongoing_usage_dialog_title">Recent use of <xliff:g id="types_list" example="camera( and location)">%s</xliff:g></string>

    <!-- Title for Ongoing usage dialog title when apps are using microphone [CHAR LIMIT=NONE] -->
    <string name="ongoing_usage_dialog_title_mic">Recent use of Microphone</string>

    <!-- Title for Ongoing usage dialog title when apps are using camera [CHAR LIMIT=NONE] -->
    <string name="ongoing_usage_dialog_title_camera">Recent use of Camera</string>

    <!-- Title for Ongoing usage dialog title when apps are using camera and microphone [CHAR LIMIT=NONE] -->
    <string name="ongoing_usage_dialog_title_mic_camera">Recent use of Microphone &amp; Camera</string>

    <!-- Separator for permissions. Include spaces before and after if needed [CHAR LIMIT=10] -->
    <string name="ongoing_usage_dialog_separator">,\u0020</string>

    <!-- Separator for permissions, before last type. Include spaces before and after if needed [CHAR LIMIT=10] -->
    <string name="ongoing_usage_dialog_last_separator">\u0020and\u0020</string>

    <!-- Keyword in the Settings app's search functionality that can be used to find links to the default app management screens [CHAR LIMIT=none] -->
    <string name="default_app_search_keyword">default apps</string>

    <!-- List of the two permission group names for microphone (android:string/permgrouplab_microphone) and camera (android:string/permgrouplab_camera) [CHAR LIMIT=60]-->
    <string name="permgroup_list_microphone_and_camera">Microphone &amp; Camera</string>

    <!-- Accessibility label for button that opens a settings screen [CHAR LIMIT=NONE] -->
    <string name="settings_button">Settings</string>

    <!-- Title for page of managing default apps. [CHAR LIMIT=30] -->
    <string name="default_apps">Default apps</string>

    <!-- Help URI, default apps [DO NOT TRANSLATE] -->
    <string name="help_uri_default_apps" translatable="false"></string>

    <!-- Label when there is no default apps [CHAR LIMIT=30] -->
    <string name="no_default_apps">No default apps</string>

    <!-- Title for preference item that will open a screen to manage more default apps [CHAR LIMIT=30] -->
    <string name="default_apps_more">More defaults</string>

    <!-- Title for preference item that will show the user's preferences for this app's priority for opening links to websites that it claims to support [CHAR LIMIT=30] -->
    <string name="default_apps_manage_domain_urls">Opening links</string>

    <!-- Title for category of default apps for work [CHAR LIMIT=30] -->
    <string name="default_apps_for_work">Default for work</string>

    <!-- Summary of a default app when there is no app set [CHAR LIMIT=60] -->
    <string name="default_app_none">None</string>

    <!-- Label for a system default app [CHAR LIMIT=60] -->
    <string name="default_app_system_default">(System default)</string>

    <!-- Label when there are no apps available for a default app [CHAR LIMIT=30] -->
    <string name="default_app_no_apps">No apps</string>

    <!-- Label for the selected default app for default app [CHAR LIMIT=30] -->
    <string name="car_default_app_selected">Selected</string>

    <!-- Label for the selected default app for default app when it has additional information to show [CHAR LIMIT=30] -->
    <string name="car_default_app_selected_with_info">Selected - <xliff:g id="additional_info" example="(System default)">%1$s</xliff:g></string>

    <!-- Keyword in the Settings app's search functionality that can be used to find links to the special app access management screens [CHAR LIMIT=none] -->
    <string name="special_app_access_search_keyword">special app access</string>

    <!-- Title for page of managing special app access. [CHAR LIMIT=30] -->
    <string name="special_app_access">Special app access</string>

    <!-- Help URI, special app access [DO NOT TRANSLATE] -->
    <string name="help_uri_special_app_access" translatable="false"></string>

    <!-- Label when there is no special app access [CHAR LIMIT=30] -->
    <string name="no_special_app_access">No special app access</string>

    <!-- Label when there are no apps available for a special app access [CHAR LIMIT=30] -->
    <string name="special_app_access_no_apps">No apps</string>

    <!-- Summary indicating that a home app is missing work profile support [CHAR LIMIT=60] -->
    <string name="home_missing_work_profile_support">Doesn\u2019t support work profile</string>

    <!-- Dialog message explaining that the app just selected by the user will not work after a reboot until the user enters their credentials, such as a PIN or password. [CHAR LIMIT=NONE] -->
    <string name="encryption_unaware_confirmation_message">Note: If you restart your device and have a screen lock set, this app can\u2019t start until you unlock your device.</string>

    <!-- Dialog message warning about security implications of setting an assistant, displayed when the user selects an assistant. The assitant app here is a generic concept and can be any assistant app. [CHAR LIMIT=NONE] -->
    <string name="assistant_confirmation_message">The assistant will be able to read information about apps in use on your system, including information visible on your screen or accessible within the apps.</string>

    <!-- Name for the notification channel for incident / bug report confirmation. Appears in
    Settings.
    [CHAR LIMIT=50] -->
    <string name="incident_report_channel_name">Share Debugging Data</string>

    <!-- Title for notification shown when the user should confirm an incident / bug report.
    [CHAR LIMIT=60] -->
    <string name="incident_report_notification_title">Share detailed debugging data?</string>

    <!-- Content for notification shown when the user should confirm an incident / bug report.
    [CHAR LIMIT=120] -->
    <string name="incident_report_notification_text"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> would like to upload debugging information.</string>

    <!-- Title for the incident / bug report confirmation dialog. [CHAR LIMIT=50] -->
    <string name="incident_report_dialog_title">Share debugging data?</string>

    <!-- Title text for introduction to incident / bug report confirmation dialog.
    Following this text is a bulleted list of reasons that a bug is being collected (e.g. "bad
    battery life detected"). Please try to keep this as short as possible (<40 chars if possible).
    The dialog is getting full, but going over is ok if necessary.  [CHAR LIMIT=60] -->
    <string name="incident_report_dialog_intro">The system has detected a problem.</string>

    <!-- Content for dialog shown when the user should confirm an incident / bug report.
    [CHAR LIMIT=none] -->
    <string name="incident_report_dialog_text">"<xliff:g id="app_name" example="Gmail">%1$s</xliff:g> is requesting to upload a bug report from this device taken on <xliff:g id="date" example="December 26, 2018">%2$s</xliff:g> at <xliff:g id="time" example="1:20 PM">%3$s</xliff:g>. Bug reports include personal information about your device or logged by apps, for example, user names, location data, device identifiers, and network information. Only share bug reports with people and apps you trust with this information.

Allow <xliff:g id="app_name" example="Gmail">%4$s</xliff:g> to upload a bug report?"</string>

    <!-- Content for dialog shown when there was an error parsing the incident / bug report.
    [CHAR LIMIT=none] -->
    <string name="incident_report_error_dialog_text">"There was an error processing the bug report for <xliff:g id="app_name" example="Gmail">%1$s</xliff:g>. So sharing the detailed debugging data has been denied. Sorry for the interruption."</string>

    <!-- Label for the button to allow sharing of the report. [CHAR LIMIT=20]-->
    <string name="incident_report_dialog_allow_label">Allow</string>

    <!-- Label for the button to NOT allow sharing of the report. [CHAR LIMIT=20] -->
    <string name="incident_report_dialog_deny_label">Deny</string>

    <!-- Label for screen allowing the user to force certain apps to always be shown in permission controller settings ui instead of being hidden behind "system app" menu. [CHAR LIMIT=60] -->
    <string name="adjust_user_sensitive_title">Advanced settings</string>

    <!-- Label for link to the screen allowing the user to force certain apps to always be shown in permission controller settings ui instead of being hidden behind "system app" menu. [CHAR LIMIT=30] -->
    <string name="menu_adjust_user_sensitive">Advanced settings</string>

    <!-- Title for global switch that enables/disables the ability for the user to force certain apps to always be shown in permission controller settings ui instead of being hidden behind "system app" menu. [CHAR LIMIT=60] -->
    <string name="adjust_user_sensitive_globally_title">Show system app usage</string>

    <!-- Subtitle for global switch that enables/disables the ability for the user to force certain apps to always be shown in permission controller settings ui instead of being hidden behind "system app" menu. [CHAR LIMIT=none] -->
    <string name="adjust_user_sensitive_globally_summary">Show system app use of permissions in status bar, dashboard \u0026 elsewhere</string>

    <!-- Header above the per app switches that enables/disables the ability for the user to force the app to always be shown in permission controller settings ui instead of being hidden behind "system app" menu. [CHAR LIMIT=60] -->
    <string name="adjust_user_sensitive_per_app_header">Highlight usage for the following</string>

    <!-- Title for switch that enables/disables the microphone status bar icon for the currently selected assistant. [CHAR LIMIT=60] -->
    <string name="assistant_record_audio_user_sensitive_title">Show assistant trigger detection</string>

    <!-- Subtitle for switch that enables/disables the microphone status bar icon for the currently selected assistant. [CHAR LIMIT=none] -->
    <string name="assistant_record_audio_user_sensitive_summary">Show icon in status bar when microphone is used to activate voice assistant</string>

    <!-- Message shown to the user when the apps requests permission from this group. Shows in the isolated storage case. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_storage_isolated">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access photos and media on your device?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_contacts">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access your contacts?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_location">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access this device\u2019s location?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the location only while app is in foreground [CHAR LIMIT=150]-->
    <string name="permgrouprequestdetail_location">The app will only have access to the location while you\u2019re using the app</string>
    <!-- Message shown to the user when the apps requests permission to use the location while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupbackgroundrequest_location">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access this device\u2019s location?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the location while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupbackgroundrequestdetail_location">This app may want to access your location all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>
    <!-- Message shown to the user when the apps requests permission to use the location while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupupgraderequest_location">Change location access for &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b>?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the location while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupupgraderequestdetail_location">This app wants to access your location all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_nearby_devices">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to find, connect to, and determine the relative position of nearby devices?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to discovery and connect to nearby devices while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupupgraderequestdetail_nearby_devices">Allow &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to find, connect to, and determine the relative position of nearby devices? <annotation id="link">Allow in settings.</annotation></string>

    <!-- Message shown to the user when the app requests permission to upgrade to fine location [CHAR LIMIT=120] -->
    <string name="permgrouprequest_fineupgrade">Change <xliff:g id="app_name" example="Gmail">&lt;b&gt;%1$s&lt;/b&gt;</xliff:g>\u2019s location access from approximate to precise?</string>
    <!-- Message shown to the user when the app requests permission to use coarse location [CHAR LIMIT=120] -->
    <string name="permgrouprequest_coarselocation">Allow &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access this device\u2019s approximate location?</string>
    <!-- Text for the FINE location image [CHAR LIMIT=20] -->
    <string name="permgrouprequest_finelocation_imagetext">Precise</string>
    <!-- Text for the COARSE location image [CHAR LIMIT=20] -->
    <string name="permgrouprequest_coarselocation_imagetext">Approximate</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_calendar">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access your calendar?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_sms">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to send and view SMS messages?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_storage">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access photos, media, and files on your device?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_microphone">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to record audio?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the microphone only while app is in foreground [CHAR LIMIT=150]-->
    <string name="permgrouprequestdetail_microphone">The app will only be able to record audio while you\u2019re using the app</string>
    <!-- Message shown to the user when the apps requests permission to use the microphone while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupbackgroundrequest_microphone">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to record audio?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the microphone while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupbackgroundrequestdetail_microphone">This app may want to record audio all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>
    <!-- Message shown to the user when the apps requests permission to use the microphone while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupupgraderequest_microphone">Change microphone access for &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b>?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the microphone while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupupgraderequestdetail_microphone">This app wants to record audio all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_activityRecognition">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access your physical activity?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_camera">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to take pictures and record video?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the camera only while app is in foreground [CHAR LIMIT=150]-->
    <string name="permgrouprequestdetail_camera">The app will only be able to take pictures and record video while you\u2019re using the app</string>
    <!-- Message shown to the user when the apps requests permission to use the camera while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupbackgroundrequest_camera">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to take pictures and record video?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the camera while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupbackgroundrequestdetail_camera">This app may want to take pictures and record video all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>
    <!-- Message shown to the user when the apps requests permission to use the camera while app is in foreground and background. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgroupupgraderequest_camera">Change camera access for &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b>?</string>
    <!-- Subtitle of the message shown to the user when the apps requests permission to use the camera while app is in foreground and background. Try to keep the link annotation at the end of the string [CHAR LIMIT=150] -->
    <string name="permgroupupgraderequestdetail_camera">This app wants to take pictures and record video all the time, even when you\u2019re not using the app. <annotation id="link">Allow in settings.</annotation></string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_calllog">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access your phone call logs?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_phone">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to make and manage phone calls?</string>

    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->
    <string name="permgrouprequest_sensors">Allow
        &lt;b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g>&lt;/b> to access sensor data about your vital signs?</string>

    <!-- Notification shown to the user when location permissions are auto-granted by admin policy. These are for when the admin is forcing the permission and the user cannot control it. [CHAR LIMIT=120]-->
    <string name="auto_granted_permissions">Controlled permissions</string>
    <!-- Content of the notification [CHAR LIMIT=120]-->
    <string name="auto_granted_location_permission_notification_title">Location can be accessed</string>
    <!-- Body of the notification, that does not include the app name and is specific to location permissions. [CHAR LIMIT=120]-->
    <string name="auto_granted_permission_notification_body">Your IT admin is allowing <xliff:g id="app_name" example="Gmail">%s</xliff:g> to access your location</string>

    <!-- The title of (and the button label for a link to) the screen that lists permissions that aren't considered the most relevant to the user at the moment, and thus did not make to the "main" screen. [CHAR LIMIT=80] -->
    <string name="other_permissions_label">Other permissions</string>

    <!-- Title for a list of permissions that are not requested by any of the installed applications. [CHAR LIMIT=80] -->
    <string name="not_used_permissions_label">Permission used by the system</string>
    <!-- Subtitle for a list of permissions that are not requested by any of the installed applications. [CHAR LIMIT=none] -->
    <string name="not_used_permissions_description">Permissions used only by the system applications.</string>

    <!-- Title for a list of "custom" permissions (defined by applications, not the platform). [CHAR LIMIT=80] -->
    <string name="additional_permissions_label">Additional permissions</string>
    <!-- Subtitle for a list of "custom" permissions (defined by applications, not the platform). [CHAR LIMIT=none] -->
    <string name="additional_permissions_description">Permissions defined by applications.</string>

    <!-- Permission label for camera. [CHAR LIMIT=20] -->
    <string name="privdash_label_camera">Camera</string>
    <!-- Permission label for microphone. [CHAR LIMIT=20] -->
    <string name="privdash_label_microphone">Microphone</string>
    <!-- Permission label for location. [CHAR LIMIT=20] -->
    <string name="privdash_label_location">Location</string>
    <!-- Permission label for "other" (not camera, microphone, or location). [CHAR LIMIT=20] -->
    <string name="privdash_label_other">Other</string>
    <!-- Permission label for "none" (not anything). [CHAR LIMIT=20] -->
    <string name="privdash_label_none">None</string>
    <!-- Label that describes a "last 24 hours" time window, prefer two lines. [CHAR LIMIT=20] -->
    <string name="privdash_label_24h">Past\n24 hours</string>
</resources>
