power/power_instance_desktop.cc

   1 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "power/power_instance_desktop.h"
   6
   7 #include <iostream>
   8 #include <fstream>
   9 #include <string>
  10 #include "common/picojson.h"
  11
  12 #define DEVICE "/sys/class/backlight/acpi_video0"
  13
  14 static double kMaxBrightness = 0;
  15
  16 static int readInt(const char* pathname) {
  17   std::ifstream file;
  18   file.open(pathname, std::ios::in);
  19
  20   if (!file.is_open())
  21     return -1;
  22
  23   char buf[4];
  24   file.read(buf, 4);
  25   file.close();
  26
  27   return atoi(buf);
  28 }
  29
  30 static void writeInt(const char* pathname, int value) {
  31   std::ofstream file;
  32   file.open(pathname, std::ios::out);
  33
  34   if (!file.is_open())
  35     return;
  36
  37   char buf[4];
  38   snprintf(buf, sizeof(buf), "%d", value);
  39
  40   file.seekp(0, std::ios::beg);
  41   file.write(buf, 4);
  42   file.close();
  43 }
  44
  45 void OnScreenProxyCreatedThunk(GObject* source, GAsyncResult* res,
  46                                gpointer data) {
  47   PowerInstanceDesktop* instance = static_cast<PowerInstanceDesktop*>(data);
  48   // Returns 0 in case of failure.
  49   instance->screen_proxy_ = g_dbus_proxy_new_for_bus_finish(res, /* error */ 0);
  50 }
  51
  52 PowerInstanceDesktop::PowerInstanceDesktop() {
  53   kMaxBrightness = readInt(DEVICE "/max_brightness");
  54
  55   g_dbus_proxy_new_for_bus(G_BUS_TYPE_SESSION,
  56       G_DBUS_PROXY_FLAGS_NONE,
  57       NULL, /* GDBusInterfaceInfo */
  58       "org.gnome.SettingsDaemon",
  59       "/org/gnome/SettingsDaemon/Power",
  60       "org.gnome.SettingsDaemon.Power.Screen",
  61       NULL, /* GCancellable */
  62       OnScreenProxyCreatedThunk,
  63       this);
  64 }
  65
  66 PowerInstanceDesktop::~PowerInstanceDesktop() {
  67   if (screen_proxy_)
  68     g_object_unref(screen_proxy_);
  69 }
  70
  71 void PowerInstanceDesktop::HandleMessage(const char* message) {
  72   picojson::value v;
  73
  74   std::string err;
  75   picojson::parse(v, message, message + strlen(message), &err);
  76   if (!err.empty()) {
  77     std::cout << "Ignoring message.\n";
  78     return;
  79   }
  80
  81   std::string cmd = v.get("cmd").to_str();
  82   if (cmd == "PowerRequest") {
  83     HandleRequest(v);
  84   } else if (cmd == "PowerRelease") {
  85     HandleRelease(v);
  86   } else if (cmd == "PowerSetScreenBrightness") {
  87     // value of -1 means restore to default value.
  88     HandleSetScreenBrightness(v);
  89   } else if (cmd == "PowerSetScreenEnabled") {
  90     HandleSetScreenEnabled(v);
  91   } else {
  92     std::cout << "ASSERT NOT REACHED.\n";
  93   }
  94 }
  95
  96 void PowerInstanceDesktop::HandleSyncMessage(const char* message) {
  97   picojson::value v;
  98
  99   std::string err;
 100   picojson::parse(v, message, message + strlen(message), &err);
 101   if (!err.empty()) {
 102     std::cout << "Ignoring message.\n";
 103     return;
 104   }
 105
 106   std::string cmd = v.get("cmd").to_str();
 107   if (cmd == "PowerGetScreenBrightness") {
 108     HandleGetScreenBrightness();
 109   }  else if (cmd == "PowerGetScreenState") {
 110     HandleGetScreenState();
 111   } else {
 112     std::cout << "ASSERT NOT REACHED.\n";
 113   }
 114 }
 115
 116 void PowerInstanceDesktop::OnScreenStateChanged(ResourceState state) {
 117   picojson::value::object o;
 118   o["cmd"] = picojson::value("ScreenStateChanged");
 119   o["state"] = picojson::value(static_cast<double>(state));
 120
 121   picojson::value v(o);
 122   PostMessage(v.serialize().c_str());
 123 }
 124
 125 void PowerInstanceDesktop::HandleRequest(const picojson::value& msg) {
 126   std::string resource = msg.get("resource").to_str();
 127   ResourceState state = static_cast<ResourceState>(
 128       msg.get("state").get<double>());
 129
 130   switch (state) {
 131     case SCREEN_OFF:
 132     case SCREEN_DIM:
 133     case SCREEN_NORMAL:
 134     case SCREEN_BRIGHT:
 135       OnScreenStateChanged(state);
 136       break;
 137     default:
 138       break;
 139   }
 140 }
 141
 142 void PowerInstanceDesktop::HandleRelease(const picojson::value& msg) {
 143   std::string resource = msg.get("resource").to_str();
 144 }
 145
 146 void PowerInstanceDesktop::HandleSetScreenBrightness(
 147     const picojson::value& msg) {
 148   double value = msg.get("value").get<double>();
 149
 150   // Attempt using the GNOME SettingsDaemon service.
 151   if (screen_proxy_) {
 152     g_dbus_proxy_call(screen_proxy_,
 153       "SetPercentage",
 154       g_variant_new("(u)", static_cast<int>(value * 100)),
 155       G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, this);
 156     return;
 157   }
 158
 159   // Fallback to manual (requires root).
 160   if (kMaxBrightness < 1)
 161     return;
 162
 163   writeInt(DEVICE "/brightness", value * kMaxBrightness);
 164 }
 165
 166 void PowerInstanceDesktop::HandleGetScreenBrightness() {
 167   char brightnessAsString[32] = "0.0";
 168
 169   double value = readInt(DEVICE "/brightness");
 170   if (kMaxBrightness > 0 && value >= 0)
 171     snprintf(brightnessAsString, sizeof(brightnessAsString),
 172              "%g", value / kMaxBrightness);
 173
 174   SendSyncReply(brightnessAsString);
 175 }
 176
 177 void PowerInstanceDesktop::HandleSetScreenEnabled(const picojson::value& msg) {
 178   bool isEnabled = msg.get("value").get<bool>();
 179 }
 180
 181 void PowerInstanceDesktop::HandleGetScreenState() {
 182   picojson::value::object o;
 183   o["state"] = picojson::value(
 184       static_cast<double>(SCREEN_NORMAL));
 185   picojson::value v(o);
 186   SendSyncReply(v.serialize().c_str());
 187 }