Merge lp:~sforshee/powerd/autobrightness into lp:powerd

[Seth Forshee]

Add support for automatically adjusting the display backlight in response to ambient brightness

Add support for automatically adjusting the display backlight in response to ambient brightness

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:96
http://jenkins.qa.ubuntu.com/job/powerd-ci/109/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/63
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/63/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/109/rebuild

review: Approve (continuous-integration)

[Michael Frey (mfrey)]

tested and works nicely.

Comment.

Please rename "android-config" to "device-config"
I don't think the config is tied to android.

review: Needs Fixing

[Seth Forshee (sforshee)]

It _is_ using android config files to get the data, but it doesn't matter much to me. I have the name changed locally but can't build due to package dependency problems in my pbuilder, so I'll repush as soon as someone gets that fixed.

[lp:~sforshee/powerd/autobrightness]

97. By Seth Forshee on 2013-08-29

s/android_config/device_config/

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:97
http://jenkins.qa.ubuntu.com/job/powerd-ci/110/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/64
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/64/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/110/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/autobrightness]

98. By Seth Forshee on 2013-08-29

Use tuna config file for maguro

It turns out that in Android maguro has two device configuration
overlay files, one under device/samsung/maguro and the other
under device/samsung/tuna. The tuna file is common to all Galaxy
Nexus devices.

For powerd's use the tuna file has all the information we really
care about, so just use that one for maguro.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:98
http://jenkins.qa.ubuntu.com/job/powerd-ci/111/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/65
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/65/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/111/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/autobrightness]

99. By Seth Forshee on 2013-08-29

Strip down device configurations

Remove all variables except those which powerd is already using
or is likely to use soon.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:99
http://jenkins.qa.ubuntu.com/job/powerd-ci/112/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/66
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/66/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/112/rebuild

review: Approve (continuous-integration)

[Michael Frey (mfrey)]

ok, works great.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-08-09 19:53:58 +0000
+++ CMakeLists.txt	2013-08-29 21:23:26 +0000
@@ -33,11 +33,17 @@
 )
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/src/${POWERD_GENERATED_SOURCES} PROPERTIES GENERATED 1)
 
+set(POWERD_DEVICE_CONFIGS_PATH "${CMAKE_INSTALL_PREFIX}/share/powerd/device_configs")
+FILE(GLOB device_config_files "${CMAKE_CURRENT_SOURCE_DIR}/data/device_configs/*.xml")
+add_definitions(-DPOWERD_DEVICE_CONFIGS_PATH=\"${POWERD_DEVICE_CONFIGS_PATH}\")
+
 set(
   SRCS
 
   src/powerd.cpp
+  src/autobrightness.c
   src/backlight.c
+  src/device-config.c
   src/display.c
   src/display-request.c
   src/log.c
@@ -46,6 +52,7 @@
   src/powerd-client.c
   src/powerd-object.c
   src/powerd-sensors.cpp
+  src/spline.c
   src/stats.c
   src/util.c
   src/${GDBUS_NAME}.c
@@ -104,6 +111,7 @@
   ${GIO-UNIX_LIBRARIES}
   ${PHABLET_LIBRARIES}
   "-lubuntu_application_api"
+  "-landroid-properties"
   ${LIBUDEV_LIBRARIES}
   ${UPOWER_GLIB_LIBRARIES}
   ${UUID_LIBRARIES}
@@ -115,3 +123,8 @@
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib/static
 )
+
+install(
+  FILES ${device_config_files}
+  DESTINATION ${POWERD_DEVICE_CONFIGS_PATH}
+)

=== added directory 'data/device_configs'
=== added file 'data/device_configs/config-default.xml'
--- data/device_configs/config-default.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-default.xml	2013-08-29 21:23:26 +0000
@@ -0,0 +1,69 @@
+<?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. -->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- 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>
+
+    <!-- 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">4</integer>
+
+    <!-- Shutdown if the battery temperature exceeds (this value * 0.1) Celsius. -->
+    <integer name="config_shutdownBatteryTemperature">680</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>
+
+    <!-- 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>
+
+    <!-- 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>
+</resources>

=== added file 'data/device_configs/config-grouper.xml'
--- data/device_configs/config-grouper.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-grouper.xml	2013-08-29 21:23:26 +0000
@@ -0,0 +1,75 @@
+<?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. -->
+<resources>
+    <!-- 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">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N  1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1     array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>5</item>
+        <item>15</item>
+        <item>50</item>
+        <item>100</item>
+        <item>200</item>
+        <item>400</item>
+        <item>1000</item>
+        <item>2000</item>
+        <item>3000</item>
+        <item>5000</item>
+        <item>10000</item>
+        <item>30000</item>
+    </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.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>5</item>    <!-- 0-5 -->
+        <item>20</item>   <!-- 5-15 -->
+        <item>30</item>   <!-- 15-50 -->
+        <item>40</item>   <!-- 50-100 -->
+        <item>50</item>   <!-- 100-200 -->
+        <item>60</item>   <!-- 200-400 -->
+        <item>70</item>   <!-- 400-1000 -->
+        <item>80</item>   <!-- 1000-2000 -->
+        <item>130</item>  <!-- 2000-3000 -->
+        <item>180</item>  <!-- 3000-5000 -->
+        <item>255</item>  <!-- 5000-10000 -->
+        <item>255</item>  <!-- 10000-30000 -->
+        <item>255</item>  <!-- 30000+ -->
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">5</integer>
+</resources>

=== added file 'data/device_configs/config-maguro.xml'
--- data/device_configs/config-maguro.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-maguro.xml	2013-08-29 21:23:26 +0000
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2011, 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. -->
+<resources>
+    <!-- Flag indicating whether we should enable the automatic brightness in Settings.
+         config_hardware_automatic_brightness_available is not set, so we will use software implementation -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N + 1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1:    array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>6</item>
+	<item>9</item>
+	<item>14</item>
+	<item>20</item>
+	<item>30</item>
+	<item>46</item>
+	<item>68</item>
+        <item>103</item>
+	<item>154</item>
+        <item>231</item>
+	<item>346</item>
+	<item>519</item>
+	<item>778</item>
+	<item>1168</item>
+	<item>1752</item>
+	<item>2627</item>
+	<item>3941</item>
+        <item>5912</item>
+	<item>8867</item>
+    </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.
+    -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>19</item>
+	<item>23</item>
+	<item>26</item>
+	<item>30</item>
+	<item>34</item>
+	<item>39</item>
+	<item>45</item>
+        <item>51</item>
+        <item>59</item>
+        <item>67</item>
+        <item>77</item>
+        <item>88</item>
+	<item>101</item>
+	<item>116</item>
+	<item>133</item>
+	<item>152</item>
+	<item>174</item>
+	<item>199</item>
+	<item>228</item>
+        <item>250</item>
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">10</integer>
+</resources>

=== added file 'data/device_configs/config-mako.xml'
--- data/device_configs/config-mako.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-mako.xml	2013-08-29 21:23:26 +0000
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2012, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+    <!-- 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">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N  1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1     array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>10</item>
+        <item>50</item>
+        <item>100</item>
+        <item>200</item>
+        <item>400</item>
+        <item>500</item>
+        <item>800</item>
+        <item>1000</item>
+        <item>1600</item>
+        <item>3000</item>
+        <item>10000</item>
+    </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.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>14</item>   <!-- 0-10 -->
+        <item>28</item>   <!-- 10-50 -->
+        <item>37</item>   <!-- 50-100 -->
+        <item>51</item>   <!-- 100-200 -->
+        <item>71</item>   <!-- 200-400 -->
+        <item>80</item>   <!-- 400-500 -->
+        <item>96</item>   <!-- 500-800 -->
+        <item>108</item>  <!-- 800-1000 -->
+        <item>144</item>  <!-- 1000-1600 -->
+        <item>181</item>  <!-- 1600-3000 -->
+        <item>254</item>  <!-- 3000-10000 -->
+        <item>255</item>  <!-- 10000+ -->
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">1</integer>
+
+    <!-- Shutdown if the battery temperature exceeds (this value * 0.1) Celsius. -->
+    <integer name="config_shutdownBatteryTemperature">600</integer>
+
+</resources>

=== added file 'data/device_configs/config-manta.xml'
--- data/device_configs/config-manta.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-manta.xml	2013-08-29 21:23:26 +0000
@@ -0,0 +1,74 @@
+<?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. -->
+<resources>
+    <!-- Flag indicating whether we should enable the automatic brightness in Settings.
+         config_hardware_automatic_brightness_available is not set, so we will use software implementation -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- 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">
+        <item>10</item>      <!-- Pitch black 0, and 9 is next possible value. -->
+        <item>30</item>      <!-- Sensor in dark office: 60, well lit: 220 -->
+        <item>90</item>      <!-- Sensor in dark office: 60, well lit: 220 -->
+        <item>15000</item>   <!-- Screen under direct sunlight, but not sensor. -->
+        <item>225000</item>  <!-- Sensor under direct sunlight. -->
+    </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">
+        <item>10</item>
+        <item>13</item>
+        <item>65</item>
+        <item>85</item>
+        <item>220</item>
+        <item>255</item>
+    </integer-array>
+
+    <!-- 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">2</integer>
+
+</resources>

=== modified file 'debian/control'
--- debian/control	2013-08-03 08:21:09 +0000
+++ debian/control	2013-08-29 21:23:26 +0000
@@ -8,6 +8,7 @@
                libhybris-dev,
                libudev-dev,
                python,
+               libandroid-properties-dev,
                libplatform-api1-dev,
                libupower-glib-dev,
                uuid-dev,

=== added file 'src/autobrightness.c'
--- src/autobrightness.c	1970-01-01 00:00:00 +0000
+++ src/autobrightness.c	2013-08-29 21:23:26 +0000
@@ -0,0 +1,357 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <math.h>
+#include <glib.h>
+
+#include "powerd-internal.h"
+#include "device-config.h"
+#include "log.h"
+#include "spline.h"
+
+/*
+ * Autobrightness Control Algorithm
+ *
+ * Automatic backlight adjustments should respond quickly to changes in
+ * the ambient brightness without constantly adjusting for minor or
+ * transient changes in ambient brightness. The following mechanisms are
+ * employed to maintain this balance.
+ *
+ * EXPONENTIAL SMOOTHING
+ *
+ * Rather than processing incoming lux values directly, an exponential
+ * moving average is calculated using an algorithm based off of the
+ * formulation known as "Brown's simple exponential smoothing" [1]:
+ *
+ *   S(n) = a * x(n) + (1 - a) * S(n - 1)
+ *        = S(n - 1) + a * (x(n) - S(n - 1))
+ *
+ * where 0 <= a <= 1. To make smoothing time-based, a is calculated
+ * based on the amount of time spent at a given lux value.
+ *
+ *   delta_t = t(n) - t(n - 1)
+ *   a(n) = delta_t / (C + delta_t)
+ *
+ * This gives decreasing weight to older samples. Smaller values of C
+ * will cause faster decay of old samples, giving a faster response
+ * time, while larger values of C create slower decay and give more
+ * filtering of transient events.
+ *
+ * This code usese two moving averages, one which responds slowly to
+ * changes and another which responds quickly. The slow average is used
+ * to detect the trend with less sensitivity to transient events, while
+ * the fast average is used for picking the brightness once we've
+ * decided to change it.
+ *
+ * HYSTERESIS
+ *
+ * To avoid making constant adjustments to screen brightness in response
+ * to small changes in ambient lighting conditions, the change in lux is
+ * required to exceed some threshold before changing screen brightness.
+ *
+ * DEBOUNCING
+ *
+ * Changes in ambient brightness which exceed the hysteresis threshold
+ * must do so for some minimum amount of time before any changes in
+ * screen brightness will be made. This "debounces" the incoming lux
+ * values and also helps to filter out transient changes in ambient
+ * conditions.
+ *
+ * [1] http://en.wikipedia.org/wiki/Exponential_smoothing
+ */
+
+#define SMOOTHING_FACTOR_SLOW 2000.0f
+#define SMOOTHING_FACTOR_FAST 200.0f
+#define HYSTERESIS_FACTOR 0.10f
+#define DEBOUNCE_MS 4000
+
+enum ab_state {
+    AB_STATE_DISABLED,
+    AB_STATE_INITIALIZING,
+    AB_STATE_IDLE,      /* Idle, nothing to do */
+    AB_STATE_DEBOUNCE,  /* Debouncing lux change */
+};
+
+struct ab_status {
+    enum ab_state state;
+    guint source_id;
+    double last_lux, applied_lux;
+    double average_slow, average_fast;
+    gint64 last_lux_ms;
+    struct ab_spline *spline;
+};
+
+static gboolean ab_supported = FALSE;
+static struct ab_status ab_status;
+struct spline *ab_spline;
+
+static gint64 get_ms(void)
+{
+    return g_get_monotonic_time() / 1000;
+}
+
+static double aggregate_lux(double old_average, double new_lux,
+                            double smoothing_factor, double time_delta)
+{
+    double alpha;
+    if (time_delta < 0.0f)
+        time_delta = 0.0f;
+    alpha = time_delta / (smoothing_factor + time_delta);
+    return old_average + alpha * (new_lux - old_average);
+}
+
+static enum ab_state process_state_debounce(guint *delay_ms)
+{
+    gint64 now;
+    double time_delta;
+    double slow_lux, fast_lux;
+    double hysteresis, slow_delta, fast_delta;
+    enum ab_state next;
+   
+    next = AB_STATE_IDLE;
+    *delay_ms = 0;
+
+    now = get_ms();
+    time_delta = (double)(now - ab_status.last_lux_ms);
+    slow_lux = aggregate_lux(ab_status.average_slow, ab_status.last_lux,
+                             SMOOTHING_FACTOR_SLOW, time_delta);
+    fast_lux = aggregate_lux(ab_status.average_fast, ab_status.last_lux,
+                             SMOOTHING_FACTOR_FAST, time_delta);
+    powerd_debug("%lld slow avg %f fast avg %f last %f",
+                 now, slow_lux, fast_lux, ab_status.last_lux);
+
+    /*
+     * Require that both slow and fast averages exceed hysteresis,
+     * and in the same direction.
+     */
+    hysteresis = ab_status.applied_lux * HYSTERESIS_FACTOR;
+    if (hysteresis < 2)
+        hysteresis = 2;
+    slow_delta = slow_lux - ab_status.applied_lux;
+    fast_delta = fast_lux - ab_status.applied_lux;
+    if ((slow_delta >= hysteresis && fast_delta >= hysteresis) ||
+        (-slow_delta >= hysteresis && -fast_delta >= hysteresis)) {
+        int brightness = (int)(spline_interpolate(ab_spline, fast_lux) + 0.5);
+        powerd_debug("set brightness %d", brightness);
+        powerd_set_brightness(brightness);
+        ab_status.applied_lux = fast_lux;
+    }
+
+    hysteresis = ab_status.last_lux * HYSTERESIS_FACTOR;
+    if (hysteresis < 2)
+        hysteresis = 2;
+    if (fabs(fast_lux - ab_status.last_lux) >= hysteresis) {
+        /*
+         * Average should settle near the last reported lux. If
+         * it hasn't made it there yet, continue debouncing.
+         */
+        next = AB_STATE_DEBOUNCE;
+        *delay_ms = DEBOUNCE_MS;
+    }
+
+    return next;
+}
+
+static gboolean ab_process(gpointer unused)
+{
+    guint delay = 0;
+
+    ab_status.source_id = 0;
+
+    switch (ab_status.state) {
+    case AB_STATE_DISABLED:
+    case AB_STATE_INITIALIZING:
+    case AB_STATE_IDLE:
+        /* Nothing to do */
+        break;
+    case AB_STATE_DEBOUNCE:
+        ab_status.state = process_state_debounce(&delay);
+        break;
+    default:
+        powerd_warn("Unexpected autobrightness state %d\n", ab_status.state);
+        ab_status.state = AB_STATE_IDLE;
+        break;
+    }
+
+    if (delay != 0 && ab_status.state != AB_STATE_IDLE)
+        ab_status.source_id = g_timeout_add(delay, ab_process, NULL);
+    return FALSE;
+}
+
+static gboolean handle_new_lux(gpointer data)
+{
+    gint64 now;
+    double lux;
+
+    if (!ab_supported)
+        return FALSE;
+
+    now = get_ms();
+    lux = *(double *)data;
+    g_free(data);
+
+    if (ab_status.state == AB_STATE_DISABLED)
+        return FALSE;
+
+    if (ab_status.state == AB_STATE_INITIALIZING) {
+        int brightness = (int)(spline_interpolate(ab_spline, lux) + 0.5);
+        powerd_debug("set brightness %d", brightness);
+        powerd_set_brightness(brightness);
+
+        ab_status.average_slow = lux;
+        ab_status.average_fast = lux;
+        ab_status.applied_lux = lux;
+        ab_status.state = AB_STATE_IDLE;
+    } else {
+        double time_delta;
+        /* Ignore duplicates */
+        if (lux == ab_status.last_lux)
+            return FALSE;
+        time_delta = (double)(now - ab_status.last_lux_ms);
+        ab_status.average_slow = aggregate_lux(ab_status.average_slow, lux,
+                                               SMOOTHING_FACTOR_SLOW,
+                                               time_delta);
+        ab_status.average_fast = aggregate_lux(ab_status.average_fast, lux,
+                                               SMOOTHING_FACTOR_FAST,
+                                               time_delta);
+    }
+    ab_status.last_lux = lux;
+    ab_status.last_lux_ms = now;
+
+    if (ab_status.state == AB_STATE_IDLE) {
+        ab_status.state = AB_STATE_DEBOUNCE;
+        ab_status.source_id = g_timeout_add(DEBOUNCE_MS, ab_process, NULL);
+    }
+
+    return FALSE;
+}
+
+void powerd_new_als_event(double lux)
+{
+    double *p_lux = g_memdup(&lux, sizeof(lux));
+    g_timeout_add(0, handle_new_lux, p_lux);
+}
+
+/* Must be run from main loop */
+void powerd_autobrightness_enable(void)
+{
+    /* Must not leave disabled state if we can't map lux to brightness */
+    if (!ab_supported)
+        return;
+
+    if (ab_status.state == AB_STATE_DISABLED) {
+        ab_status.state = AB_STATE_INITIALIZING;
+        powerd_sensors_als_enable();
+    }
+}
+
+/* Must be run from main loop */
+void powerd_autobrightness_disable(void)
+{
+    if (ab_status.state != AB_STATE_DISABLED) {
+        ab_status.state = AB_STATE_DISABLED;
+        powerd_sensors_als_disable();
+        if (ab_status.source_id != 0)
+            g_source_remove(ab_status.source_id);
+    }
+}
+
+int powerd_autobrightness_init(void)
+{
+    GValue v = G_VALUE_INIT;
+    GArray *levels = NULL, *lux = NULL;
+    double (*mappings)[2] = NULL;
+    int i;
+    int ret = -ENODEV;
+
+    if (device_config_get("automatic_brightness_available", &v)) {
+        powerd_info("Could not determine platform autobrightness capability, disabling");
+        goto error;
+    }
+
+    if (!G_VALUE_HOLDS_BOOLEAN(&v) || !g_value_get_boolean(&v)) {
+        powerd_info("Platform does not support autobrightness, disabling");
+        goto error;
+    }
+    g_value_unset(&v);
+
+    if (device_config_get("autoBrightnessLevels", &v)) {
+        powerd_info("No device-specific autobrightness lux table defined, disabling");
+        goto error;
+    }
+    if (G_VALUE_HOLDS_BOXED(&v))
+        lux = g_value_dup_boxed(&v);
+    g_value_unset(&v);
+    if (!lux || lux->len == 0) {
+        powerd_info("Invalid autobrighness lux levels, disabling");
+        goto error;
+    }
+
+    if (device_config_get("autoBrightnessLcdBacklightValues", &v)) {
+        powerd_info("No device-specific autobrightness backlight levels defined, disabling");
+        goto error;
+    }
+    if (G_VALUE_HOLDS_BOXED(&v))
+        levels = g_value_dup_boxed(&v);
+    g_value_unset(&v);
+    if (!levels || levels->len == 0) {
+        powerd_info("Invalid autobrighness backlight levels, disabling");
+        goto error;
+    }
+
+    /* We should have one more backlight level than lux values */
+    if (levels->len != lux->len + 1) {
+        powerd_info("Invalid lux->brightness mappings, autobrightness disabled");
+        goto error;
+    }
+
+    mappings = g_malloc(2 * sizeof(double) * levels->len);
+    for (i = 0; i < levels->len; i++) {
+        mappings[i][0] = (double)((i == 0) ? 0 : g_array_index(lux, guint, i-1));
+        mappings[i][1] = (double)g_array_index(levels, guint, i);
+    }
+
+    ab_status.state = AB_STATE_DISABLED;
+    ab_spline = spline_new(mappings, levels->len);
+    if (!ab_spline) {
+        ret = -ENOMEM;
+        goto error;
+    }
+    g_free(mappings);
+    ab_supported = TRUE;
+    return 0;
+
+error:
+    if (levels)
+        g_array_unref(levels);
+    if (lux)
+        g_array_unref(lux);
+    if (mappings)
+        g_free(mappings);
+    return ret;
+}
+
+void powerd_autobrightness_deinit(void)
+{
+    powerd_autobrightness_disable();
+    ab_supported = FALSE;
+    if (ab_spline)
+        spline_free(ab_spline);
+}

=== added file 'src/device-config.c'
--- src/device-config.c	1970-01-01 00:00:00 +0000
+++ src/device-config.c	2013-08-29 21:23:26 +0000
@@ -0,0 +1,407 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib-object.h>
+#include <hybris/properties/properties.h>
+
+#include "powerd-internal.h"
+#include "device-config.h"
+#include "log.h"
+
+/*
+ * Android defines various device-specific parameters in files named
+ * config.xml. The general structure of the tags is:
+ *
+ *   <type name="config_foo">...</type>
+ *
+ * This will define a config option named "foo" of type "type". Types
+ * for arrays are included. For example, the following defines an
+ * array of integers:
+ *
+ *   <integer-array name="config_myIntArray">
+ *     <item>0</item>
+ *     <item>1</item>
+ *   </integer-array>
+ *
+ * In powerd we are only interested in a few specific variables. The
+ * code here offers fairly general parsing of the config files, but
+ * handling of only a few specific types is present.
+ */
+
+enum elem_type {
+    ELEM_TYPE_NONE,
+    ELEM_TYPE_BOOL,
+    ELEM_TYPE_INT,
+    ELEM_TYPE_STRING,
+    ELEM_TYPE_FRACTION,
+    ELEM_TYPE_DIMENSION,
+    ELEM_TYPE_INT_ARRAY,
+    ELEM_TYPE_STRING_ARRAY,
+    ELEM_TYPE_ITEM,
+
+    NUM_ELEM_TYPES
+};
+
+static const char *elem_strs[NUM_ELEM_TYPES] = {
+    [ELEM_TYPE_BOOL]          = "bool",
+    [ELEM_TYPE_INT]           = "integer",
+    [ELEM_TYPE_STRING]        = "string",
+    [ELEM_TYPE_FRACTION]      = "fraction",
+    [ELEM_TYPE_DIMENSION]     = "dimen",
+    [ELEM_TYPE_INT_ARRAY]     = "integer-array",
+    [ELEM_TYPE_STRING_ARRAY]  = "string-array",
+    [ELEM_TYPE_ITEM]          = "item",
+};
+
+struct parser_state {
+    enum elem_type type;
+    gboolean in_item;
+    gchar *name;
+    GValue value;
+};
+
+static struct parser_state state = {
+    .value = G_VALUE_INIT,
+};
+static GHashTable *config_hash;
+
+static enum elem_type get_elem_type(const gchar *name)
+{
+    int i;
+    for (i = 0; i < NUM_ELEM_TYPES; i++) {
+        if (elem_strs[i] && !strcmp(name, elem_strs[i]))
+            break;
+    }
+    if (i >= NUM_ELEM_TYPES)
+        return ELEM_TYPE_NONE;
+    return i;
+}
+
+static const gchar *get_elem_name(const gchar **attr_names,
+                                  const gchar **attr_values)
+{
+    int i;
+    for (i = 0; attr_names[i]; i++) {
+        if (!strcmp(attr_names[i], "name"))
+            break;
+    }
+    if (!attr_names[i])
+        return NULL;
+    return attr_values[i];
+}
+
+static void on_start_elem(GMarkupParseContext *context, const gchar *name,
+                          const gchar **attr_names, const gchar **attr_values,
+                          gpointer user_data, GError **error)
+{
+    const gchar *config_name;
+    enum elem_type type;
+
+    type = get_elem_type(name);
+    if (type == ELEM_TYPE_NONE)
+        return;
+    if (type == ELEM_TYPE_ITEM) {
+        if (state.type == ELEM_TYPE_INT_ARRAY ||
+            state.type == ELEM_TYPE_STRING_ARRAY)
+            state.in_item = TRUE;
+        return;
+    }
+    if (state.type != ELEM_TYPE_NONE) {
+        g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
+                    "Nested elements not supported");
+        return;
+    }
+
+    config_name = get_elem_name(attr_names, attr_values);
+    if (!config_name)
+        return;
+    /* Strip leading "config_" if present, not all vars have it */
+    if (!strncmp(config_name, "config_", 7))
+        config_name += 7;
+
+    switch (type) {
+    case ELEM_TYPE_BOOL:
+        g_value_init(&state.value, G_TYPE_BOOLEAN);
+        break;
+    case ELEM_TYPE_INT:
+        g_value_init(&state.value, G_TYPE_UINT);
+        break;
+    case ELEM_TYPE_INT_ARRAY:
+        {
+            GArray *a;
+            g_value_init(&state.value, G_TYPE_ARRAY);
+            a = g_array_new(FALSE, FALSE, sizeof(guint32));
+            g_value_set_boxed(&state.value, a);
+            break;
+        }
+    default:
+        /* Type not supported at this time */
+        return;
+    }
+
+    state.type = type;
+    state.in_item = FALSE;
+    state.name = g_strdup(config_name);
+}
+
+static void on_end_elem(GMarkupParseContext *context, const gchar *name,
+                        gpointer user_data, GError **error)
+{
+    enum elem_type type;
+    GValue *value;
+
+    if (state.type == ELEM_TYPE_NONE)
+        return;
+
+    type = get_elem_type(name);
+    if (type == ELEM_TYPE_NONE)
+        return;
+    if (type == ELEM_TYPE_ITEM) {
+        state.in_item = FALSE;
+        return;
+    }
+
+    if (type == state.type) {
+        value = g_new0(GValue, 1);
+        g_value_init(value, G_VALUE_TYPE(&state.value));
+        g_value_copy(&state.value, value);
+        g_hash_table_replace(config_hash, state.name, value);
+        /* Note: state.name is not freed as it is used for hash table key */
+    } else {
+        g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
+                    "Start and end element types don't match");
+        g_free(state.name);
+    }
+
+    state.type = ELEM_TYPE_NONE;
+    state.name = NULL;
+    g_value_unset(&state.value);
+}
+
+/* WARNING: pt_text is not nul-terminated */
+static void on_text(GMarkupParseContext *context, const gchar *pt_text,
+                    gsize text_len, gpointer user_data, GError **error)
+{
+    gchar *text = g_strndup(pt_text, text_len);
+    switch (state.type) {
+    case ELEM_TYPE_BOOL:
+        {
+            gboolean value;
+            if (!G_VALUE_HOLDS_BOOLEAN(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = !g_ascii_strcasecmp(text, "true");
+            g_value_set_boolean(&state.value, value);
+            break;
+        }
+    case ELEM_TYPE_INT:
+        {
+            guint value;
+            gchar *endp;
+            if (!G_VALUE_HOLDS_UINT(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = (guint)g_ascii_strtoll(text, &endp, 0);
+            if (endp - text == text_len)
+                g_value_set_uint(&state.value, value);
+            break;
+        }
+    case ELEM_TYPE_INT_ARRAY:
+        {
+            GArray *a;
+            guint value;
+            gchar *endp;
+            if (!state.in_item)
+                break;
+            if (!G_VALUE_HOLDS_BOXED(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = (guint)g_ascii_strtoll(text, &endp, 0);
+            if (endp - text == text_len) {
+                a = g_value_get_boxed(&state.value);
+                g_array_append_val(a, value);
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    g_free(text);
+}
+
+static GMarkupParser parser = {
+    .start_element  = on_start_elem,
+    .end_element    = on_end_elem,
+    .text           = on_text,
+};
+
+static void config_hash_destroy_key(gpointer data)
+{
+    g_free(data);
+}
+
+static void config_hash_destroy_value(gpointer data)
+{
+    GValue *v = data;
+    if (G_VALUE_HOLDS_BOXED(v)) {
+        /* Currently only boxed data is arrays */
+        GArray *a = g_value_get_boxed(v);
+        g_array_free(a, TRUE);
+    }
+    g_value_unset(v);
+    g_free(v);
+}
+
+static int process_config(const char *fname)
+{
+    int fd, ret = 0;
+    gchar *buf = NULL;
+    int buf_len;
+    ssize_t len;
+    GMarkupParseContext *context = NULL;
+    GError *error;
+
+    fd = open(fname, O_RDONLY);
+    if (fd == -1) {
+        powerd_warn("Could not open device config %s: %s",
+                    fname, strerror(errno));
+        return -errno;
+    }
+
+    buf_len = (int)sysconf(_SC_PAGESIZE);
+    buf = malloc(buf_len);
+    if (!buf) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    context = g_markup_parse_context_new(&parser, 0, NULL, NULL);
+    do {
+        len = read(fd, buf, buf_len);
+        if (len == 0)
+            break;
+        if (len == -1) {
+            if (errno == EINTR)
+                continue;
+            powerd_warn("Error reading %s: %s", fname, strerror(errno));
+            ret = -errno;
+            break;
+        }
+
+        error = NULL;
+        if (!g_markup_parse_context_parse(context, buf, len, &error)) {
+            powerd_warn("Failed parsing device config %s\n", fname);
+            if (error) {
+                powerd_warn("%s", error->message);
+                g_error_free(error);
+            }
+            ret = -EIO;
+        }
+    } while (!ret);
+
+out:
+    if (context)
+        g_markup_parse_context_free(context);
+    if (buf)
+        free(buf);
+    close(fd);
+    return ret;
+}
+
+/*
+ * Get the device config option specified by @name. The leading
+ * "config_" characters should be stripped from the name if present.
+ * Returns 0 if the given variable is found.
+ *
+ * @value should be an initialized GValue. On success, the value of
+ * the variable will be copied to the GValue, and the caller is
+ * responsible for freeing the memory. E.g.:
+ *
+ *   GValue v = G_VALUE_INIT;
+ *   if (!device_config_get("myVar", &v)) {
+ *       do_something_with_value(&v);
+ *       g_value_unset(&v);
+ *   }
+ */
+int device_config_get(const char *name, GValue *value)
+{
+    GValue *v;
+
+    if (!config_hash)
+        return -ENODEV;
+
+    v = g_hash_table_lookup(config_hash, name);
+    if (!v)
+        return -ENOENT;
+
+    g_value_init(value, G_VALUE_TYPE(v));
+    g_value_copy(v, value);
+    return 0;
+}
+
+void device_config_init(void)
+{
+    char device[PROP_VALUE_MAX];
+    char *xml_path;
+
+    if (!property_get("ro.product.device", device, NULL)) {
+        powerd_warn("Could not determine device, running without config");
+        return;
+    }
+    powerd_info("Running on %s\n", device);
+
+    config_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+                                        config_hash_destroy_key,
+                                        config_hash_destroy_value);
+
+    /*
+     * Always start with config-default.xml for defaults, then
+     * the device-specific config
+     */
+    if (process_config(POWERD_DEVICE_CONFIGS_PATH "/config-default.xml"))
+        goto error;
+    xml_path = g_strdup_printf("%s/config-%s.xml",
+                               POWERD_DEVICE_CONFIGS_PATH, device);
+    if (process_config(xml_path))
+        goto error;
+    g_free(xml_path);
+    return;
+
+error:
+    device_config_deinit();
+}
+
+void device_config_deinit(void)
+{
+    if (config_hash) {
+        g_hash_table_destroy(config_hash);
+        config_hash = NULL;
+    }
+}

=== added file 'src/device-config.h'
--- src/device-config.h	1970-01-01 00:00:00 +0000
+++ src/device-config.h	2013-08-29 21:23:26 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __DEVICE_CONFIG_H__
+#define __DEVICE_CONFIG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void device_config_init(void);
+void device_config_deinit(void);
+int device_config_get(const char *name, GValue *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __DEVICE_CONFIG_H__ */

=== modified file 'src/display.c'
--- src/display.c	2013-07-29 16:05:34 +0000
+++ src/display.c	2013-08-29 21:23:26 +0000
@@ -36,11 +36,17 @@
 
 #include "powerd.h"
 #include "powerd-internal.h"
+#include "device-config.h"
 #include "log.h"
 
 /* Treat "don't care" display state as off */
 #define DISPLAY_STATE_OFF POWERD_DISPLAY_STATE_DONT_CARE
 
+/* Autobrightness only enabled when bright && !disabled */
+#define AB_ENABLED_MASK (POWERD_DISPLAY_FLAG_BRIGHT | \
+                         POWERD_DISPLAY_FLAG_DISABLE_AUTOBRIGHTNESS)
+#define AB_ENABLED      POWERD_DISPLAY_FLAG_BRIGHT
+
 static gint saved_brightness = 255;
 static gint target_brightness;
 static gint dim_brightness;
@@ -92,10 +98,18 @@
     return display_state_strs[state];
 }
 
-static void turn_on_display(void) {
+static gboolean ab_enabled(guint32 flags)
+{
+    return (flags & AB_ENABLED_MASK) == AB_ENABLED;
+}
+
+static void turn_on_display(gboolean autobrightness) {
     powerd_debug("turning on display");
     sf_unblank(0);
-    powerd_set_brightness(target_brightness);
+    if (autobrightness)
+        powerd_autobrightness_enable();
+    else
+        powerd_set_brightness(target_brightness);
 }
 
 gboolean powerd_display_enabled(void)
@@ -127,19 +141,25 @@
 static void update_display_state(struct powerd_display_request *req)
 {
     enum powerd_display_state state = req->state;
+    gboolean use_ab, using_ab;
     int applied_state;
     int ret;
     int hw_brightness;
 
+    use_ab = ab_enabled(req->flags);
+    using_ab = ab_enabled(internal_state.flags);
+
     hw_brightness = powerd_get_brightness();
     if (hw_brightness < 0)
         hw_brightness = saved_brightness;
 
-    if ((internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT) &&
-        (hw_brightness != 0))
+    if (!using_ab && hw_brightness != 0 &&
+        (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT))
         saved_brightness = hw_brightness;
-    target_brightness = get_target_brightness((!!(req->flags & POWERD_DISPLAY_FLAG_BRIGHT)),
-            hw_brightness);
+    if (!use_ab)
+        target_brightness = get_target_brightness(
+                    !!(req->flags & POWERD_DISPLAY_FLAG_BRIGHT),
+                    hw_brightness);
 
     applied_state = screen_off_overrides ? DISPLAY_STATE_OFF : state;
 
@@ -151,6 +171,8 @@
         }
 
         powerd_debug("turning off display");
+        if (using_ab)
+            powerd_autobrightness_disable();
         powerd_set_brightness(0);
         sf_blank(0);
 
@@ -179,12 +201,21 @@
              * Otherwise we can turn on the screen right away.
              */
             if (fb_state == FB_AWAKE)
-                turn_on_display();
+                turn_on_display(use_ab);
         } else {
             /* Only changing brightness */
-            if ((req->flags & POWERD_DISPLAY_FLAG_BRIGHT) !=
-                (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT))
-                powerd_set_brightness(target_brightness);
+            if (use_ab) {
+                if (!using_ab)
+                    powerd_autobrightness_enable();
+            } else {
+                if (using_ab) {
+                    powerd_autobrightness_disable();
+                    powerd_set_brightness(target_brightness);
+                } else if ((req->flags & POWERD_DISPLAY_FLAG_BRIGHT) !=
+                           (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT)) {
+                    powerd_set_brightness(target_brightness);
+                }
+            }
         }
         break;
     default:
@@ -198,7 +229,6 @@
 static void update_flags(guint32 flags)
 {
     int prox_enabled, internal_prox_enabled;
-    /* XXX: Handle autobrightness flag */
 
     prox_enabled = (flags & POWERD_DISPLAY_FLAG_USE_PROXIMITY);
     internal_prox_enabled = (internal_state.flags & POWERD_DISPLAY_FLAG_USE_PROXIMITY);
@@ -323,7 +353,7 @@
     fb_state = (enum fb_state)data;
     powerd_debug("fb state %s", fb_state == FB_SLEEP ? "sleep" : "awake");
     if (fb_state == FB_AWAKE && powerd_display_enabled())
-        turn_on_display();
+        turn_on_display(ab_enabled(internal_state.flags));
     return FALSE;
 }
 
@@ -350,14 +380,17 @@
 int powerd_display_init(void)
 {
     GError *error;
+    GValue v = G_VALUE_INIT;
     int brightness, max_brightness;
 
     /*
      * Warning: much hand waving follows
      *
      * Right now there's no coherent system brightness policy, so we
-     * just do the best we can. For "dim" brightness we just go with
-     * 5% of maximum. For "bright" brightness, it's more complicated.
+     * just do the best we can. For "dim" brightness we try to read
+     * the value from the Android config files, otherwise we just go
+     * with 5% of maximum. For "bright" brightness, it's more
+     * complicated.
      *
      * Our first preference for the bright value is whatever the screen
      * is currently set to. However, the screen could be off or dimmed
@@ -365,15 +398,23 @@
      * happens.
      */
 
+    if (!device_config_get("screenBrightnessDim", &v)) {
+        if (G_VALUE_HOLDS_UINT(&v))
+            dim_brightness = (int)g_value_get_uint(&v);
+        g_value_unset(&v);
+    }
+
     max_brightness = powerd_get_max_brightness();
 
     if (max_brightness <= 0) {
         powerd_warn("Could not read maximum brightness, guessing at dim/bright values");
-        dim_brightness = 5;
         saved_brightness = 100;
+        if (dim_brightness == 0)
+            dim_brightness = 5;
     } else {
-        dim_brightness = max_brightness / 20;
         saved_brightness = (3 * max_brightness) / 4;
+        if (dim_brightness == 0)
+            dim_brightness = max_brightness / 20;
     }
 
     brightness = powerd_get_brightness();

=== modified file 'src/powerd-internal.h'
--- src/powerd-internal.h	2013-08-12 04:45:17 +0000
+++ src/powerd-internal.h	2013-08-29 21:23:26 +0000
@@ -57,6 +57,13 @@
 void powerd_dbus_init_complete(void);
 int powerd_is_mainloop(void);
 
+/* Autobrightness functions */
+void powerd_new_als_event(double lux);
+void powerd_autobrightness_enable(void);
+void powerd_autobrightness_disable(void);
+int powerd_autobrightness_init(void);
+void powerd_autobrightness_deinit(void);
+
 /* Backlight functions */
 int powerd_backlight_init(void);
 void powerd_backlight_deinit(void);
@@ -147,6 +154,8 @@
 /* Sensor functions */
 void powerd_sensors_proximity_enable(void);
 void powerd_sensors_proximity_disable(void);
+void powerd_sensors_als_enable(void);
+void powerd_sensors_als_disable(void);
 
 /* Power source functions */
 int powerd_ps_init(void);

=== modified file 'src/powerd-sensors.cpp'
--- src/powerd-sensors.cpp	2013-06-07 23:02:23 +0000
+++ src/powerd-sensors.cpp	2013-08-29 21:23:26 +0000
@@ -21,10 +21,13 @@
 
 #include "powerd-internal.h"
 #include "powerd-sensors.h"
+#include "log.h"
 
+#include <ubuntu/application/sensors/light.h>
 #include <ubuntu/application/sensors/proximity.h>
 
 UASensorsProximity* prox_sensor;
+UASensorsLight* light_sensor;
 
 void on_new_proximity_event(UASProximityEvent *event, void *context)
 {
@@ -53,13 +56,40 @@
     ua_sensors_proximity_disable(prox_sensor);
 }
 
+void on_new_als_event(UASLightEvent *event, void *context)
+{
+    float lux = uas_light_event_get_light(event);
+    powerd_new_als_event(lux);
+}
+
+void powerd_sensors_als_enable(void)
+{
+    if (light_sensor)
+        ua_sensors_light_enable(light_sensor);
+}
+
+void powerd_sensors_als_disable(void)
+{
+    if (light_sensor)
+        ua_sensors_light_disable(light_sensor);
+}
+
 void powerd_sensors_init(void)
 {
     prox_sensor = ua_sensors_proximity_new();
-
     if (prox_sensor != NULL) {
         ua_sensors_proximity_set_reading_cb(prox_sensor,
                                             on_new_proximity_event,
                                             NULL);
+    } else {
+        powerd_warn("Failed to allocate proximity sensor");
+    }
+
+    light_sensor = ua_sensors_light_new();
+    if (light_sensor) {
+        ua_sensors_light_set_reading_cb(light_sensor, on_new_als_event,
+                                        NULL);
+    } else {
+        powerd_warn("Failed to allocate ambient light sensor");
     }
 }

=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2013-08-09 19:53:58 +0000
+++ src/powerd.cpp	2013-08-29 21:23:26 +0000
@@ -40,6 +40,7 @@
 #include "powerd-object.h"
 #include "powerd-dbus.h"
 #include "powerd-sensors.h"
+#include "device-config.h"
 #include "log.h"
 
 #include <hybris/input/input_stack_compatibility_layer.h>
@@ -471,6 +472,9 @@
     powerd_debug("Activity Timeout is %d seconds\n", activity_timeout);
     powerd_debug("Auto-dim Timeout is %d seconds\n", dim_timeout);
 
+    /* Init this first, data is used by other inits */
+    device_config_init();
+
     libsuspend_init(0);
     powerd_stats_init();
     powerd_client_init();
@@ -478,6 +482,7 @@
     display_request_init();
     dbus_name_watch_init();
     powerd_backlight_init();
+    powerd_autobrightness_init();
     powerd_display_init();
     powerd_sensors_init();
     powerd_ps_init();
@@ -497,6 +502,9 @@
     android_input_stack_initialize(&listener, &config);
     android_input_stack_start();
 
+    /* Config use should be done during init, okay to free now */
+    device_config_deinit();
+
     /* This needs to be the first thing to run on the main loop */
     g_idle_add_full(G_PRIORITY_HIGH, main_init, NULL, NULL);
 
@@ -509,6 +517,7 @@
 
     powerd_ps_deinit();
     dbus_name_watch_deinit();
+    powerd_autobrightness_deinit();
     powerd_backlight_deinit();
     display_request_deinit();
     power_request_deinit();

=== added file 'src/spline.c'
--- src/spline.c	1970-01-01 00:00:00 +0000
+++ src/spline.c	2013-08-29 21:23:26 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct spline_params {
+    double k, m;
+};
+
+struct spline {
+    double (*points)[2];
+    int n;
+    struct spline_params params[0];
+};
+
+int spline_sort_comp(const void *a, const void *b)
+{
+    double x1 = *(double *)a;
+    double x2 = *(double *)b;
+    return (int)(x1 - x2);
+}
+
+/*
+ * Initializes a monotone cubic Hermite spline for interpolating
+ * between the input points, using the Fritsch–Carlson method.
+ *
+ *   http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+ *
+ * The interpolated points are guaranteed to have piecewise
+ * monotonicity, and will be fully monotone if the input points
+ * are monotone.
+ */
+struct spline *spline_new(double (*points)[2], int num_points)
+{
+    struct spline *s;
+    struct spline_params *param;
+    double (*p)[2];
+    int i;
+    double alpha, beta, prev_beta;
+
+    s = malloc(sizeof(struct spline) +
+               sizeof(struct spline_params) * num_points);
+    if (!s)
+        return NULL;
+    s->points = malloc(2 * sizeof(double) * num_points);
+    if (!s->points) {
+        free(s);
+        return NULL;
+    }
+    s->n = num_points;
+
+    /*
+     * Input points are likely to already be in order of increasing
+     * x, but sort them just in case.
+     */
+    memcpy(s->points, points, 2 * sizeof(double) * num_points);
+    qsort(s->points, num_points, 2 * sizeof(double), spline_sort_comp);
+
+    p = s->points;
+    param = s->params;
+
+    for (i = 0; i < s->n - 1; i++)
+        param[i].k = (p[i+1][1] - p[i][1]) / (p[i+1][0] - p[i][0]);
+
+    param[0].m = param[0].k;
+    for (i = 1; i < s->n; i++)
+        param[i].m = (param[i-1].k + param[i].k) / 2;
+    param[s->n - 1].m = param[s->n - 2].k;
+
+    beta = 0;
+    for (i = 0; i < s->n - 1; i++) {
+        if (p[i][1] == p[i+1][1]) {
+            param[i].m = 0;
+            param[++i].m = 0;
+            beta = 0;
+            continue;
+        }
+        prev_beta = beta;
+        alpha = param[i].m / param[i].k;
+        beta = param[i+1].m / param[i].k;
+        if (alpha < 0 || prev_beta < 0) {
+            param[i].m = 0;
+            continue;
+        }
+        if (alpha > 3)
+            param[i].m = 3 * param[i].k;
+        if (beta > 3)
+            param[i+1].m = 3 * param[i].k;
+    }
+
+    return s;
+}
+
+void spline_free(struct spline *s)
+{
+    free(s->points);
+    free(s);
+}
+
+double spline_interpolate(struct spline *s, double x)
+{
+    int i;
+    double h, t, ret;
+
+    for (i = 0; i < s->n - 1; i++) {
+        if (x >= s->points[i][0] && x < s->points[i+1][0])
+            break;
+    }
+
+    /* Handle out-of-bounds and boundary cases */
+    if (i == 0 && x <= s->points[0][0])
+        return s->points[0][1];
+    if (i >= s->n - 1)
+        return s->points[s->n - 1][1];
+
+    h = s->points[i+1][0] - s->points[i][0];
+    t = (x - s->points[i][0]) / h;
+    ret = s->points[i][1] * (1 + t * t * (2 * t - 3));
+    ret += h * s->params[i].m * t * (1 + t * (t - 2));
+    ret += s->points[i+1][1] * t * t * (3 - 2 * t);
+    ret += h * s->params[i+1].m * t * t * (t - 1);
+    return ret;
+}

=== added file 'src/spline.h'
--- src/spline.h	1970-01-01 00:00:00 +0000
+++ src/spline.h	2013-08-29 21:23:26 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * powerd is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SPLINE_H__
+#define __SPLINE_H__
+
+struct spline;
+
+struct spline *spline_new(double (*points)[2], int num_points);
+void spline_free(struct spline *s);
+double spline_interpolate(struct spline *s, double x);
+
+#endif