<?xml version="1.0" encoding="utf-8"?>
<!--
/*
** Copyright 2009, 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.
*/
-->

<!-- These resources are around just to allow their values to be customized
     for different hardware and product builds.  Do not translate.

     NOTE: The naming convention is "config_camelCaseValue". Some legacy
     entries do not follow the convention, but all new entries should. -->

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- Do not translate. Defines the slots for the right-hand side icons.  That is to say, the
         icons in the status bar that are not notifications. -->
    <string-array name="config_statusBarIcons">
        <item><xliff:g id="id">@string/status_bar_rotate</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_headset</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_data_saver</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_managed_profile</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_ime</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_sync_failing</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_sync_active</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_cast</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_hotspot</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_location</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_bluetooth</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_nfc</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_tty</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_speakerphone</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_zen</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_mute</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_volume</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_wifi</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_cdma_eri</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_data_connection</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_phone_evdo_signal</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_phone_signal</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_battery</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_alarm_clock</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_secure</xliff:g></item>
        <item><xliff:g id="id">@string/status_bar_clock</xliff:g></item>
    </string-array>

    <string translatable="false" name="status_bar_rotate">rotate</string>
    <string translatable="false" name="status_bar_headset">headset</string>
    <string translatable="false" name="status_bar_data_saver">data_saver</string>
    <string translatable="false" name="status_bar_managed_profile">managed_profile</string>
    <string translatable="false" name="status_bar_ime">ime</string>
    <string translatable="false" name="status_bar_sync_failing">sync_failing</string>
    <string translatable="false" name="status_bar_sync_active">sync_active</string>
    <string translatable="false" name="status_bar_cast">cast</string>
    <string translatable="false" name="status_bar_hotspot">hotspot</string>
    <string translatable="false" name="status_bar_location">location</string>
    <string translatable="false" name="status_bar_bluetooth">bluetooth</string>
    <string translatable="false" name="status_bar_nfc">nfc</string>
    <string translatable="false" name="status_bar_tty">tty</string>
    <string translatable="false" name="status_bar_speakerphone">speakerphone</string>
    <string translatable="false" name="status_bar_zen">zen</string>
    <string translatable="false" name="status_bar_mute">mute</string>
    <string translatable="false" name="status_bar_volume">volume</string>
    <string translatable="false" name="status_bar_wifi">wifi</string>
    <string translatable="false" name="status_bar_cdma_eri">cdma_eri</string>
    <string translatable="false" name="status_bar_data_connection">data_connection</string>
    <string translatable="false" name="status_bar_phone_evdo_signal">phone_evdo_signal</string>
    <string translatable="false" name="status_bar_phone_signal">phone_signal</string>
    <string translatable="false" name="status_bar_battery">battery</string>
    <string translatable="false" name="status_bar_alarm_clock">alarm_clock</string>
    <string translatable="false" name="status_bar_secure">secure</string>
    <string translatable="false" name="status_bar_clock">clock</string>

    <!-- Flag indicating whether the surface flinger has limited
         alpha compositing functionality in hardware.  If set, the window
         manager will disable alpha trasformation in animations where not
         strictly needed. -->
    <bool name="config_sf_limitedAlpha">false</bool>

    <!-- Default value used to block data calls if ims is not
         connected.  If you use the ims apn DCT will block
         any other apn from connecting until ims apn is connected-->
    <bool name="ImsConnectedDefaultValue">false</bool>

    <!-- Flag indicating whether the surface flinger is inefficient
         at performing a blur.  Used by parts of the UI to turn off
         the blur effect where it isn't worth the performance hit.
         As of Honeycomb, blurring is not supported anymore. -->
    <bool name="config_sf_slowBlur">true</bool>

    <!-- Flag indicating that the media framework should support playing of sounds on volume
         key usage.  This adds noticeable additional overhead to volume key processing, so
         is disableable for products for which it is irrelevant. -->
    <bool name="config_useVolumeKeySounds">true</bool>

    <!-- The attenuation in dB applied to the sound effects played
         through AudioManager.playSoundEffect() when no volume is specified. -->
    <integer name="config_soundEffectVolumeDb">-6</integer>

    <!-- The attenuation in dB applied to the lock/unlock sounds. -->
    <integer name="config_lockSoundVolumeDb">-6</integer>

    <!-- Flag indicating whether the AUDIO_BECOMING_NOISY notification should
         be sent during a change to the audio output device. -->
    <bool name="config_sendAudioBecomingNoisy">true</bool>

    <!-- The duration (in milliseconds) of a short animation. -->
    <integer name="config_shortAnimTime">200</integer>

    <!-- The duration (in milliseconds) of a medium-length animation. -->
    <integer name="config_mediumAnimTime">400</integer>

    <!-- The duration (in milliseconds) of a long animation. -->
    <integer name="config_longAnimTime">500</integer>

    <!-- The duration (in milliseconds) of the activity open/close and fragment open/close animations. -->
    <integer name="config_activityShortDur">150</integer>
    <integer name="config_activityDefaultDur">220</integer>

    <!-- Duration for the dim animation behind a dialog.  This may be either
         a percentage, which is relative to the duration of the enter/open
         animation of the window being shown that is dimming behind, or it may
         be an integer for a constant duration. -->
    <fraction name="config_dimBehindFadeDuration">100%</fraction>

    <!-- The maximum width we would prefer dialogs to be.  0 if there is no
         maximum (let them grow as large as the screen).  Actual values are
         specified for -large and -xlarge configurations. -->
    <dimen name="config_prefDialogWidth">320dp</dimen>

    <!-- Enables or disables fading edges when marquee is enabled in TextView.
         Off by default, since the framebuffer readback used to implement the
         fading edges is prohibitively expensive on most GPUs. -->
    <bool name="config_ui_enableFadingMarquee">false</bool>

    <!-- Whether dialogs should close automatically when the user touches outside
         of them.  This should not normally be modified. -->
    <bool name="config_closeDialogWhenTouchOutside">true</bool>

    <!-- Device configuration indicating whether we should avoid using accelerated graphics
         in certain places to reduce RAM footprint.  This is ignored if ro.config.low_ram
         is true (in that case this is assumed true as well).  It can allow you to tune down
         your device's memory use without going to the point of causing applications to turn
         off features. -->
    <bool name="config_avoidGfxAccel">false</bool>

    <!-- Device configuration setting the minfree tunable in the lowmemorykiller in the kernel.
         A high value will cause the lowmemorykiller to fire earlier, keeping more memory
         in the file cache and preventing I/O thrashing, but allowing fewer processes to
         stay in memory.  A low value will keep more processes in memory but may cause
         thrashing if set too low.  Overrides the default value chosen by ActivityManager
         based on screen size and total memory for the largest lowmemorykiller bucket, and
         scaled proportionally to the smaller buckets.  -1 keeps the default. -->
    <integer name="config_lowMemoryKillerMinFreeKbytesAbsolute">-1</integer>

    <!-- Device configuration adjusting the minfree tunable in the lowmemorykiller in the
         kernel.  A high value will cause the lowmemorykiller to fire earlier, keeping more
         memory in the file cache and preventing I/O thrashing, but allowing fewer processes
         to stay in memory.  A low value will keep more processes in memory but may cause
         thrashing if set too low.  Directly added to the default value chosen by
         ActivityManager based on screen size and total memory for the largest lowmemorykiller
         bucket, and scaled proportionally to the smaller buckets. 0 keeps the default. -->
    <integer name="config_lowMemoryKillerMinFreeKbytesAdjust">0</integer>

    <!-- Device configuration setting the /proc/sys/vm/extra_free_kbytes tunable in the kernel
         (if it exists).  A high value will increase the amount of memory that the kernel
         tries to keep free, reducing allocation time and causing the lowmemorykiller to kill
         earlier.  A low value allows more memory to be used by processes but may cause more
         allocations to block waiting on disk I/O or lowmemorykiller.  Overrides the default
         value chosen by ActivityManager based on screen size.  0 prevents keeping any extra
         memory over what the kernel keeps by default.  -1 keeps the default. -->
    <integer name="config_extraFreeKbytesAbsolute">-1</integer>

    <!-- Device configuration adjusting the /proc/sys/vm/extra_free_kbytes tunable in the kernel
         (if it exists).  0 uses the default value chosen by ActivityManager.  A positive value
         will increase the amount of memory that the kernel tries to keep free, reducing
         allocation time and causing the lowmemorykiller to kill earlier.  A negative value
         allows more memory to be used by processes but may cause more allocations to block
         waiting on disk I/O or lowmemorykiller.  Directly added to the default value chosen by
         ActivityManager based on screen size. -->
    <integer name="config_extraFreeKbytesAdjust">0</integer>

    <!-- Set this to true to enable the platform's auto-power-save modes like doze and
         app standby.  These are not enabled by default because they require a standard
         cloud-to-device messaging service for apps to interact correctly with the modes
         (such as to be able to deliver an instant message to the device even when it is
         dozing).  This should be enabled if you have such services and expect apps to
         correctly use them when installed on your device.  Otherwise, keep this disabled
         so that applications can still use their own mechanisms. -->
    <bool name="config_enableAutoPowerModes">false</bool>

    <!-- The threshold angle for any motion detection in auto-power save modes.
         In hundreths of a degree. -->
    <integer name="config_autoPowerModeThresholdAngle">200</integer>

    <!-- The sensor id of an "any motion" sensor used in auto-power save modes.
         0 indicates this sensor is not available. -->
    <integer name="config_autoPowerModeAnyMotionSensor">0</integer>

    <!-- If an any motion sensor is not available, prefer the wrist tilt detector over the
         SMD. -->
    <bool name="config_autoPowerModePreferWristTilt">false</bool>

    <!-- If a location should be pre-fetched when going into device idle. -->
    <bool name="config_autoPowerModePrefetchLocation">true</bool>

    <!-- The duration (in milliseconds) that the radio will scan for a signal
         when there's no network connection. If the scan doesn't timeout, use zero -->
    <integer name="config_radioScanningTimeout">0</integer>

    <!-- XXXXX NOTE THE FOLLOWING RESOURCES USE THE WRONG NAMING CONVENTION.
         Please don't copy them, copy anything else. -->

    <!-- This string array should be overridden by the device to present a list of network
         attributes.  This is used by the connectivity manager to decide which networks can coexist
         based on the hardware -->
    <!-- An Array of "[Connection name],[ConnectivityManager.TYPE_xxxx],
         [associated radio-type],[priority],[restoral-timer(ms)],[dependencyMet]  -->
    <!-- the 5th element "resore-time" indicates the number of milliseconds to delay
         before automatically restore the default connection.  Set -1 if the connection
         does not require auto-restore. -->
    <!-- the 6th element indicates boot-time dependency-met value. -->
    <string-array translatable="false" name="networkAttributes">
        <item>"wifi,1,1,1,-1,true"</item>
        <item>"mobile,0,0,0,-1,true"</item>
        <item>"mobile_mms,2,0,2,60000,true"</item>
        <item>"mobile_supl,3,0,2,60000,true"</item>
        <item>"mobile_hipri,5,0,3,60000,true"</item>
        <item>"mobile_fota,10,0,2,60000,true"</item>
        <item>"mobile_ims,11,0,2,60000,true"</item>
        <item>"mobile_cbs,12,0,2,60000,true"</item>
        <item>"wifi_p2p,13,1,0,-1,true"</item>
        <item>"mobile_ia,14,0,2,-1,true"</item>
        <item>"mobile_emergency,15,0,2,-1,true"</item>
    </string-array>

    <!-- Array of ConnectivityManager.TYPE_xxxx constants for networks that may only
         be controlled by systemOrSignature apps.  -->
    <integer-array translatable="false" name="config_protectedNetworks">
        <item>10</item>
        <item>11</item>
        <item>12</item>
        <item>14</item>
        <item>15</item>
    </integer-array>

    <!-- This string array should be overridden by the device to present a list of radio
         attributes.  This is used by the connectivity manager to decide which networks can coexist
         based on the hardware -->
    <!-- An Array of "[ConnectivityManager connectionType],
                      [# simultaneous connection types]"  -->
    <string-array translatable="false" name="radioAttributes">
        <item>"1,1"</item>
        <item>"0,1"</item>
    </string-array>

    <!-- The maximum duration (in milliseconds) we expect a network transition to take -->
    <integer name="config_networkTransitionTimeout">60000</integer>

    <!-- Whether/how to notify the user on network switches. See LingerMonitor.java. -->
    <integer translatable="false" name="config_networkNotifySwitchType">0</integer>

    <!-- What types of network switches to notify. See LingerMonitor.java. -->
    <string-array translatable="false" name="config_networkNotifySwitches">
    </string-array>

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

    <!-- 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">
    </string-array>

    <!-- List of regexpressions describing the interface (if any) that represent tetherable
         WiMAX 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_wimax_regexs">
    </string-array>

    <!-- List of regexpressions describing the interface (if any) that represent tetherable
         bluetooth interfaces.  If the device doesn't want to support tethering over bluetooth this
         should be empty. -->
    <string-array translatable="false" name="config_tether_bluetooth_regexs">
    </string-array>

    <!-- Max number of Bluetooth tethering connections allowed. If this is
         updated config_tether_dhcp_range has to be updated appropriately. -->
    <integer translateable="false" name="config_max_pan_devices">5</integer>

    <!-- Dhcp range (min, max) to use for tethering purposes -->
    <string-array translatable="false" name="config_tether_dhcp_range">
    </string-array>

    <!-- Regex of wired ethernet ifaces -->
    <string translatable="false" name="config_ethernet_iface_regex">eth\\d</string>

    <!-- If the mobile hotspot feature requires provisioning, a package name and class name
        can be provided to launch a supported application that provisions the devices.

        Example Usage:

        String[] appDetails = getStringArray(R.array.config_mobile_hotspot_provision_app);
        Intent intent = new Intent(Intent.ACTION_MAIN);
        intent.setClassName(appDetails[0], appDetails[1]);
        startActivityForResult(intent, 0);

        public void onActivityResult(int requestCode, int resultCode, Intent intent) {
            super.onActivityResult(requestCode, resultCode, intent);
            if (requestCode == 0) {
                if (resultCode == Activity.RESULT_OK) {
                    //Mobile hotspot provisioning successful
                } else {
                    //Mobile hotspot provisioning failed
                }
            }

        See src/com/android/settings/TetherSettings.java for more details.
        For ui-less/periodic recheck support see config_mobile_hotspot_provision_app_no_ui
        -->
    <!-- The first element is the package name and the second element is the class name
         of the provisioning app -->
    <string-array translatable="false" name="config_mobile_hotspot_provision_app">
    <!--
        <item>com.example.provisioning</item>
        <item>com.example.provisioning.Activity</item>
    -->
    </string-array>

    <!-- If the mobile hotspot feature requires provisioning, an action can be provided
         that will be broadcast in non-ui cases for checking the provisioning status.

         A second broadcast, action defined by config_mobile_hotspot_provision_response,
         will be sent back to notify if provisioning succeeded or not.  The response will
         match that of the activity in config_mobile_hotspot_provision_app, but instead
         contained within the int extra "EntitlementResult".

         Example Usage:
         String provisionAction = getString(R.string.config_mobile_hotspot_provision_check);
         sendBroadcast(new Intent(provisionAction));

         public void onReceive(Context context, Intent intent) {
             String provisionResponse =
                    getString(R.string.config_mobile_hotspot_provision_response);
             if (provisionResponse.equals(intent.getAction())
                    && intent.getIntExtra("EntitlementResult") == Activity.RESULT_OK) {
                 //Mobile hotspot provisioning successful
             } else {
                 //Mobile hotspot provisioning failed
             }
         }
        -->
    <string translatable="false" name="config_mobile_hotspot_provision_app_no_ui"></string>
    <!-- Sent in response to a provisioning check. The caller must hold the
         permission android.permission.CONNECTIVITY_INTERNAL for Settings to
         receive this response.

         See config_mobile_hotspot_provision_response
         -->
    <string translatable="false" name="config_mobile_hotspot_provision_response"></string>
    <!-- Number of hours between each background provisioning call -->
    <integer translatable="false" name="config_mobile_hotspot_provision_check_period">24</integer>

    <!-- Activity name to enable wifi tethering after provisioning app succeeds -->
    <string translatable="false" name="config_wifi_tether_enable">com.android.settings/.TetherService</string>

    <!-- Array of ConnectivityManager.TYPE_xxxx values allowable for tethering -->
    <!-- Common options are [1, 4] for TYPE_WIFI and TYPE_MOBILE_DUN or
    <!== [0,1,5,7] for TYPE_MOBILE, TYPE_WIFI, TYPE_MOBILE_HIPRI and TYPE_BLUETOOTH -->
    <integer-array translatable="false" name="config_tether_upstream_types">
        <item>0</item>
        <item>1</item>
        <item>5</item>
        <item>7</item>
        <item>9</item>
    </integer-array>

    <!-- If the DUN connection for this CDMA device supports more than just DUN -->
    <!-- traffic you should list them here. -->
    <!-- If this device is not CDMA this is ignored.  If this list is empty on -->
    <!-- a DUN-requiring CDMA device, the DUN APN will just support just DUN. -->
    <string-array translatable="false" name="config_cdma_dun_supported_types">
    </string-array>

    <!-- String containing the apn value for tethering.  May be overriden by secure settings
         TETHER_DUN_APN.  Value is a comma separated series of strings:
         "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type",
         Or string format of ApnSettingV3.
         note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN"
         Multiple entries are separated by using string-array:
         "<item>[ApnSettingV3]Name,apn,,,,,,,,,123,45,,mms|*,IPV6,IP,true,14,,,,,,,spn,testspn</item>
          <item>[ApnSettingV3]Name1,apn2,,,,,,,,,123,46,,mms|*,IPV6,IP,true,12,,,,,,,,</item>" -->
    <string-array translatable="false" name="config_tether_apndata">
    </string-array>

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

    <!-- Boolean indicating whether Hotspot 2.0/Passpoint and ANQP queries is enabled -->
    <bool translatable="false" name="config_wifi_hotspot2_enabled">false</bool>

    <!-- Device type information conforming to Annex B format in WiFi Direct specification.
         The default represents a dual-mode smartphone -->
    <string translatable="false" name="config_wifi_p2p_device_type">10-0050F204-5</string>

    <!-- Boolean indicating whether the wifi chipset supports background scanning mechanism.
         This mechanism allows the host to remain in suspend state and the dongle to actively
         scan and wake the host when a configured SSID is detected by the dongle. This chipset
         capability can provide power savings when wifi needs to be always kept on. -->
    <bool translatable="false" name="config_wifi_background_scan_support">false</bool>

    <!-- Boolean indicating we re-try re-associating once upon disconnection and RSSI is high failure  -->
    <bool translatable="true" name="config_wifi_enable_disconnection_debounce">true</bool>

    <!-- Boolean indicating whether or not to revert to default country code when cellular
         radio is unable to find any MCC information to infer wifi country code from -->
    <bool translatable="false" name="config_wifi_revert_country_code_on_cellular_loss">false</bool>

    <!-- Boolean indicating whether or not wifi firmware debugging is enabled -->
    <bool translatable="false" name="config_wifi_enable_wifi_firmware_debugging">true</bool>

    <!-- Integer size limit, in KB, for a single WifiLogger ringbuffer, in default logging mode -->
    <integer translatable="false" name="config_wifi_logger_ring_buffer_default_size_limit_kb">32</integer>

    <!-- Integer size limit, in KB, for a single WifiLogger ringbuffer, in verbose logging mode -->
    <integer translatable="false" name="config_wifi_logger_ring_buffer_verbose_size_limit_kb">1024</integer>

    <!-- Boolean indicating whether or not wifi should turn off when emergency call is made -->
    <bool translatable="false" name="config_wifi_turn_off_during_emergency_call">false</bool>

    <!-- Integer specifying the basic autojoin parameters -->
    <integer translatable="false" name="config_wifi_framework_5GHz_preference_boost_threshold">-65</integer>
    <integer translatable="false" name="config_wifi_framework_5GHz_preference_boost_factor">40</integer>
    <integer translatable="false" name="config_wifi_framework_5GHz_preference_penalty_threshold">-75</integer>
    <integer translatable="false" name="config_wifi_framework_RSSI_SCORE_OFFSET">85</integer>
    <integer translatable="false" name="config_wifi_framework_RSSI_SCORE_SLOPE">4</integer>
    <integer translatable="false" name="config_wifi_framework_SAME_BSSID_AWARD">24</integer>
    <integer translatable="false" name="config_wifi_framework_LAST_SELECTION_AWARD">480</integer>
    <integer translatable="false" name="config_wifi_framework_PASSPOINT_SECURITY_AWARD">40</integer>
    <integer translatable="false" name="config_wifi_framework_SECURITY_AWARD">80</integer>
    <!-- Integer parameters of the wifi to cellular handover feature
         wifi should not stick to bad networks -->
    <integer translatable="false" name="config_wifi_framework_wifi_score_bad_rssi_threshold_5GHz">-82</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_low_rssi_threshold_5GHz">-70</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_good_rssi_threshold_5GHz">-57</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_bad_rssi_threshold_24GHz">-85</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_low_rssi_threshold_24GHz">-73</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_good_rssi_threshold_24GHz">-60</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_bad_link_speed_24">6</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_bad_link_speed_5">12</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_good_link_speed_24">24</integer>
    <integer translatable="false" name="config_wifi_framework_wifi_score_good_link_speed_5">36</integer>
    <string  translatable="false" name="config_wifi_random_mac_oui">DA-A1-19</string>
    <string  translatable="false" name="config_wifi_framework_sap_2G_channel_list">1,6,11</string>

    <bool translatable="false" name="config_wifi_framework_cellular_handover_enable_user_triggered_adjustment">true</bool>

    <!-- Integer packet threshold used to allow scan while associated -->
    <integer translatable="false" name="config_wifi_framework_associated_full_scan_tx_packet_threshold">5</integer>
    <integer translatable="false" name="config_wifi_framework_associated_full_scan_rx_packet_threshold">10</integer>
    <integer translatable="false" name="config_wifi_framework_associated_partial_scan_tx_packet_threshold">40</integer>
    <integer translatable="false" name="config_wifi_framework_associated_partial_scan_rx_packet_threshold">80</integer>
    <integer translatable="false" name="config_wifi_framework_network_switch_tx_packet_threshold">2</integer>
    <integer translatable="false" name="config_wifi_framework_network_switch_rx_packet_threshold">20</integer>

    <!-- Integer indicating wpa_supplicant scan interval in milliseconds -->
    <integer translatable="false" name="config_wifi_supplicant_scan_interval">15000</integer>

    <!-- Integer indicating amount of time failed networks areblacklisted for the purpose
         of network switching in milliseconds -->
    <integer translatable="false" name="config_wifi_network_switching_blacklist_time">172800000</integer>

    <!-- Integer indicating wpa_supplicant scan interval when p2p is connected in milliseconds -->
    <integer translatable="false" name="config_wifi_scan_interval_p2p_connected">60000</integer>

    <!-- Integer indicating the framework scan interval in milliseconds. This is used in the scenario
         where the chipset does not support background scanning (config_wifi_background_scan_suport
         is false) to set up a periodic wake up scan so that the device can connect to a new access
         point on the move. A value of 0 means no periodic scans will be used in the framework. -->
    <integer translatable="false" name="config_wifi_framework_scan_interval">300000</integer>

    <!-- Integer indicating the framework no networks periodic scan interval in milliseconds. -->
    <integer translatable="false" name="config_wifi_no_network_periodic_scan_interval">300000</integer>

    <!-- Integer indicating disconnect mode short scan interval in milliseconds -->
    <integer translatable="false" name="config_wifi_disconnected_short_scan_interval">15000</integer>

    <!-- Integer indicating associated partial scan short interval in milliseconds -->
    <integer translatable="false" name="config_wifi_associated_short_scan_interval">20000</integer>

    <!-- Integer indicating associated full scan backoff, representing a fraction: xx/8 -->
    <integer translatable="false" name="config_wifi_framework_associated_full_scan_backoff">12</integer>

    <!-- Integer indicating associated full scan max interval in milliseconds -->
    <integer translatable="false" name="config_wifi_framework_associated_full_scan_max_interval">300000</integer>

    <!-- Integer indicating associated full scan max total dwell time in milliseconds -->
    <integer translatable="false" name="config_wifi_framework_associated_full_scan_max_total_dwell_time">500</integer>

    <!-- Integer indicating associated full scan max num active channels -->
    <integer translatable="false" name="config_wifi_framework_associated_partial_scan_max_num_active_channels">6</integer>

    <!-- Integer indicating RSSI boost given to current network -->
    <integer translatable="false" name="config_wifi_framework_current_network_boost">16</integer>

    <!-- Integer indicating how to handle beacons with uninitialized RSSI value of 0 -->
    <integer translatable="false" name="config_wifi_framework_scan_result_rssi_level_patchup_value">-85</integer>

    <!-- Boolean indicating associated network selection is allowed -->
    <bool translatable="false" name="config_wifi_framework_enable_associated_network_selection">true</bool>

    <!-- Boolean indicating that wifi only link configuratios that have exact same credentials (i.e PSK) -->
    <bool translatable="false" name="config_wifi_only_link_same_credential_configurations">true</bool>

    <!-- Wifi driver supports batched scan -->
    <bool translatable="false" name="config_wifi_batched_scan_supported">false</bool>

    <!-- Idle Receive current for wifi radio. 0 by default-->
    <integer translatable="false" name="config_wifi_idle_receive_cur_ma">0</integer>

    <!-- Rx current for wifi radio. 0 by default-->
    <integer translatable="false" name="config_wifi_active_rx_cur_ma">0</integer>

    <!-- Tx current for wifi radio. 0 by default-->
    <integer translatable="false" name="config_wifi_tx_cur_ma">0</integer>

    <!-- Operating volatage for wifi radio. 0 by default-->
    <integer translatable="false" name="config_wifi_operating_voltage_mv">0</integer>

    <!-- Flag indicating whether the we should enable the automatic brightness in Settings.
         Software implementation will be used if config_hardware_auto_brightness_available is not set -->
    <bool name="config_automatic_brightness_available">false</bool>

    <!-- Fast brightness animation ramp rate -->
    <integer translatable="false" name="config_brightness_ramp_rate_fast">200</integer>

    <!-- Don't name config resources like this.  It should look like config_annoyDianne -->
    <bool name="config_annoy_dianne">true</bool>

    <!-- XXXXXX END OF RESOURCES USING WRONG NAMING CONVENTION -->

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

    <!-- If this is true, the message that USB is only being used for charging will be shown. -->
    <bool name="config_usbChargingMessage">true</bool>

    <!-- Set this true only if the device has separate attention and notification lights. -->
    <bool name="config_useAttentionLight">false</bool>

    <!-- If this is true, the screen will fade off. -->
    <bool name="config_animateScreenLights">false</bool>

    <!-- If this is true, key chords can be used to take a screenshot on the device. -->
    <bool name="config_enableScreenshotChord">true</bool>

    <!-- If this is true, allow wake from theater mode when plugged in or unplugged. -->
    <bool name="config_allowTheaterModeWakeFromUnplug">false</bool>
    <!-- If this is true, allow wake from theater mode from gesture. -->
    <bool name="config_allowTheaterModeWakeFromGesture">false</bool>
    <!-- If this is true, allow wake from theater mode from camera lens cover is switched. -->
    <bool name="config_allowTheaterModeWakeFromCameraLens">false</bool>
    <!-- If this is true, allow wake from theater mode from power key press. -->
    <bool name="config_allowTheaterModeWakeFromPowerKey">true</bool>
    <!-- If this is true, allow wake from theater mode from regular key press. Setting this value to
         true implies config_allowTheaterModeWakeFromPowerKey is also true-->
    <bool name="config_allowTheaterModeWakeFromKey">false</bool>
    <!-- If this is true, allow wake from theater mode from motion. -->
    <bool name="config_allowTheaterModeWakeFromMotion">false</bool>
    <!-- If this is true, allow wake from theater mode from motion. -->
    <bool name="config_allowTheaterModeWakeFromMotionWhenNotDreaming">false</bool>
    <!-- If this is true, allow wake from theater mode from lid switch. -->
    <bool name="config_allowTheaterModeWakeFromLidSwitch">false</bool>
    <!-- If this is true, allow wake from theater mode when docked. -->
    <bool name="config_allowTheaterModeWakeFromDock">false</bool>
    <!-- If this is true, allow wake from theater mode from window layout flag. -->
    <bool name="config_allowTheaterModeWakeFromWindowLayout">false</bool>
    <!-- If this is true, go to sleep when theater mode is enabled from button press -->
    <bool name="config_goToSleepOnButtonPressTheaterMode">true</bool>
    <!-- If this is true, long press on power button will be available from the non-interactive state -->
    <bool name="config_supportLongPressPowerWhenNonInteractive">false</bool>

    <!-- Auto-rotation behavior -->

    <!-- If true, enables auto-rotation features using the accelerometer.
         Otherwise, auto-rotation is disabled.  Applications may still request
         to use specific orientations but the sensor is ignored and sensor-based
         orientations are not available.  Furthermore, all auto-rotation related
         settings are omitted from the system UI.  In certain situations we may
         still use the accelerometer to determine the orientation, such as when
         docked if the dock is configured to enable the accelerometer. -->
    <bool name="config_supportAutoRotation">true</bool>

    <!-- If true, the screen can be rotated via the accelerometer in all 4
         rotations as the default behavior. -->
    <bool name="config_allowAllRotations">false</bool>

    <!-- If true, the direction rotation is applied to get to an application's requested
         orientation is reversed.  Normally, the model is that landscape is
         clockwise from portrait; thus on a portrait device an app requesting
         landscape will cause a clockwise rotation, and on a landscape device an
         app requesting portrait will cause a counter-clockwise rotation.  Setting
         true here reverses that logic. -->
    <bool name="config_reverseDefaultRotation">false</bool>

    <!-- Sets the minimum and maximum tilt tolerance for each possible rotation.
         This array consists of 4 pairs of values which specify the minimum and maximum
         tilt angle at which the device will transition into each rotation.

         The tilt angle represents the direction in which the plane of the screen is facing;
         it is also known as the angle of elevation.

           -90 degree tilt means that the screen is facing straight down
                           (the device is being held overhead upside-down)
             0 degree tilt means that the screen is facing outwards
                           (the device is being held vertically)
            90 degree tilt means that the screen is facing straight up
                           (the device is resting on a flat table)

        The default tolerances are set conservatively such that the device is more
        likely to remain in its natural orientation than rotate into a counterclockwise,
        clockwise, or reversed posture (with an especially strong bias against the latter)
        to prevent accidental rotation while carrying the device in hand.

        These thresholds may need to be tuned when the device is intended to be
        mounted into a dock with a particularly shallow profile wherein rotation
        would ordinarily have been suppressed.

        It is helpful to consider the desired behavior both when the device is being
        held at a positive tilt (typical case) vs. a negative tilt (reading overhead in
        bed) since they are quite different.  In the overhead case, we typically want
        the device to more strongly prefer to retain its current configuration (in absence
        of a clear indication that a rotation is desired) since the user's head and neck may
        be held at an unusual angle.
    -->
    <integer-array name="config_autoRotationTiltTolerance">
        <!-- rotation:   0 (natural)    --> <item>-25</item> <item>70</item>
        <!-- rotation:  90 (rotate CCW) --> <item>-25</item> <item>65</item>
        <!-- rotation: 180 (reverse)    --> <item>-25</item> <item>60</item>
        <!-- rotation: 270 (rotate CW)  --> <item>-25</item> <item>65</item>
    </integer-array>

    <!-- Lid switch behavior -->

    <!-- The number of degrees to rotate the display when the keyboard is open.
         A value of -1 means no change in orientation by default. -->
    <integer name="config_lidOpenRotation">-1</integer>

    <!-- Indicate whether the lid state impacts the accessibility of
         the physical keyboard.  0 means it doesn't, 1 means it is accessible
         when the lid is open, 2 means it is accessible when the lid is
         closed.  The default is 0. -->
    <integer name="config_lidKeyboardAccessibility">0</integer>

    <!-- Indicate whether the lid state impacts the accessibility of
         the navigation buttons.  0 means it doesn't, 1 means it is accessible
         when the lid is open, 2 means it is accessible when the lid is
         closed.  The default is 0. -->
    <integer name="config_lidNavigationAccessibility">0</integer>

    <!-- Indicate whether closing the lid causes the lockscreen to appear.
         The default is false. -->
    <bool name="config_lidControlsScreenLock">false</bool>

    <!-- Indicate whether closing the lid causes the device to go to sleep and opening
         it causes the device to wake up.
         The default is false. -->
    <bool name="config_lidControlsSleep">false</bool>

    <!-- Desk dock behavior -->

    <!-- The number of degrees to rotate the display when the device is in a desk dock.
         A value of -1 means no change in orientation by default. -->
    <integer name="config_deskDockRotation">-1</integer>

    <!-- Control whether being in the desk dock (and powered) always
         keeps the screen on.  By default it stays on when plugged in to
         AC.  0 will not keep it on; or together 1 to stay on when plugged
         in to AC and 2 to stay on when plugged in to USB.  (So 3 for both.) -->
    <integer name="config_deskDockKeepsScreenOn">1</integer>

    <!-- Control whether being in the desk dock should enable accelerometer
         based screen orientation.  This defaults to true because it is
         common for desk docks to be sold in a variety of form factors
         with different orientations.  Since we cannot always tell these docks
         apart and the docks cannot report their true orientation on their own,
         we rely on gravity to determine the effective orientation. -->
    <bool name="config_deskDockEnablesAccelerometer">true</bool>

    <!-- Car dock behavior -->

    <!-- The number of degrees to rotate the display when the device is in a car dock.
         A value of -1 means no change in orientation by default. -->
    <integer name="config_carDockRotation">-1</integer>

    <!-- Control whether being in the car dock (and powered) always
         keeps the screen on.  By default it stays on when plugged in to
         AC.  0 will not keep it on; or together 1 to stay on when plugged
         in to AC and 2 to stay on when plugged in to USB.  (So 3 for both.) -->
    <integer name="config_carDockKeepsScreenOn">1</integer>

    <!-- Control whether being in the car dock should enable accelerometer based
         screen orientation.  This defaults to true because putting a device in
         a car dock make the accelerometer more a physical input (like a lid). -->

    <bool name="config_carDockEnablesAccelerometer">true</bool>

    <!--  Control whether to launch Car dock home app when user presses home button or when
          car dock intent is fired.
          In mobile device, usually separate home app is expected in car mode, and this should be
          enabled. But in environments like real car, default home app may be enough, and in that
          case, this can be disabled (set to false). -->
    <bool name="config_enableCarDockHomeLaunch">true</bool>

    <!-- HDMI behavior -->

    <!-- The number of degrees to rotate the display when the device has HDMI connected
         but is not in a dock.  A value of -1 means no change in orientation by default.
         Use -1 except on older devices whose Hardware Composer HAL does not
         provide full support for multiple displays.  -->
    <integer name="config_undockedHdmiRotation">-1</integer>

    <!-- Control the default UI mode type to use when there is no other type override
         happening.  One of the following values (See Configuration.java):
             1  UI_MODE_TYPE_NORMAL
             4  UI_MODE_TYPE_TELEVISION
             5  UI_MODE_TYPE_APPLIANCE
             6  UI_MODE_TYPE_WATCH
         Any other values will have surprising consequences. -->
    <integer name="config_defaultUiModeType">1</integer>

    <!--  Control whether to lock UI mode to what is selected from config_defaultUiModeType.
          Once UI mode is locked, applications cannot change it anymore. -->
    <bool name="config_lockUiMode">false</bool>

    <!--  Control whether to lock day/night mode change from normal application. When it is
          true, day / night mode change is only allowed to apps with MODIFY_DAY_NIGHT_MODE
          permission. -->
    <bool name="config_lockDayNightMode">false</bool>

    <!-- Control the default night mode to use when there is no other mode override set.
         One of the following values (see UiModeManager.java):
             0 - MODE_NIGHT_AUTO
             1 - MODE_NIGHT_NO
             2 - MODE_NIGHT_YES
    -->
    <integer name="config_defaultNightMode">1</integer>

    <!-- Control whether Night display is available. This should only be enabled on devices
         with HWC 2.0 or higher. -->
    <bool name="config_nightDisplayAvailable">false</bool>

    <!-- Default mode to control how Night display is automatically activated.
         One of the following values (see NightDisplayController.java):
             0 - AUTO_MODE_DISABLED
             1 - AUTO_MODE_CUSTOM
             2 - AUTO_MODE_TWILIGHT
    -->
    <integer name="config_defaultNightDisplayAutoMode">0</integer>

    <!-- Default time when Night display is automatically activated.
         Represented as milliseconds from midnight (e.g. 79200000 == 10pm). -->
    <integer name="config_defaultNightDisplayCustomStartTime">79200000</integer>

    <!-- Default time when Night display is automatically deactivated.
         Represented as milliseconds from midnight (e.g. 21600000 == 6am). -->
    <integer name="config_defaultNightDisplayCustomEndTime">21600000</integer>

    <!-- Indicate whether to allow the device to suspend when the screen is off
         due to the proximity sensor.  This resource should only be set to true
         if the sensor HAL correctly handles the proximity sensor as a wake-up source.
         Otherwise, the device may fail to wake out of suspend reliably.
         The default is false. -->
    <bool name="config_suspendWhenScreenOffDueToProximity">false</bool>

    <!-- Control the behavior when the user long presses the power button.
            0 - Nothing
            1 - Global actions menu
            2 - Power off (with confirmation)
            3 - Power off (without confirmation)
    -->
    <integer name="config_longPressOnPowerBehavior">1</integer>

    <!-- Control the behavior when the user long presses the back button.  Non-zero values are only
         valid for watches as part of CDD/CTS.
            0 - Nothing
            1 - Go to voice assist
    -->
    <integer name="config_longPressOnBackBehavior">0</integer>

    <!-- Control the behavior when the user short presses the power button.
            0 - Nothing
            1 - Go to sleep (doze)
            2 - Really go to sleep (don't doze)
            3 - Really go to sleep and go home (don't doze)
    -->
    <integer name="config_shortPressOnPowerBehavior">1</integer>

    <!-- Control the behavior when the user double presses the power button.
            0 - Nothing
            1 - Toggle theater mode setting
            2 - Brightness boost
    -->
    <integer name="config_doublePressOnPowerBehavior">0</integer>

    <!-- Control the behavior when the user triple presses the power button.
            0 - Nothing
            1 - Toggle theater mode setting
            2 - Brightness boost
    -->
    <integer name="config_triplePressOnPowerBehavior">0</integer>

    <!-- Control the behavior when the user presses the sleep button.
            0 - Go to sleep (doze)
            1 - Go to sleep (doze) and go home
    -->
    <integer name="config_shortPressOnSleepBehavior">0</integer>

    <!-- Package name for default keyguard appwidget [DO NOT TRANSLATE] -->
    <string name="widget_default_package_name" translatable="false"></string>

    <!-- Class name for default keyguard appwidget [DO NOT TRANSLATE] -->
    <string name="widget_default_class_name" translatable="false"></string>

    <!-- Indicate whether the SD card is accessible without removing the battery. -->
    <bool name="config_batterySdCardAccessibility">false</bool>

    <!-- List of file paths for USB host busses to exclude from USB host support.
         For example, if the first USB bus on the device is used to communicate
         with the modem or some other restricted hardware, add "/dev/bus/usb/001/"
         to this list.  If this is empty, no parts of the host USB bus will be excluded.
    -->
    <string-array name="config_usbHostBlacklist" translatable="false">
    </string-array>

    <!-- List of paths to serial ports that are available to the serial manager.
         for example, /dev/ttyUSB0
    -->
    <string-array translatable="false" name="config_serialPorts">
    </string-array>

    <!-- Vibrator pattern for feedback about a long screen/key press -->
    <integer-array name="config_longPressVibePattern">
        <item>0</item>
        <item>1</item>
        <item>20</item>
        <item>21</item>
    </integer-array>

    <!-- Vibrator pattern for feedback about touching a virtual key -->
    <integer-array name="config_virtualKeyVibePattern">
        <item>0</item>
        <item>10</item>
        <item>20</item>
        <item>30</item>
    </integer-array>

    <!-- Vibrator pattern for a very short but reliable vibration for soft keyboard tap -->
    <integer-array name="config_keyboardTapVibePattern">
        <item>40</item>
    </integer-array>

    <!-- Vibrator pattern for feedback when selecting an hour/minute tick of a Clock -->
    <integer-array name="config_clockTickVibePattern">
        <item>125</item>
        <item>30</item>
    </integer-array>

    <!-- Vibrator pattern for feedback when selecting a day/month/year date of a Calendar -->
    <integer-array name="config_calendarDateVibePattern">
        <item>125</item>
        <item>30</item>
    </integer-array>

    <!-- Vibrator pattern for feedback about booting with safe mode disabled -->
    <integer-array name="config_safeModeDisabledVibePattern">
        <item>0</item>
        <item>1</item>
        <item>20</item>
        <item>21</item>
    </integer-array>

    <!-- Vibrator pattern for feedback about booting with safe mode disabled -->
    <integer-array name="config_safeModeEnabledVibePattern">
        <item>0</item>
        <item>1</item>
        <item>20</item>
        <item>21</item>
        <item>500</item>
        <item>600</item>
    </integer-array>

    <!-- Vibrator pattern for feedback about hitting a scroll barrier -->
    <integer-array name="config_scrollBarrierVibePattern">
        <item>0</item>
        <item>15</item>
        <item>10</item>
        <item>10</item>
    </integer-array>

    <!-- Vibrator pattern for feedback about a context click -->
    <integer-array name="config_contextClickVibePattern">
        <item>0</item>
        <item>1</item>
        <item>20</item>
        <item>21</item>
    </integer-array>

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

    <!-- Display low battery warning when battery level dips to this value.
         Also, the battery stats are flushed to disk when we hit this level.  -->
    <integer name="config_criticalBatteryWarningLevel">5</integer>

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

    <!-- Display low battery warning when battery level dips to this value -->
    <integer name="config_lowBatteryWarningLevel">15</integer>

    <!-- Close low battery warning when battery level reaches the lowBatteryWarningLevel
         plus this -->
    <integer name="config_lowBatteryCloseWarningBump">5</integer>

    <!-- Default color for notification LED. -->
    <color name="config_defaultNotificationColor">#ffffffff</color>

    <!-- Default LED on time for notification LED in milliseconds. -->
    <integer name="config_defaultNotificationLedOn">500</integer>

    <!-- Default LED off time for notification LED in milliseconds. -->
    <integer name="config_defaultNotificationLedOff">2000</integer>

    <!-- Default value for led color when battery is low on charge -->
    <integer name="config_notificationsBatteryLowARGB">0xFFFF0000</integer>

    <!-- Default value for led color when battery is medium charged -->
    <integer name="config_notificationsBatteryMediumARGB">0xFFFFFF00</integer>

    <!-- Default value for led color when battery is fully charged -->
    <integer name="config_notificationsBatteryFullARGB">0xFF00FF00</integer>

    <!-- Default value for LED on time when the battery is low on charge in miliseconds -->
    <integer name="config_notificationsBatteryLedOn">125</integer>

    <!-- Is the notification LED intrusive? Used to decide if there should be a disable option -->
    <bool name="config_intrusiveNotificationLed">false</bool>

    <!-- Default value for LED off time when the battery is low on charge in miliseconds -->
    <integer name="config_notificationsBatteryLedOff">2875</integer>

    <!-- Number of notifications to keep in the notification service historical archive -->
    <integer name="config_notificationServiceArchiveSize">100</integer>

    <!-- Allow the menu hard key to be disabled in LockScreen on some devices -->
    <bool name="config_disableMenuKeyInLockScreen">false</bool>

    <!-- Don't show lock screen before unlock screen (PIN/pattern/password) -->
    <bool name="config_enableLockBeforeUnlockScreen">false</bool>

    <!-- Disable lockscreen rotation by default -->
    <bool name="config_enableLockScreenRotation">false</bool>

    <!-- Enable lockscreen translucent decor by default -->
    <bool name="config_enableLockScreenTranslucentDecor">true</bool>

    <!-- Enable translucent decor by default -->
    <bool name="config_enableTranslucentDecor">true</bool>

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

    <!-- Component name of the ICC hotswap prompt for restart dialog -->
    <string name="config_iccHotswapPromptForRestartDialogComponent" translateable="false">@null</string>

    <!-- Enable puk unlockscreen by default.
         If unlock screen is disabled, the puk should be unlocked through Emergency Dialer -->
    <bool name="config_enable_puk_unlock_screen">true</bool>

    <!-- Enable emergency call when sim is locked or puk locked. Some countries/carriers do not
         allow emergency calls to be placed without the IMSI, which is locked in the SIM.
         If so, this should be set to 'false' in an overlay. -->
    <bool name="config_enable_emergency_call_while_sim_locked">true</bool>

    <!-- Control the behavior when the user long presses the home button.
            0 - Nothing
            1 - Recent apps view in SystemUI
            2 - Launch assist intent
         This needs to match the constants in
         policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
    -->
    <integer name="config_longPressOnHomeBehavior">0</integer>

    <!-- Control the behavior when the user double-taps the home button.
            0 - Nothing
            1 - Recent apps view in SystemUI
         This needs to match the constants in
         policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
    -->
    <integer name="config_doubleTapOnHomeBehavior">0</integer>

    <!-- Minimum screen brightness setting allowed by the power manager.
         The user is forbidden from setting the brightness below this level. -->
    <integer name="config_screenBrightnessSettingMinimum">10</integer>

    <!-- Maximum screen brightness allowed by the power manager.
         The user is forbidden from setting the brightness above this level. -->
    <integer name="config_screenBrightnessSettingMaximum">255</integer>

    <!-- Default screen brightness setting.
         Must be in the range specified by minimum and maximum. -->
    <integer name="config_screenBrightnessSettingDefault">102</integer>

    <!-- Screen brightness used to dim the screen while dozing in a very low power state.
         May be less than the minimum allowed brightness setting
         that can be set by the user. -->
    <integer name="config_screenBrightnessDoze">1</integer>

    <!-- Allow automatic adjusting of the screen brightness while dozing in low power state. -->
    <bool name="config_allowAutoBrightnessWhileDozing">false</bool>

    <!-- Stability requirements in milliseconds for accepting a new brightness level.  This is used
         for debouncing the light sensor.  Different constants are used to debounce the light sensor
         when adapting to brighter or darker environments.  This parameter controls how quickly
         brightness changes occur in response to an observed change in light level that exceeds the
         hysteresis threshold. -->
    <integer name="config_autoBrightnessBrighteningLightDebounce">4000</integer>
    <integer name="config_autoBrightnessDarkeningLightDebounce">8000</integer>

    <!-- Light sensor event rate in milliseconds for automatic brightness control. -->
    <integer name="config_autoBrightnessLightSensorRate">250</integer>

    <!-- The maximum range of gamma adjustment possible using the screen
         auto-brightness adjustment setting. -->
    <fraction name="config_autoBrightnessAdjustmentMaxGamma">300%</fraction>

    <!-- If we allow automatic adjustment of screen brightness while dozing, how many times we want
         to reduce it to preserve the battery. Value of 100% means no scaling. -->
    <fraction name="config_screenAutoBrightnessDozeScaleFactor">100%</fraction>

    <!-- When the screen is turned on, the previous estimate of the ambient light level at the time
         the screen was turned off is restored and is used to determine the initial screen
         brightness.

         If this flag is true, then the ambient light level estimate will be promptly recomputed
         after the warm-up interface and the screen brightness will be adjusted immediately.

         If this flag is false, then the ambient light level estimate will be adjusted more
         gradually in the same manner that normally happens when the screen is on according to the
         brightening or dimming debounce thresholds.  As a result, it may take somewhat longer to
         adapt to the environment.  This mode may be better suited for watches. -->
    <bool name="config_autoBrightnessResetAmbientLuxAfterWarmUp">true</bool>

    <!-- Period of time in which to consider light samples in milliseconds. -->
    <integer name="config_autoBrightnessAmbientLightHorizon">10000</integer>

    <!-- Screen brightness used to dim the screen when the user activity
         timeout expires.  May be less than the minimum allowed brightness setting
         that can be set by the user. -->
    <integer name="config_screenBrightnessDim">10</integer>

    <!-- Minimum allowable screen brightness to use in a very dark room.
         This value sets the floor for the darkest possible auto-brightness
         adjustment.  It is expected to be somewhat less than the first entry in
         config_autoBrightnessLcdBacklightValues so as to allow the user to have
         some range of adjustment to dim the screen further than usual in very
         dark rooms. The contents of the screen must still be clearly visible
         in darkness (although they may not be visible in a bright room). -->
    <integer name="config_screenBrightnessDark">1</integer>

    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
         The N entries of this array define N + 1 control points as follows:
         (1-based arrays)

         Point 1:            (0, value[1]):             lux <= 0
         Point 2:     (level[1], value[2]):  0        < lux <= level[1]
         Point 3:     (level[2], value[3]):  level[2] < lux <= level[3]
         ...
         Point N+1: (level[N], value[N+1]):  level[N] < lux

         The control points must be strictly increasing.  Each control point
         corresponds to an entry in the brightness backlight values arrays.
         For example, if LUX == level[1] (first element of the levels array)
         then the brightness will be determined by value[2] (second element
         of the brightness values array).

         Spline interpolation is used to determine the auto-brightness
         backlight values for LUX levels between these control points.

         Must be overridden in platform specific overlays -->
    <integer-array name="config_autoBrightnessLevels">
    </integer-array>

    <!-- Array of output values for LCD backlight corresponding to the LUX values
         in the config_autoBrightnessLevels array.  This array should have size one greater
         than the size of the config_autoBrightnessLevels array.
         The brightness values must be between 0 and 255 and be non-decreasing.
         This must be overridden in platform specific overlays -->
    <integer-array name="config_autoBrightnessLcdBacklightValues">
    </integer-array>

    <!-- Array of output values for button backlight corresponding to the LUX values
         in the config_autoBrightnessLevels array.  This array should have size one greater
         than the size of the config_autoBrightnessLevels array.
         The brightness values must be between 0 and 255 and be non-decreasing.
         This must be overridden in platform specific overlays -->
    <integer-array name="config_autoBrightnessButtonBacklightValues">
    </integer-array>

    <!-- Array of output values for keyboard backlight corresponding to the LUX values
         in the config_autoBrightnessLevels array.  This array should have size one greater
         than the size of the config_autoBrightnessLevels array.
         The brightness values must be between 0 and 255 and be non-decreasing.
         This must be overridden in platform specific overlays -->
    <integer-array name="config_autoBrightnessKeyboardBacklightValues">
    </integer-array>

    <!-- Amount of time it takes for the light sensor to warm up in milliseconds.
         For this time after the screen turns on, the Power Manager
         will not debounce light sensor readings -->
    <integer name="config_lightSensorWarmupTime">0</integer>

    <!-- Enables swipe versus poly-finger touch disambiguation in the KeyboardView -->
    <bool name="config_swipeDisambiguation">true</bool>

    <!-- Specifies the amount of time to disable virtual keys after the screen is touched
         in order to filter out accidental virtual key presses due to swiping gestures
         or taps near the edge of the display.  May be 0 to disable the feature.
         It is recommended that this value be no more than 250 ms.
         This feature should be disabled for most devices. -->
    <integer name="config_virtualKeyQuietTimeMillis">0</integer>

    <!-- A list of potential packages, in priority order, that may contain an
         ephemeral resolver. Each package will be be queried for a component
         that has been granted the PACKAGE_EPHEMERAL_AGENT permission.
         This may be empty if ephemeral apps are not supported. -->
    <string-array name="config_ephemeralResolverPackage" translatable="false">
        <!-- Add packages here -->
    </string-array>

    <!-- Component name of the default wallpaper. This will be ImageWallpaper if not
         specified -->
    <string name="default_wallpaper_component" translatable="false">@null</string>

    <!-- By default a product has no distinct default lock wallpaper -->
    <item name="default_lock_wallpaper" type="drawable">@null</item>

    <!-- Component name of the built in wallpaper used to display bitmap wallpapers. This must not be null. -->
    <string name="image_wallpaper_component" translatable="false">com.android.systemui/com.android.systemui.ImageWallpaper</string>

    <!-- True if WallpaperService is enabled -->
    <bool name="config_enableWallpaperService">true</bool>

    <!-- Whether to enable network location overlay which allows network
         location provider to be replaced by an app at run-time. When disabled,
         only the config_networkLocationProviderPackageName package will be
         searched for network location provider, otherwise packages whose
         signature matches the signatures of config_locationProviderPackageNames
         will be searched, and the service with the highest version number will
         be picked. Anyone who wants to disable the overlay mechanism can set it
         to false.
         -->
    <bool name="config_enableNetworkLocationOverlay" translatable="false">true</bool>
    <!-- Package name providing network location support. Used only when
         config_enableNetworkLocationOverlay is false. -->
    <string name="config_networkLocationProviderPackageName" translatable="false">@null</string>

    <!-- Whether to enable fused location provider overlay which allows fused
         location provider to be replaced by an app at run-time. When disabled,
         only the config_fusedLocationProviderPackageName package will be
         searched for fused location provider, otherwise packages whose
         signature matches the signatures of config_locationProviderPackageNames
         will be searched, and the service with the highest version number will
         be picked. Anyone who wants to disable the overlay mechanism can set it
         to false.
         -->
    <bool name="config_enableFusedLocationOverlay" translatable="false">true</bool>
    <!-- Package name providing fused location support. Used only when
         config_enableFusedLocationOverlay is false. -->
    <string name="config_fusedLocationProviderPackageName" translatable="false">com.android.location.fused</string>

    <!-- Whether to enable Hardware FLP overlay which allows Hardware FLP to be
         replaced by an app at run-time. When disabled, only the
         config_hardwareFlpPackageName package will be searched for Hardware Flp,
         otherwise packages whose signature matches the signatures of
         config_locationProviderPackageNames will be searched, and the service
         with the highest version number will be picked. Anyone who wants to
         disable the overlay mechanism can set it to false.
         -->
    <bool name="config_enableHardwareFlpOverlay" translatable="false">true</bool>
    <!-- Package name providing Hardware Flp. Used only when
         config_enableHardwareFlpOverlay is false. -->
    <string name="config_hardwareFlpPackageName" translatable="false">com.android.location.fused</string>

    <!-- Whether to enable geocoder overlay which allows geocoder to be replaced
         by an app at run-time. When disabled, only the
         config_geocoderProviderPackageName package will be searched for
         geocoder, otherwise packages whose signature matches the signatures of
         config_locationProviderPackageNames will be searched, and the service
         with the highest version number will be picked. Anyone who wants to
         disable the overlay mechanism can set it to false.
         -->
    <bool name="config_enableGeocoderOverlay" translatable="false">true</bool>
    <!-- Package name providing geocoder API support. Used only when
         config_enableGeocoderOverlay is false. -->
    <string name="config_geocoderProviderPackageName" translatable="false">@null</string>

    <!-- Whether to enable geofence overlay which allows geofence to be replaced
         by an app at run-time. When disabled, only the
         config_geofenceProviderPackageName package will be searched for
         geofence implementation, otherwise packages whose signature matches the
         signatures of config_locationProviderPackageNames will be searched, and
         the service with the highest version number will be picked. Anyone who
         wants to disable the overlay mechanism can set it to false.
         -->
    <bool name="config_enableGeofenceOverlay" translatable="false">true</bool>
    <!-- Package name providing geofence API support. Used only when
         config_enableGeofenceOverlay is false. -->
    <string name="config_geofenceProviderPackageName" translatable="false">@null</string>

    <!-- Whether to enable Hardware Activity-Recognition overlay which allows Hardware
         Activity-Recognition to be replaced by an app at run-time. When disabled, only the
         config_activityRecognitionHardwarePackageName package will be searched for
         its implementation, otherwise packages whose signature matches the
         signatures of config_locationProviderPackageNames will be searched, and
         the service with the highest version number will be picked. Anyone who
         wants to disable the overlay mechanism can set it to false.
         -->
    <bool name="config_enableActivityRecognitionHardwareOverlay" translatable="false">true</bool>
    <!-- Package name providing Hardware Activity-Recognition API support. Used only when
         config_enableActivityRecognitionHardwareOverlay is false. -->
    <string name="config_activityRecognitionHardwarePackageName" translatable="false">@null</string>

    <!-- Package name(s) containing location provider support.
         These packages can contain services implementing location providers,
         such as the Geocode Provider, Network Location Provider, and
         Fused Location Provider. They will each be searched for
         service components implementing these providers.
         It is strongly recommended that the packages explicitly named
         below are on the system image, so that they will not map to
         a 3rd party application.
         The location framework also has support for installation
         of new location providers at run-time. The new package does not
         have to be explicitly listed here, however it must have a signature
         that matches the signature of at least one package on this list.
         -->
    <string-array name="config_locationProviderPackageNames" translatable="false">
        <!-- The standard AOSP fused location provider -->
        <item>com.android.location.fused</item>
    </string-array>

    <!-- This string array can be overriden to enable test location providers initially. -->
    <!-- Array of "[locationProviderName],[requiresNetwork],
         [requiresSatellite],[requiresCell],[hasMonetaryCost],
         [supportAltitute],[supportsSpeed],[supportsBearing],
         [powerRequirement],[accuracy]" -->
    <!-- powerRequirement is defined in android.location.Criteria
         0 = NO_REQUIREMENT / 1 = POWER_LOW / 2 = POWER_MEDIUM / 3 = POWER_HIGH -->
    <!-- accuracy is defined in anroid.location.Criteria
         1 = ACCURACY_FINE / 2 = ACCURACY_COARSE -->
    <string-array name="config_testLocationProviders" translatable="false">
        <!-- Example test network location provider
        <item>network,false,false,false,false,true,true,true,1,2</item>
        -->
    </string-array>

    <!-- Boolean indicating if current platform supports bluetooth SCO for off call
    use cases -->
    <bool name="config_bluetooth_sco_off_call">true</bool>

    <!-- Boolean indicating if current platform supports bluetooth wide band
         speech -->
    <bool name="config_bluetooth_wide_band_speech">true</bool>

    <!-- Boolean indicating if current platform need do one-time bluetooth address
         re-validation -->
    <bool name="config_bluetooth_address_validation">false</bool>

    <!-- Boolean indicating if current platform supports BLE peripheral mode -->
    <bool name="config_bluetooth_le_peripheral_mode_supported">false</bool>

    <!-- Max number of scan filters supported by blutooth controller. 0 if the
         device does not support hardware scan filters-->
    <integer translatable="false" name="config_bluetooth_max_scan_filters">0</integer>

    <!-- Max number of advertisers supported by bluetooth controller. 0 if the
         device does not support multiple advertisement-->
    <integer translatable="false" name="config_bluetooth_max_advertisers">0</integer>

    <!-- Idle current for bluetooth controller. 0 by default-->
    <integer translatable="false" name="config_bluetooth_idle_cur_ma">1</integer>

    <!-- Rx current for bluetooth controller. 0 by default-->
    <integer translatable="false" name="config_bluetooth_rx_cur_ma">2</integer>

    <!-- Tx current for bluetooth controller. 0 by default-->
    <integer translatable="false" name="config_bluetooth_tx_cur_ma">3</integer>

    <!-- Operating volatage for bluetooth controller. 0 by default-->
    <integer translatable="false" name="config_bluetooth_operating_voltage_mv">4</integer>

    <!-- Whether supported profiles should be reloaded upon enabling bluetooth -->
    <bool name="config_bluetooth_reload_supported_profiles_when_enabled">false</bool>

    <!-- The default data-use polling period. -->
    <integer name="config_datause_polling_period_sec">600</integer>

    <!-- The default data-use threshold in bytes. 0 disables-->
    <integer name="config_datause_threshold_bytes">0</integer>

    <!-- The default reduced-datarate value in kilobits per sec -->
    <integer name="config_datause_throttle_kbitsps">300</integer>

    <!-- The default iface on which to monitor data use -->
    <string name="config_datause_iface" translatable="false">rmnet0</string>

    <!-- The default reduced-datarate notification mask -->
    <!-- 2 means give warning -->
    <integer name="config_datause_notification_type">2</integer>

    <!-- If Voice Radio Technology is RIL_RADIO_TECHNOLOGY_LTE:14 or
         RIL_RADIO_TECHNOLOGY_UNKNOWN:0 this is the value that should be used instead.
         A configuration value of RIL_RADIO_TECHNOLOGY_UNKNOWN:0 means
         there is no replacement value and that the default assumption
         for phone type (GSM) should be used. -->
    <integer name="config_volte_replacement_rat">0</integer>

    <!-- Flag indicating whether the current device is "voice capable".
         If true, this means that the device supports circuit-switched
         (i.e. voice) phone calls over the telephony network, and is
         allowed to display the in-call UI while a cellular voice call is
         active.  This can be overridden to false for "data only" devices
         which can't make voice calls and don't support any in-call UI.

         Note: this flag is subtly different from the
         PackageManager.FEATURE_TELEPHONY system feature, which is
         available on *any* device with a telephony radio, even if the
         device is data-only. -->
    <bool name="config_voice_capable">true</bool>

    <!-- Flag indicating that an outbound call must have a call capable phone account
         that has declared it can process the call's handle. -->
    <bool name="config_requireCallCapableAccountForHandle">false</bool>

    <!-- Flag indicating if the user is notified when the mobile network access is restricted -->
    <bool name="config_user_notification_of_restrictied_mobile_access">true</bool>

    <!-- Flag indicating whether the current device allows sms service.
         If true, this means that the device supports both sending and
         receiving sms via the telephony network.
         This can be overridden to false for "data only" devices
         which can't send and receive sms message.

         Note: Disable SMS also disable voicemail waiting sms,
               cell broadcasting sms, and MMS. -->
    <bool name="config_sms_capable">true</bool>

    <!-- Default SMS Application. This will be the default SMS application when
         the phone first boots. The user can then change the default app to one
         of their choosing.
         This can be overridden for devices where a different default SMS
         application is desired.

         If this string is empty or the specified package does not exist, then
         the platform will search for an SMS app and use that (if there is one)-->
    <string name="default_sms_application" translatable="false">com.android.messaging</string>

    <!-- Default web browser.  This is the package name of the application that will
         be the default browser when the device first boots.  Afterwards the user
         can select whatever browser app they wish to use as the default.

         If this string is empty or the specified package does not exist, then
         the behavior will be as though no app was named as an explicit default. -->
    <string name="default_browser" translatable="false"></string>

    <!-- Enable/disable default bluetooth profiles:
        HSP_AG, ObexObjectPush, Audio, NAP -->
    <bool name="config_bluetooth_default_profiles">true</bool>

    <!-- IP address of the dns server to use if nobody else suggests one -->
    <string name="config_default_dns_server" translatable="false">8.8.8.8</string>

    <!-- The default mobile provisioning apn. Empty by default, maybe overridden by
         an mcc/mnc specific config.xml -->
    <string name="mobile_provisioning_apn" translatable="false"></string>

    <!-- The default mobile provisioning url. Empty by default, maybe overridden by
         an mcc/mnc specific config.xml -->
    <string name="mobile_provisioning_url" translatable="false"></string>

    <!-- The default character set for GsmAlphabet -->
    <!-- Empty string means MBCS is not considered -->
    <string name="gsm_alphabet_default_charset" translatable="false"></string>

    <!-- Enables SIP on WIFI only -->
    <bool name="config_sip_wifi_only">false</bool>

    <!-- Enables built-in SIP phone capability -->
    <bool name="config_built_in_sip_phone">true</bool>

    <!-- Boolean indicating if restoring network selection should be skipped -->
    <!-- The restoring is handled by modem if it is true-->
    <bool translatable="false" name="skip_restoring_network_selection">false</bool>

    <!-- Maximum number of database connections opened and managed by framework layer
         to handle queries on each database when using Write-Ahead Logging. -->
    <integer name="db_connection_pool_size">4</integer>

    <!-- The default journal mode to use use when Write-Ahead Logging is not active.
         Choices are: OFF, DELETE, TRUNCATE, PERSIST and MEMORY.
         PERSIST may improve performance by reducing how often journal blocks are
         reallocated (compared to truncation) resulting in better data block locality
         and less churn of the storage media. -->
    <string name="db_default_journal_mode" translatable="false">PERSIST</string>

    <!-- Maximum size of the persistent journal file in bytes.
         If the journal file grows to be larger than this amount then SQLite will
         truncate it after committing the transaction. -->
    <integer name="db_journal_size_limit">524288</integer>

    <!-- The database synchronization mode when using the default journal mode.
         FULL is safest and preserves durability at the cost of extra fsyncs.
         NORMAL also preserves durability in non-WAL modes and uses checksums to ensure
         integrity although there is a small chance that an error might go unnoticed.
         Choices are: FULL, NORMAL, OFF. -->
    <string name="db_default_sync_mode" translatable="false">FULL</string>

    <!-- The database synchronization mode when using Write-Ahead Logging.
         FULL is safest and preserves durability at the cost of extra fsyncs.
         NORMAL sacrifices durability in WAL mode because syncs are only performed before
         and after checkpoint operations.  If checkpoints are infrequent and power loss
         occurs, then committed transactions could be lost and applications might break.
         Choices are: FULL, NORMAL, OFF. -->
    <string name="db_wal_sync_mode" translatable="false">FULL</string>

    <!-- The Write-Ahead Log auto-checkpoint interval in database pages (typically 1 to 4KB).
         The log is checkpointed automatically whenever it exceeds this many pages.
         When a database is reopened, its journal mode is set back to the default
         journal mode, which may cause a checkpoint operation to occur.  Checkpoints
         can also happen at other times when transactions are committed.
         The bigger the WAL file, the longer a checkpoint operation takes, so we try
         to keep the WAL file relatively small to avoid long delays.
         The size of the WAL file is also constrained by 'db_journal_size_limit'. -->
    <integer name="db_wal_autocheckpoint">100</integer>

    <!-- Max space (in MB) allocated to DownloadManager to store the downloaded
         files if they are to be stored in DownloadManager's data dir,
         which typically is /data/data/com.android.providers.downloads/files -->
    <integer name="config_downloadDataDirSize">200</integer>

    <!-- Max number of downloads allowed to proceed concurrently -->
    <integer name="config_MaxConcurrentDownloadsAllowed">5</integer>

    <!-- When the free space available in DownloadManager's data dir falls
         below the percentage value specified by this param, DownloadManager
         starts removing files to try to make percentage of available
         free space above this threshold value. -->
    <integer name="config_downloadDataDirLowSpaceThreshold">10</integer>

    <!-- The URL that should be sent in an x-wap-profile header with an HTTP request,
         as defined in the Open Mobile Alliance User Agent Profile specification
         OMA-TS-UAProf-V2_0-20060206-A Section 8.1.1.1. If the URL contains a '%s'
         format string then that substring will be replaced with the value of
         Build.MODEL. The format string shall not be escaped. -->
    <string name="config_useragentprofile_url" translatable="false"></string>

    <!-- When a database query is executed, the results retuned are paginated
         in pages of size (in KB) indicated by this value -->
    <integer name="config_cursorWindowSize">2048</integer>

    <!-- Sets whether menu shortcuts should be displayed on panel menus when
         a keyboard is present. -->
    <bool name="config_showMenuShortcutsWhenKeyboardPresent">false</bool>

    <!-- Do not translate. Defines the slots is Two Digit Number for dialing normally not USSD -->
    <string-array name="config_twoDigitNumberPattern" translatable="false">
    </string-array>

    <!-- The VoiceMail default value is displayed to my own number if it is true -->
    <bool name="config_telephony_use_own_number_for_voicemail">false</bool>

    <!-- If this value is true, Sms encoded as octet is decoded by utf8 decoder.
         If false, decoded by Latin decoder. -->
    <bool name="config_sms_utf8_support">false</bool>

    <!-- If this value is true, The mms content-disposition field is supported correctly.
         If false, Content-disposition fragments are ignored -->
    <bool name="config_mms_content_disposition_support">true</bool>

    <!-- MMS user agent string -->
    <string name="config_mms_user_agent" translatable="false"></string>

    <!-- MMS user agent prolfile url -->
    <string name="config_mms_user_agent_profile_url" translatable="false"></string>

    <!-- National Language Identifier codes for the following two config items.
         (from 3GPP TS 23.038 V9.1.1 Table 6.2.1.2.4.1):
          0  - reserved
          1  - Turkish
          2  - Spanish (single shift table only)
          3  - Portuguese
          4  - Bengali
          5  - Gujarati
          6  - Hindi
          7  - Kannada
          8  - Malayalam
          9  - Oriya
         10  - Punjabi
         11  - Tamil
         12  - Telugu
         13  - Urdu
         14+ - reserved -->

    <!-- National language single shift tables to enable for SMS encoding.
         Decoding is always enabled. 3GPP TS 23.038 states that this feature
         should not be enabled until a formal request is issued by the relevant
         national regulatory body. Array elements are codes from the table above.
         Example 1: devices sold in Turkey must include table 1 to conform with
           By-Law Number 27230. (http://www.btk.gov.tr/eng/pdf/2009/BY-LAW_SMS.pdf)
         Example 2: devices sold in India should include tables 4 through 13
           to enable use of the new Release 9 tables for Indic languages. -->
    <integer-array name="config_sms_enabled_single_shift_tables"></integer-array>

    <!-- National language locking shift tables to enable for SMS encoding.
         Decoding is always enabled. 3GPP TS 23.038 states that this feature
         should not be enabled until a formal request is issued by the relevant
         national regulatory body. Array elements are codes from the table above.
         Example 1: devices sold in Turkey must include table 1 after the
           Turkish Telecommunication Authority requires locking shift encoding
           to be enabled (est. July 2012). (http://www.btk.gov.tr/eng/pdf/2009/BY-LAW_SMS.pdf)
           See also: http://www.mobitech.com.tr/tr/ersanozturkblog_en/index.php?entry=entry090223-160014
         Example 2: devices sold in India should include tables 4 through 13
         to enable use of the new Release 9 tables for Indic languages. -->
    <integer-array name="config_sms_enabled_locking_shift_tables"></integer-array>

    <!-- Set to true if the RSSI should always display CDMA signal strength even on EVDO -->
    <bool name="config_alwaysUseCdmaRssi">false</bool>


    <!-- If this value is true, duplicate Source/Destination port fields
         in WDP header of some carriers OMADM wap push are supported.
         ex: MSGTYPE-TotalSegments-CurrentSegment
             -SourcePortDestPort-SourcePortDestPort-OMADM PDU
         If false, not supported. -->
    <bool name="config_duplicate_port_omadm_wappush">false</bool>

    <!-- Maximum numerical value that will be shown in a status bar
         notification icon or in the notification itself. Will be replaced
         with @string/status_bar_notification_info_overflow when shown in the
         UI. -->
    <integer name="status_bar_notification_info_maxnum">999</integer>

    <!-- Path to an ISO image to be shared with via USB mass storage.
         This is intended to allow packaging drivers or tools for installation on a PC. -->
    <string translatable="false" name="config_isoImagePath"></string>

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

    <!-- Whether action menu items should be displayed in ALLCAPS or not.
         Defaults to true. If this is not appropriate for specific locales
         it should be disabled in that locale's resources. -->
    <bool name="config_actionMenuItemAllCaps">true</bool>

    <!-- Remote server that can provide NTP responses. -->
    <string translatable="false" name="config_ntpServer">2.android.pool.ntp.org</string>
    <!-- Normal polling frequency in milliseconds -->
    <integer name="config_ntpPollingInterval">86400000</integer>
    <!-- Try-again polling interval in milliseconds, in case the network request failed -->
    <integer name="config_ntpPollingIntervalShorter">60000</integer>
    <!-- Number of times to try again with the shorter interval, before backing
         off until the normal polling interval. A value < 0 indicates infinite. -->
    <integer name="config_ntpRetry">3</integer>
    <!-- If the time difference is greater than this threshold in milliseconds,
         then update the time. -->
    <integer name="config_ntpThreshold">5000</integer>
    <!-- Timeout to wait for NTP server response in milliseconds. -->
    <integer name="config_ntpTimeout">5000</integer>

    <!-- Default network policy warning threshold, in megabytes. -->
    <integer name="config_networkPolicyDefaultWarning">2048</integer>

    <!-- Set and Unsets WiMAX -->
    <bool name="config_wimaxEnabled">false</bool>
    <!-- Location of the wimax framwork jar location -->
    <string name="config_wimaxServiceJarLocation" translatable="false"></string>
    <!-- Location of the wimax native library locaiton -->
    <string name="config_wimaxNativeLibLocation" translatable="false"></string>
    <!-- Name of the wimax manager class -->
    <string name="config_wimaxManagerClassname" translatable="false"></string>
    <!-- Name of the wimax service class -->
    <string name="config_wimaxServiceClassname" translatable="false"></string>
    <!-- Name of the wimax state tracker clas -->
    <string name="config_wimaxStateTrackerClassname" translatable="false"></string>

    <!-- Specifies whether the dreams feature should be supported.
         When true, the system will allow the user to configure dreams (screensavers)
         to launch when a user activity timeout occurs or the system is told to nap.
         When false, the dreams feature will be disabled (this does not affect dozing).

         Consider setting this resource to false or disabling dreams by default when a
         doze component is specified below since dreaming will supercede dozing and
         will prevent the system from entering a low power state until the dream ends. -->
    <bool name="config_dreamsSupported">true</bool>

    <!-- If supported, are dreams enabled? (by default) -->
    <bool name="config_dreamsEnabledByDefault">true</bool>
    <!-- If supported and enabled, are dreams activated when docked? (by default) -->
    <bool name="config_dreamsActivatedOnDockByDefault">true</bool>
    <!-- If supported and enabled, are dreams activated when asleep and charging? (by default) -->
    <bool name="config_dreamsActivatedOnSleepByDefault">false</bool>
    <!-- ComponentName of the default dream (Settings.Secure.DEFAULT_SCREENSAVER_COMPONENT) -->
    <string name="config_dreamsDefaultComponent" translatable="false">com.google.android.deskclock/com.android.deskclock.Screensaver</string>

    <!-- Are we allowed to dream while not plugged in? -->
    <bool name="config_dreamsEnabledOnBattery">false</bool>
    <!-- Minimum battery level to allow dreaming when powered.
         Use -1 to disable this safety feature. -->
    <integer name="config_dreamsBatteryLevelMinimumWhenPowered">-1</integer>
    <!-- Minimum battery level to allow dreaming when not powered.
         Use -1 to disable this safety feature. -->
    <integer name="config_dreamsBatteryLevelMinimumWhenNotPowered">15</integer>
    <!-- If the battery level drops by this percentage and the user activity timeout
         has expired, then assume the device is receiving insufficient current to charge
         effectively and terminate the dream.  Use -1 to disable this safety feature.  -->
    <integer name="config_dreamsBatteryLevelDrainCutoff">5</integer>

    <!-- ComponentName of a dream to show whenever the system would otherwise have
         gone to sleep.  When the PowerManager is asked to go to sleep, it will instead
         try to start this dream if possible.  The dream should typically call startDozing()
         to put the display into a low power state and allow the application processor
         to be suspended.  When the dream ends, the system will go to sleep as usual.
         Specify the component name or an empty string if none.

         Note that doze dreams are not subject to the same start conditions as ordinary dreams.
         Doze dreams will run whenever the power manager is in a dozing state. -->
    <string name="config_dozeComponent" translatable="false"></string>

    <!-- If true, the doze component is not started until after the screen has been
         turned off and the screen off animation has been performed. -->
    <bool name="config_dozeAfterScreenOff">false</bool>

    <!-- Power Management: Specifies whether to decouple the auto-suspend state of the
         device from the display on/off state.

         When false, autosuspend_disable() will be called before the display is turned on
         and autosuspend_enable() will be called after the display is turned off.
         This mode provides best compatibility for devices using legacy power management
         features such as early suspend / late resume.

         When true, autosuspend_display() and autosuspend_enable() will be called
         independently of whether the display is being turned on or off.  This mode
         enables the power manager to suspend the application processor while the
         display is on.

         This resource should be set to "true" when a doze component has been specified
         to maximize power savings but not all devices support it.

         Refer to autosuspend.h for details.
    -->
    <bool name="config_powerDecoupleAutoSuspendModeFromDisplay">false</bool>

    <!-- Power Management: Specifies whether to decouple the interactive state of the
         device from the display on/off state.

         When false, setInteractive(..., true) will be called before the display is turned on
         and setInteractive(..., false) will be called after the display is turned off.
         This mode provides best compatibility for devices that expect the interactive
         state to be tied to the display state.

         When true, setInteractive(...) will be called independently of whether the display
         is being turned on or off.  This mode enables the power manager to reduce
         clocks and disable the touch controller while the display is on.

         This resource should be set to "true" when a doze component has been specified
         to maximize power savings but not all devices support it.

         Refer to power.h for details.
    -->
    <bool name="config_powerDecoupleInteractiveModeFromDisplay">false</bool>

    <!-- User activity timeout: Minimum screen off timeout in milliseconds.

         Sets a lower bound for the {@link Settings.System#SCREEN_OFF_TIMEOUT} setting
         which determines how soon the device will go to sleep when there is no
         user activity.

         This value must be greater than zero, otherwise the device will immediately
         fall asleep again as soon as it is awoken.
    -->
    <integer name="config_minimumScreenOffTimeout">10000</integer>

    <!-- User activity timeout: Maximum screen dim duration in milliseconds.

         Sets an upper bound for how long the screen will dim before the device goes
         to sleep when there is no user activity.  The dim duration is subtracted from
         the overall screen off timeout to determine the screen dim timeout.
         When the screen dim timeout expires, the screen will dim, shortly thereafter
         the device will go to sleep.

         If the screen off timeout is very short, the dim duration may be reduced
         proportionally.  See config_maximumScreenDimRatio.

         This value may be zero in which case the screen will not dim before the
         device goes to sleep.
    -->
    <integer name="config_maximumScreenDimDuration">7000</integer>

    <!-- User activity timeout: Maximum screen dim duration as a percentage of screen off timeout.

         This resource is similar to config_maximumScreenDimDuration but the maximum
         screen dim duration is defined as a ratio of the overall screen off timeout
         instead of as an absolute value in milliseconds.  This is useful for reducing
         the dim duration when the screen off timeout is very short.

         When computing the screen dim duration, the power manager uses the lesser
         of the effective durations expressed by config_maximumScreenDimDuration and
         config_maximumScreenDimRatio.

         This value must be between 0% and 100%.  If the value is zero, the screen will not
         dim before the device goes to sleep.
    -->
    <fraction name="config_maximumScreenDimRatio">20%</fraction>

    <!-- Base "touch slop" value used by ViewConfiguration as a
         movement threshold where scrolling should begin. -->
    <dimen name="config_viewConfigurationTouchSlop">8dp</dimen>

    <!-- Minimum velocity to initiate a fling, as measured in dips per second. -->
    <dimen name="config_viewMinFlingVelocity">50dp</dimen>

    <!-- Maximum velocity to initiate a fling, as measured in dips per second. -->
    <dimen name="config_viewMaxFlingVelocity">8000dp</dimen>

    <!-- Amount of time in ms the user needs to press the relevant key to bring up the global actions dialog -->
    <integer name="config_globalActionsKeyTimeout">500</integer>

    <!-- Maximum number of grid columns permitted in the ResolverActivity
         used for picking activities to handle an intent. -->
    <integer name="config_maxResolverActivityColumns">3</integer>

    <!-- Array of OEM specific USB mode override config.
         OEM can override a certain USB mode depending on ro.bootmode.
         Specify an array of below items to set override rule.
         [bootmode]:[original USB mode]:[USB mode used]-->
    <integer-array translatable="false" name="config_oemUsbModeOverride">
    </integer-array>

    <!-- Set to true to add links to Cell Broadcast app from Settings and MMS app. -->
    <bool name="config_cellBroadcastAppLinks">false</bool>

    <!-- The default value if the SyncStorageEngine should sync automatically or not -->
    <bool name="config_syncstorageengine_masterSyncAutomatically">true</bool>

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

    <!-- Whether UI for multi user should be shown -->
    <bool name="config_enableMultiUserUI">false</bool>

    <!-- If true, then we do not ask user for permission for apps to connect to USB devices.
         Do not set this to true for production devices. Doing so will cause you to fail CTS. -->
    <bool name="config_disableUsbPermissionDialogs">false</bool>

    <!-- Minimum span needed to begin a touch scaling gesture.
         If the span is equal to or greater than this size, a scaling gesture
         will begin, where supported. (See android.view.ScaleGestureDetector)

         This also takes into account the size of any active touch points.
         Devices with screens that deviate too far from their assigned density
         bucket should consider tuning this value in a device-specific overlay.
         For best results, care should be taken such that this value remains
         larger than the minimum reported touchMajor/touchMinor values
         reported by the hardware. -->
    <dimen name="config_minScalingSpan">27mm</dimen>

    <!-- Minimum accepted value for touchMajor while scaling. This may be tuned
         per-device in overlays. -->
    <dimen name="config_minScalingTouchMajor">48dp</dimen>

    <!-- Safe headphone volume index. When music stream volume is below this index
    the SPL on headphone output is compliant to EN 60950 requirements for portable music
    players. -->
    <integer name="config_safe_media_volume_index">10</integer>

    <!-- Configure mobile network MTU. The standard default is set here but each carrier
         may have a specific value set in an overlay config.xml file. -->
    <integer name="config_mobile_mtu">1500</integer>

    <!-- Configure mobile tcp buffer sizes in the form:
         rat-name:rmem_min,rmem_def,rmem_max,wmem_min,wmem_def,wmem_max
         If no value is found for the rat-name in use, the system default will be applied.
    -->
    <string-array name="config_mobile_tcp_buffers">
    </string-array>

    <!-- Configure ethernet tcp buffersizes in the form:
         rmem_min,rmem_def,rmem_max,wmem_min,wmem_def,wmem_max -->
    <string name="config_ethernet_tcp_buffers" translatable="false">524288,1048576,3145728,524288,1048576,2097152</string>

    <!-- Configure wifi tcp buffersizes in the form:
         rmem_min,rmem_def,rmem_max,wmem_min,wmem_def,wmem_max -->
    <string name="config_wifi_tcp_buffers" translatable="false">524288,1048576,2097152,262144,524288,1048576</string>

    <!-- Whether WiFi display is supported by this device.
         There are many prerequisites for this feature to work correctly.
         Here are a few of them:
         * The WiFi radio must support WiFi P2P.
         * The WiFi radio must support concurrent connections to the WiFi display and
           to an access point.
         * The Audio Flinger audio_policy.conf file must specify a rule for the "r_submix"
           remote submix module.  This module is used to record and stream system
           audio output to the WiFi display encoder in the media server.
         * The remote submix module "audio.r_submix.default" must be installed on the device.
         * The device must be provisioned with HDCP keys (for protected content).
    -->
    <bool name="config_enableWifiDisplay">false</bool>

    <!-- When true, local displays that do not contain any of their own content will automatically
         mirror the content of the default display. -->
    <bool name="config_localDisplaysMirrorContent">true</bool>

    <!-- 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">false</bool>

    <!-- Whether safe headphone volume is enabled or not (country specific). -->
    <bool name="config_safe_media_volume_enabled">true</bool>

    <!-- Set to true if the wifi display supports compositing content stored
         in gralloc protected buffers.  For this to be true, there must exist
         a protected hardware path for surface flinger to composite and send
         protected buffers to the wifi display video encoder.

         If this flag is false, we advise applications not to use protected
         buffers (if possible) when presenting content to a wifi display because
         the content may be blanked.

         This flag controls whether the {@link Display#FLAG_SUPPORTS_PROTECTED_BUFFERS}
         flag is set for wifi displays.
    -->
    <bool name="config_wifiDisplaySupportsProtectedBuffers">false</bool>

    <!-- Whether camera shutter sound is forced or not  (country specific). -->
    <bool name="config_camera_sound_forced">false</bool>

    <!-- Set to true if we need to not prefer an APN.
         This is being added to enable a simple scenario of pre-paid
         provisioning on some carriers, working around a bug (7305641)
         where if the preferred is used we don't try the others. -->
    <bool name="config_dontPreferApn">false</bool>

    <!-- The list of ril radio technologies (see ServiceState.java) which only support
         a single data connection at one time.  This may change by carrier via
         overlays (some don't support multiple pdp on UMTS).  All unlisted radio
         tech types support unlimited types (practically only 2-4 used). -->
    <integer-array name="config_onlySingleDcAllowed">
        <item>4</item>  <!-- IS95A -->
        <item>5</item>  <!-- IS95B -->
        <item>6</item>  <!-- 1xRTT -->
        <item>7</item>  <!-- EVDO_0 -->
        <item>8</item>  <!-- EVDO_A -->
        <item>12</item> <!-- EVDO_B -->
    </integer-array>

    <!-- Set to true if after a provisioning apn the radio should be restarted -->
    <bool name="config_restartRadioAfterProvisioning">false</bool>

    <!-- Boolean indicating if RADIO POWER OFF is required on receiving SIM REFRESH with RESET.
         This will be handled by modem if it is false. -->
    <bool name="config_requireRadioPowerOffOnSimRefreshReset">false</bool>

    <!-- Vibrator pattern to be used as the default for notifications
         that specify DEFAULT_VIBRATE.
     -->
    <integer-array name="config_defaultNotificationVibePattern">
        <item>0</item>
        <item>350</item>
        <item>250</item>
        <item>350</item>
    </integer-array>

    <!-- Vibrator pattern to be used as the default for notifications
         that do not specify vibration but vibrate anyway because the device
         is in vibrate mode.
     -->
    <integer-array name="config_notificationFallbackVibePattern">
        <item>0</item>
        <item>100</item>
        <item>150</item>
        <item>100</item>
    </integer-array>

    <!-- Flag indicating if the speed up audio on mt call code should be executed -->
    <bool name="config_speed_up_audio_on_mt_calls">false</bool>

    <!-- Class name of the framework account picker activity.
         Can be customized for other product types -->
    <string name="config_chooseAccountActivity" translatable="false"
            >android/android.accounts.ChooseAccountActivity</string>
    <!-- Class name of the account type and account picker activity.
         Can be customized for other product types -->
    <string name="config_chooseTypeAndAccountActivity" translatable="false"
            >android/android.accounts.ChooseTypeAndAccountActivity</string>

    <!-- Component name of a custom ResolverActivity (Intent resolver) to be used instead of
         the default framework version. If left empty, then the framework version will be used.
         Example: com.google.android.myapp/.resolver.MyResolverActivity  -->
    <string name="config_customResolverActivity" translatable="false"></string>

    <!-- Name of the activity or service that prompts the user to reject, accept, or whitelist
         an adb host's public key, when an unwhitelisted host connects to the local adbd.
         Can be customized for other product types -->
    <string name="config_customAdbPublicKeyConfirmationComponent"
            >com.android.systemui/com.android.systemui.usb.UsbDebuggingActivity</string>

    <!-- Name of the activity that prompts the secondary user to acknowledge she/he needs to
         switch to the primary user to enable USB debugging.
         Can be customized for other product types -->
    <string name="config_customAdbPublicKeyConfirmationSecondaryUserComponent"
            >com.android.systemui/com.android.systemui.usb.UsbDebuggingSecondaryUserActivity</string>

    <!-- Name of the CustomDialog that is used for VPN -->
    <string name="config_customVpnConfirmDialogComponent"
            >com.android.vpndialogs/com.android.vpndialogs.ConfirmDialog</string>

    <!-- Apps that are authorized to access shared accounts, overridden by product overlays -->
    <string name="config_appsAuthorizedForSharedAccounts" translatable="false">;com.android.settings;</string>

    <!-- Flag indicating that the media framework should not allow changes or mute on any
         stream or master volumes. -->
    <bool name="config_useFixedVolume">false</bool>

    <!-- The list of IMEs which should be disabled until used.
         This function suppresses update notifications for these pre-installed apps.
         We need to set this configuration carefully that they should not have functionarities
         other than "IME" or "Spell Checker". In InputMethodManagerService,
         the listed IMEs are disabled until used when all of the following conditions are met.
         1. Not selected as an enabled IME in the Settings
         2. Not selected as a spell checker in the Settings
         3. Installed
         4. A pre-installed IME
         5. Not enabled
         And the disabled_until_used state for an IME is released by InputMethodManagerService
         when the IME is selected as an enabled IME. -->
    <string-array name="config_disabledUntilUsedPreinstalledImes" translatable="false">
        <item>com.android.inputmethod.latin</item>
    </string-array>

    <!-- The list of carrier applications which should be disabled until used.
         This function suppresses update notifications for these pre-installed apps.
         In SubscriptionInfoUpdater, the listed applications are disabled until used when all of the
         following conditions are met.
         1. Not currently carrier-privileged according to the inserted SIM
         2. Pre-installed
         3. In the default state (enabled but not explicitly)
         And SubscriptionInfoUpdater undoes this and marks the app enabled when a SIM is inserted
         that marks the app as carrier privileged. It also grants the app default permissions
         for Phone and Location. As such, apps MUST only ever be added to this list if they
         obtain user consent to access their location through other means. -->
    <string-array name="config_disabledUntilUsedPreinstalledCarrierApps" translatable="false" />

    <!-- The list of classes that should be added to the notification ranking pipline.
     See {@link com.android.server.notification.NotificationSignalExtractor} -->
    <string-array name="config_notificationSignalExtractors">
        <item>com.android.server.notification.ValidateNotificationPeople</item>
        <item>com.android.server.notification.PriorityExtractor</item>
        <item>com.android.server.notification.ImportanceExtractor</item>
        <item>com.android.server.notification.NotificationIntrusivenessExtractor</item>
        <item>com.android.server.notification.VisibilityExtractor</item>
    </string-array>

    <!-- Flag indicating that this device does not rotate and will always remain in its default
         orientation. Activities that desire to run in a non-compatible orientation will be run
         from an emulated display within the physical display. -->
    <bool name="config_forceDefaultOrientation">false</bool>

    <!-- Default Gravity setting for the system Toast view. Equivalent to: Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM -->
    <integer name="config_toastDefaultGravity">0x00000051</integer>

    <!-- set to false if we need to show user confirmation
         when alpha identifier is not provided by the UICC -->
    <bool name="config_stkNoAlphaUsrCnf">true</bool>

    <!-- Don't use roaming icon for considered operators.
         A match on config_sameNamedOperatorConsideredRoaming supersedes a match on this.
         Can use mcc or mcc+mnc as item. For example, 302 or 21407.
         If operators, 21404 and 21407, make roaming agreements, user of 21404 should not see
         the roaming icon as using 21407 network.
         To do this, add 21407 item to values-mcc214-mnc04/config.xml -->
    <string-array translatable="false" name="config_operatorConsideredNonRoaming">
    </string-array>

    <!-- Threshold (in ms) under which a screen off / screen on will be considered a reset of the
         immersive mode confirmation prompt.-->
    <integer name="config_immersive_mode_confirmation_panic">5000</integer>

    <!-- For some operators, PDU has garbages. To fix it, need to use valid index -->
    <integer name="config_valid_wappush_index">-1</integer>

    <!-- This is NOT just for same named operators unlike the name suggests (will blacklist regardless of name).
         A match on this supersedes a match on config_operatorConsideredNonRoaming.
         Uses "startsWith" so you can use a leading substring like the mcc or
         use the complete mcc+mnc string.
         For a given mcc/mcc-mnc, some operators may want to roam (even if
         config_operatorConsideredNonRoaming has the mcc/mcc-mnc).
         user of 40485 should see the roaming icon as using 40483 network
         though same Reliance network.
         To do this, add 40483 item to values-mcc404-mnc85/config.xml -->
    <string-array translatable="false" name="config_sameNamedOperatorConsideredRoaming">
    </string-array>
    <!-- call barring MMI code from TS 22.030 Annex B -->
    <string-array translatable="false" name="config_callBarringMMI">
        <item>33</item>
        <item>331</item>
        <item>332</item>
        <item>35</item>
        <item>351</item>
        <item>330</item>
        <item>333</item>
        <item>353</item>
    </string-array>

    <!-- Override the default detection behavior for the framework method
         android.view.ViewConfiguration#hasPermanentMenuKey().
         Valid settings are:
         0 - No change. Use the default autodetection behavior.
         1 - The device DOES have a permanent menu key; ignore autodetection.
         2 - The device DOES NOT have a permanent menu key; ignore autodetection. -->
    <integer name="config_overrideHasPermanentMenuKey">0</integer>

    <!-- Override the DPad detection behavior for configuration purposes -->
    <bool name="config_hasPermanentDpad">false</bool>

    <!-- default window inset isRound property -->
    <bool name="config_windowIsRound">false</bool>

    <!-- Override this value if the device has a chin, i.e. area that is not actual part of the
         screen but you would like to be treated as a real display. The value is the height of the
         chin. -->
    <integer name="config_windowOutsetBottom">0</integer>

    <!-- Package name for default network scorer app; overridden by product overlays. -->
    <string name="config_defaultNetworkScorerPackageName"></string>

    <!-- default device has recents property -->
    <bool name="config_hasRecents">true</bool>

    <!-- default window ShowCircularMask property -->
    <bool name="config_windowShowCircularMask">false</bool>

    <!-- default value for whether circular emulators (ro.emulator.circular)
         should show a display overlay on the screen -->
    <bool name="config_windowEnableCircularEmulatorDisplayOverlay">false</bool>

    <!-- Defines the default set of global actions. Actions may still be disabled or hidden based
         on the current state of the device.
         Each item must be one of the following strings:
         "power" = Power off
         "settings" = An action to launch settings
         "airplane" = Airplane mode toggle
         "bugreport" = Take bug report, if available
         "silent" = silent mode
         "users" = list of users
         "restart" = restart device
         -->
    <string-array translatable="false" name="config_globalActionsList">
        <item>power</item>
        <item>restart</item>
        <item>bugreport</item>
        <item>users</item>
    </string-array>

    <!-- Number of milliseconds to hold a wake lock to ensure that drawing is fully
         flushed to the display while dozing.  This value needs to be large enough
         to account for processing and rendering time plus a frame or two of latency
         in the display pipeline plus some slack just to be sure. -->
    <integer name="config_drawLockTimeoutMillis">120</integer>

    <!-- default telephony hardware configuration for this platform.
    -->
    <!-- this string array should be overridden by the device to present a list
         telephony hardware resource.  this is used by the telephony device controller
         (TDC) to offer the basic capabilities of the hardware to the telephony
         framework
    -->
    <!-- an array of "[hardware type],[hardware-uuid],[state],[[hardware-type specific]]"
         with, [[hardware-type specific]] in:
            - "[[ril-model],[rat],[max-active-voice],[max-active-data],[max-active-standby]]"
              for 'modem' hardware
            - "[[associated-modem-uuid]]"
              for 'sim' hardware.
         refer to HardwareConfig in com.android.internal.telephony for specific details/values
         those elements can carry.
    -->
    <string-array translatable="false" name="config_telephonyHardware">
        <!-- modem -->
        <item>"0,modem,0,0,0,1,1,1"</item>
        <!-- sim -->
        <item>"1,sim,0,modem"</item>
    </string-array>

    <!-- This string array can be overriden to add an additional DRM support for WebView EME. -->
    <!-- Array of "[keySystemName],[UuidOfMediaDrm]" @hide @SystemApi -->
    <string-array name="config_keySystemUuidMapping" translatable="false">
        <!-- Example:
        <item>"x-com.microsoft.playready,9A04F079-9840-4286-AB92-E65BE0885F95"</item>
        -->
    </string-array>

    <!-- Flag indicating which package name can access the persistent data partition -->
    <string name="config_persistentDataPackageName" translatable="false"></string>

    <!-- Flag indicating apps will skip sending hold request before merge. In this case
        IMS service implementation will do both.i.e.hold followed by merge. -->
    <bool name="skipHoldBeforeMerge">true</bool>

    <!-- Flag indicating whether the IMS service can be turned off. If false then
        the service will not be turned-off completely (the ImsManager.turnOffIms() will
        be disabled) but individual Features can be disabled using ImsConfig.setFeatureValue() -->
    <bool name="imsServiceAllowTurnOff">true</bool>

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

    <!-- Flag specifying whether VoLTE should be available for carrier: independent of
         carrier provisioning. If false: hard disabled. If true: then depends on carrier
         provisioning, availability etc -->
    <bool name="config_carrier_volte_available">false</bool>

    <!-- Flag specifying whether VoLTE availability is based on provisioning -->
    <bool name="config_carrier_volte_provisioned">false</bool>

    <!-- Flag specifying whether VoLTE TTY is supported -->
    <bool name="config_carrier_volte_tty_supported">true</bool>

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

    <!-- Flag specifying whether the device will use the "allow_hold_in_ims_call" carrier config
         option.  When false, the device will support holding of IMS calls, regardless of the
         carrier config setting. -->
    <bool name="config_device_respects_hold_carrier_config">true</bool>

    <!-- Flag specifying whether VT should be available for carrier: independent of
         carrier provisioning. If false: hard disabled. If true: then depends on carrier
         provisioning, availability etc -->
    <bool name="config_carrier_vt_available">false</bool>

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

    <!-- Flag specifying whether WFC over IMS should be available for carrier: independent of
         carrier provisioning. If false: hard disabled. If true: then depends on carrier
         provisioning, availability etc -->
    <bool name="config_carrier_wfc_ims_available">false</bool>

    <bool name="config_networkSamplingWakesDevice">true</bool>

    <string-array translatable="false" name="config_cdma_home_system" />

    <!--From SmsMessage-->
    <!--Support decoding the user data payload as pack GSM 8-bit (a GSM alphabet
        string that's stored in 8-bit unpacked format) characters.-->
    <bool translatable="false" name="config_sms_decode_gsm_8bit_data">false</bool>

    <!-- If EMS is not supported, framework breaks down EMS into single segment SMS
         and adds page info " x/y". This config is used to set which carrier doesn't
         support EMS and whether page info should be added at the beginning or the end.
         We use tag 'prefix' for position beginning and 'suffix' for position end.
         And use gid to distinguish different carriers which using same mcc and mnc.
         Examples: <item>simOperatorNumber;position;gid(optional)</item>>
    -->
    <string-array translatable="false" name="no_ems_support_sim_operators">
        <!-- VZW -->
        <item>20404;suffix;BAE0000000000000</item>
    </string-array>

    <bool name="config_auto_attach_data_on_creation">true</bool>

    <!-- Values for GPS configuration -->
    <string-array translatable="false" name="config_gpsParameters">
        <item>SUPL_HOST=supl.google.com</item>
        <item>SUPL_PORT=7275</item>
        <item>NTP_SERVER=north-america.pool.ntp.org</item>
        <item>SUPL_VER=0x20000</item>
        <item>SUPL_MODE=1</item>
    </string-array>

    <!-- If there is no preload VM number in the sim card, carriers such as
         Verizon require to load a default vm number from the configurantion.
         Define config_default_vm_number for this purpose. And there are two
         optional formats for this configuration as below:
         (1)<item>voicemail number</item>
         (2)<item>voicemail number;gid</item>
         The logic to pick up the correct voicemail number:
         (1) If the config_default_vm_number array has no gid special item, the last one will be
         picked
         (2) If the config_default_vm_number array has gid special item and  it matches the current
         sim's gid, it will be picked.
         (3) If the config_default_vm_number array has gid special item but it doesn't match the
         current sim's gid, the last one without gid will be picked -->
    <string-array translatable="false" name="config_default_vm_number" />

    <!-- Sprint need a 70 ms delay for 3way call -->
    <integer name="config_cdma_3waycall_flash_delay">0</integer>

    <!--SIM does not save, but the voice mail number to be changed. -->
    <bool name="editable_voicemailnumber">false</bool>

    <!-- service number convert map in roaming network. -->
    <!-- [dialstring],[replacement][,optional gid] -->
    <string-array translatable="false" name="dial_string_replace">
    </string-array>

    <!-- Flag indicating whether radio is to be restarted on the error of
         PDP_FAIL_REGULAR_DEACTIVATION/0x24 -->
    <bool name="config_restart_radio_on_pdp_fail_regular_deactivation">false</bool>

    <!-- networks that don't want data deactivate when shutdown the phone
         note this is dependent on the operator of the network we're on,
         not operator on the SIM -->
    <string-array translatable="false" name="networks_not_clear_data">
        <item>71203</item>
        <item>71606</item>
        <item>71610</item>
        <item>732101</item>
    </string-array>

    <!-- Config determines whether to update phone object when voice registration
         state changes. Voice radio tech change will always trigger an update of
         phone object irrespective of this config -->
    <bool name="config_switch_phone_on_voice_reg_state_change">true</bool>

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

    <!-- Flag indicating whether strict threshold is used, or lenient threshold is used,
          when evaluating RSRP for LTE antenna bar display
           0. Strict threshold
           1. Lenient threshold
    -->
    <integer name="config_LTE_RSRP_threshold_type">1</integer>

    <!-- Enabled built-in zen mode condition providers -->
    <string-array translatable="false" name="config_system_condition_providers">
        <item>countdown</item>
        <item>schedule</item>
        <item>event</item>
    </string-array>

    <!-- Priority repeat caller threshold, in minutes -->
    <integer name="config_zen_repeat_callers_threshold">15</integer>

    <!-- Flags enabling default window features. See Window.java -->
    <bool name="config_defaultWindowFeatureOptionsPanel">true</bool>
    <bool name="config_defaultWindowFeatureContextMenu">true</bool>

    <!-- If true, the transition for a RemoteViews is read from a resource instead of using the
         default scale-up transition. -->
    <bool name="config_overrideRemoteViewsActivityTransition">false</bool>

    <!-- This config is used to check if the carrier requires converting destination
         number before sending out a SMS.
         Formats for this configuration as below:
         [true or false][;optional gid]
         The logic to pick up the configuration:
         (1) If the "config_sms_convert_destination_number_support" array has no gid
             special item, the last one will be picked
         (2) If the "config_sms_convert_destination_number_support" array has gid special
             item and it matches the current sim's gid, it will be picked.
         (3) If the "config_sms_convert_destination_number_support" array has gid special
             item but it doesn't match the current sim's gid, the last one without gid
             will be picked -->
    <string-array translatable="false" name="config_sms_convert_destination_number_support">
        <item>false</item>
    </string-array>

    <!-- The maximum bitmap size that can be written to a MediaMetadata object. This value
         is the max width/height allowed in dips.-->
    <dimen name="config_mediaMetadataBitmapMaxSize">320dp</dimen>

    <string translatable="false" name="prohibit_manual_network_selection_in_gobal_mode">false</string>

    <!-- An array of CDMA roaming indicators which means international roaming -->
    <integer-array translatable="false" name="config_cdma_international_roaming_indicators" />

    <!-- flag to indicate if EF LI/EF PL should be used for system language -->
    <bool name="config_use_sim_language_file">false</bool>

    <!-- Use ERI text for network name on CDMA LTE -->
    <bool name="config_LTE_eri_for_network_name">true</bool>

    <!-- Whether to start in touch mode -->
    <bool name="config_defaultInTouchMode">true</bool>

    <!-- Time adjustment, in milliseconds, applied to the default double tap threshold
         used for gesture detection by the screen magnifier. -->
    <integer name="config_screen_magnification_multi_tap_adjustment">-50</integer>

    <!-- Scale factor threshold used by the screen magnifier to determine when to switch from
         panning to scaling the magnification viewport. -->
    <item name="config_screen_magnification_scaling_threshold" format="float" type="dimen">0.3</item>

    <!-- If true, the display will be shifted around in ambient mode. -->
    <bool name="config_enableBurnInProtection">false</bool>

    <!-- Specifies the maximum burn-in offset displacement from the center. If -1, no maximum value
         will be used. -->
    <integer name="config_burnInProtectionMaxRadius">-1</integer>

    <!-- Specifies the minimum burn-in offset horizontally. -->
    <integer name="config_burnInProtectionMinHorizontalOffset">0</integer>

    <!-- Specifies the maximum burn-in offset horizontally. -->
    <integer name="config_burnInProtectionMaxHorizontalOffset">0</integer>

    <!-- Specifies the minimum burn-in offset vertically. -->
    <integer name="config_burnInProtectionMinVerticalOffset">0</integer>

    <!-- Specifies the maximum burn-in offset vertically. -->
    <integer name="config_burnInProtectionMaxVerticalOffset">0</integer>

    <!-- Keyguard component -->
    <string name="config_keyguardComponent" translatable="false">com.android.systemui/com.android.systemui.keyguard.KeyguardService</string>

    <!-- For performance and storage reasons, limit the number of fingerprints per user -->
    <integer name="config_fingerprintMaxTemplatesPerUser">5</integer>

    <!-- This config is used to force VoiceInteractionService to start on certain low ram devices.
         It declares the package name of VoiceInteractionService that should be started. -->
    <string translatable="false" name="config_forceVoiceInteractionServicePackage"></string>

    <!-- This config is ued to determine whether animations are allowed in low power mode. -->
    <bool name="config_allowAnimationsInLowPowerMode">false</bool>

    <!-- Whether device supports double tap to wake -->
    <bool name="config_supportDoubleTapWake">false</bool>

    <!-- The RadioAccessFamilies supported by the device.
         Empty is viewed as "all".  Only used on devices which
         don't support RIL_REQUEST_GET_RADIO_CAPABILITY
         format is UMTS|LTE|... -->
    <string translatable="false" name="config_radio_access_family"></string>

    <!-- Whether the main built-in display is round. This will affect
         Configuration.screenLayout's SCREENLAYOUT_ROUND_MASK flags for Configurations on the
         main built-in display. Change this in device-specific overlays.
         Defaults to the older, deprecated config_windowIsRound already used in
         some existing device-specific resource overlays. -->
    <bool name="config_mainBuiltInDisplayIsRound">@bool/config_windowIsRound</bool>

    <!-- Ultrasound support for Mic/speaker path -->
    <!-- Whether the default microphone audio source supports near-ultrasound frequencies
         (range of 18 - 21 kHz). -->
    <bool name="config_supportMicNearUltrasound">true</bool>
    <!-- Whether the default speaker audio output path supports near-ultrasound frequencies
         (range of 18 - 21 kHz). -->
    <bool name="config_supportSpeakerNearUltrasound">true</bool>

    <!-- Whether the Unprocessed audio source supports the required frequency range and level -->
    <bool name="config_supportAudioSourceUnprocessed">false</bool>

    <!-- Flag indicating device support for EAP SIM, AKA, AKA' -->
    <bool name="config_eap_sim_based_auth_supported">true</bool>

    <!-- How long history of previous vibrations should be kept for the dumpsys. -->
    <integer name="config_previousVibrationsDumpLimit">20</integer>

    <!-- Number of retries Cell Data should attempt for a given error code before
         restarting the modem.
         Error codes not listed will not lead to modem restarts.
         Array of "code#,retry#"  -->
    <string-array name="config_cell_retries_per_error_code">
    </string-array>

    <!-- Set initial MaxRetry value for operators -->
    <integer name="config_mdc_initial_max_retry">1</integer>

    <!-- The OEM specified sensor type for the gesture to launch the camera app. -->
    <integer name="config_cameraLaunchGestureSensorType">-1</integer>
    <!-- The OEM specified sensor string type for the gesture to launch camera app, this value
         must match the value of config_cameraLaunchGestureSensorType in OEM's HAL -->
    <string translatable="false" name="config_cameraLaunchGestureSensorStringType"></string>

    <!-- Allow the gesture to double tap the power button twice to start the camera while the device
         is non-interactive. -->
    <bool name="config_cameraDoubleTapPowerGestureEnabled">true</bool>

    <!-- Name of the component to handle network policy notifications. If present,
         disables NetworkPolicyManagerService's presentation of data-usage notifications. -->
    <string translatable="false" name="config_networkPolicyNotificationComponent"></string>

    <!-- The BT name of the keyboard packaged with the device. If this is defined, SystemUI will
         automatically try to pair with it when the device exits tablet mode. -->
    <string translatable="false" name="config_packagedKeyboardName"></string>

    <!-- The device supports freeform window management. Windows have title bars and can be moved
         and resized. If you set this to true, you also need to add
         PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT feature to your device specification.
         The duplication is necessary, because this information is used before the features are
         available to the system.-->
    <bool name="config_freeformWindowManagement">false</bool>

    <!-- If set, this will force all windows to draw the status bar background, including the apps
         that have not requested doing so (via the WindowManager.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
         flag). -->
    <bool name="config_forceWindowDrawsStatusBarBackground">true</bool>

    <!-- Controls the opacity of the navigation bar depending on the visibility of the
         various workspace stacks.
         0 - Nav bar is always opaque when either the freeform stack or docked stack is visible.
         1 - Nav bar is always translucent when the freeform stack is visible, otherwise always
         opaque.
         -->
    <integer name="config_navBarOpacityMode">0</integer>

    <!-- Default bounds [left top right bottom] on screen for picture-in-picture windows. -->
    <string translatable="false" name="config_defaultPictureInPictureBounds">"0 0 100 100"</string>

    <!-- Controls the snap mode for the docked stack divider
             0 - 3 snap targets: left/top has 16:9 ratio, 1:1, and right/bottom has 16:9 ratio
             1 - 3 snap targets: fixed ratio, 1:1, (1 - fixed ratio)
             2 - 1 snap target: 1:1
    -->
    <integer name="config_dockedStackDividerSnapMode">0</integer>

    <!-- List of comma separated package names for which we the system will not show crash, ANR,
         etc. dialogs. -->
    <string translatable="false" name="config_appsNotReportingCrashes"></string>

    <!-- Inactivity threshold (in milliseconds) used in JobScheduler. JobScheduler will consider
         the device to be "idle" after being inactive for this long. -->
    <integer name="config_jobSchedulerInactivityIdleThreshold">4260000</integer>
    <!-- The alarm window (in milliseconds) that JobScheduler uses to enter the idle state -->
    <integer name="config_jobSchedulerIdleWindowSlop">300000</integer>

    <!-- If true, all guest users created on the device will be ephemeral. -->
    <bool name="config_guestUserEphemeral">false</bool>

    <!-- Enforce strong auth on boot. Setting this to false represents a security risk and should
         not be ordinarily done. The only case in which this might be permissible is in a car head
         unit where there are hardware mechanisms to protect the device (physical keys) and not
         much in the way of user data.
    -->
    <bool name="config_strongAuthRequiredOnBoot">true</bool>

    <!-- Wallpaper cropper package. Used as the default cropper if the active launcher doesn't
         handle wallpaper cropping.
    -->
    <string name="config_wallpaperCropperPackage" translatable="false">com.android.wallpapercropper</string>

    <!-- True if the device supports at least one form of multi-window.
         E.g. freeform, split-screen, picture-in-picture. -->
    <bool name="config_supportsMultiWindow">true</bool>

    <!-- True if the device requires AppWidgetService even if it does not have
         the PackageManager.FEATURE_APP_WIDGETS feature -->
    <bool name="config_enableAppWidgetService">false</bool>

    <!-- True if the device supports Sustained Performance Mode-->
    <bool name="config_sustainedPerformanceModeSupported">false</bool>

    <!-- File used to enable the double touch gesture.
         TODO: move to input HAL once ready. -->
    <string name="config_doubleTouchGestureEnableFile"></string>

    <!-- Controls how we deal with externally connected physical keyboards.
         0 - When using this device, it is not clear for users to recognize when the physical
             keyboard is (should be) connected and when it is (should be) disconnected.  Most of
             phones and tablets with Bluetooth keyboard would fall into this category because the
             connected Bluetooth keyboard may or may not be nearby the host device.
         1 - When using this device, it is clear for users to recognize when the physical
             keyboard is (should be) connected and when it is (should be) disconnected.
             Devices with wired USB keyboard is one clear example.  Some 2-in-1 convertible
             tablets with dedicated keyboards may have the same affordance to wired USB keyboard.
    -->
    <integer name="config_externalHardKeyboardBehavior">0</integer>

    <!-- Package of the unbundled tv remote service which can connect to tv
         remote provider -->
    <string name="config_tvRemoteServicePackage" translatable="false"></string>

    <!-- True if the device supports persisting security logs across reboots.
         This requires the device's kernel to have pstore and pmsg enabled,
         and DRAM to be powered and refreshed through all stages of reboot. -->
    <bool name="config_supportPreRebootSecurityLogs">false</bool>

    <!-- Default files to pin via Pinner Service -->
    <string-array translatable="false" name="config_defaultPinnerServiceFiles">
    </string-array>

    <!-- True if camera app should be pinned via Pinner Service -->
    <bool name="config_pinnerCameraApp">false</bool>

    <!-- Component that is the default launcher when demo mode is enabled. -->
    <string name="config_demoModeLauncherComponent">com.android.retaildemo/.DemoPlayer</string>

    <!-- Flag indicating whether round icons should be parsed from the application manifest. -->
    <bool name="config_useRoundIcon">false</bool>

    <!-- Flag indicating whether the assist disclosure can be disabled using
         ASSIST_DISCLOSURE_ENABLED. -->
    <bool name="config_allowDisablingAssistDisclosure">false</bool>

    <!-- True if the device supports system navigation keys. -->
    <bool name="config_supportSystemNavigationKeys">false</bool>

    <!-- Package name for the device provisioning package. -->
    <string name="config_deviceProvisioningPackage"></string>

    <!-- Colon separated list of package names that should be granted DND access -->
    <string name="config_defaultDndAccessPackages" translatable="false">com.android.camera2</string>

    <!-- User restrictions set when the first user is created.
         Note: Also update appropriate overlay files. -->
    <string-array translatable="false" name="config_defaultFirstUserRestrictions">
    </string-array>

    <!-- A array of regex to treat a SMS as VVM SMS if the message body matches.
         Each item represents an entry, which consists of two parts:
         a comma (,) separated list of MCCMNC the regex applies to, followed by a semicolon (;), and
         then the regex itself. -->
    <string-array translatable="false" name="config_vvmSmsFilterRegexes">
        <!-- Verizon requires any SMS that starts with //VZWVVM to be treated as a VVM SMS-->
        <item>310004,310010,310012,310013,310590,310890,310910,311110,311270,311271,311272,311273,311274,311275,311276,311277,311278,311279,311280,311281,311282,311283,311284,311285,311286,311287,311288,311289,311390,311480,311481,311482,311483,311484,311485,311486,311487,311488,311489;^//VZWVVM.*</item>
    </string-array>
    <!-- This config is holding calling number conversion map - expected to convert to emergency
         number. Formats for this config as below:
         <item>[dialstring1],[dialstring2],[dialstring3]:[replacement]</item>

         E.g. for Taiwan Type Approval, 110 and 119 should be converted to 112.
         <item>110,119:112</item>
    -->
    <string-array translatable="false" name="config_convert_to_emergency_number_map" />

    <!-- An array of packages for which notifications cannot be blocked. -->
    <string-array translatable="false" name="config_nonBlockableNotificationPackages" />
</resources>
