<?xml version="1.0" encoding="utf-8"?>
<!--
 * Copyright (c) 2006, 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>
    <!-- Recommended minimum clickable element dimension -->
    <dimen name="min_clickable_item_size">48dp</dimen>

    <!-- Amount to offset bottom of notification peek window from top of status bar. -->
    <dimen name="peek_window_y_offset">-12dp</dimen>

    <!-- thickness (height) of the navigation bar on phones that require it -->
    <dimen name="navigation_bar_size">@*android:dimen/navigation_bar_height</dimen>
    <!-- Minimum swipe distance to catch the swipe gestures to invoke assist or switch tasks. -->
    <dimen name="navigation_bar_min_swipe_distance">48dp</dimen>
    <dimen name="navigation_bar_default_edge_height">500dp</dimen>

    <!-- thickness (height) of the dead zone at the top of the navigation bar,
         reducing false presses on navbar buttons; approx 2mm -->
    <dimen name="navigation_bar_deadzone_size">12dp</dimen>
    <!-- size of the dead zone when touches have recently occurred elsewhere on screen -->
    <dimen name="navigation_bar_deadzone_size_max">32dp</dimen>

    <!-- dimensions for the navigation bar handle -->
    <dimen name="navigation_handle_radius">1dp</dimen>
    <dimen name="navigation_handle_bottom">6dp</dimen>
    <dimen name="navigation_handle_horizontal_margin">30dp</dimen>
    <dimen name="navigation_handle_sample_horizontal_margin">10dp</dimen>
    <dimen name="navigation_home_handle_width">72dp</dimen>

    <!-- Size of the nav bar edge panels, should be greater to the
         edge sensitivity + the drag threshold -->
    <dimen name="navigation_edge_panel_width">70dp</dimen>
    <!-- Padding at the end of the navigation panel to allow the arrow not to be clipped off -->
    <dimen name="navigation_edge_panel_padding">8dp</dimen>
    <dimen name="navigation_edge_panel_height">96dp</dimen>
    <!-- The threshold to drag to trigger the edge action -->
    <dimen name="navigation_edge_action_drag_threshold">16dp</dimen>
    <!-- The minimum display position of the arrow on the screen -->
    <dimen name="navigation_edge_arrow_min_y">64dp</dimen>
    <!-- The amount by which the arrow is shifted to avoid the finger-->
    <dimen name="navigation_edge_finger_offset">48dp</dimen>

    <!-- Luminance threshold to determine black/white contrast for the navigation affordances -->
    <item name="navigation_luminance_threshold" type="dimen" format="float">0.5</item>
    <!-- Luminance change threshold that allows applying new value if difference was exceeded -->
    <item name="navigation_luminance_change_threshold" type="dimen" format="float">0.05</item>

    <dimen name="floating_rotation_button_diameter">40dp</dimen>
    <dimen name="floating_rotation_button_min_margin">4dp</dimen>

    <!-- Height of notification icons in the status bar -->
    <dimen name="status_bar_icon_size">@*android:dimen/status_bar_icon_size</dimen>

    <!-- Default horizontal drawable padding for status bar icons. -->
    <dimen name="status_bar_horizontal_padding">2.5dp</dimen>

    <!-- Height of the battery icon in the status bar. -->
    <dimen name="status_bar_battery_icon_height">13.0dp</dimen>

    <!-- Width of the battery icon in the status bar. The battery drawable assumes a 12x20 canvas,
    so the width of the icon should be 13.0dp * (12.0 / 20.0) -->
    <dimen name="status_bar_battery_icon_width">7.8dp</dimen>

    <!-- The font size for the clock in the status bar. -->
    <dimen name="status_bar_clock_size">14sp</dimen>

    <!-- The starting padding for the clock in the status bar. -->
    <dimen name="status_bar_clock_starting_padding">7dp</dimen>

    <!-- The end padding for the clock in the status bar. -->
    <dimen name="status_bar_clock_end_padding">0dp</dimen>

    <!-- Starting padding for a left-aligned status bar clock -->
    <dimen name="status_bar_left_clock_starting_padding">0dp</dimen>

    <!-- End padding for left-aligned status bar clock -->
    <dimen name="status_bar_left_clock_end_padding">7dp</dimen>

    <!-- Spacing after the wifi signals that is present if there are any icons following it. -->
    <dimen name="status_bar_wifi_signal_spacer_width">2.5dp</dimen>

    <!-- Size of the view displaying the wifi signal icon in the status bar. -->
    <dimen name="status_bar_wifi_signal_size">@*android:dimen/status_bar_system_icon_size</dimen>

    <!-- Spacing before the airplane mode icon if there are any icons preceding it. -->
    <dimen name="status_bar_airplane_spacer_width">4dp</dimen>

    <!-- Spacing between system icons. -->
    <dimen name="status_bar_system_icon_spacing">0dp</dimen>

    <!-- The amount to scale each of the status bar icons by. A value of 1 means no scaling. -->
    <item name="status_bar_icon_scale_factor" format="float" type="dimen">1.0</item>

    <dimen name="group_overflow_number_size">@*android:dimen/notification_text_size</dimen>
    <dimen name="group_overflow_number_padding">@*android:dimen/notification_content_margin_end
    </dimen>

    <!-- max height of a notification such that the content can still fade out when closing -->
    <dimen name="max_notification_fadeout_height">100dp</dimen>

    <!-- End margin for the RSSI status icon of a device connected via bluetooth. -->
    <dimen name="status_bar_connected_device_signal_margin_end">16dp</dimen>

    <!-- The size of a bluetooth indicator icon that displays next to the RSSI status icon. -->
    <dimen name="status_bar_connected_device_bt_indicator_size">17dp</dimen>

    <!-- Height of a small notification in the status bar-->
    <dimen name="notification_min_height">@*android:dimen/notification_min_height</dimen>

    <!-- Increased height of a small notification in the status bar -->
    <dimen name="notification_min_height_increased">146dp</dimen>

    <!-- Increased height of a collapsed media notification in the status bar -->
    <dimen name="notification_min_height_media">160dp</dimen>

    <!-- Height of a small notification in the status bar which was used before android N -->
    <dimen name="notification_min_height_legacy">64dp</dimen>

    <!-- Height of a small notification in the status bar which was used before android P -->
    <dimen name="notification_min_height_before_p">92dp</dimen>

    <!-- Height of a large notification in the status bar -->
    <dimen name="notification_max_height">294dp</dimen>

    <!-- Height of a heads up notification in the status bar for legacy custom views -->
    <dimen name="notification_max_heads_up_height_legacy">128dp</dimen>

    <!-- Height of a heads up notification in the status bar for custom views before andoid P -->
    <dimen name="notification_max_heads_up_height_before_p">148dp</dimen>

    <!-- Height of a heads up notification in the status bar -->
    <dimen name="notification_max_heads_up_height">162dp</dimen>

    <!-- Height of a heads up notification in the status bar -->
    <dimen name="notification_max_heads_up_height_increased">188dp</dimen>

    <!-- Side padding on the lockscreen on the side of notifications -->
    <dimen name="notification_side_paddings">4dp</dimen>

    <!-- padding between the heads up and the statusbar -->
    <dimen name="heads_up_status_bar_padding">8dp</dimen>

    <!-- heads up elevation that is added if the view is pinned -->
    <dimen name="heads_up_pinned_elevation">16dp</dimen>

    <!-- Height of a messaging notifications with actions at least. Not that this is an upper bound
         and the notification won't use this much, but is measured with wrap_content -->
    <dimen name="notification_messaging_actions_min_height">196dp</dimen>

    <!-- a threshold in dp per second that is considered fast scrolling -->
    <dimen name="scroll_fast_threshold">1500dp</dimen>

    <!-- Height of a the shelf with the notification icons -->
    <dimen name="notification_shelf_height">32dp</dimen>

    <!-- Minimum height of a notification to be interactable -->
    <dimen name="notification_min_interaction_height">40dp</dimen>

    <!-- the padding of the shelf icon container -->
    <dimen name="shelf_icon_container_padding">13dp</dimen>

    <!-- The padding of a notification icon on top to the start of the notification. Used for custom
         views where the distance can't be measured -->
    <dimen name="notification_icon_appear_padding">15dp</dimen>

    <!-- Vertical translation of the shelf during animation that happens after the
    notification panel collapses -->
    <dimen name="shelf_appear_translation">42dp</dimen>

    <!-- Vertical translation of pulsing notification animations -->
    <dimen name="pulsing_notification_appear_translation">10dp</dimen>

    <!-- The amount the content shifts upwards when transforming into the shelf -->
    <dimen name="shelf_transform_content_shift">32dp</dimen>

    <!-- The padding on the bottom of the notifications on the keyguard -->
    <dimen name="keyguard_indication_bottom_padding">12sp</dimen>

    <!-- The padding at start and end of indication text shown on AOD -->
    <dimen name="keyguard_indication_text_padding">16dp</dimen>

    <!-- Shadows under the clock, date and other keyguard text fields -->
    <dimen name="keyguard_shadow_radius">5</dimen>

    <!-- Minimum layouted height of a notification in the statusbar-->
    <dimen name="min_notification_layout_height">48dp</dimen>

    <!-- Size of the space to place a notification menu item -->
    <dimen name="notification_menu_icon_size">64dp</dimen>

    <!-- The space around a notification menu item  -->
    <dimen name="notification_menu_icon_padding">20dp</dimen>

    <!-- The vertical space around the buttons in the inline settings -->
    <dimen name="notification_guts_button_spacing">12dp</dimen>

    <!-- Extra horizontal space for properly aligning guts buttons with the notification content -->
    <dimen name="notification_guts_button_side_margin">8dp</dimen>

    <!-- The vertical padding a notification guts button has to fulfill the 48dp touch target -->
    <dimen name="notification_guts_button_vertical_padding">14dp</dimen>

    <!-- The horizontal padding for notification guts buttons-->
    <dimen name="notification_guts_button_horizontal_padding">8dp</dimen>

    <!-- The horizontal space around the buttons in the inline settings -->
    <dimen name="notification_guts_button_horizontal_spacing">8dp</dimen>

    <dimen name="notification_guts_conversation_header_height">84dp</dimen>
    <dimen name="notification_guts_conversation_icon_size">52dp</dimen>
    <dimen name="notification_guts_conversation_action_height">56dp</dimen>
    <dimen name="notification_guts_conversation_action_text_padding_start">32dp</dimen>

    <!-- The height of the header in inline settings -->
    <dimen name="notification_guts_header_height">24dp</dimen>

    <!-- The text size of the header in inline settings -->
    <dimen name="notification_guts_header_text_size">16sp</dimen>

    <!-- The horizontal space between items in the alert selections in the inline settings -->
    <dimen name="notification_guts_option_horizontal_padding">15dp</dimen>

    <!-- The vertical space between items in the alert selections in the inline settings -->
    <dimen name="notification_guts_option_vertical_padding">16dp</dimen>

    <!-- The vertical space between the alert selections in the inline settings -->
    <dimen name="notification_guts_option_vertical_margin">6dp</dimen>

    <dimen name="notification_importance_toggle_size">48dp</dimen>
    <dimen name="notification_importance_toggle_marginTop">28dp</dimen>
    <dimen name="notification_importance_toggle_marginBottom">28dp</dimen>
    <dimen name="notification_importance_text_marginTop">20dp</dimen>
    <dimen name="notification_importance_button_separation">8dp</dimen>
    <dimen name="notification_importance_button_width">178dp</dimen>
    <dimen name="notification_importance_button_horiz_padding">28dp</dimen>
    <dimen name="notification_importance_drawable_padding">8dp</dimen>
    <dimen name="notification_importance_description_padding">20dp</dimen>
    <dimen name="notification_importance_header_text">12sp</dimen>
    <dimen name="notification_importance_description_text">14sp</dimen>
    <dimen name="notification_importance_channel_text">16sp</dimen>
    <dimen name="notification_importance_channel_group_text">14sp</dimen>
    <dimen name="notification_importance_button_text">14sp</dimen>
    <dimen name="notification_importance_button_padding">16dp</dimen>
    <dimen name="notification_importance_button_description_top_margin">12dp</dimen>
    <dimen name="rect_button_radius">8dp</dimen>

    <!-- The minimum height for the snackbar shown after the snooze option has been chosen. -->
    <dimen name="snooze_snackbar_min_height">56dp</dimen>

    <!-- The text size of options in the snooze menu. -->
    <dimen name="snooze_option_text_size">14sp</dimen>

    <!-- The padding around options int the snooze menu. -->
    <dimen name="snooze_option_padding">8dp</dimen>

    <!-- size at which Notification icons will be drawn in the status bar -->
    <dimen name="status_bar_icon_drawing_size">15dp</dimen>

    <!-- size at which Notification icons will be drawn on Ambient Display -->
    <dimen name="status_bar_icon_drawing_size_dark">
        @*android:dimen/notification_header_icon_size_ambient
    </dimen>

    <!-- size of notification icons when the notifications are hidden -->
    <dimen name="hidden_shelf_icon_size">16dp</dimen>

    <!-- opacity at which Notification icons will be drawn in the status bar -->
    <item type="dimen" name="status_bar_icon_drawing_alpha">90%</item>

    <!-- gap on either side of status bar notification icons -->
    <dimen name="status_bar_icon_padding">0dp</dimen>

    <!-- the padding on the start of the statusbar -->
    <dimen name="status_bar_padding_start">8dp</dimen>

    <!-- the padding on the end of the statusbar -->
    <dimen name="status_bar_padding_end">8dp</dimen>

    <!-- the padding on the top of the statusbar (usually 0) -->
    <dimen name="status_bar_padding_top">0dp</dimen>

    <!-- the radius of the overflow dot in the status bar -->
    <dimen name="overflow_dot_radius">2dp</dimen>

    <!-- the padding between dots in the icon overflow -->
    <dimen name="overflow_icon_dot_padding">3dp</dimen>

    <!-- Dimensions related to screenshots -->

    <!-- The padding on the global screenshot background image -->
    <dimen name="global_screenshot_legacy_bg_padding">20dp</dimen>
    <dimen name="global_screenshot_bg_padding">20dp</dimen>
    <dimen name="global_screenshot_bg_protection_height">400dp</dimen>
    <dimen name="global_screenshot_x_scale">80dp</dimen>
    <dimen name="screenshot_bg_protection_height">242dp</dimen>
    <dimen name="screenshot_preview_elevation">6dp</dimen>
    <dimen name="screenshot_offset_y">48dp</dimen>
    <dimen name="screenshot_offset_x">16dp</dimen>
    <dimen name="screenshot_dismiss_button_tappable_size">48dp</dimen>
    <dimen name="screenshot_dismiss_button_margin">8dp</dimen>
    <dimen name="screenshot_action_container_offset_y">32dp</dimen>
    <dimen name="screenshot_action_container_corner_radius">10dp</dimen>
    <dimen name="screenshot_action_container_padding_vertical">10dp</dimen>
    <dimen name="screenshot_action_container_margin_horizontal">8dp</dimen>
    <dimen name="screenshot_action_container_padding_left">96dp</dimen>
    <dimen name="screenshot_action_container_padding_right">8dp</dimen>
    <!-- Radius of the chip background on global screenshot actions -->
    <dimen name="screenshot_button_corner_radius">20dp</dimen>
    <dimen name="screenshot_action_chip_margin_right">8dp</dimen>
    <dimen name="screenshot_action_chip_padding_vertical">7dp</dimen>
    <dimen name="screenshot_action_chip_icon_size">18dp</dimen>
    <dimen name="screenshot_action_chip_padding_start">8dp</dimen>
    <!-- Padding between icon and text -->
    <dimen name="screenshot_action_chip_padding_middle">8dp</dimen>
    <dimen name="screenshot_action_chip_padding_end">16dp</dimen>
    <dimen name="screenshot_action_chip_text_size">14sp</dimen>
    <dimen name="screenshot_dismissal_height_delta">80dp</dimen>


    <!-- The width of the view containing navigation buttons -->
    <dimen name="navigation_key_width">70dp</dimen>

    <!-- The width/height of the icon of a navigation button -->
    <dimen name="navigation_icon_size">32dp</dimen>

    <dimen name="navigation_key_padding">0dp</dimen>

    <!-- The width of the view containing the menu/ime navigation bar icons -->
    <dimen name="navigation_extra_key_width">36dp</dimen>

    <!-- The padding on the side of the navigation bar. Must be greater than or equal to
         navigation_extra_key_width -->
    <dimen name="navigation_side_padding">36dp</dimen>

    <!-- Default distance beyond which snaps to the matching target -->
    <dimen name="navbar_search_snap_margin">40dip</dimen>

    <!-- Diameter of outer shape drawable shown in navbar search-->
    <dimen name="navbar_search_outerring_diameter">340dp</dimen>

    <!-- Diameter of outer shape drawable shown in navbar search. Should be 1/2 of above value -->
    <dimen name="navbar_search_outerring_radius">170dp</dimen>

    <!-- Height of search panel including navigation bar height -->
    <dimen name="navbar_search_panel_height">230dip</dimen>

    <!-- Move the back button drawable for 3 button layout upwards in ime mode and in portrait -->
    <dimen name="navbar_back_button_ime_offset">2dp</dimen>

    <!-- Height of the draggable handle at the bottom of the phone notification panel -->
    <dimen name="close_handle_height">36dp</dimen>

    <!-- Amount of close_handle that will NOT overlap the notification list -->
    <dimen name="close_handle_underlap">32dp</dimen>

    <!-- Height of the status bar header bar in the car setting. -->
    <dimen name="car_status_bar_header_height">128dp</dimen>

    <!-- The bottom padding of the status bar header. -->
    <dimen name="status_bar_header_padding_bottom">48dp</dimen>

    <!-- The height of the container that holds the battery and time in the quick settings header.
         -->
    <dimen name="qs_header_system_icons_area_height">48dp</dimen>

    <!-- How far the quick-quick settings panel extends below the status bar -->
    <dimen name="qs_quick_header_panel_height">128dp</dimen>

    <!-- The height of the container that holds the system icons in the quick settings header in the
         car setting. -->
    <dimen name="car_qs_header_system_icons_area_height">54dp</dimen>

    <!-- The height of the quick settings footer that holds the user switcher, settings icon,
         etc. -->
    <dimen name="qs_footer_height">48dp</dimen>

    <!-- The size of each of the icon buttons in the QS footer -->
    <dimen name="qs_footer_action_button_size">@dimen/qs_footer_height</dimen>

    <!-- Margins on each side of QS Footer -->
    <dimen name="qs_footer_margin">2dp</dimen>

    <!-- Padding on each QS Footer Icon to make the icons 20dpx20dp -->
    <dimen name="qs_footer_icon_padding">14dp</dimen>

    <!-- The padding between the notifications and the quick settings container -->
    <dimen name="qs_notification_padding">@dimen/notification_side_paddings</dimen>

    <!-- Height of the status bar header bar when expanded -->
    <dimen name="status_bar_header_height_expanded">124dp</dimen>

    <!-- Height of the status bar header bar when on Keyguard -->
    <dimen name="status_bar_header_height_keyguard">40dp</dimen>

    <!-- Margin start of the system icons super container -->
    <dimen name="system_icons_super_container_margin_start">16dp</dimen>

    <!-- Margin end of the system icons super container when the avatar is missing. -->
    <dimen name="system_icons_super_container_avatarless_margin_end">6dp</dimen>

    <!-- Width for the notification panel and related windows -->
    <dimen name="match_parent">-1px</dimen>

    <!-- The top margin of the panel that holds the list of notifications. -->
    <dimen name="notification_panel_margin_top">0dp</dimen>

    <!-- The bottom margin of the panel that holds the list of notifications. -->
    <dimen name="notification_panel_margin_bottom">0dp</dimen>

    <dimen name="notification_panel_width">@dimen/match_parent</dimen>

    <dimen name="brightness_mirror_height">48dp</dimen>

    <!-- The width of the panel that holds the quick settings. -->
    <dimen name="qs_panel_width">@dimen/notification_panel_width</dimen>

    <dimen name="volume_dialog_panel_transparent_padding_right">4dp</dimen>

    <dimen name="volume_dialog_panel_transparent_padding">20dp</dimen>

    <dimen name="volume_dialog_stream_padding">8dp</dimen>

    <dimen name="volume_dialog_panel_width">64dp</dimen>

    <dimen name="volume_dialog_slider_height">116dp</dimen>

    <dimen name="volume_dialog_ringer_size">64dp</dimen>

    <dimen name="volume_dialog_ringer_icon_padding">20dp</dimen>

    <dimen name="volume_dialog_caption_size">64dp</dimen>

    <dimen name="volume_dialog_tap_target_size">48dp</dimen>

    <dimen name="volume_dialog_spacer">4dp</dimen>

    <dimen name="volume_dialog_slider_margin_top">14dp</dimen>

    <dimen name="volume_dialog_slider_margin_bottom">-2dp</dimen>

    <dimen name="volume_dialog_row_margin_bottom">8dp</dimen>

    <dimen name="volume_dialog_elevation">9dp</dimen>

    <dimen name="volume_tool_tip_right_margin">76dp</dimen>

    <dimen name="volume_tool_tip_bottom_margin">32dp</dimen>

    <dimen name="volume_tool_tip_arrow_corner_radius">2dp</dimen>

    <!-- Gravity for the notification panel -->
    <integer name="notification_panel_layout_gravity">0x31</integer><!-- center_horizontal|top -->

    <!-- Height of the carrier/wifi name label -->
    <dimen name="carrier_label_height">24dp</dimen>

    <!-- The distance you can pull a notification before it pops open -->
    <dimen name="one_finger_pop_limit">0dp</dimen>

    <!-- Minimum fraction of the screen that should be taken up by the notification panel.
         Not used at this screen size. -->
    <item type="dimen" name="notification_panel_min_height_frac">0%</item>

    <dimen name="blinds_pop_threshold">0dp</dimen>

    <!-- The size of the gesture span needed to activate the "pull" notification expansion -->
    <dimen name="pull_span_min">25dp</dimen>

    <dimen name="qs_tile_height">106dp</dimen>
    <dimen name="qs_tile_layout_margin_side">6dp</dimen>
    <dimen name="qs_tile_margin_horizontal">18dp</dimen>
    <dimen name="qs_tile_margin_horizontal_two_line">2dp</dimen>
    <dimen name="qs_tile_margin_vertical">24dp</dimen>
    <dimen name="qs_tile_margin_top_bottom">12dp</dimen>
    <dimen name="qs_tile_margin_top_bottom_negative">-12dp</dimen>
    <!-- The height of the qs customize header. Should be
         (qs_panel_padding_top (48dp) +  brightness_mirror_height (48dp) + qs_tile_margin_top (18dp)) -
         (Toolbar_minWidth (56dp) + qs_tile_margin_top_bottom (12dp))
    -->
    <dimen name="qs_customize_header_min_height">46dp</dimen>
    <dimen name="qs_tile_margin_top">18dp</dimen>
    <dimen name="qs_tile_background_size">44dp</dimen>
    <dimen name="qs_quick_tile_size">48dp</dimen>
    <dimen name="qs_quick_tile_padding">12dp</dimen>
    <dimen name="qs_header_gear_translation">16dp</dimen>
    <dimen name="qs_header_tile_margin_horizontal">4dp</dimen>
    <dimen name="qs_header_tile_margin_bottom">18dp</dimen>
    <dimen name="qs_page_indicator_width">16dp</dimen>
    <dimen name="qs_page_indicator_height">8dp</dimen>
    <dimen name="qs_tile_icon_size">24dp</dimen>
    <dimen name="qs_tile_detail_padding">3dp</dimen>
    <dimen name="qs_tile_text_size">12sp</dimen>
    <dimen name="qs_tile_divider_height">1dp</dimen>
    <dimen name="qs_panel_padding">16dp</dimen>
    <dimen name="qs_dual_tile_height">112dp</dimen>
    <dimen name="qs_dual_tile_padding_vertical">8dp</dimen>
    <dimen name="qs_dual_tile_padding_horizontal">6dp</dimen>
    <dimen name="qs_tile_padding_top">14dp</dimen>
    <dimen name="qs_tile_padding_top_large_text">4dp</dimen>
    <dimen name="qs_tile_padding_bottom">16dp</dimen>
    <dimen name="qs_tile_spacing">4dp</dimen>
    <dimen name="qs_panel_padding_bottom">0dp</dimen>
    <dimen name="qs_panel_padding_top">@dimen/qs_header_tooltip_height</dimen>
    <dimen name="qs_detail_header_height">56dp</dimen>
    <dimen name="qs_detail_header_padding">0dp</dimen>
    <dimen name="qs_detail_image_width">56dp</dimen>
    <dimen name="qs_detail_image_height">56dp</dimen>
    <dimen name="qs_detail_image_padding">16dp</dimen>
    <dimen name="qs_detail_item_height">48dp</dimen>
    <dimen name="qs_detail_header_text_size">20sp</dimen>
    <dimen name="qs_detail_button_text_size">14sp</dimen>
    <dimen name="qs_detail_item_primary_text_size">16sp</dimen>
    <dimen name="qs_detail_item_secondary_text_size">14sp</dimen>
    <dimen name="qs_detail_empty_text_size">14sp</dimen>
    <dimen name="qs_detail_margin_top">28dp</dimen>
    <dimen name="qs_detail_back_margin_end">16dp</dimen>
    <dimen name="qs_detail_header_text_padding">16dp</dimen>
    <dimen name="qs_data_usage_text_size">14sp</dimen>
    <dimen name="qs_data_usage_usage_text_size">36sp</dimen>
    <dimen name="qs_battery_padding">2dp</dimen>
    <dimen name="qs_detail_padding_start">16dp</dimen>
    <dimen name="qs_detail_items_padding_top">4dp</dimen>
    <dimen name="qs_detail_item_icon_size">24dp</dimen>
    <dimen name="qs_detail_item_icon_width">32dp</dimen>
    <dimen name="qs_detail_item_icon_marginStart">0dp</dimen>
    <dimen name="qs_detail_item_icon_marginEnd">20dp</dimen>
    <dimen name="qs_header_tooltip_height">48dp</dimen>
    <dimen name="qs_header_alarm_icon_size">@dimen/status_bar_icon_drawing_size</dimen>
    <dimen name="qs_header_mobile_icon_size">@dimen/status_bar_icon_drawing_size</dimen>
    <dimen name="qs_header_alarm_text_margin_start">6dp</dimen>
    <dimen name="qs_header_separator_width">8dp</dimen>
    <dimen name="qs_header_carrier_separator_width">6dp</dimen>
    <dimen name="qs_status_separator">32dp</dimen>
    <dimen name="qs_carrier_margin_width">4dp</dimen>
    <dimen name="qs_footer_padding_start">16dp</dimen>
    <dimen name="qs_footer_padding_end">16dp</dimen>
    <dimen name="qs_footer_icon_size">16dp</dimen>
    <dimen name="qs_paged_tile_layout_padding_bottom">0dp</dimen>
    <dimen name="qs_header_top_padding">15dp</dimen>
    <dimen name="qs_header_bottom_padding">14dp</dimen>

    <dimen name="qs_notif_collapsed_space">64dp</dimen>

    <!-- Desired qs icon overlay size. -->
    <dimen name="qs_detail_icon_overlay_size">24dp</dimen>

    <dimen name="segmented_button_spacing">0dp</dimen>
    <dimen name="borderless_button_radius">2dp</dimen>

    <dimen name="restricted_padlock_pading">4dp</dimen>

    <!-- How far the expanded QS panel peeks from the header in collapsed state. -->
    <dimen name="qs_peek_height">0dp</dimen>

    <!-- How large the icons in the quick settings footer dialog are -->
    <dimen name="qs_footer_dialog_icon_size">24sp</dimen>
    <!-- Left and right margin of the icons -->
    <dimen name="qs_footer_dialog_icon_margin">8sp</dimen>
    <!-- Padding between subtitles and the following text in the QSFooter dialog -->
    <dimen name="qs_footer_dialog_subtitle_padding">20dp</dimen>

    <dimen name="seek_bar_height">3dp</dimen>
    <dimen name="seek_bar_corner_radius">3dp</dimen>

    <!-- Zen mode panel: condition item button padding -->
    <dimen name="zen_mode_condition_detail_button_padding">8dp</dimen>

    <!-- Zen mode panel: spacing between condition items -->
    <dimen name="zen_mode_condition_detail_item_spacing">12dp</dimen>

    <!-- Zen mode panel: spacing between two-line condition upper and lower lines -->
    <dimen name="zen_mode_condition_detail_item_interline_spacing">4dp</dimen>

    <!-- Zen mode panel: bottom padding, a bit less than qs_panel_padding -->
    <dimen name="zen_mode_condition_detail_bottom_padding">4dp</dimen>

    <!-- used by DessertCase -->
    <dimen name="dessert_case_cell_size">192dp</dimen>

    <!-- Default glow radius for GlowPadView -->
    <dimen name="glowpadview_glow_radius">75dip</dimen>

    <!-- Default distance from each snap target that GlowPadView considers a "hit" -->
    <dimen name="glowpadview_inner_radius">15dip</dimen>

    <!-- Z distance between notifications if they are in the stack -->
    <dimen name="z_distance_between_notifications">0.5dp</dimen>

    <!-- The height of the divider between the individual notifications. -->
    <dimen name="notification_divider_height">0.5dp</dimen>

    <!-- The corner radius of the shadow behind the notification. -->
    <dimen name="notification_shadow_radius">0dp</dimen>

    <!-- The alpha of the dividing line between child notifications of a notification group. -->
    <item name="notification_divider_alpha" format="float" type="dimen">0.5</item>

    <!-- The height of the divider between the individual notifications in a notification
         group. -->
    <dimen name="notification_children_container_divider_height">
        @dimen/notification_divider_height
    </dimen>

    <!-- The top margin for the notification children container in its non-expanded form. -->
    <dimen name="notification_children_container_margin_top">
        @*android:dimen/notification_content_margin_top
    </dimen>

    <!-- The height of a notification header -->
    <dimen name="notification_header_height">53dp</dimen>

    <!-- The height of the divider between the individual notifications when the notification wants it to be increased. This is currently the case for notification groups -->
    <dimen name="notification_divider_height_increased">6dp</dimen>

    <!-- The height of the gap between adjacent notification sections. -->
    <dimen name="notification_section_divider_height">@dimen/notification_side_paddings</dimen>

    <!-- Size of the face pile shown on one-line (children of a group) conversation notifications -->
    <dimen name="conversation_single_line_face_pile_size">36dp</dimen>

    <!-- Size of an avatar shown on one-line (children of a group) conversation notifications -->
    <dimen name="conversation_single_line_avatar_size">24dp</dimen>

    <!-- Border width for avatars in the face pile shown on one-line (children of a group) conversation notifications -->
    <dimen name="conversation_single_line_face_pile_protection_width">1dp</dimen>

    <!-- The minimum amount of top overscroll to go to the quick settings. -->
    <dimen name="min_top_overscroll_to_qs">36dp</dimen>

    <!-- The height of the speed bump view. -->
    <dimen name="speed_bump_height">16dp</dimen>

    <!-- Lockscreen unlocking falsing threshold. -->
    <dimen name="unlock_falsing_threshold">80dp</dimen>

    <!-- Lockscreen falsing threshold for quick settings. -->
    <dimen name="qs_falsing_threshold">60dp</dimen>

    <!-- Falsing threshold used when dismissing notifications from the lockscreen. -->
    <dimen name="swipe_helper_falsing_threshold">70dp</dimen>

    <!-- Minimum distance the user has to drag down to go to the full shade. -->
    <dimen name="keyguard_drag_down_min_distance">100dp</dimen>

    <!-- The margin between the clock and the notifications on Keyguard.-->
    <dimen name="keyguard_clock_notifications_margin">30dp</dimen>
    <!-- Minimum margin between clock and status bar -->
    <dimen name="keyguard_clock_top_margin">36dp</dimen>
    <!-- The margin between top of clock and bottom of lock icon. -->
    <dimen name="keyguard_clock_lock_margin">16dp</dimen>

    <item name="scrim_behind_alpha" format="float" type="dimen">0.62</item>

    <!-- The minimum amount the user needs to swipe to go to the camera / phone. -->
    <dimen name="keyguard_min_swipe_amount">110dp</dimen>

    <!-- The minimum background radius when swiping to a side for the camera / phone affordances. -->
    <dimen name="keyguard_affordance_min_background_radius">30dp</dimen>

    <!-- The size of the touch targets on the keyguard for the affordances. -->
    <dimen name="keyguard_affordance_touch_target_size">120dp</dimen>

    <!-- The grow amount for the camera and phone circles when hinting -->
    <dimen name="hint_grow_amount_sideways">60dp</dimen>

    <!-- Distance between notifications and header when they are considered to be colliding. -->
    <dimen name="header_notifications_collide_distance">48dp</dimen>

    <!-- Distance the user needs to drag vertically such that a swipe is accepted to unlock the
         device. -->
    <dimen name="unlock_move_distance">75dp</dimen>

    <!-- Move distance for the unlock hint animation on the lockscreen -->
    <dimen name="hint_move_distance">75dp</dimen>

    <!-- The width of the region on the left/right edge of the screen for performing the camera/
         phone hints. -->
    <dimen name="edge_tap_area_width">48dp</dimen>

    <!-- The padding between notification children when collapsed -->
    <dimen name="notification_children_padding">4dp</dimen>

    <!-- The padding on top of the first notification to the children container -->
    <dimen name="notification_children_container_top_padding">8dp</dimen>

    <!-- end margin for multi user switch in expanded quick settings -->
    <dimen name="multi_user_switch_expanded_margin">8dp</dimen>

    <!-- end margin for multi user switch in collapsed quick settings -->
    <dimen name="multi_user_switch_collapsed_margin">13dp</dimen>

    <!-- end margin for multi user switch in collapsed quick settings -->
    <dimen name="multi_user_switch_keyguard_margin">3dp</dimen>

    <!-- end margin for system icons if multi user switch is hidden -->
    <dimen name="system_icons_switcher_hidden_expanded_margin">16dp</dimen>

    <!-- The thickness of the colored border around the current user. -->
    <dimen name="keyguard_user_switcher_border_thickness">2dp</dimen>

    <dimen name="data_usage_graph_marker_width">4dp</dimen>

    <!-- The padding bottom of the clock group when QS is expanded. -->
    <dimen name="clock_expanded_bottom_margin">20dp</dimen>

    <!-- The padding bottom of the clock group when QS is collapsed. -->
    <dimen name="clock_collapsed_bottom_margin">10dp</dimen>

    <!-- The padding bottom of the clock group when QS is collapsed for large text -->
    <dimen name="clock_collapsed_bottom_margin_large_text">6dp</dimen>

    <!-- The width of the multi user switch on keyguard and collapsed QS header. -->
    <dimen name="multi_user_switch_width_collapsed">34dp</dimen>

    <!-- The width of the multi user switch in expanded QS header. -->
    <dimen name="multi_user_switch_width_expanded">48dp</dimen>

    <!-- The width of user avatar when on Keyguard -->
    <dimen name="multi_user_switch_width_keyguard">34dp</dimen>

    <!-- The width of user avatar when collapsed -->
    <dimen name="multi_user_avatar_collapsed_size">22dp</dimen>

    <!-- The width of user avatar when on Keyguard -->
    <dimen name="multi_user_avatar_keyguard_size">22dp</dimen>

    <!-- The width of user avatar when expanded -->
    <dimen name="multi_user_avatar_expanded_size">20dp</dimen>

    <!-- The font size of the time when collapsed in QS -->
    <dimen name="qs_time_collapsed_size">14sp</dimen>

    <!-- The font size of the time when expanded in QS -->
    <dimen name="qs_time_expanded_size">14sp</dimen>

    <!-- The font size of the "emergency calls only" label in QS -->
    <dimen name="qs_emergency_calls_only_text_size">12sp</dimen>

    <!-- The font size of the date in QS -->
    <dimen name="qs_date_collapsed_size">14sp</dimen>
    <!-- Amount the date/time move when emergency calls only is present -->
    <dimen name="qs_date_time_translation">8dp</dimen>

    <!-- Padding before battery level text in status bar, QS, and Keyguard -->
    <dimen name="battery_level_padding_start">4dp</dimen>

    <!-- The top padding of the clear all button -->
    <dimen name="clear_all_padding_top">12dp</dimen>

    <dimen name="notification_section_header_height">48dp</dimen>
    <dimen name="notification_section_header_padding_left">16dp</dimen>

    <!-- Largest size an avatar might need to be drawn in the user picker, status bar, or
         quick settings header -->
    <dimen name="max_avatar_size">48dp</dimen>

    <!-- Size of user icon + frame in the qs user picker (incl. frame) -->
    <dimen name="qs_framed_avatar_size">54dp</dimen>
    <!-- Size of user icon + frame in the keyguard user picker (incl. frame) -->
    <dimen name="kg_framed_avatar_size">54dp</dimen>

    <!-- Margin on the left side of the carrier text on Keyguard -->
    <dimen name="keyguard_carrier_text_margin">16dp</dimen>

    <!-- Margin on the left side of the battery % in the header. -->
    <dimen name="header_battery_margin_expanded">6dp</dimen>

    <!-- Margin on the left side of the battery % when on Keyguard. -->
    <dimen name="header_battery_margin_keyguard">6dp</dimen>

    <!-- Margin on the right side of the system icon group on Keyguard. -->
    <dimen name="system_icons_keyguard_padding_end">4dp</dimen>

    <!-- Additional translation (downwards) for appearing notifications when going to the full shade
         from Keyguard. -->
    <dimen name="go_to_full_shade_appearing_translation">200dp</dimen>

    <!-- The diameter of the search panel circle. -->
    <dimen name="assist_orb_size">144dp</dimen>

    <!-- The margin to the edge of the screen from where the orb starts to appear -->
    <dimen name="assist_orb_base_margin">22dp</dimen>

    <!-- The amount the orb translates when appearing -->
    <dimen name="assist_orb_travel_distance">26dp</dimen>

    <!-- The elevation of the orb -->
    <dimen name="assist_orb_elevation">12dp</dimen>

    <!-- The height of the scrim behind the orb. -->
    <dimen name="assist_orb_scrim_height">250dp</dimen>

    <!-- The height of the scrim behind the search panel circle. Should be navigation_bar_height
         + 8dp. -->
    <dimen name="assist_orb_navbar_scrim_height">56dp</dimen>

    <!-- The width/height of the phone/camera icon view on keyguard. -->
    <dimen name="keyguard_affordance_height">56dp</dimen>
    <dimen name="keyguard_affordance_width">56dp</dimen>

    <!-- The width/height of the unlock icon view on keyguard. -->
    <dimen name="keyguard_lock_height">42dp</dimen>
    <dimen name="keyguard_lock_width">42dp</dimen>
    <dimen name="keyguard_lock_padding">20dp</dimen>

    <dimen name="keyguard_indication_margin_bottom">40dp</dimen>

    <!-- The text size for battery level -->
    <dimen name="battery_level_text_size">12sp</dimen>

    <!-- TrustDrawable: Minimum inner radius of the breathing animation -->
    <dimen name="trust_circle_inner_radius_visible_min">22dp</dimen>
    <!-- TrustDrawable: Maximum inner radius of the breathing animation -->
    <dimen name="trust_circle_inner_radius_visible_max">24dp</dimen>
    <!-- TrustDrawable: Inner radius at the end of the exit animation -->
    <dimen name="trust_circle_inner_radius_exit">38dp</dimen>
    <!-- TrustDrawable: Inner radius at the beginning of the enter animation -->
    <dimen name="trust_circle_inner_radius_enter">18dp</dimen>
    <!-- TrustDrawable: Thickness of the circle -->
    <dimen name="trust_circle_thickness">2dp</dimen>

    <!-- How much two taps can be apart to still be recognized as a double tap on the lockscreen -->
    <dimen name="double_tap_slop">32dp</dimen>

    <dimen name="battery_margin_bottom">0dp</dimen>

    <!-- Padding at the end of the view that displays the mobile signal icons. If the view is
         empty, then this padding will not be added to that view. -->
    <dimen name="mobile_signal_group_end_padding">0dp</dimen>

    <!-- Padding between the mobile data type and the strength indicator. -->
    <dimen name="mobile_data_icon_start_padding">0dp</dimen>

    <!-- Extra padding between the mobile data type icon and the strength indicator when the data
         type icon is wide. -->
    <dimen name="wide_type_icon_start_padding">2dp</dimen>

    <!-- Padding between the mobile signal indicator and the start icon when the roaming icon
         is displayed in the upper left corner. -->
    <dimen name="roaming_icon_start_padding">2dp</dimen>

    <!-- Extra padding between multiple phone signal icons. -->
    <dimen name="secondary_telephony_padding">2dp</dimen>

    <!-- Extra padding between the mobile data type icon and the strength indicator when the data
         type icon is wide for the tile in quick settings. -->
    <dimen name="wide_type_icon_start_padding_qs">3dp</dimen>

    <dimen name="signal_indicator_to_icon_frame_spacing">3dp</dimen>

    <!-- The maximum width of the navigation bar ripples. -->
    <dimen name="key_button_ripple_max_width">95dp</dimen>

    <!-- Inset shadow for FakeShadowDrawable. It is used to avoid gaps between the card
         and the shadow. -->
    <dimen name="fake_shadow_inset">1dp</dimen>

    <dimen name="fake_shadow_size">8dp</dimen>

    <!-- Starting margin before the signal cluster -->
    <dimen name="signal_cluster_margin_start">2.5dp</dimen>

    <!-- Padding between signal cluster and battery icon -->
    <dimen name="signal_cluster_battery_padding">6dp</dimen>

    <!-- Padding for signal cluster and battery icon when there are not icons in signal cluster -->
    <dimen name="no_signal_cluster_battery_padding">3dp</dimen>

    <!-- Screen pinning request width -->
    <dimen name="screen_pinning_request_width">@dimen/match_parent</dimen>
    <!-- Screen pinning request nav button circle heights -->
    <dimen name="screen_pinning_request_button_height">66dp</dimen>
    <!-- Screen pinning request nav button circle widths -->
    <dimen name="screen_pinning_request_button_width">84dp</dimen>
    <!-- Screen pinning request padding on top of inner circle -->
    <dimen name="screen_pinning_request_inner_padding">14dp</dimen>
    <!-- Screen pinning request seascape negative padding -->
    <dimen name="screen_pinning_request_seascape_padding_negative">-18dp</dimen>
    <!-- Screen pinning request seascape button offset -->
    <dimen name="screen_pinning_request_seascape_button_offset">-4dp</dimen>
    <!-- Screen pinning request padding on top of icons -->
    <dimen name="screen_pinning_request_nav_icon_padding">18dp</dimen>
    <!-- Screen pinning request padding on side of icons
         (makes the width match the nav bar)-->
    <dimen name="screen_pinning_request_nav_side_padding">7dp</dimen>
    <!-- Screen pinning request side views to match nav bar
         navigation_side_padding - 3 / 2 * (screen_pinning_request_button_width
                                                - navigation_key_width) -->
    <dimen name="screen_pinning_request_side_width">34dp</dimen>
    <!-- Screen pinning request controls padding on bigger screens -->
    <dimen name="screen_pinning_request_frame_padding">0dp</dimen>
    <!-- Screen pinning inner nav bar circle size -->
    <dimen name="screen_pinning_nav_highlight_size">56dp</dimen>
    <!-- Screen pinning inner nav bar outer circle size -->
    <dimen name="screen_pinning_nav_highlight_outer_size">84dp</dimen>

    <!-- Padding to be used on the bottom of the fingerprint icon on Keyguard so it better aligns
         with the other icons. -->
    <dimen name="fingerprint_icon_additional_padding">4dp</dimen>

    <!-- Minimum margin of the notification panel on the side, when being positioned dynamically -->
    <dimen name="notification_panel_min_side_margin">48dp</dimen>

    <!-- Vertical spacing between multiple volume slider rows -->
    <dimen name="volume_slider_interspacing">8dp</dimen>

    <!-- Volume dialog vertical offset from the top of the screen -->
    <dimen name="volume_offset_top">0dp</dimen>

    <!-- Standard image button size for volume dialog buttons -->
    <dimen name="volume_button_size">48dp</dimen>

    <!-- Volume dialog root view bottom margin, at rest -->
    <dimen name="volume_dialog_margin_bottom">4dp</dimen>
    <dimen name="volume_dialog_padding_top">8dp</dimen>
    <dimen name="volume_dialog_padding_end">40dp</dimen>

    <dimen name="volume_row_padding_bottom">9.4dp</dimen>
    <dimen name="volume_row_padding_start">4dp</dimen>
    <dimen name="volume_row_header_padding_start">16dp</dimen>
    <dimen name="volume_row_height">64dp</dimen>
    <dimen name="volume_row_slider_height">48dp</dimen>
    <dimen name="volume_row_slider_padding_start">12dp</dimen>

    <dimen name="volume_expander_margin_end">2dp</dimen>
    <dimen name="volume_expander_margin_top">6dp</dimen>

    <!-- Thickness of the assist disclosure beams -->
    <dimen name="assist_disclosure_thickness">2.5dp</dimen>

    <!-- Thickness of the shadows of the assist disclosure beams -->
    <dimen name="assist_disclosure_shadow_thickness">1.5dp</dimen>

    <dimen name="fab_size">56dp</dimen>
    <dimen name="fab_margin">16dp</dimen>
    <dimen name="fab_elevation">12dp</dimen>
    <dimen name="fab_press_translation_z">9dp</dimen>

    <!-- How high we lift the divider when touching -->
    <dimen name="docked_stack_divider_lift_elevation">4dp</dimen>

    <dimen name="docked_divider_handle_width">16dp</dimen>
    <dimen name="docked_divider_handle_height">2dp</dimen>

    <dimen name="battery_detail_graph_space_top">27dp</dimen>
    <dimen name="battery_detail_graph_space_bottom">27dp</dimen>

    <!-- Keyboard shortcuts helper -->
    <dimen name="ksh_layout_width">@dimen/match_parent</dimen>
    <dimen name="ksh_item_text_size">14sp</dimen>
    <dimen name="ksh_item_padding">4dp</dimen>
    <dimen name="ksh_item_margin_start">4dp</dimen>

    <!-- The size of corner radius of the arrow in the onboarding toast. -->
    <dimen name="recents_onboarding_toast_arrow_corner_radius">2dp</dimen>
    <!-- The start margin of quick scrub onboarding toast. -->
    <dimen name="recents_quick_scrub_onboarding_margin_start">8dp</dimen>

    <!-- The height of the gradient indicating the dismiss edge when moving a PIP. -->
    <dimen name="floating_dismiss_gradient_height">176dp</dimen>

    <!-- The bottom margin of the PIP drag to dismiss info text shown when moving a PIP. -->
    <dimen name="pip_dismiss_text_bottom_margin">24dp</dimen>

    <!-- The shortest-edge size of the expanded PiP. -->
    <dimen name="pip_expanded_shortest_edge_size">160dp</dimen>

    <!-- The additional offset to apply to the IME animation to account for the input field. -->
    <dimen name="pip_ime_offset">48dp</dimen>

    <!-- The padding between actions in the PiP in landscape  Note that the PiP does not reflect
         the configuration of the device, so we can't use -land resources. -->
    <dimen name="pip_between_action_padding_land">8dp</dimen>

    <!-- The height of the PiP actions container in which the actions are vertically centered. -->
    <dimen name="pip_action_size">48dp</dimen>

    <!-- The padding around a PiP actions. -->
    <dimen name="pip_action_padding">12dp</dimen>

    <!-- The bottom margin of the expand container when there are actions.
         Equal to pip_action_size - pip_action_padding. -->
    <dimen name="pip_expand_container_edge_margin">30dp</dimen>

    <!-- The touchable/draggable edge size for PIP resize. -->
    <dimen name="pip_resize_edge_size">48dp</dimen>

    <!-- The corner radius for PiP window. -->
    <dimen name="pip_corner_radius">8dp</dimen>

    <dimen name="default_gear_space">18dp</dimen>
    <dimen name="cell_overlay_padding">18dp</dimen>

    <!-- Global actions power menu -->
    <dimen name="global_actions_panel_width">120dp</dimen>
    <dimen name="global_actions_padding">12dp</dimen>
    <dimen name="global_actions_translate">9dp</dimen>

    <!-- Distance from the top of screen in pixels, to position the power menu near the button. -->
    <dimen name="global_actions_top_padding">330px</dimen>

    <!-- Global actions grid layout -->
    <dimen name="global_actions_grid_side_margin">4dp</dimen>
    <dimen name="global_actions_grid_container_bottom_margin">8dp</dimen>

    <!-- Used to workaround a bug where shadows are clipped during animations by expanding
         the bounds of the parent view. -->
    <dimen name="global_actions_grid_container_shadow_offset">20dp</dimen>
    <dimen name="global_actions_grid_container_negative_shadow_offset">-20dp</dimen>

    <!-- Margins at the left and right of the power menu and home controls widgets. -->
    <dimen name="global_actions_side_margin">16dp</dimen>

    <!-- Amount to shift the layout when exiting/entering for controls activities -->
    <dimen name="global_actions_controls_y_translation">20dp</dimen>

    <!-- The maximum offset in either direction that elements are moved horizontally to prevent
         burn-in on AOD. -->
    <dimen name="burn_in_prevention_offset_x">8dp</dimen>

    <!-- The maximum offset in either direction that elements are moved vertically to prevent
         burn-in on AOD. -->
    <dimen name="burn_in_prevention_offset_y">50dp</dimen>

    <!-- The maximum offset in either direction that icons move to prevent burn-in on AOD. -->
    <dimen name="default_burn_in_prevention_offset">15dp</dimen>

    <dimen name="corner_size">8dp</dimen>
    <dimen name="top_padding">0dp</dimen>
    <dimen name="bottom_padding">48dp</dimen>
    <dimen name="edge_margin">8dp</dimen>

    <!-- The absolute side margins of quick settings -->
    <dimen name="quick_settings_side_margins">16dp</dimen>
    <dimen name="quick_settings_expanded_bottom_margin">16dp</dimen>
    <dimen name="quick_settings_media_extra_bottom_margin">4dp</dimen>
    <dimen name="rounded_corner_content_padding">0dp</dimen>
    <dimen name="nav_content_padding">0dp</dimen>
    <dimen name="nav_quick_scrub_track_edge_padding">24dp</dimen>
    <dimen name="nav_quick_scrub_track_thickness">10dp</dimen>

    <!-- Navigation bar shadow params. -->
    <dimen name="nav_key_button_shadow_offset_x">0dp</dimen>
    <dimen name="nav_key_button_shadow_offset_y">1dp</dimen>
    <dimen name="nav_key_button_shadow_radius">0.5dp</dimen>

    <!-- Smart reply button. Total height 48dp, visible height 32dp. -->
    <dimen name="smart_reply_button_spacing">8dp</dimen>
    <dimen name="smart_reply_button_padding_vertical">14dp</dimen>
    <!-- Note: The following two paddings need to be different until b/78876518 is fixed. -->
    <dimen name="smart_reply_button_padding_horizontal_single_line">20dp</dimen>
    <dimen name="smart_reply_button_padding_horizontal_double_line">19dp</dimen>
    <dimen name="smart_reply_button_min_height">48dp</dimen>
    <dimen name="smart_reply_button_stroke_width">1dp</dimen>
    <dimen name="smart_reply_button_font_size">14sp</dimen>
    <dimen name="smart_reply_button_line_spacing_extra">6sp</dimen> <!-- Total line height 20sp. -->
    <!-- Corner radius = half of min_height to create rounded sides. -->
    <dimen name="smart_reply_button_corner_radius">24dp</dimen>
    <dimen name="smart_action_button_icon_size">18dp</dimen>
    <dimen name="smart_action_button_icon_padding">8dp</dimen>

    <!-- A reasonable upper bound for the height of the smart reply button. The measuring code
            needs to start with a guess for the maximum size. Currently two-line smart reply buttons
            add about 88dp of height to the notifications. -->
    <dimen name="smart_reply_button_max_height">100dp</dimen>

    <!-- The extra height that we allow a notification with a remote input history to be taller than
         the regular notification, when we have remote input history texts present. -->
    <dimen name="remote_input_history_extra_height">60dp</dimen>

    <!-- Biometric Dialog values -->
    <dimen name="biometric_dialog_biometric_icon_size">64dp</dimen>
    <dimen name="biometric_dialog_corner_size">4dp</dimen>
    <!-- Y translation when showing/dismissing the dialog-->
    <dimen name="biometric_dialog_animation_translation_offset">350dp</dimen>
    <dimen name="biometric_dialog_border_padding">4dp</dimen>
    <dimen name="biometric_dialog_elevation">1dp</dimen>
    <dimen name="biometric_dialog_icon_padding">16dp</dimen>
    <!-- Y translation for biometric contents when transitioning to device credential UI -->
    <dimen name="biometric_dialog_medium_to_large_translation_offset">100dp</dimen>
    <!-- Y translation for credential contents when animating in -->
    <dimen name="biometric_dialog_credential_translation_offset">60dp</dimen>

    <!-- Wireless Charging Animation values -->
    <dimen name="wireless_charging_dots_radius_start">0dp</dimen>
    <dimen name="wireless_charging_dots_radius_end">4dp</dimen>
    <dimen name="wireless_charging_circle_radius_start">28dp</dimen>
    <dimen name="wireless_charging_circle_radius_end">84dp</dimen>
    <integer name="wireless_charging_angle_offset">20</integer>
    <integer name="wireless_charging_scale_dots_duration">83</integer>
    <integer name="wireless_charging_num_dots">16</integer>
    <!-- Starting text size in sp of batteryLevel for wireless charging animation -->
    <item name="wireless_charging_anim_battery_level_text_size_start" format="float" type="dimen">
        0
    </item>
    <!-- Ending text size in sp of batteryLevel for wireless charging animation -->
    <item name="wireless_charging_anim_battery_level_text_size_end" format="float" type="dimen">24
    </item>
    <!-- time until battery info is at full opacity-->
    <integer name="wireless_charging_anim_opacity_offset">80</integer>
    <!-- duration batteryLevel opacity goes from 0 to 1 duration -->
    <integer name="wireless_charging_battery_level_text_opacity_duration">117</integer>
    <!-- battery text scale animation duration -->
    <integer name="wireless_charging_battery_level_text_scale_animation_duration">367</integer>
    <!--time until wireless charging animation starts to fade-->
    <integer name="wireless_charging_fade_offset">920</integer>
    <!-- duration wireless charging animation takes to full fade to 0 opacity -->
    <integer name="wireless_charging_fade_duration">200</integer>

    <!-- Wired charging on AOD, text animation duration -->
    <integer name="wired_charging_keyguard_text_animation_duration_down">500</integer>
    <!-- Wired charging on AOD, text animation duration -->
    <integer name="wired_charging_keyguard_text_animation_duration_up">300</integer>
    <!-- Wired charging on AOD, text animation distance -->
    <integer name="wired_charging_keyguard_text_animation_distance">-30</integer>

    <!-- Logout button -->
    <dimen name="logout_button_layout_height">32dp</dimen>
    <dimen name="logout_button_padding_horizontal">16dp</dimen>
    <dimen name="logout_button_margin_bottom">12dp</dimen>
    <dimen name="logout_button_corner_radius">2dp</dimen>

    <!--  Blur radius on status bar window and power menu  -->
    <dimen name="min_window_blur_radius">1px</dimen>
    <dimen name="max_window_blur_radius">150px</dimen>

    <!-- How much into a DisplayCutout's bounds we can go, on each side -->
    <dimen name="display_cutout_margin_consumption">0px</dimen>
    <!-- How much each bubble is elevated. -->
    <dimen name="bubble_elevation">1dp</dimen>
    <!-- How much the bubble flyout text container is elevated. -->
    <dimen name="bubble_flyout_elevation">4dp</dimen>
    <!-- How much padding is around the left and right sides of the flyout text. -->
    <dimen name="bubble_flyout_padding_x">12dp</dimen>
    <!-- How much padding is around the top and bottom of the flyout text. -->
    <dimen name="bubble_flyout_padding_y">10dp</dimen>
    <!-- Size of the triangle that points from the flyout to the bubble stack. -->
    <dimen name="bubble_flyout_pointer_size">6dp</dimen>
    <!-- How much space to leave between the flyout (tip of the arrow) and the bubble stack. -->
    <dimen name="bubble_flyout_space_from_bubble">8dp</dimen>
    <!-- How much space to leave between the flyout text and the avatar displayed in the flyout. -->
    <dimen name="bubble_flyout_avatar_message_space">6dp</dimen>
    <!-- Padding between status bar and bubbles when displayed in expanded state -->
    <dimen name="bubble_padding_top">16dp</dimen>
    <!-- Size of individual bubbles. -->
    <dimen name="individual_bubble_size">60dp</dimen>
    <!-- Size of bubble bitmap. -->
    <dimen name="bubble_bitmap_size">52dp</dimen>
    <!-- Size of bubble icon bitmap. -->
    <dimen name="bubble_overflow_icon_bitmap_size">24dp</dimen>
    <!-- Extra padding added to the touchable rect for bubbles so they are easier to grab. -->
    <dimen name="bubble_touch_padding">12dp</dimen>
    <!-- Size of the circle around the bubbles when they're in the dismiss target. -->
    <dimen name="bubble_dismiss_encircle_size">52dp</dimen>
    <!-- Padding around the view displayed when the bubble is expanded -->
    <dimen name="bubble_expanded_view_padding">4dp</dimen>
    <!-- This should be at least the size of bubble_expanded_view_padding; it is used to include
         a slight touch slop around the expanded view. -->
    <dimen name="bubble_expanded_view_slop">8dp</dimen>
    <!-- Default (and minimum) height of the expanded view shown when the bubble is expanded -->
    <dimen name="bubble_expanded_default_height">180dp</dimen>
    <!-- Default height of bubble overflow -->
    <dimen name="bubble_overflow_height">480dp</dimen>
    <!-- Bubble overflow padding when there are no bubbles  -->
    <dimen name="bubble_overflow_empty_state_padding">16dp</dimen>
    <!-- Padding of container for overflow bubbles -->
    <dimen name="bubble_overflow_padding">15dp</dimen>
    <!-- Padding of label for bubble overflow view -->
    <dimen name="bubble_overflow_text_padding">7dp</dimen>
    <!-- Height of bubble overflow empty state illustration -->
    <dimen name="bubble_empty_overflow_image_height">200dp</dimen>
    <!-- Padding of bubble overflow empty state subtitle -->
    <dimen name="bubble_empty_overflow_subtitle_padding">50dp</dimen>
    <!-- Height of the triangle that points to the expanded bubble -->
    <dimen name="bubble_pointer_height">4dp</dimen>
    <!-- Width of the triangle that points to the expanded bubble -->
    <dimen name="bubble_pointer_width">6dp</dimen>
    <!-- Extra padding around the dismiss target for bubbles -->
    <dimen name="bubble_dismiss_slop">16dp</dimen>
    <!-- Height of button allowing users to adjust settings for bubbles. -->
    <dimen name="bubble_manage_button_height">48dp</dimen>
    <!-- How far, horizontally, to animate the expanded view over when animating in/out. -->
    <dimen name="bubble_expanded_animate_x_distance">100dp</dimen>
    <!-- How far, vertically, to animate the expanded view over when animating in/out. -->
    <dimen name="bubble_expanded_animate_y_distance">500dp</dimen>
    <!-- Max width of the message bubble-->
    <dimen name="bubble_message_max_width">144dp</dimen>
    <!-- Min width of the message bubble -->
    <dimen name="bubble_message_min_width">32dp</dimen>
    <!-- Interior padding of the message bubble -->
    <dimen name="bubble_message_padding">4dp</dimen>
    <!-- Offset between bubbles in their stacked position. -->
    <dimen name="bubble_stack_offset">5dp</dimen>
    <!-- How far offscreen the bubble stack rests. Cuts off padding and part of icon bitmap. -->
    <dimen name="bubble_stack_offscreen">9dp</dimen>
    <!-- How far down the screen the stack starts. -->
    <dimen name="bubble_stack_starting_offset_y">120dp</dimen>
    <!-- Space between the pointer triangle and the bubble expanded view -->
    <dimen name="bubble_pointer_margin">8dp</dimen>
    <!-- Padding applied to the bubble dismiss target. Touches in this padding cause the bubbles to
         snap to the dismiss target. -->
    <dimen name="bubble_dismiss_target_padding_x">40dp</dimen>
    <dimen name="bubble_dismiss_target_padding_y">20dp</dimen>
    <dimen name="bubble_manage_menu_elevation">4dp</dimen>

    <dimen name="dismiss_circle_size">52dp</dimen>
    <dimen name="dismiss_target_x_size">24dp</dimen>

    <!-- Bubbles user education views -->
    <dimen name="bubbles_manage_education_width">160dp</dimen>
    <!-- The inset from the top bound of the manage button to place the user education. -->
    <dimen name="bubbles_manage_education_top_inset">10dp</dimen>
    <!-- Size of padding for the user education cling, this should at minimum be larger than
        individual_bubble_size + some padding. -->
    <dimen name="bubble_stack_user_education_side_inset">72dp</dimen>

    <!-- Size of the RAT type for CellularTile -->
    <dimen name="celltile_rat_type_size">10sp</dimen>

    <dimen name="new_qs_vertical_margin">8dp</dimen>

    <!-- Size of media cards in the QSPanel carousel -->
    <dimen name="qs_media_width">350dp</dimen>
    <dimen name="qs_media_padding">16dp</dimen>
    <dimen name="qs_media_panel_outer_padding">16dp</dimen>
    <dimen name="qs_media_album_size">52dp</dimen>
    <dimen name="qs_seamless_icon_size">20dp</dimen>
    <dimen name="qqs_media_spacing">8dp</dimen>
    <dimen name="qqs_horizonal_tile_padding_bottom">8dp</dimen>

    <dimen name="magnification_border_size">5dp</dimen>
    <dimen name="magnification_frame_move_short">5dp</dimen>
    <dimen name="magnification_frame_move_long">25dp</dimen>
    <dimen name="magnification_drag_view_width">100dp</dimen>
    <dimen name="magnification_drag_view_height">35dp</dimen>
    <dimen name="magnification_controls_size">90dp</dimen>
    <dimen name="magnifier_left_right_controls_width">35dp</dimen>
    <dimen name="magnifier_left_right_controls_height">45dp</dimen>
    <dimen name="magnifier_up_down_controls_width">45dp</dimen>
    <dimen name="magnifier_up_down_controls_height">40dp</dimen>

    <!-- Home Controls -->
    <dimen name="controls_header_side_margin">4dp</dimen>
    <dimen name="controls_header_menu_size">48dp</dimen>
    <dimen name="controls_header_bottom_margin">24dp</dimen>
    <dimen name="controls_header_app_icon_size">24dp</dimen>
    <dimen name="controls_top_margin">48dp</dimen>
    <dimen name="control_header_text_size">20sp</dimen>
    <dimen name="control_item_text_size">16sp</dimen>
    <dimen name="control_menu_item_text_size">16sp</dimen>
    <dimen name="control_menu_item_min_height">56dp</dimen>
    <dimen name="control_menu_vertical_padding">12dp</dimen>
    <dimen name="control_menu_horizontal_padding">16dp</dimen>
    <dimen name="control_spinner_padding_vertical">24dp</dimen>
    <dimen name="control_spinner_padding_horizontal">20dp</dimen>
    <dimen name="control_text_size">14sp</dimen>
    <dimen name="control_icon_size">24dp</dimen>
    <dimen name="control_spacing">4dp</dimen>
    <dimen name="control_list_divider">1dp</dimen>
    <dimen name="control_corner_radius">12dp</dimen>
    <dimen name="control_height">106dp</dimen>
    <dimen name="control_padding">12dp</dimen>
    <dimen name="control_padding_adjustment">4dp</dimen>
    <dimen name="control_status_normal">14sp</dimen>
    <dimen name="control_status_expanded">18sp</dimen>
    <dimen name="control_base_item_margin">2dp</dimen>
    <dimen name="control_status_padding">3dp</dimen>
    <fraction name="controls_toggle_bg_intensity">5%</fraction>
    <fraction name="controls_dimmed_alpha">40%</fraction>
    <dimen name="controls_setup_top_margin">16dp</dimen>
    <dimen name="controls_setup_title">22sp</dimen>
    <dimen name="controls_setup_subtitle">14sp</dimen>
    <dimen name="controls_setup_vertical_padding">52dp</dimen>

    <!-- Home Controls activity view detail panel-->
    <dimen name="controls_activity_view_top_offset">100dp</dimen>
    <dimen name="controls_activity_view_text_size">17sp</dimen>
    <dimen name="controls_activity_view_corner_radius">@*android:dimen/config_bottomDialogCornerRadius</dimen>

    <!-- Home Controls management screens -->
    <dimen name="controls_management_top_padding">48dp</dimen>
    <dimen name="controls_management_side_padding">16dp</dimen>
    <dimen name="controls_management_titles_margin">16dp</dimen>
    <dimen name="controls_management_footer_side_margin">8dp</dimen>
    <dimen name="controls_management_list_margin">16dp</dimen>
    <dimen name="controls_management_apps_list_margin">64dp</dimen>
    <dimen name="controls_management_editing_list_margin">48dp</dimen>
    <dimen name="controls_management_editing_divider_margin">24dp</dimen>
    <dimen name="controls_management_apps_extra_side_margin">8dp</dimen>
    <dimen name="controls_management_apps_top_margin"></dimen>
    <dimen name="controls_management_zone_top_margin">32dp</dimen>
    <dimen name="controls_management_page_indicator_height">24dp</dimen>
    <dimen name="controls_management_checkbox_size">25dp</dimen>
    <dimen name="controls_title_size">24sp</dimen>
    <dimen name="controls_subtitle_size">16sp</dimen>

    <dimen name="controls_app_icon_size">24dp</dimen>
    <dimen name="controls_app_icon_frame_side_padding">16dp</dimen>
    <dimen name="controls_app_icon_frame_top_padding">4dp</dimen>
    <dimen name="controls_app_icon_frame_bottom_padding">@dimen/controls_app_icon_frame_top_padding</dimen>
    <dimen name="controls_app_bottom_margin">8dp</dimen>
    <dimen name="controls_app_text_padding">8dp</dimen>
    <dimen name="controls_app_divider_height">2dp</dimen>
    <dimen name="controls_app_divider_side_margin">32dp</dimen>

    <dimen name="controls_card_margin">2dp</dimen>
    <item name="control_card_elevation" type="dimen" format="float">15</item>

    <dimen name="controls_dialog_padding">32dp</dimen>
    <dimen name="controls_dialog_control_width">200dp</dimen>

    <!-- Screen Record -->
    <dimen name="screenrecord_dialog_padding">18dp</dimen>
    <dimen name="screenrecord_logo_size">24dp</dimen>
    <dimen name="screenrecord_status_text_size">14sp</dimen>
    <dimen name="screenrecord_status_icon_radius">7dp</dimen>
    <dimen name="screenrecord_status_icon_width">21dp</dimen>
    <dimen name="screenrecord_status_icon_height">17.5dp</dimen>
    <dimen name="screenrecord_status_icon_bg_radius">8dp</dimen>

    <dimen name="kg_user_switcher_text_size">16sp</dimen>

    <!-- Opacity at which the background for the shutdown UI will be drawn. -->
    <item name="shutdown_scrim_behind_alpha" format="float" type="dimen">0.95</item>

    <!--  Allow CornerHandleView and PathSpecCornerPathRenderer to decouple from corner-radius -->
    <dimen name="config_rounded_mask_size">@*android:dimen/rounded_corner_radius</dimen>
    <dimen name="config_rounded_mask_size_top">@*android:dimen/rounded_corner_radius_top</dimen>
    <dimen name="config_rounded_mask_size_bottom">@*android:dimen/rounded_corner_radius_bottom</dimen>
</resources>
