<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2017-2021 The LineageOS 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">
    <!-- FastCharge feature -->
    <string name="fast_charging_title">Fast charging</string>
    <string name="fast_charging_summary">Disable to reduce the heat produced by the device while charging or to extend the lifespan of the battery</string>

    <!-- High touch sensitivity -->
    <string name="high_touch_sensitivity_title">High touch sensitivity</string>
    <string name="high_touch_sensitivity_summary">Increase touchscreen sensitivity so it can be used while wearing gloves</string>

    <!-- Navigation bar hint -->
    <string name="show_navbar_gesture_bar_title">Gesture bar</string>
    <string name="show_navbar_gesture_bar_summary">Show gesture bar at the bottom of the screen</string>

    <!-- Black theme for dark mode -->
    <string name="berry_black_theme_title">Pure black</string>
    <string name="berry_black_theme_summary">Pure black background for dark theme</string>

    <!-- Advanced restart options -->
    <string name="power_menu_advanced_restart_title">Advanced restart</string>
    <string name="power_menu_advanced_restart_summary">When unlocked, include options in the power menu for restarting into recovery or bootloader</string>

    <!-- Lock screen pattern size -->
    <string name="lock_pattern_size_3" translatable="false">3 \u00d7 3</string>
    <string name="lock_pattern_size_4" translatable="false">4 \u00d7 4</string>
    <string name="lock_pattern_size_5" translatable="false">5 \u00d7 5</string>
    <string name="lock_pattern_size_6" translatable="false">6 \u00d7 6</string>
    <string name="lock_settings_picker_pattern_size_message">Choose a pattern size</string>

    <!-- Whether a visible red line will be drawn after the user has drawn the unlock pattern incorrectly -->
    <string name="lockpattern_settings_enable_error_path_title">Show pattern error</string>
    <!-- Whether the dots will be drawn when using the lockscreen pattern -->
    <string name="lockpattern_settings_enable_dots_title">Show pattern dots</string>

    <!-- Max refresh rate -->
    <string name="max_refresh_rate_title">Peak refresh rate</string>

    <!-- Min refresh rate -->
    <string name="min_refresh_rate_title">Minimum refresh rate</string>

    <!-- PIN scramble -->
    <string name="unlock_scramble_pin_layout_title">Scramble layout</string>
    <string name="unlock_scramble_pin_layout_summary">Scramble PIN layout when unlocking device</string>

    <!-- Hotspot extras -->
    <string name="tethering_allow_vpn_upstreams_title">Allow clients to use VPNs</string>
    <string name="tethering_allow_vpn_upstreams_summary">Permit hotspot clients to use this device\u2019s VPN connections for upstream connectivity</string>

    <!-- Display : Rotation -->
    <string name="display_rotation_title">Rotation settings</string>
    <string name="display_rotation_enabled">Auto-rotation is enabled</string>
    <string name="display_rotation_disabled">Auto-rotation is disabled</string>
    <string name="display_rotation_unit">degrees</string>
    <string name="display_rotation_category_title">Rotation modes</string>
    <string name="display_rotation_0_title">0 degrees</string>
    <string name="display_rotation_90_title">90 degrees</string>
    <string name="display_rotation_180_title">180 degrees</string>
    <string name="display_rotation_270_title">270 degrees</string>

    <!-- Status bar -->
    <string name="status_bar_title">Status bar</string>
    <string name="status_bar_system_icons_summary">Control which status bar icons are shown</string>

    <!-- Display settings screen, peak refresh rate settings summary [CHAR LIMIT=NONE] -->
    <string name="peak_refresh_rate_summary_custom">Automatically raises the refresh rate from 60 to %1$d Hz for some content. Increases battery usage.</string>

    <!-- Location settings screen, setting check box label if Assisted GPS should be enabled -->
    <string name="assisted_gps">Use assisted GPS</string>
    <!-- Location settings screen, setting summary for Assisted GPS switch -->
    <string name="assisted_gps_summary">Download satellite assistance data from the internet which can greatly improve the GPS startup performance. For emergency calls, assisted GPS is always allowed.</string>

    <!-- Backup Transport selection settings menu and activity title -->
    <string name="backup_transport_setting_label">Change backup provider</string>
    <string name="backup_transport_title">Select backup provider</string>

    <!-- Charging control settings -->
    <string name="charging_control_title">Charging control</string>
    <string name="charging_control_summary">Customize charging schedule and limits for battery</string>
    <string name="charging_control_enable_title">Enable charging control</string>
    <string name="charging_control_mode_title">Charging mode</string>
    <string name="charging_control_mode_auto_title">Automatic schedule</string>
    <string name="charging_control_mode_auto_summary">Automatically determine when to start charging based on alarms set</string>
    <string name="charging_control_mode_custom_title">Custom schedule</string>
    <string name="charging_control_mode_custom_summary">Set a target time to full charge</string>
    <string name="charging_control_mode_limit_title">Limit charging</string>
    <string name="charging_control_mode_limit_summary">Limit charging to a certain percentage</string>
    <string name="charging_control_start_time_title">Start time</string>
    <string name="charging_control_start_time_summary">Charging control activates when you start charging after %s</string>
    <string name="charging_control_target_time_title">Target time to full charge</string>
    <string name="charging_control_target_time_summary">Battery will be fully charged by %s</string>
    <string name="charging_control_limit_title">Limit</string>
    <string name="reset">Reset</string>

    <!-- Battery Info: Technology -->
    <string name="battery_technology">Technology</string>
    <string name="battery_technology_not_available" translatable="false">@string/battery_cycle_count_not_available</string>

    <!-- Battery Info: Health -->
    <string name="battery_health">Health</string>
    <string name="battery_health_good">Good</string>
    <string name="battery_health_overheat">Overheat</string>
    <string name="battery_health_dead">Dead</string>
    <string name="battery_health_over_voltage">Over voltage</string>
    <string name="battery_health_unspecified_failure">Unspecified failure</string>
    <string name="battery_health_cold">Cold</string>
    <string name="battery_health_unknown">Unknown</string>

    <!-- Battery Info: Temperature -->
    <string name="battery_temperature">Temperature</string>
    <string name="battery_temperature_not_available" translatable="false">@string/battery_cycle_count_not_available</string>

    <!-- Battery Info: Voltage -->
    <string name="battery_voltage">Voltage</string>
    <string name="battery_voltage_not_available" translatable="false">@string/battery_cycle_count_not_available</string>

    <!-- Battery Info: Charge Counter -->
    <string name="battery_charge_counter_summary">%1$d mAh</string>

    <!-- Battery Info: Design Capacity -->
    <string name="battery_design_capacity">Design capacity</string>
    <string name="battery_design_capacity_summary">%1$d mAh</string>
    <string name="battery_design_capacity_not_available" translatable="false">@string/battery_cycle_count_not_available</string>

    <!-- Battery Info: Maximum Capacity -->
    <string name="battery_maximum_capacity">Maximum capacity</string>
    <string name="battery_maximum_capacity_summary">%1$d mAh (%2$d%%)</string>
    <string name="battery_maximum_capacity_not_available" translatable="false">@string/battery_cycle_count_not_available</string>
</resources>
