<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2018 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>
    <!-- Values used for finding elements on the system ui nav bars -->
    <item type="id" name="lock_screen_nav_buttons"/>
    <item type="id" name="hvac_panel_close_button"/>

    <!-- Values assigned to quick control views    -->
    <item type="id" name="qc_display_status_icon"/>
    <item type="id" name="qc_bluetooth_status_icon"/>
    <item type="id" name="qc_signal_status_icon"/>
    <item type="id" name="qc_sound_status_icon"/>
    <item type="id" name="qc_location_status_icon"/>
    <item type="id" name="qc_phone_call_status_icon"/>
    <item type="id" name="qc_drive_mode_status_icon"/>
    <item type="id" name="qc_mobile_signal_status_icon"/>
    <item type="id" name="qc_wifi_signal_status_icon"/>
    <item type="id" name="qc_media_volume_status_icon"/>
    <item type="id" name="qc_status_icon_list"/>

    <!-- Id values for system bar windows (to guarantee root view id uniqueness for the individual bars) -->
    <item type="id" name="car_top_bar_window"/>
    <item type="id" name="car_bottom_bar_window"/>
    <item type="id" name="car_left_bar_window"/>
    <item type="id" name="car_right_bar_window"/>

    <!-- Id values for custom HVAC animations -->
    <item type="anim" name="hvac_open_anim"/>
    <item type="anim" name="hvac_close_anim"/>
</resources>
