<?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:key="all_tether_prefs_screen"
    android:title="@string/tether_settings_title_all"
    settings:searchable="false">

    <PreferenceCategory
        android:key="wifi_tether_settings_group"
        android:title="@string/wifi_hotspot_checkbox_text"
        settings:searchable="false">
        <com.android.settings.wifi.tether.WifiTetherSsidPreference
            android:key="wifi_tether_network_name_2"
            android:title="@string/wifi_hotspot_name_title"
            android:summary="@string/summary_placeholder"/>

        <com.android.settings.widget.ValidatedEditTextPreference
            android:key="wifi_tether_network_password_2"
            android:persistent="false"
            android:title="@string/wifi_hotspot_password_title"/>

        <SwitchPreference
            android:key="wifi_tether_auto_turn_off_2"
            android:title="@string/wifi_hotspot_auto_off_title"
            android:summary="@string/wifi_hotspot_auto_off_summary"/>

        <ListPreference
            android:key="wifi_tether_network_ap_band_2"
            android:title="@string/wifi_hotspot_ap_band_title"/>

        <ListPreference
            android:key="wifi_tether_security_2"
            android:title="@string/wifi_security"
            android:summary="@string/summary_placeholder"
            android:entries="@array/wifi_tether_security"
            android:entryValues="@array/wifi_tether_security_values"/>
    </PreferenceCategory>

    <PreferenceCategory
        android:key="tethering_options_group"
        android:title="@string/tethering_interface_options"
        settings:searchable="false">
        <SwitchPreference
            android:key="enable_usb_tethering"
            android:title="@string/usb_tethering_button_text"
            android:summary="@string/usb_tethering_subtext"
            settings:controller="com.android.settings.network.UsbTetherPreferenceController"
            settings:keywords="@string/keywords_hotspot_tethering" />

        <SwitchPreference
            android:key="enable_bluetooth_tethering_2"
            android:title="@string/bluetooth_tether_checkbox_text"
            android:summary="@string/bluetooth_tethering_subtext"
            settings:controller="com.android.settings.network.BluetoothTetherPreferenceController"
            settings:keywords="@string/keywords_hotspot_tethering" />

        <SwitchPreference
            android:key="enable_ethernet_tethering_2"
            android:title="@string/ethernet_tether_checkbox_text"
            android:summary="@string/ethernet_tethering_subtext"
            settings:controller="com.android.settings.network.EthernetTetherPreferenceController"
            settings:keywords="@string/keywords_hotspot_tethering"/>

        <SwitchPreference
            android:key="disable_wifi_tethering"
            android:title="@string/disable_wifi_hotspot_title"
            android:summary="@string/summary_placeholder"
            settings:controller="com.android.settings.network.WifiTetherDisablePreferenceController"
            settings:keywords="@string/keywords_hotspot_tethering" />
    </PreferenceCategory>

    <Preference
        android:key="disabled_on_data_saver_2"
        android:summary="@string/tether_settings_disabled_on_data_saver"
        android:selectable="false"
        settings:searchable="false"
        settings:allowDividerAbove="true" />

    <com.android.settingslib.widget.FooterPreference
        android:key="tether_prefs_footer_2"
        android:selectable="false"
        settings:searchable="false"/>
</PreferenceScreen>
