Merge lp:~phablet-team/powerd/dbus-stuff into lp:powerd

[Matt Fischer]

Massive influx of changes including:
1) control file cleanup and new deps
2) support for listening for power requests on dbus
3) tie in to seth's low level libsuspend code
4) a simple C based test client for the power requests

Massive influx of changes including:
1) control file cleanup and new deps
2) support for listening for power requests on dbus
3) tie in to seth's low level libsuspend code
4) a simple C based test client for the power requests

What did not land:
1) full internal use of power state requests, for example, the activity timer could hold an active request until it expired. Seth is working on this now, but it will not impact the functionality

We have more work to do before we move on to display power states but we should merge this and release now or the merges will get larger and larger.

No new changelog entry, we can discuss whether we're releasing this tomorrow.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:32
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~phablet-team/powerd/dbus-stuff/+merge/164811/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/powerd-ci/4/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-raring-armhf-ci/4

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

review: Needs Fixing (continuous-integration)

[lp:~phablet-team/powerd/dbus-stuff]

33. By Matt Fischer on 2013-05-20

removing bzrignore which should not be committed

34. By Matt Fischer on 2013-05-21

merging seth's changes also remove the debug line from the find function, it's too chatty

35. By Matt Fischer on 2013-05-21

Adding more debug info by printing the string and not the number in most
places, some whitespace cleanup

36. By Matt Fischer on 2013-05-21

fixing merge mistake

37. By Matt Fischer on 2013-05-21

update changelog

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:36
http://jenkins.qa.ubuntu.com/job/powerd-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-raring-armhf-ci/5

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:37
http://jenkins.qa.ubuntu.com/job/powerd-ci/6/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-raring-armhf-ci/6

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

review: Approve (continuous-integration)

[Michael Frey (mfrey)]

Tested. All working well. Approved.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-02-13 17:41:38 +0000
+++ CMakeLists.txt	2013-05-21 14:54:26 +0000
@@ -1,39 +1,78 @@
 project(powerd)
+cmake_minimum_required(VERSION 2.8.9)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -ggdb -g")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -ggdb -g")
+
+set(GDBUS_NAME powerd-dbus)
+
+find_package(PkgConfig)
+pkg_check_modules(GLIB glib-2.0)
+pkg_check_modules(GUDEV gudev-1.0)
+pkg_check_modules(GIO gio-2.0)
+pkg_check_modules(GIO-UNIX gio-unix-2.0)
+
+set(POWERD_GENERATED_SOURCES
+  ${GDBUS_NAME}.c
+)
+set(POWERD_GENERATED_HEADERS
+  ${GDBUS_NAME}.h
+)
+SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/src/${POWERD_GENERATED_SOURCES} PROPERTIES GENERATED 1)
 
 set(
   SRCS
 
   src/powerd.cpp
+  src/powerd-object.c
+  src/power-request.c
+  src/${GDBUS_NAME}.c
 )
 
-find_package(PkgConfig)
-pkg_check_modules(GLIB glib-2.0)
-pkg_check_modules(GUDEV gudev-1.0)
-
 link_directories(
   ${GLIB_LIBRARY_DIRS}
+  ${GIO_LIBRARY_DIRS}
+  ${GIO-UNIX_LIBRARY_DIRS}
   ${GUDEV_LIBRARY_DIRS}
 )
 
 include_directories(
   ${GLIB_INCLUDE_DIRS}
+  ${GIO_INCLUDE_DIRS}
+  ${GIO-UNIX_INCLUDE_DIRS}
   ${GUDEV_INCLUDE_DIRS}
+  ${PROJECT_SOURCE_DIR}/libsuspend
+  ${CMAKE_CURRENT_BINARY_DIR}/src
 )
 
+add_subdirectory(libsuspend)
+add_subdirectory(src)
+add_subdirectory(testclient)
+
 add_executable(
   powerd
 
   ${SRCS}
 )
 
+add_dependencies(
+  powerd
+
+  dbus_bindings
+)
+
 target_link_libraries(
   powerd
+  suspend
 
   is
   sf
   hybris_ics
   ${GLIB_LIBRARIES}
   ${GUDEV_LIBRARIES}
+  ${GIO_LIBRARIES}
+  ${GIO-UNIX_LIBRARIES}
 )
 
 install(

=== added directory 'cmake'
=== added file 'cmake/COPYING-CMAKE-SCRIPTS'
--- cmake/COPYING-CMAKE-SCRIPTS	1970-01-01 00:00:00 +0000
+++ cmake/COPYING-CMAKE-SCRIPTS	2013-05-21 14:54:26 +0000
@@ -0,0 +1,22 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products 
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== added file 'cmake/UseGdbusCodegen.cmake'
--- cmake/UseGdbusCodegen.cmake	1970-01-01 00:00:00 +0000
+++ cmake/UseGdbusCodegen.cmake	2013-05-21 14:54:26 +0000
@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 2.6)
+if(POLICY CMP0011)
+  cmake_policy(SET CMP0011 NEW)
+endif(POLICY CMP0011)
+
+find_program(GDBUS_CODEGEN NAMES gdbus-codegen DOC "gdbus-codegen executable")
+if(NOT GDBUS_CODEGEN)
+  message(FATAL_ERROR "Excutable gdbus-codegen not found")
+endif()
+
+function(add_gdbus_codegen)
+  set(_one_value OUTFILES NAME PREFIX NAMESPACE SERVICE_XML)
+  set(_multi_value DEPENDS)
+  cmake_parse_arguments (arg "" "${_one_value}" "${_multi_value}" ${ARGN})
+
+  if(arg_PREFIX)
+    set(PREFIX --interface-prefix ${arg_PREFIX})
+  endif()
+
+  if(arg_NAMESPACE)
+    set(NAMESPACE --c-namespace ${arg_NAMESPACE})
+  endif()
+
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.h" "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.c"
+    COMMAND "${GDBUS_CODEGEN}"
+        --generate-c-code "${arg_NAME}"
+        ${PREFIX}
+        ${NAMESPACE}
+        "${arg_SERVICE_XML}"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    DEPENDS ${arg_DEPENDS} "${arg_SERVICE_XML}"
+  )
+  set(${arg_OUTFILES} ${${arg_OUTFILES}} "${CMAKE_CURRENT_BINARY_DIR}/${arg_NAME}.c" PARENT_SCOPE)
+endfunction(add_gdbus_codegen)

=== added directory 'data'
=== added file 'data/com.canonical.powerd.xml'
--- data/com.canonical.powerd.xml	1970-01-01 00:00:00 +0000
+++ data/com.canonical.powerd.xml	2013-05-21 14:54:26 +0000
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<node name="/">
+  <interface name="com.canonical.powerd">
+    <!-- Properties -->
+
+    <!-- Functions -->
+    <method name="requestSysState">
+      <arg type="i" name="state" direction="in" />
+      <arg type="i" name="pid" direction="in" />
+      <arg type="u" name="cookie" direction="out" />
+    </method>
+
+    <method name="clearSysState">
+      <arg type="u" name="cookie" direction="in" />
+    </method>
+
+    <!-- for debug/testing -->
+    <method name="listSysRequests">
+      <arg type="a(si)" name="requestList" direction="out" /> 
+    </method>
+
+    <!-- Signals -->
+      <!-- None -->
+    </interface>
+</node>

=== modified file 'debian/changelog'
--- debian/changelog	2013-02-13 17:41:38 +0000
+++ debian/changelog	2013-05-21 14:54:26 +0000
@@ -1,3 +1,17 @@
+powerd (0.6) raring; urgency=low
+
+  [ Michael Frey ]
+  * Automatically suspend the device when inactive
+
+  [ Matthew Fischer ]
+  * Add dbus methods for requesting system power states
+
+  [ Seth Forshee ]
+  * Add a low-level platform-neutral suspend library
+  * Modify code internally to use system power requests
+
+ -- Matthew Fischer <[e-mail]>  Tue, 21 May 2013 08:45:06 -0600
+
 powerd (0.5) quantal; urgency=low
 
   * Dim / un-dim screen on suspend / resume.

=== modified file 'debian/control'
--- debian/control	2013-02-20 15:52:29 +0000
+++ debian/control	2013-05-21 14:54:26 +0000
@@ -8,11 +8,12 @@
                libgudev-1.0-dev,
                libhybris-dev,
                libgles2-mesa-dev,
+               python
 Standards-Version: 3.9.3
-Vcs-Bzr: lp:phablet-powerd
+Vcs-Bzr: lp:powerd
 
 Package: powerd
-Architecture: armel armhf
+Architecture: armhf
 Depends: ${misc:Depends}, ${shlibs:Depends}
 Description: Power daemon to monitor power button events.
  This daemon provides monitoring capabilities for the ubuntu phone

=== added file 'debian/install'
--- debian/install	1970-01-01 00:00:00 +0000
+++ debian/install	2013-05-21 14:54:26 +0000
@@ -0,0 +1,1 @@
+debian/powerd.conf etc/dbus-1/system.d/

=== added file 'debian/powerd.conf'
--- debian/powerd.conf	1970-01-01 00:00:00 +0000
+++ debian/powerd.conf	2013-05-21 14:54:26 +0000
@@ -0,0 +1,24 @@
+<!-- This configuration file specifies the required security policies
+     for powerd daemon to work. -->
+
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+
+  <!-- ../system.conf have denied everything, so we just punch some holes -->
+
+  <policy user="root">
+    <allow own="com.canonical.powerd"/>
+    <allow send_destination="com.canonical.powerd"/>
+    <allow send_interface="com.canonical.powerd"/>
+  </policy>
+
+  <policy at_console="true">
+    <allow send_destination="com.canonical.powerd"/>
+  </policy>
+
+  <policy context="default">
+    <deny send_destination="com.canonical.powerd"/>
+  </policy>
+
+</busconfig>

=== modified file 'debian/upstart'
--- debian/upstart	2012-11-01 04:56:16 +0000
+++ debian/upstart	2013-05-21 14:54:26 +0000
@@ -24,8 +24,10 @@
 export ANDROID_ROOT=/system
 export EXTERNAL_STORAGE=/mnt/sdcard
 export QT_PLUGIN_PATH=/opt/qt5/plugins
-
-        
+# for debugging purposes, remove when closer to shipping (mfisch)
+export G_MESSAGES_DEBUG=all
+
+
         exec /usr/bin/powerd
 
 end script

=== added directory 'libsuspend'
=== added file 'libsuspend/CMakeLists.txt'
--- libsuspend/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ libsuspend/CMakeLists.txt	2013-05-21 14:54:26 +0000
@@ -0,0 +1,12 @@
+set(CMAKE_C_FLAGS "-Wall -Werror -Wextra")
+
+add_library(
+  suspend
+
+  libsuspend.c
+  sysfs.c
+  autosleep.c
+  earlysuspend.c
+  legacy.c
+  mocksuspend.c
+)

=== added file 'libsuspend/autosleep.c'
--- libsuspend/autosleep.c	1970-01-01 00:00:00 +0000
+++ libsuspend/autosleep.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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 "common.h"
+#include "sysfs.h"
+
+static const char autosleep_path[] = "/sys/power/autosleep";
+static const char mem_str[] = "mem";
+static const char off_str[] = "off";
+
+static int autosleep_enter(void)
+{
+    int ret = sysfs_write(autosleep_path, mem_str, ARRAY_SIZE(mem_str) - 1);
+    return ret < 0 ? ret : 0;
+}
+
+static int autosleep_exit(void)
+{
+    int ret = sysfs_write(autosleep_path, mem_str, ARRAY_SIZE(off_str) - 1);
+    return ret < 0 ? ret : 0;
+}
+
+static const struct suspend_handler autosleep_handler = {
+    .enter = autosleep_enter,
+    .exit = autosleep_exit,
+};
+
+const struct suspend_handler *autosleep_detect(void)
+{
+    if (!sysfs_file_exists(autosleep_path))
+        return NULL;
+    return &autosleep_handler;
+}

=== added file 'libsuspend/common.h'
--- libsuspend/common.h	1970-01-01 00:00:00 +0000
+++ libsuspend/common.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,35 @@
+/*
+ * 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 SUSPENDIF_H
+#define SUSPENDIF_H
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+struct suspend_handler {
+	int (*prepare)(void);
+	int (*enter)(void);
+	int (*exit)(void);
+};
+
+const struct suspend_handler *autosleep_detect(void);
+const struct suspend_handler *earlysuspend_detect(void);
+const struct suspend_handler *legacy_detect(void);
+const struct suspend_handler *mocksuspend_detect(void);
+
+#endif /* SUSPENDIF_H */

=== added file 'libsuspend/earlysuspend.c'
--- libsuspend/earlysuspend.c	1970-01-01 00:00:00 +0000
+++ libsuspend/earlysuspend.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,55 @@
+/*
+ * 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 "common.h"
+#include "sysfs.h"
+
+static const char state_path[] = "/sys/power/state";
+static const char wakelock_path[] = "/sys/power/wake_lock";
+static const char autosleep_path[] = "/sys/power/autosleep";
+
+static const char mem_str[] = "mem";
+static const char on_str[] = "on";
+
+static int earlysuspend_enter(void)
+{
+    int ret = sysfs_write(state_path, mem_str, ARRAY_SIZE(mem_str) - 1);
+    return ret < 0 ? ret : 0;
+}
+
+static int earlysuspend_exit(void)
+{
+    int ret = sysfs_write(state_path, on_str, ARRAY_SIZE(on_str) - 1);
+    return ret < 0 ? ret : 0;
+}
+
+static const struct suspend_handler earlysuspend_handler = {
+    .enter = earlysuspend_enter,
+    .exit = earlysuspend_exit,
+};
+
+const struct suspend_handler *earlysuspend_detect(void)
+{
+    if (!sysfs_file_exists(autosleep_path) &&
+        sysfs_file_exists(wakelock_path) &&
+        sysfs_file_exists(state_path))
+        return &earlysuspend_handler;
+
+    return NULL;
+}

=== added file 'libsuspend/legacy.c'
--- libsuspend/legacy.c	1970-01-01 00:00:00 +0000
+++ libsuspend/legacy.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,82 @@
+/*
+ * 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 <string.h>
+#include "common.h"
+#include "sysfs.h"
+
+static const char state_path[] = "/sys/power/state";
+static const char wakelock_path[] = "/sys/power/wake_lock";
+static const char wakeup_count_path[] = "/sys/power/wakeup_count";
+static const char mem_str[] = "mem";
+
+#define WAKEUP_COUNT_LEN 64
+
+static int wakeup_count_supported, wakeup_count_valid;
+static char wakeup_count[WAKEUP_COUNT_LEN];
+
+static int legacy_prepare(void)
+{
+    int ret;
+
+    if (wakeup_count_supported) {
+        ret = sysfs_read(wakeup_count_path, wakeup_count, WAKEUP_COUNT_LEN);
+        if (ret < 0) {
+            wakeup_count_valid = 0;
+            return ret;
+        }
+        wakeup_count_valid = 1;
+    }
+
+    return 0;
+}
+
+static int legacy_enter(void)
+{
+    int ret;
+
+    if (wakeup_count_supported && wakeup_count_valid) {
+        wakeup_count_valid = 0;
+
+        ret = sysfs_write(wakeup_count_path, wakeup_count,
+                          strlen(wakeup_count));
+        if (ret < 0) {
+            /* Wakup happened since reading wakeup_count */
+            return ret;
+        }
+    }
+
+    ret = sysfs_write(state_path, mem_str, ARRAY_SIZE(mem_str) - 1);
+    return ret < 0 ? ret : 0;
+}
+
+static const struct suspend_handler legacy_handler = {
+    .prepare = legacy_prepare,
+    .enter = legacy_enter,
+};
+
+const struct suspend_handler *legacy_detect(void)
+{
+    if (sysfs_file_exists(state_path) && !sysfs_file_exists(wakelock_path)) {
+        wakeup_count_supported = sysfs_file_exists(wakeup_count_path);
+        return &legacy_handler;
+    }
+
+    return NULL;
+}

=== added file 'libsuspend/libsuspend.c'
--- libsuspend/libsuspend.c	1970-01-01 00:00:00 +0000
+++ libsuspend/libsuspend.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,78 @@
+/*
+ * 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 <errno.h>
+#include "libsuspend.h"
+#include "common.h"
+
+const struct suspend_handler *handler;
+
+void libsuspend_init(int force_mock)
+{
+    if (!force_mock) {
+        handler = autosleep_detect();
+        if (handler)
+            return;
+
+        handler = earlysuspend_detect();
+        if (handler)
+            return;
+
+        handler = legacy_detect();
+        if (handler)
+            return;
+
+        printf("No suspend interface detected, using mock suspend\n");
+    }
+
+    handler = mocksuspend_detect();
+}
+
+int libsuspend_prepare_suspend(void)
+{
+    if (!handler)
+        return -ENODEV;
+
+    if (handler->prepare)
+        return handler->prepare();
+
+    return 0;
+}
+
+int libsuspend_enter_suspend(void)
+{
+    if (!handler)
+        return -ENODEV;
+
+    if (handler->enter)
+        return handler->enter();
+
+    return 0;
+}
+
+int libsuspend_exit_suspend(void)
+{
+    if (!handler)
+        return -ENODEV;
+
+    if (handler->exit)
+        return handler->exit();
+
+    return 0;
+}

=== added file 'libsuspend/libsuspend.h'
--- libsuspend/libsuspend.h	1970-01-01 00:00:00 +0000
+++ libsuspend/libsuspend.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,35 @@
+/*
+ * 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 LIBSUSPEND_H
+#define LIBSUSPEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void libsuspend_init(int force_mock);
+int libsuspend_prepare_suspend(void);
+int libsuspend_enter_suspend(void);
+int libsuspend_exit_suspend(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBSUSPEND_H */

=== added file 'libsuspend/mocksuspend.c'
--- libsuspend/mocksuspend.c	1970-01-01 00:00:00 +0000
+++ libsuspend/mocksuspend.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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 "common.h"
+
+static int mocksuspend_prepare(void)
+{
+    printf("mocksuspend prepare\n");
+    return 0;
+}
+
+static int mocksuspend_enter(void)
+{
+    printf("mocksuspend enter\n");
+    return 0;
+}
+
+static int mocksuspend_exit(void)
+{
+    printf("mocksuspend exit\n");
+    return 0;
+}
+
+static const struct suspend_handler mocksuspend_handler = {
+    .prepare = mocksuspend_prepare,
+    .enter = mocksuspend_enter,
+    .exit = mocksuspend_exit,
+};
+
+const struct suspend_handler *mocksuspend_detect(void)
+{
+    return &mocksuspend_handler;
+}

=== added file 'libsuspend/sysfs.c'
--- libsuspend/sysfs.c	1970-01-01 00:00:00 +0000
+++ libsuspend/sysfs.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,62 @@
+/*
+ * 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 <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+int sysfs_file_exists(const char *path)
+{
+    return !access(path, F_OK);
+}
+
+int sysfs_read(const char *path, void *buf, int len)
+{
+    int fd;
+    ssize_t ret;
+
+    fd = open(path, O_RDONLY);
+    if (fd == -1)
+        return -errno;
+
+    ret = read(fd, buf, len);
+    if (ret == -1)
+        ret = -errno;
+
+    close(fd);
+    return ret;
+}
+
+int sysfs_write(const char *path, const void *buf, int len)
+{
+    int fd;
+    ssize_t ret;
+
+    fd = open(path, O_WRONLY);
+    if (fd == -1)
+        return -errno;
+
+    ret = write(fd, buf, len);
+    if (ret == -1)
+        ret = -errno;
+
+    close(fd);
+    return ret;
+}

=== added file 'libsuspend/sysfs.h'
--- libsuspend/sysfs.h	1970-01-01 00:00:00 +0000
+++ libsuspend/sysfs.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,26 @@
+/*
+ * 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 SYSFS_H
+#define SYSFS_H
+
+int sysfs_file_exists(const char *path);
+int sysfs_read(const char *path, void *buf, int len);
+int sysfs_write(const char *path, const void *buf, int len);
+
+#endif /* SYSFS_H */

=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2013-05-21 14:54:26 +0000
@@ -0,0 +1,18 @@
+include(UseGdbusCodegen)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(GDBUS_NAME powerd-dbus)
+
+set(POWERD_GENERATED_SOURCES
+  ${GDBUS_NAME}.c
+)
+set(POWERD_GENERATED_HEADERS
+  ${GDBUS_NAME}.h
+)
+
+add_gdbus_codegen(
+  OUTFILES POWERD_GENERATED_SOURCES
+  NAME ${GDBUS_NAME}
+  SERVICE_XML ${CMAKE_CURRENT_SOURCE_DIR}/../data/com.canonical.powerd.xml
+)
+ADD_CUSTOM_TARGET(dbus_bindings DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${POWERD_GENERATED_SOURCES})

=== added file 'src/power-request.c'
--- src/power-request.c	1970-01-01 00:00:00 +0000
+++ src/power-request.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,446 @@
+/*
+ * 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 <glib.h>
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include "powerd-internal.h"
+#include "powerd-dbus.h"
+
+#include "libsuspend.h"
+
+struct SysStateRequest {
+    GString *owner;
+    int pid;        /* uint? left as int so we can use -1 for implying that
+                       the request comes from no app specifically */
+    enum SysPowerStates state;
+    uint cookie;
+};
+
+/* Current system power state */
+static enum SysPowerStates current_system_state = POWERD_SYS_STATE_ACTIVE;
+
+/*
+ * Lists for system power state requests, with one list for each power
+ * level. Requests for the suspend state are not allowed, so the actual
+ * number of lists is POWERD_NUM_POWER_STATES - 1.
+ */
+static GSList *sys_state_requests[POWERD_NUM_POWER_STATES - 1];
+
+#define INVALID_STATE -1
+static GQueue queued_state_changes;
+static enum SysPowerStates pending_system_state = INVALID_STATE;
+
+/*
+ * Monotonically increasing value for use in generating unique cookies
+ * for power state requests.
+ *
+ * XXX: Consider whether we might need something more random (i.e. not
+ * guessable) for security purposes.
+ */
+static guint power_requeust_next_cookie;
+
+/* simple helper for debugging */
+const gchar *
+state_to_string(int state)
+{
+    switch (state) {
+        case POWERD_SYS_STATE_ACTIVE: return "ACTIVE";
+        case POWERD_SYS_STATE_SUSPEND: return "SUSPEND";
+        default: return "UNKNOWN";
+    }
+}
+
+/* Returns TRUE if the state request is valid, FALSE otherwise.
+ * Nobody can request the SUSPEND state. */
+static gboolean
+is_valid_state_request(int state)
+{
+    return state > POWERD_SYS_STATE_SUSPEND && state < POWERD_NUM_POWER_STATES;
+}
+
+static GSList **
+sys_request_list(int state)
+{
+    if (!is_valid_state_request(state))
+        return NULL;
+    return &sys_state_requests[state - 1];
+}
+
+/* internal callers should pass in NULL for the builder, its only used
+ * by dbus callers. Returns TRUE if there are any elements in any list,
+ * FALSE otherwise. */
+static gboolean
+list_sys_requests_internal(GVariantBuilder *builder)
+{
+    gboolean ret = FALSE;
+    GSList **list, *iterator = NULL;
+    int i;
+
+    for (i = POWERD_SYS_STATE_SUSPEND + 1; i < POWERD_NUM_POWER_STATES; i++) {
+        list = sys_request_list(i);
+
+        g_message("Requests for %s state:", state_to_string(i));
+        if (*list == NULL) {
+            g_message("  no requests active");
+        }
+        else {
+            for (iterator = *list; iterator; iterator = iterator->next) {
+                struct SysStateRequest *sr = (struct SysStateRequest *)iterator->data;
+                // XXX - we should probably not dump the cookie here, it's a
+                // security risk
+                g_message("  Owner: %s, Pid: %d, Cookie: %u",
+                          sr->owner->str, sr->pid, sr->cookie);
+                ret = TRUE;
+                if (builder) {
+                    g_variant_builder_add(builder, "(si)", sr->owner->str, sr->pid);
+                }
+            }
+        }
+    }
+    return ret;
+}
+
+/* Dump the requests to stdout and return the list via dbus */
+gboolean
+handle_list_sys_requests(PowerdSource *obj, GDBusMethodInvocation *invocation)
+{
+    GVariant *list, *tuple = NULL;
+    GVariantBuilder *builder;
+    gboolean ret;
+
+    // XXX - fix me, we should be returning an empty list when there are
+    // no elements
+    builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
+    ret = list_sys_requests_internal(builder);
+    if (ret) {
+        list = g_variant_builder_end(builder);
+        // XXX - is a tuple with the first element as a list correct here? seems odd
+        tuple = g_variant_new_tuple(&list,1);
+        g_dbus_method_invocation_return_value(invocation, tuple);
+    }
+    else {
+        g_dbus_method_invocation_return_value(invocation, NULL);
+    }
+    return TRUE;
+}
+
+static gint
+find_request_by_cookie(gconstpointer a, gconstpointer b) {
+    struct SysStateRequest *sr_a = (struct SysStateRequest *)a;
+    struct SysStateRequest *sr_b = (struct SysStateRequest *)b;
+    return (sr_a->cookie == sr_b->cookie) ? 0 : 1;
+}
+
+/* Note: invocation is NULL for internal usage */
+gboolean
+request_sys_state_internal(GDBusMethodInvocation *invocation, int state, int pid, uint *cookie)
+{
+    GSList **list, *item = NULL;
+    struct SysStateRequest *sr = NULL;
+
+    if (cookie == NULL) {
+        g_error("you need to pass in memory for a cookie");
+        return FALSE;
+    }
+
+    if (!is_valid_state_request(state))
+    {
+        g_warning("invalid state requested: %d",state);
+        if (invocation) {
+            g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
+                G_DBUS_ERROR_INVALID_ARGS,"Invalid state requested %d",state);
+        }
+        return FALSE;
+    }
+
+    list = sys_request_list(state);
+    if (!list) {
+        /* Should never hit this code since we've already verified that
+         * the state is valid */
+        g_error("Could not get request list for state %d (%s)", state,
+                state_to_string(state));
+        if (invocation) {
+            g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
+                G_DBUS_ERROR_INVALID_ARGS, "Invalid state requested %d",state);
+        }
+        return FALSE;
+    }
+
+    sr = g_new(struct SysStateRequest, 1);
+    sr->state = (enum SysPowerStates)state;
+    sr->pid = pid;
+    if (invocation) {
+        sr->owner = g_string_new(g_dbus_method_invocation_get_sender(invocation));
+    }
+    else {
+        sr->owner = g_string_new("internal");
+    }
+
+    // The request is valid at this point, create a cookie and insert into list
+    *cookie = g_atomic_int_add(&power_requeust_next_cookie, 1);
+    sr->cookie = *cookie;
+    *list = g_slist_append(*list, sr);
+    update_system_state();
+    return TRUE;
+}
+
+gboolean
+handle_request_sys_state (PowerdSource *obj, GDBusMethodInvocation *invocation, int state, int pid)
+{
+    gboolean retval = FALSE;
+    GVariant *gvCookie, *ret = NULL;
+    guint cookie;
+
+    g_debug("handle_requestSysState from %s: %d - %s (%d)",
+        g_dbus_method_invocation_get_sender(invocation), pid,
+        state_to_string(state), state);
+
+    retval = request_sys_state_internal(invocation, state, pid, &cookie);
+    if (retval == TRUE) {
+        gvCookie = g_variant_new_uint32(cookie);
+        ret = g_variant_new_tuple(&gvCookie,1);
+        g_debug("handle_requestSysState - SUCCESS");
+        g_dbus_method_invocation_return_value(invocation, ret);
+    }
+    return retval;
+}
+
+gboolean
+clear_sys_state_internal(GDBusMethodInvocation *invocation, uint cookie)
+{
+    struct SysStateRequest *tmpsr = NULL;
+    GSList **list, *matched_requests = NULL;
+    int i;
+
+    tmpsr = g_new(struct SysStateRequest, 1);
+    tmpsr->cookie = cookie;
+
+    for (i = POWERD_SYS_STATE_SUSPEND + 1; i < POWERD_NUM_POWER_STATES; i++) {
+        list = sys_request_list(i);
+        if (!list)
+            continue;
+
+        matched_requests = g_slist_find_custom(*list, tmpsr, find_request_by_cookie);
+
+        if (matched_requests)
+            break;
+    }
+    g_free(tmpsr);
+
+    if (matched_requests == NULL)
+    {
+        g_warning("request (%u) not found", cookie);
+	if (invocation)
+		g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
+						      "No request with cookie: %u", cookie);
+        return FALSE;
+    }
+
+    for ( ; matched_requests; matched_requests = matched_requests->next) {
+        struct SysStateRequest *sr = (struct SysStateRequest *)matched_requests->data;
+        g_debug("removing an element: %u",sr->cookie);
+        *list = g_slist_remove_all(*list, sr);
+    }
+
+	g_slist_free_full(matched_requests, sys_state_request_destroy);
+    update_system_state();
+    return TRUE;
+}
+
+gboolean
+handle_clear_sys_state (PowerdSource *obj, GDBusMethodInvocation *invocation, uint cookie)
+{
+    gboolean retval = FALSE;
+    g_debug("handle_clearSysState from %s, cookie: %u",
+        g_dbus_method_invocation_get_sender(invocation), cookie);
+
+    retval = clear_sys_state_internal(invocation, cookie);
+    if (retval == TRUE) {
+        g_dbus_method_invocation_return_value(invocation, NULL);
+    }
+    return retval;
+}
+
+gboolean any_active_sys_state_requests(void)
+{
+    GSList **list = sys_request_list(POWERD_SYS_STATE_ACTIVE);
+    if (list && *list)
+        return TRUE;
+    return FALSE;
+}
+
+static enum SysPowerStates max_requested_state(void)
+{
+    int i;
+    GSList **list;
+
+    for (i = POWERD_NUM_POWER_STATES - 1; i > POWERD_SYS_STATE_SUSPEND; i--) {
+        list = sys_request_list(i);
+        if (list && *list)
+            return i;
+    };
+
+    return POWERD_SYS_STATE_SUSPEND;
+}
+
+static void check_queued_state_changes(void)
+{
+    enum SysPowerStates new_state;
+    int ret;
+
+    /*
+     * If state change in progress we'll process the next queued state
+     * change when finished.
+     */
+    if (pending_system_state != INVALID_STATE) {
+        g_debug("state change in progress, delaying");
+        return;
+    }
+
+    if (g_queue_is_empty(&queued_state_changes)) {
+        g_debug("no pending state changes");
+        return;
+    }
+
+    pending_system_state = (enum SysPowerStates)g_queue_pop_head(&queued_state_changes);
+    if (pending_system_state == current_system_state) {
+        g_debug("pending state == current state, discarding");
+        pending_system_state = INVALID_STATE;
+        return;
+    }
+
+    /*
+     * XXX: This code needs to be split up. Here's what it needs to do:
+     *
+     * 1. If going to suspend, possibly delay a few seconds to see if
+     *    any new active requests come in. If so, abort the suspend
+     *    transition.
+     * 2. Send out the signal to prepare for the state change.
+     * 3. Wait for acks or the timeout period to elapse.
+     * 4. Complete the state transition. If going to suspend, check to
+     *    be sure that there's not a queued request to transition to a
+     *    higher state, and if not tell the kernel to suspend.
+     */
+    if (current_system_state == POWERD_SYS_STATE_SUSPEND) {
+        g_debug("exiting suspend");
+        ret = libsuspend_exit_suspend();
+        if (ret)
+            g_warning("Failed to exit suspend: %d\n", ret);
+    } else if (pending_system_state == POWERD_SYS_STATE_SUSPEND &&
+               g_queue_is_empty(&queued_state_changes)) {
+        g_debug("entering suspend");
+        ret = libsuspend_prepare_suspend();
+        if (ret)
+            g_warning("Failed to prepare for suspend: %d\n", ret);
+        /* XXX: Here is where notifications should be sent out */
+        ret = libsuspend_enter_suspend();
+        if (ret)
+            g_warning("Failed to enter suspend: %d\n", ret);
+    }
+
+    current_system_state = pending_system_state;
+    pending_system_state = INVALID_STATE;
+}
+
+/*
+ * XXX: Currently the coalescing is very simplistic and may need
+ * improvement.
+ */
+static void enqueue_state_change(enum SysPowerStates state)
+{
+    gboolean queue_empty;
+
+    g_debug("Enqueue state change to %s", state_to_string(state));
+
+    /*
+     * If the new request is the same as the one we're currently
+     * processing we can drop all pending requests (including the
+     * new one).
+     */
+    if (pending_system_state == state) {
+        g_debug("State == pending state, discarding");
+        g_queue_clear(&queued_state_changes);
+        return;
+    } else if (pending_system_state == INVALID_STATE) {
+        queue_empty = g_queue_is_empty(&queued_state_changes);
+
+        /*
+         * If no state changes are pending or in progress and the
+         * requested state is the same as the current state, do nothing.
+         */
+        if (queue_empty && state == current_system_state) {
+            g_debug("queue empty && state == current, discarding");
+            return;
+        }
+
+        /*
+         * If we aren't processing a request and the current request is
+         * the same as the next reques in the queue, all intermediate
+         * requests can be dropped. We do this by clearing the queue and
+         * then adding in the new request.
+         *
+         * XXX: This situation is probably impossible currently.
+         */
+        if (!queue_empty &&
+            (enum SysPowerStates)g_queue_peek_tail(&queued_state_changes) == state) {
+            g_debug("new state == next queued state, discarding all intermediate requests");
+            g_queue_clear(&queued_state_changes);
+        }
+    }
+
+    g_queue_push_tail(&queued_state_changes, (gpointer)state);
+    check_queued_state_changes();
+}
+
+void update_system_state(void)
+{
+    enqueue_state_change(max_requested_state());
+}
+
+void power_request_init(void)
+{
+    g_queue_init(&queued_state_changes);
+}
+
+// Destructor for the state request object
+void sys_state_request_destroy(gpointer data)
+{
+    struct SysStateRequest *sr = (struct SysStateRequest *)data;
+    if (sr->owner) {
+        g_free(sr->owner);
+        sr->owner = NULL;
+    }
+}
+
+void power_request_deinit(void)
+{
+    int i;
+    for (i = POWERD_SYS_STATE_SUSPEND + 1; i < POWERD_NUM_POWER_STATES; i++)
+        g_slist_free_full(sys_state_requests[i-1], sys_state_request_destroy);
+    g_queue_clear(&queued_state_changes);
+}

=== added file 'src/powerd-internal.h'
--- src/powerd-internal.h	1970-01-01 00:00:00 +0000
+++ src/powerd-internal.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,63 @@
+/*
+ * 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 __POWERD_INTERNAL_H__
+#define __POWERD_INTERNAL_H__
+
+#include "powerd-object.h"
+#include "powerd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void powerd_exit(void);
+
+/* System power state requests */
+gboolean handle_list_sys_requests(PowerdSource *obj,
+                                  GDBusMethodInvocation *invocation);
+gboolean handle_request_sys_state(PowerdSource *obj,
+                                  GDBusMethodInvocation *invocation,
+                                  int state, int pid);
+gboolean handle_clear_sys_state(PowerdSource *obj,
+                                GDBusMethodInvocation *invocation,
+                                uint cookie);
+gboolean request_sys_state_internal(GDBusMethodInvocation *invocation,
+                                    int state, int pid, uint *cookie);
+gboolean clear_sys_state_internal(GDBusMethodInvocation *invocation,
+                                  uint cookie);
+gboolean any_active_sys_state_requests(void);
+void update_system_state(void);
+void power_request_init(void);
+void power_request_deinit(void);
+void sys_state_request_destroy(gpointer data);
+const gchar * state_to_string(int state);
+
+/* dbus callbacks */
+void powerd_bus_acquired_cb(GDBusConnection *connection, const gchar *name,
+                            gpointer user_data);
+void powerd_name_acquired_cb(GDBusConnection *connection, const gchar *name,
+                             gpointer user_data);
+void powerd_name_lost_cb(GDBusConnection *connection, const gchar *name,
+                         gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

=== added file 'src/powerd-object.c'
--- src/powerd-object.c	1970-01-01 00:00:00 +0000
+++ src/powerd-object.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,125 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+#include "powerd-internal.h"
+#include "powerd-dbus.h"
+
+struct _PowerdSourcePrivate {
+    GDBusConnection * system_bus;
+    const gchar * path;
+    ComCanonicalPowerd * skel;
+};
+
+static void powerd_source_class_init (PowerdSourceClass * klass);
+static void powerd_source_init       (PowerdSource *      self);
+static void powerd_source_dispose    (GObject *           object);
+static void powerd_source_finalize   (GObject *           object);
+
+G_DEFINE_TYPE (PowerdSource, powerd_source, G_TYPE_OBJECT);
+
+#define POWERD_SOURCE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), POWERD_TYPE_SOURCE, PowerdSourcePrivate))
+
+/* Instance */
+static void
+powerd_source_init (PowerdSource *self)
+{
+    self->priv = POWERD_SOURCE_GET_PRIVATE(self);
+    self->priv->system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+    return;
+}
+
+/* Class Init */
+static void
+powerd_source_class_init (PowerdSourceClass *self)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (self);
+    g_type_class_add_private (self, sizeof (PowerdSourcePrivate));
+    object_class->dispose = powerd_source_dispose;
+    object_class->finalize = powerd_source_finalize;
+    return;
+}
+
+/* Clean up references */
+static void
+powerd_source_dispose (GObject *object)
+{
+    PowerdSource * self = POWERD_SOURCE(object);
+    if (self->priv->skel != NULL) {
+        g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(self->priv->skel));
+        g_clear_object(&self->priv->skel);
+    }
+    g_clear_object(&self->priv->system_bus);
+    return;
+}
+
+/* Free memory */
+static void
+powerd_source_finalize (GObject *object)
+{
+    return;
+}
+
+void
+powerd_bus_acquired_cb (GDBusConnection *connection,
+                        const gchar     *name,
+                        gpointer         user_data)
+{
+    GError *error = NULL;
+    PowerdSource *source = NULL;
+
+    g_debug("Bus acquired (guid %s)", g_dbus_connection_get_guid (connection));
+    source = (PowerdSource *)g_object_new(POWERD_TYPE_SOURCE, NULL);
+    source->priv->skel = com_canonical_powerd_skeleton_new();
+    source->priv->path = "/com/canonical/powerd";
+
+    if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(source->priv->skel),
+            source->priv->system_bus, source->priv->path, &error)) {
+        g_error("Unable to export skeleton on path '%s': %s", source->priv->path,
+            error->message);
+        g_error_free(error);
+        error = NULL;
+        powerd_exit();
+    }
+
+    g_signal_connect(G_OBJECT(source->priv->skel), "handle-request-sys-state",
+        G_CALLBACK(handle_request_sys_state), source);
+    g_signal_connect(G_OBJECT(source->priv->skel), "handle-clear-sys-state",
+        G_CALLBACK(handle_clear_sys_state), source);
+    g_signal_connect(G_OBJECT(source->priv->skel), "handle-list-sys-requests",
+        G_CALLBACK(handle_list_sys_requests), source);
+}
+
+void
+powerd_name_acquired_cb (GDBusConnection *connection,
+                         const gchar     *name,
+                         gpointer         user_data)
+{
+    g_debug("name acquired (%s)", name);
+}
+
+void
+powerd_name_lost_cb (GDBusConnection *connection,
+                     const gchar     *name,
+                     gpointer         user_data)
+{
+    g_warning("name lost (%s)", name);
+    //XXX - quit here
+}

=== added file 'src/powerd-object.h'
--- src/powerd-object.h	1970-01-01 00:00:00 +0000
+++ src/powerd-object.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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 __POWERD_OBJECT_H__
+#define __POWERD_OBJECT_H__
+
+#include <glib-object.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+G_BEGIN_DECLS
+
+#define POWERD_TYPE_SOURCE            (powerd_source_get_type ())
+#define POWERD_SOURCE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), POWERD_TYPE_SOURCE, PowerdSource))
+#define POWERD_IS_SOURCE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), POWERD_TYPE_SOURCE))
+#define POWERD_SOURCE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), POWERD_TYPE_SOURCE, PowerdSourceClass))
+#define POWERD_IS_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), POWERD_TYPE_SOURCE))
+#define POWERD_SOURCE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), POWERD_TYPE_SOURCE, PowerdSourceClass))
+
+struct _PowerdSourcePrivate;
+
+typedef struct _PowerdSource         PowerdSource;
+typedef struct _PowerdSourceClass    PowerdSourceClass;
+typedef struct _PowerdSourcePrivate  PowerdSourcePrivate;
+
+struct _PowerdSourceClass {
+	GObjectClass parent_class;
+};
+
+struct _PowerdSource {
+	GObject parent;
+	PowerdSourcePrivate * priv;
+};
+
+GType                    powerd_source_get_type          (void);
+
+G_END_DECLS
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2013-02-20 15:42:12 +0000
+++ src/powerd.cpp	2013-05-21 14:54:26 +0000
@@ -1,6 +1,11 @@
 /*
  * Copyright 2013 Canonical Ltd.
  *
+ * Authors:
+ * Michael Frey: [e-mail]
+ * Matthew Fischer: [e-mail]
+ * Seth Forshee: [e-mail]
+ *
  * This file is part of powerd.
  *
  * powerd is free software; you can redistribute it and/or modify
@@ -27,12 +32,21 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/types.h>
+
+#include <glib-object.h>
+#include <gio/gio.h>
+#include "powerd-internal.h"
+#include "powerd-object.h"
+#include "powerd-dbus.h"
 
 #include <hybris/input/input_stack_compatibility_layer.h>
 #include <hybris/input/input_stack_compatibility_layer_codes_key.h>
 
 #include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
 
+#include "libsuspend.h"
+
 namespace
 {
 
@@ -43,20 +57,6 @@
     OUR_FD_COUNT
 };
 
-const char * const PATHS[] = {
-    "/sys/power/wake_lock",
-    "/sys/power/wake_unlock",
-    "/sys/power/state"
-};
-
-static const char *off_state = "mem";
-static const char *on_state = "on";
-
-static bool in_suspend = false;
-static int g_initialized = 0;
-static int g_fds[OUR_FD_COUNT];
-static int g_error = 1;
-
 static uint button_timer = 0;
 static uint activity_timer = 0;
 
@@ -68,6 +68,8 @@
 static gchar *brightness_path;
 
 static int ACTIVITY_TIMEOUT = 30;
+static GMainLoop *main_loop = NULL;
+static guint name_id;
 
 enum state {
     BUTTON_DOWN,
@@ -77,6 +79,16 @@
 
 static state button_state  = BUTTON_UP;
 
+enum screen_state {
+    SCREEN_OFF,
+    SCREEN_ON
+};
+
+static enum screen_state current_screen_state = SCREEN_ON;
+static uint internal_request_cookie;
+static bool internal_cookie_valid;
+
+gboolean activity_monitor(gpointer data);
 
 void get_brightness_path (void)
 {
@@ -100,11 +112,9 @@
             (g_strcmp0 (device_type, "platform") == 0) ||
             (g_strcmp0 (device_type, "raw") == 0)) {
             brightness_path = g_strdup (g_udev_device_get_sysfs_path ((GUdevDevice *)device->data));
-            g_print ("found: %s\n", brightness_path);
             break;
         }
     }
-    g_print ("found2: %s\n", brightness_path);
 
     g_list_foreach (devices, (GFunc) g_object_unref, NULL);
     g_list_free (devices);
@@ -167,110 +177,103 @@
 
 }
 
-static int
-open_file_descriptors(const char * const paths[])
-{
-    int i;
-    for (i=0; i<OUR_FD_COUNT; i++) {
-        int fd = open(paths[i], O_RDWR);
-        if (fd < 0) {
-            fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]);
-            g_error = errno;
-            return -1;
-        }
-        g_fds[i] = fd;
-    }
-
-    g_error = 0;
-    return 0;
-}
-
-static inline void
-initialize_fds(void)
-{
-    if (g_initialized == 0) {
-        if(open_file_descriptors(PATHS) < 0) {
-            on_state = "on";
-            off_state = "mem";
-        }
-        g_initialized = 1;
-    }
-}
-
-
 gboolean call_shutdown(gpointer data)
 {
-    gchar   *argv[] = {"poweroff",
+    static char poweroff_cmd[] = "poweroff";
+    gchar   *argv[] = {poweroff_cmd,
                         NULL};
+
     if (button_state == BUTTON_DOWN) {
         button_state = SHUTDOWN;
         brightness_set_value(0);
         sf_blank(0);
         g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
     }
-}
-
-int set_screen_state(void)
-{
-    initialize_fds();
-
-    if (g_error)
-        goto failure;
-
-    char buf[32];
-    int len;
-    if(in_suspend) {
-        len = snprintf(buf, sizeof(buf), "%s", on_state);
-        in_suspend = false;
-    } else {
-        if (activity_timer > 0) {
-            g_source_remove(activity_timer);               
-            activity_timer = 0;
-        }
+
+}
+
+void reset_activity_timer(int add)
+{
+    if (activity_timer > 0) {
+        g_source_remove(activity_timer);
+        activity_timer = 0;
+    }
+    if (add)
+        activity_timer = g_timeout_add_seconds(ACTIVITY_TIMEOUT, activity_monitor, NULL);
+}
+
+
+int set_screen_state(enum screen_state new_state)
+{
+    int ret;
+
+    g_debug("set_screen_state: current %s (%d) new %s (%d)",
+        state_to_string(current_screen_state), current_screen_state,
+        state_to_string(new_state), new_state);
+
+    if (current_screen_state == new_state)
+        return 0;
+
+    switch (new_state) {
+    case SCREEN_OFF:
+        reset_activity_timer(0);
         saved_brightness = brightness_get_value();
         brightness_set_value(0);
         sf_blank(0);
-        len = snprintf(buf, sizeof(buf), "%s", off_state);
-        in_suspend = true;
-    }
-
-    buf[sizeof(buf) - 1] = '\0';
-    len = write(g_fds[REQUEST_STATE], buf, len);
-    if(len < 0) {
-    failure:
-        printf("Failed setting last user activity: g_error=%d\n", g_error);
-    }
-
-    //Need to wait for system wakeup otherwise we will get
-    //permission denied if we try to ake the screen up before that.
-    if (!in_suspend) {
+
+        g_debug("Releasing internal active state request");
+        ret = clear_sys_state_internal(NULL, internal_request_cookie);
+        if (!ret)
+            g_warning("Internal system state request cookie invalid: %d\n",
+                      internal_request_cookie);
+        break;
+    case SCREEN_ON:
+        g_debug("Requesting active state internally");
+        ret = request_sys_state_internal(NULL, POWERD_SYS_STATE_ACTIVE,
+                getpid(), &internal_request_cookie);
+        if (!ret)
+            g_warning("Request for active state failed");
+
+        /* Need to wait for system wakeup before waking screen */
         sleep(1);
         sf_unblank(0);
         brightness_set_value(saved_brightness);
+
+        activity_timer = g_timeout_add_seconds(ACTIVITY_TIMEOUT, activity_monitor, NULL);
+        break;
+    default:
+        g_warning("Invalid screen state %d", new_state);
+        return -1;
     }
 
+    current_screen_state = new_state;
     return 0;
 }
 
+gboolean activity_monitor(gpointer data)
+{
+    set_screen_state(SCREEN_OFF);
+}
 
 void on_new_event(Event* event, void* context)
 {
-    
-    if (activity_timer > 0) {
-        g_source_remove(activity_timer);               
-        activity_timer = 0;
-    }
-
     switch(event->type)
     {
         case KEY_EVENT_TYPE:
             if (event->details.key.key_code == ISCL_KEYCODE_POWER && button_state != SHUTDOWN) {
                 if (event->action == 1) {
+                    g_debug("power button pressed");
                     button_state = BUTTON_UP;
                     curtime = time(0);
                     tm = localtime (&curtime);
-                    if (tm->tm_sec - lasttime < 2)
-                        set_screen_state();
+                    if (tm->tm_sec - lasttime < 2) {
+                        enum screen_state new_state;
+                        if (current_screen_state == SCREEN_OFF)
+                            new_state = SCREEN_ON;
+                        else
+                            new_state = SCREEN_OFF;
+                        set_screen_state(new_state);
+                    }
                 } else if (event->action == 0) {
                     button_state = BUTTON_DOWN;
                     curtime = time(0);
@@ -278,7 +281,7 @@
                     lasttime = tm->tm_sec;
                     if (button_timer > 0)
                     {
-                        g_source_remove(button_timer);               
+                        g_source_remove(button_timer);
                         button_timer = 0;
                     }
                     button_timer = g_timeout_add_seconds(2, call_shutdown, NULL);
@@ -286,19 +289,49 @@
             }
             break;
         default:
+            reset_activity_timer(1);
             break;
     }
 }
 
-}
-
+void powerd_exit(void)
+{
+    g_main_loop_quit(main_loop);
+}
+
+static void
+sigterm_quit(int signal)
+{
+    g_warning("SIGTERM recieved, cleaning up");
+    // XXX - strangely this call to unown name claims the id is invalid
+    // but I'm sure we're using it properly
+    g_bus_unown_name(name_id);
+    g_main_loop_quit(main_loop);
+}
+
+}   //namespace
 
 int main(int argc, char** argv)
 {
-
-    GMainLoop* main_loop = NULL;
+    int i, ret;
+
+    g_type_init();
+    name_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, "com.canonical.powerd",
+        G_BUS_NAME_OWNER_FLAGS_REPLACE, powerd_bus_acquired_cb,
+        powerd_name_acquired_cb, powerd_name_lost_cb, NULL, NULL);
+    g_debug("owner id: %u", name_id);
+
+    libsuspend_init(0);
+    power_request_init();
+
+    /* We start in the active state, so take a request */
+    ret = request_sys_state_internal(NULL, POWERD_SYS_STATE_ACTIVE,
+            getpid(), &internal_request_cookie);
+    if (!ret)
+        g_warning("Initial request for active state failed");
 
     main_loop = g_main_loop_new (NULL, FALSE);
+    signal(SIGTERM, sigterm_quit);
 
     AndroidEventListener listener;
     listener.on_new_event = on_new_event;
@@ -312,11 +345,16 @@
     android_input_stack_initialize(&listener, &config);
     android_input_stack_start();
 
-    g_type_init();
     get_brightness_path();
+    activity_timer = g_timeout_add_seconds(ACTIVITY_TIMEOUT, activity_monitor, NULL);
+
     g_main_loop_run(main_loop);
+    g_bus_unown_name(name_id);
+    g_main_loop_unref(main_loop);
 
     android_input_stack_stop();
     android_input_stack_shutdown();
+
+    power_request_deinit();
+    return 0;
 }
-

=== added file 'src/powerd.h'
--- src/powerd.h	1970-01-01 00:00:00 +0000
+++ src/powerd.h	2013-05-21 14:54:26 +0000
@@ -0,0 +1,41 @@
+/*
+ * 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 __POWERD_H__
+#define __POWERD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum SysPowerStates {
+    //Note that callers will be notified of suspend state changes
+    //but may not request this state.
+    POWERD_SYS_STATE_SUSPEND = 0,
+
+    //The Active state will prevent system suspend
+    POWERD_SYS_STATE_ACTIVE,
+
+    POWERD_NUM_POWER_STATES
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

=== added directory 'testclient'
=== added file 'testclient/CMakeLists.txt'
--- testclient/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ testclient/CMakeLists.txt	2013-05-21 14:54:26 +0000
@@ -0,0 +1,37 @@
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -ggdb -g")
+
+set(
+  SRCS
+
+  testclient.c
+)
+
+link_directories(
+  ${GLIB_LIBRARY_DIRS}
+  ${GIO_LIBRARY_DIRS}
+  ${GIO-UNIX_LIBRARY_DIRS}
+  ${GUDEV_LIBRARY_DIRS}
+)
+
+include_directories(
+  ${GLIB_INCLUDE_DIRS}
+  ${GIO_INCLUDE_DIRS}
+  ${GIO-UNIX_INCLUDE_DIRS}
+  ${GUDEV_INCLUDE_DIRS}
+  ../src
+)
+
+add_executable(
+  powerd-testclient
+
+  ${SRCS}
+)
+
+target_link_libraries(
+  powerd-testclient
+
+  ${GLIB_LIBRARIES}
+  ${GUDEV_LIBRARIES}
+  ${GIO_LIBRARIES}
+  ${GIO-UNIX_LIBRARIES}
+)

=== added file 'testclient/testclient.c'
--- testclient/testclient.c	1970-01-01 00:00:00 +0000
+++ testclient/testclient.c	2013-05-21 14:54:26 +0000
@@ -0,0 +1,120 @@
+/*
+ * 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 <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+#include <powerd.h>
+
+static void
+on_signal (GDBusProxy *proxy,
+           gchar      *sender_name,
+           gchar      *signal_name,
+           GVariant   *parameters,
+           gpointer    user_data)
+{
+    g_warning("we get signal from %s: %s", sender_name, signal_name);
+}
+
+static gboolean
+requestSysState(GDBusProxy *proxy, int state, pid_t pid, uint *cookie)
+{
+    GVariant *ret = NULL;
+    GError *error = NULL;
+
+    if (proxy == NULL) {
+        g_warning("requires a valid proxy object");
+        return FALSE;
+    }
+
+    if (cookie == NULL) {
+        g_warning("requires a valid pointer for cookie");
+        return FALSE;
+    }
+
+    ret = g_dbus_proxy_call_sync(proxy,
+            "requestSysState",
+            g_variant_new("(ii)", state, pid),
+            G_DBUS_CALL_FLAGS_NONE,
+            -1,
+            NULL,
+            &error);
+    if (ret == NULL) {
+        g_warning("Error when calling requestSysState: %s", error->message);
+        g_error_free(error);
+        return FALSE;
+    }
+    else {
+        g_variant_get(ret, "(u)", cookie);
+        g_message("Got cookie: %u", *cookie);
+        return TRUE;
+    }
+}
+
+int main (int argc, char **argv)
+{
+    GDBusProxy *proxy = NULL;
+    GMainLoop *loop = NULL;
+    GError *error = NULL;
+    pid_t mypid;
+    uint cookie;
+
+    g_type_init();
+    loop = g_main_loop_new (NULL, FALSE);
+
+    proxy = g_dbus_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
+                G_DBUS_PROXY_FLAGS_NONE,
+                NULL,
+                "com.canonical.powerd",
+                "/com/canonical/powerd",
+                "com.canonical.powerd",
+                NULL,
+                &error);
+
+    if (error != NULL) {
+        g_error("error, could not acquire system bus: %s", error->message);
+        g_error_free(error);
+        return -1;
+    }
+
+    // XXX - attach to real signal once we have one
+    g_signal_connect(proxy,
+        "g-signal",
+        G_CALLBACK (on_signal),
+        NULL);
+
+    mypid = getpid();
+    g_message("Running as pid %d\n", mypid);
+
+    assert(requestSysState(proxy, POWERD_SYS_STATE_ACTIVE, mypid, &cookie) == TRUE);
+    //cannot request the suspend state, this will fail
+    assert(requestSysState(proxy, POWERD_SYS_STATE_SUSPEND, mypid, &cookie) == FALSE);
+    //invalid values
+    assert(requestSysState(proxy, -1, mypid, &cookie) == FALSE);
+    assert(requestSysState(proxy, POWERD_NUM_POWER_STATES, mypid,&cookie) == FALSE);
+    assert(requestSysState(proxy, POWERD_NUM_POWER_STATES+1, mypid,&cookie) == FALSE);
+
+    g_message("Waiting for events");
+    g_main_loop_run(loop);
+    g_main_loop_unref(loop);
+    return 0;
+}

=== added file 'tester.sh'
--- tester.sh	1970-01-01 00:00:00 +0000
+++ tester.sh	2013-05-21 14:54:26 +0000
@@ -0,0 +1,51 @@
+#!/bin/sh
+
+RET=`sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.requestSysState 1 99`
+COOKIEA=`echo ${RET%,*} | sed 's/.* //'`
+echo "Cookie: $COOKIEA"
+RET=`sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.requestSysState 1 99`
+COOKIEB=`echo ${RET%,*} | sed 's/.* //'`
+echo "Cookie: $COOKIEB"
+
+# should have 2
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.listSysRequests
+
+# clear our requests
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.clearSysState $COOKIEA
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.clearSysState $COOKIEB
+
+# should have 0
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.listSysRequests
+
+# these should fail
+echo "These should all fail"
+# invalid state 99
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.requestSysState 99 99
+# illegal to request the suspend state
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.requestSysState 0 99
+# gdbus does not like passing -1
+#sudo gdbus call --system --dest com.canonical.powerd --object-path\
+#    /com/canonical/powerd --method com.canonical.powerd.requestSysState \-1 99
+# bad arg
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.requestSysState fred
+# bad arg
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.listStateRequests fred
+# bad cookie
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.clearSysState 18181
+# bad arg
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.clearSysState fred
+# invalid call to non-existant method
+sudo gdbus call --system --dest com.canonical.powerd --object-path\
+    /com/canonical/powerd --method com.canonical.powerd.chickenCutlass