<?xml version="1.0" encoding="utf-8"?>
<!--
/*
** Copyright 2016, 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 xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">

    <!-- Our amoled doesn't animate well. -->
    <bool name="config_animateScreenLights">false</bool>

    <bool name="config_ui_enableFadingMarquee">false</bool>

    <!-- Whether a software navigation bar should be shown. NOTE: in the future this may be
         autodetected from the Configuration. -->
    <bool name="config_showNavigationBar">true</bool>

    <!--  Whether Multiuser UI should be shown -->
    <bool name="config_enableMultiUserUI">true</bool>

    <!--  Maximum number of supported users -->
    <integer name="config_multiuserMaximumUsers">4</integer>

    <!-- Boolean indicating if current platform supports HFP inband ringing -->
    <bool name="config_bluetooth_hfp_inband_ringing_support">true</bool>

    <!-- Whether Hearing Aid profile is supported -->
    <bool name="config_hearing_aid_profile_supported">true</bool>

    <!-- Boolean indicating whether the wifi chipset has dual frequency band support -->
    <bool translatable="false" name="config_wifi_dual_band_support">true</bool>

    <!-- Enable 802.11ac for Wifi hotspot (SAP) -->
    <bool translatable="false" name="config_wifi_softap_ieee80211ac_supported">true</bool>

    <!-- List of regexpressions describing the interface (if any) that represent tetherable
         Wifi interfaces.  If the device doesn't want to support tethering over Wifi this
         should be empty.  An example would be "softap.*" -->
    <string-array translatable="false" name="config_tether_wifi_regexs">
        <item>"wlan0"</item>
        <item>"softap.*"</item>
    </string-array>

    <!-- List of regexpressions describing the interface (if any) that represent tetherable
         USB interfaces.  If the device doesn't want to support tething over USB this should
         be empty.  An example would be "usb.*" -->
    <string-array translatable="false" name="config_tether_usb_regexs">
        <item>"usb\\d"</item>
        <item>"rndis\\d"</item>
    </string-array>

    <!-- When true use the linux /dev/input/event subsystem to detect the switch changes
         on the headphone/microphone jack. When false use the older uevent framework. -->
    <bool name="config_useDevInputEventForAudioJack">true</bool>

    <string translatable="false" name="config_radio_access_family">GSM|CDMA|EVDO|WCDMA|LTE</string>

    <!-- Enable doze mode
         ComponentName of a dream to show whenever the system would otherwise have gone to sleep. -->
    <string translatable="false" name="config_dozeComponent">com.android.systemui/com.android.systemui.doze.DozeService</string>

    <!-- Type of the ambient tap sensor. Empty if ambient tap is not supported. -->
    <string name="config_dozeTapSensorType" translatable="false">com.google.sensor.single_touch</string>

    <!-- If this is true, the screen will come on when you unplug usb/power/whatever. -->
    <bool name="config_unplugTurnsOnScreen">true</bool>

    <!-- If device supports pickup/lift gesture -->
    <bool name="config_dozePulsePickup">true</bool>

    <!-- Screen brightness when dozing. -->
    <integer name="config_screenBrightnessDoze">34</integer>

    <!-- Whether the always on display mode is available. -->
    <bool name="config_dozeAlwaysOnDisplayAvailable">true</bool>

    <!-- Disable AOD by default -->
    <bool name="config_dozeAlwaysOnEnabled">false</bool>

    <!-- Specifies whether to decouple the auto-suspend state of the device from the display on/off state. -->
    <bool name="config_powerDecoupleAutoSuspendModeFromDisplay">true</bool>

    <!-- Specifies whether to decouple the interactive state of the device from the display on/off state. -->
    <bool name="config_powerDecoupleInteractiveModeFromDisplay">true</bool>

    <!-- Radius of the software rounded corners. -->
    <dimen name="rounded_corner_radius">157px</dimen>

    <!-- Adjustment for software rounded corners since corners aren't perfectly round. -->
    <dimen name="rounded_corner_radius_adjustment">25px</dimen>

    <!-- Height of the status bar -->
    <dimen name="status_bar_height_portrait">28dp</dimen>

    <!-- Height of area above QQS where battery/time go (equal to status bar height if > 48dp) -->
    <dimen name="quick_qs_offset_height">171px</dimen>
    <!-- Total height of QQS (quick_qs_offset_height + 128dp) -->
    <dimen name="quick_qs_total_height">177dp</dimen>

    <!-- Shutdown if the battery temperature exceeds (this value * 0.1) Celsius. -->
    <integer name="config_shutdownBatteryTemperature">600</integer>

    <!-- Whether or not we should show the option to show battery percentage -->
    <bool name="config_battery_percentage_setting_available">true</bool>

    <!-- Number of physical SIM slots on the device. This includes both eSIM
    and pSIM slots, and is not necessarily the same as the number of phones/logical modems
    supported by the device.  For example, a multi-sim device can have 2 phones/logical modems,
    but 3 physical slots, or a single SIM device can have 1 phones/logical modems, but 2
    physical slots (one eSIM and one pSIM) -->
    <integer name="config_num_physical_slots">3</integer>

    <!-- Enable CBRS support -->
    <bool translatable="false" name="config_cbrs_supported">true</bool>

    <!-- IWLAN-->
    <string name="config_wlan_data_service_package">com.google.android.iwlan</string>
    <string name="config_wlan_network_service_package">com.google.android.iwlan</string>
    <bool name="config_wlan_data_service_conn_persistence_on_restart">false</bool>
    <string name="config_qualified_networks_service_package">com.shannon.qualifiednetworksservice</string>

    <!-- Boolean indicating USSD over IMS is allowed.
     If it is not supported due to modem limitations, USSD send over the CS pipe instead.-->
    <bool name="config_allow_ussd_over_ims">true</bool>

    <!-- Flag specifying whether VoLTE is available on device -->
    <bool name="config_device_volte_available">true</bool>

    <!-- Flag specifying whether VoLTE is available on device -->
    <bool name="config_device_vt_available">true</bool>

    <!-- Flag specifying whether WFC over IMS is availasble on device -->
    <bool name="config_device_wfc_ims_available">true</bool>

    <!-- Whether the new Auto Selection Network UI should be shown -->
    <bool name="config_enableNewAutoSelectNetworkUI">true</bool>

    <!-- Is the device capable of hot swapping an UICC Card -->
    <bool name="config_hotswapCapable">true</bool>

    <!-- The default refresh rate. P21 manages this using the peak refresh rate setting, so set
         this value to 0 so it has no effect. -->
    <integer name="config_defaultRefreshRate">0</integer>

    <!-- The default peak refresh rate. -->
    <integer name="config_defaultPeakRefreshRate">60</integer>

    <!-- Optional IPsec algorithms enabled by this device, defaulting to empty. OEMs can override
         it by providing a list of algorithm names in an overlay config.xml file.

         As Android releases new versions, more algorithms are becoming mandatory. Mandatory
         algorithms will be automatically enabled on the device. Optional algorithms need
         to be explicitly declared in this resource to be enabled.
             * SDK level 28 makes the following algorithms mandatory : "cbc(aes)", "hmac(md5)",
               "hmac(sha1)", "hmac(sha256)", "hmac(sha384)", "hmac(sha512)", "rfc4106(gcm(aes))"
             * SDK level 31 makes the following algorithms mandatory : "rfc3686(ctr(aes))",
               "xcbc(aes)", "rfc7539esp(chacha20,poly1305)"
     -->
    <string-array name="config_optionalIpSecAlgorithms" translatable="false">
        <!-- Add algorithm here -->
        <item>"xcbc(aes)"</item>
        <item>"rfc3686(ctr(aes))"</item>
    </string-array>

    <!-- List supported color modes. -->
    <integer-array name="config_availableColorModes">
        <item>0</item> <!-- COLOR_MODE_NATURAL -->
        <item>256</item> <!-- vendor color mode boosted -->
        <item>3</item> <!-- COLOR_MODE_AUTOMATIC -->
    </integer-array>

    <integer-array name="config_mappedColorModes">
        <item>0</item> <!-- COLOR_MODE_NATURAL -->
        <item>256</item> <!-- COLOR_MODE_BOOSTED -->
        <item>2</item> <!-- COLOR_MODE_SATURATED -->
        <item>3</item> <!-- COLOR_MODE_AUTOMATIC -->
    </integer-array>

    <!-- Color mode to use when accessibility transforms are enabled. This color mode must be
     supported by the device, but not necessarily appear in config_availableColorModes. The
     regularly selected color mode will be used if this value is negative. -->
    <integer name="config_accessibilityColorMode">2</integer>

    <!-- Boolean indicating whether the HWC setColorTransform function can be performed efficiently
         in hardware. -->
    <bool name="config_setColorTransformAccelerated">true</bool>

    <!-- Default color temperature, in Kelvin, to tint the screen when night display is
         activated. -->
    <integer name="config_nightDisplayColorTemperatureDefault">3339</integer>

    <!-- Whether the device enable the standalone (SA) mode of 5G NR.-->
    <bool name="config_telephony5gStandalone">true</bool>
    <!-- Whether the device enable the non-standalone (NSA) mode of 5G NR.-->
    <bool name="config_telephony5gNonStandalone">true</bool>

    <!-- An array of device capabilities defined by GSMA SGP.22 v2.2.2, and their corresponding major
     version. -->
     <string-array translatable="false" name="config_telephonyEuiccDeviceCapabilities">
          <item>"gsm,8"</item>
          <item>"utran,9"</item>
          <item>"eutran,15"</item>
          <item>"nrepc,15"</item>
          <item>"nr5gc,15"</item>
          <item>"eutran5gc,15"</item>
     </string-array>

    <!-- Auto-brightness sensor type string -->
    <string name="config_displayLightSensorType">"com.google.sensor.auto_brightness"</string>

    <!-- List of biometric sensors on the device, in decreasing strength. Consumed by AuthService
     when registering authenticators with BiometricService. Format must be ID:Modality:Strength,
     where: IDs are unique per device, Modality as defined in BiometricAuthenticator.java,
     and Strength as defined in Authenticators.java -->
    <string-array name="config_biometric_sensors" translatable="false" >
        <item>0:2:15</item> <!-- ID0:Fingerprint:Strong -->
    </string-array>

    <!-- Default list of files pinned by the Pinner Service -->
    <string-array translatable="false" name="config_defaultPinnerServiceFiles">
        <item>"/apex/com.android.art/javalib/core-oj.jar"</item>
        <item>"/apex/com.android.art/javalib/core-libart.jar"</item>
        <item>"/apex/com.android.media/javalib/updatable-media.jar"</item>
        <item>"/system/framework/framework.jar"</item>
        <item>"/system/framework/services.jar"</item>
        <item>"/system_ext/priv-app/SystemUIGoogle/SystemUIGoogle.apk"</item>
    </string-array>

    <!-- Should the pinner service pin the Camera application? -->
    <bool name="config_pinnerCameraApp">true</bool>

    <!-- Should the pinner service pin the Home application? -->
    <bool name="config_pinnerHomeApp">true</bool>

    <!-- Display 90Hz blacklist. Apps that do not work well when the display refreshes at 90Hz.
         When these apps are visible, the display's refresh rate gets fixed to 60Hz. -->
    <string-array name="config_highRefreshRateBlacklist">
        <item>com.nianticlabs.pokemongo</item>
        <item>com.google.android.documentsui</item>
        <item>com.activision.callofduty.shooter</item>
        <item>jp.konami.epjCastlevania2</item>
    </string-array>

    <!-- The default intensity level for haptic feedback. See
         Settings.System.HAPTIC_FEEDBACK_INTENSITY more details on the constant values and
         meanings. -->
    <integer name="config_defaultHapticFeedbackIntensity">3</integer>
    <!-- The default intensity level for notification vibrations. See
         Settings.System.NOTIFICATION_VIBRATION_INTENSITY more details on the constant values and
         meanings. -->
    <integer name="config_defaultNotificationVibrationIntensity">3</integer>
    <!-- The default intensity level for notification vibrations. See
         Settings.System.RING_VIBRATION_INTENSITY more details on the constant values and
         meanings. -->
    <integer name="config_defaultRingVibrationIntensity">3</integer>

    <!-- Enables or disables haptic effect when the text insertion/selection handle is moved
          manually by the user. Off by default, since the expected haptic feedback may not be
          available on some devices. -->
    <bool name="config_enableHapticTextHandle">true</bool>
</resources>
