<?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>
    <!-- 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>
    <!-- The distance from a side of device of the navigation bar to start an edge swipe -->
    <dimen name="navigation_bar_edge_swipe_threshold">48dp</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>

    <!-- Height of notification icons in the status bar -->
    <dimen name="status_bar_icon_size">@*android:dimen/status_bar_icon_size</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. -->
    <dimen name="status_bar_battery_icon_width">8.5dp</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>

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

    <!-- Increased height of a small notification in the status bar -->
    <dimen name="notification_min_height_increased">146dp</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 icon -->
    <dimen name="notification_icon_transform_content_shift">32dp</dimen>

    <!-- The padding on the bottom of the notifications on the keyguard -->
    <dimen name="keyguard_indication_bottom_padding">12sp</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">6dp</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>

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

    <!-- 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">6dp</dimen>

    <!-- the padding on the end of the statusbar -->
    <dimen name="status_bar_padding_end">6dp</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>

    <!-- The padding on the global screenshot background image -->
    <dimen name="global_screenshot_bg_padding">20dp</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">56dp</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">8dp</dimen>

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

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

    <!-- the amount the volume panel should be offset at the end from the view next to it (or
    the screen edge, in portrait-->
    <dimen name="volume_dialog_base_margin">8dp</dimen>

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

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

    <dimen name="volume_dialog_row_height">252dp</dimen>

    <dimen name="volume_dialog_ringer_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_settings_icon_size">16dp</dimen>

    <dimen name="volume_dialog_elevation">9dp</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_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 (28dp - qs_tile_margin_top_bottom). -->
    <dimen name="qs_customize_header_min_height">40dp</dimen>
    <dimen name="qs_tile_margin_top">18dp</dimen>
    <dimen name="qs_tile_background_size">40dp</dimen>
    <dimen name="qs_quick_tile_size">48dp</dimen>
    <!-- Maximum width of quick quick settings panel. Defaults to MATCH_PARENT-->
    <dimen name="qs_quick_layout_width">-1px</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_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_text_size">12sp</dimen>
    <dimen name="qs_carrier_info_text_size">14sp</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_below_icon">12dp</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">30dp</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">18dp</dimen>
    <dimen name="qs_header_alarm_icon_size">18dp</dimen>
    <dimen name="qs_header_alarm_text_margin_start">6dp</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">24dp</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>

    <!-- 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>

    <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">18dp</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>

    <!-- 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/keyguard user picker (incl. frame) -->
    <dimen name="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">32dp</dimen>
    <dimen name="keyguard_lock_width">32dp</dimen>
    <dimen name="keyguard_lock_padding">24dp</dimen>

    <dimen name="keyguard_indication_margin_bottom">65dp</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="pip_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>

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

    <dimen name="global_actions_panel_width">120dp</dimen>

    <dimen name="global_actions_grid_container_bottom_margin">16dp</dimen>

    <dimen name="global_actions_grid_side_margin">4dp</dimen>
    <dimen name="global_actions_grid_separated_panel_width">104dp</dimen>
    <dimen name="global_actions_grid_top_padding">8dp</dimen>
    <dimen name="global_actions_grid_bottom_padding">8dp</dimen>
    <dimen name="global_actions_grid_left_padding">4dp</dimen>
    <dimen name="global_actions_grid_right_padding">4dp</dimen>

    <dimen name="global_actions_grid_item_side_margin">12dp</dimen>
    <dimen name="global_actions_grid_item_vertical_margin">8dp</dimen>

    <dimen name="global_actions_top_padding">120dp</dimen>

    <dimen name="global_actions_padding">12dp</dimen>

    <dimen name="global_actions_translate">9dp</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>

    <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>
    <dimen name="biometric_dialog_animation_translation_offset">350dp</dimen>
    <dimen name="biometric_dialog_border_padding">4dp</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>

    <!-- How much into a DisplayCutout's bounds we can go, on each side -->
    <dimen name="display_cutout_margin_consumption">0px</dimen>

    <!-- How much we expand the touchable region of the status bar below the notch to catch touches
         that just start below the notch. -->
    <dimen name="display_cutout_touchable_region_size">12dp</dimen>

    <!-- Padding below Ongoing App Ops dialog title -->
    <dimen name="ongoing_appops_dialog_sep">16dp</dimen>
    <!--Padding around text items in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_text_padding">16dp</dimen>
    <!-- Height and width of App Opp icons in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_icon_size">24dp</dimen>
    <!-- Left margin of App Opp icons in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_icon_margin">8dp</dimen>
    <!-- Height and width of Application icons in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_app_icon_size">32dp</dimen>
    <!-- Height and width of Plus sign in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_app_plus_size">24dp</dimen>
    <!-- Height of line in Ongoing App Ops dialog-->
    <dimen name="ongoing_appops_dialog_line_height">48dp</dimen>
    <!-- Side margin of title in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_title_margin_sides">24dp</dimen>
    <!-- Bottom margin of items in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_items_bottom_margin">24dp</dimen>
    <!-- Top and bottom margin of title in Ongoing App Ops dialog -->
    <dimen name="ongoing_appops_dialog_title_margin_top_bottom">18dp</dimen>
    <!-- Side margins around the Ongoing App Ops chip-->
    <dimen name="ongoing_appops_chip_margin">12dp</dimen>
    <!-- Top and bottom margins around the Ongoing App Ops chip -->
    <dimen name="ongoing_appops_top_chip_margin">12dp</dimen>
    <!-- Start and End padding for Ongoing App Ops chip -->
    <dimen name="ongoing_appops_chip_side_padding">6dp</dimen>
    <!-- Padding between background of Ongoing App Ops chip and content -->
    <dimen name="ongoing_appops_chip_bg_padding">0dp</dimen>
    <!-- Margin between icons of Ongoing App Ops chip -->
    <dimen name="ongoing_appops_chip_icon_margin">4dp</dimen>
    <!-- Icon size of Ongoing App Ops chip -->
    <dimen name="ongoing_appops_chip_icon_size">18dp</dimen>
    <!-- Radius of Ongoing App Ops chip corners -->
    <dimen name="ongoing_appops_chip_bg_corner_radius">12dp</dimen>
    <!-- Text size for Ongoing App Ops dialog title -->
    <dimen name="ongoing_appops_dialog_title_size">20sp</dimen>
    <!-- Text size for Ongoing App Ops dialog items -->
    <dimen name="ongoing_appops_dialog_item_size">16sp</dimen>

    <!-- How much a bubble is elevated -->
    <dimen name="bubble_elevation">8dp</dimen>
    <!-- Padding around a collapsed bubble -->
    <dimen name="bubble_view_padding">0dp</dimen>
    <!-- Padding between bubbles when displayed in expanded state -->
    <dimen name="bubble_padding">8dp</dimen>
    <!-- Size of individual bubbles. -->
    <dimen name="individual_bubble_size">56dp</dimen>
    <!-- How much to inset the icon in the circle -->
    <dimen name="bubble_icon_inset">16dp</dimen>
    <!-- Padding around the view displayed when the bubble is expanded -->
    <dimen name="bubble_expanded_view_padding">8dp</dimen>
    <!-- Default height of the expanded view shown when the bubble is expanded -->
    <dimen name="bubble_expanded_default_height">400dp</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 the header within the expanded view. -->
    <dimen name="bubble_expanded_header_height">48dp</dimen>
    <!-- Left and right padding applied to the header. -->
    <dimen name="bubble_expanded_header_horizontal_padding">24dp</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. -->
    <dimen name="bubble_stack_offscreen">5dp</dimen>
    <!-- How far down the screen the stack starts. -->
    <dimen name="bubble_stack_starting_offset_y">100dp</dimen>
    <!-- Size of image buttons in the bubble header -->
    <dimen name="bubble_header_icon_size">48dp</dimen>
</resources>
