<?xml version="1.0" encoding="utf-8"?>
<!--
     Copyright (C) 2020 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.
-->

<PreferenceScreen
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:settings="http://schemas.android.com/apk/res-auto"
    android:title="@string/zen_category_people" >

   <!-- Conversations -->
   <PreferenceCategory
       android:key="zen_mode_settings_category_conversations"
       android:title="@string/zen_mode_conversations_section_title">

      <!-- Senders image -->
      <com.android.settingslib.widget.LayoutPreference
          android:key="zen_mode_conversations_image"
          android:layout="@layout/zen_mode_senders_overlay_image"
          android:selectable="false"/>

      <Preference
          android:key="zen_mode_conversations"
          android:title="@string/zen_mode_conversations_title"
          android:fragment="com.android.settings.notification.zen.ZenModeConversationsSettings"/>
   </PreferenceCategory>

   <!-- Calls & Messages -->
   <PreferenceCategory
       android:key="zen_mode_people_calls_messages_section"
       android:title="@string/zen_mode_people_calls_messages_section_title">

      <Preference
          android:key="zen_mode_people_calls"
          android:title="@string/zen_mode_calls_title"
          android:fragment="com.android.settings.notification.zen.ZenModeCallsSettings"/>

      <Preference
          android:key="zen_mode_people_messages"
          android:title="@string/zen_mode_messages_title"
          android:fragment="com.android.settings.notification.zen.ZenModeMessagesSettings"/>
   </PreferenceCategory>

   <!-- Footer that shows if user is put into alarms only or total silence mode by an app -->
   <com.android.settingslib.widget.FooterPreference/>

</PreferenceScreen>
