/**
* This file is a part of the Cairo-Dock project
*
* Copyright : (C) see the 'copyright' file.
3* E-mail : see the 'copyright' file.
*
* This program 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; either version 3
* of the License, or (at your option) any later version.
*
* This program 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 .
*/
#include
#include
#include
#include
#include "powermanager-struct.h"
#include "powermanager-draw.h"
#include "powermanager-common.h"
#include "powermanager-upower.h"
#ifdef CD_UPOWER_AVAILABLE // code with libupower
static GList * _cd_upower_add_and_ref_device_if_battery (UpDevice *pDevice, GList *pBatteryDeviceList)
{
UpDeviceKind kind;
g_object_get (G_OBJECT (pDevice), "kind", &kind, NULL);
if (kind == UP_DEVICE_KIND_BATTERY)
{
pBatteryDeviceList = g_list_append (pBatteryDeviceList, pDevice);
g_object_ref (pDevice); // since the object does not belong to us, we ref it here, and we'll keep our ref until the end of the applet.
}
return pBatteryDeviceList;
}
static void _cd_upower_connect_async (CDSharedMemory *pSharedMemory)
{
// connect to UPower on Dbus.
UpClient *pUPowerClient = up_client_new ();
// get the list of devices.
if (pUPowerClient == NULL
#ifndef CD_UPOWER_0_99 // no longer available with UPower 0.99+
|| ! up_client_enumerate_devices_sync (pUPowerClient, NULL, NULL)
#endif
)
{
cd_warning ("couldn't get devices from UPower daemon");
if (pUPowerClient)
g_object_unref (pUPowerClient);
return;
}
// find the battery device.
GPtrArray *pDevices = up_client_get_devices (pUPowerClient);
g_return_if_fail (pDevices != NULL); // just to be sure.
UpDevice *pDevice;
GList *pBatteryDeviceList = NULL;
guint i;
for (i = 0; i < pDevices->len; i ++)
{
pDevice = g_ptr_array_index (pDevices, i);
pBatteryDeviceList = _cd_upower_add_and_ref_device_if_battery (pDevice, pBatteryDeviceList);
}
if (pBatteryDeviceList == NULL)
{
cd_debug ("no battery found amongst %d devices", pDevices->len);
/* g_object_unref (pUPowerClient); // => if we launch the dock without any battery and then connect the battery, we need to be notified
return;*/
}
pSharedMemory->pUPowerClient = pUPowerClient;
pSharedMemory->pBatteryDeviceList = pBatteryDeviceList;
}
static void _fetch_current_values (GList *pBatteryDeviceList)
{
myData.bOnBattery = FALSE;
myData.bBatteryPresent = FALSE;
myData.iTime = 0;
myData.iPercentage = 0; // since we are not on battery, this will not trigger any alert.
if (! pBatteryDeviceList)
return;
UpDevice *pDevice;
gboolean is_present;
gdouble fPercentageGlobal = 0.;
GList *pItem;
gint iNbBatteries = 0;
for (pItem = pBatteryDeviceList; pItem != NULL; pItem = g_list_next (pItem))
{
pDevice = pItem->data;
g_object_get (G_OBJECT (pDevice), "is-present", &is_present, NULL);
myData.bBatteryPresent |= is_present;
if (is_present)
{
UpDeviceState iState;
g_object_get (G_OBJECT (pDevice), "state", &iState, NULL);
myData.bOnBattery |= (iState == UP_DEVICE_STATE_DISCHARGING || iState == UP_DEVICE_STATE_PENDING_DISCHARGE); // we assume that all batteries are either charging or discharging, not a mix of both, so that we won't add a 'time-to-empty' with a 'time-to-full'; this avoid us making a first pass on the list to determine 'myData.bOnBattery' and then a 2nd pass to compute the time.
gdouble percentage;
g_object_get (G_OBJECT (pDevice), "percentage", &percentage, NULL);
fPercentageGlobal += percentage;
guint64 time;
g_object_get (G_OBJECT (pDevice), myData.bOnBattery ? "time-to-empty" : "time-to-full", &time, NULL);
myData.iTime += time;
cd_debug ("New data (%d: %p): OnBattery %d ; percentage %f ; time %lu", iNbBatteries, pDevice, myData.bOnBattery, percentage, time);
iNbBatteries ++;
}
}
if (iNbBatteries > 0)
myData.iPercentage = round (fPercentageGlobal / iNbBatteries);
if (myData.iTime == 0 && myData.iPercentage < 100) // the UPower daemon doesn't give us a time, let's compute it ourselves.
myData.iTime = cd_estimate_time ();
}
static void _on_device_list_changed_free_data (void)
{
cd_debug ("Device list changed");
g_free (myData.cTechnology);
myData.cTechnology = NULL;
g_free (myData.cVendor);
myData.cVendor = NULL;
g_free (myData.cModel);
myData.cModel = NULL;
}
static gboolean _cd_upower_update_state (CDSharedMemory *pSharedMemory);
static void _on_device_added (UpClient *pClient, UpDevice *pDevice, gpointer data)
{
CD_APPLET_ENTER;
if (pClient != myData.pUPowerClient) // should not happen...
{
g_object_unref (myData.pUPowerClient);
myData.pUPowerClient = NULL;
}
// if it's really a new device (yes, be secured...)
if (g_list_find (myData.pBatteryDeviceList, pDevice) == NULL)
{
_on_device_list_changed_free_data (); // free data
// update state: get all devices and all info
CDSharedMemory *pSharedMemory = g_new0 (CDSharedMemory, 1);
pSharedMemory->pBatteryDeviceList = _cd_upower_add_and_ref_device_if_battery (pDevice, myData.pBatteryDeviceList);
pSharedMemory->pUPowerClient = pClient;
_cd_upower_update_state (pSharedMemory);
}
CD_APPLET_LEAVE ();
}
static void _on_device_removed (UpClient *pClient, UpDevice *pDevice, gpointer data)
{
CD_APPLET_ENTER;
if (pClient != myData.pUPowerClient) // should not happen...
{
g_object_unref (myData.pUPowerClient);
myData.pUPowerClient = NULL;
}
GList *pOldDevice = g_list_find (myData.pBatteryDeviceList, pDevice);
if (pOldDevice != NULL) // if we've already added this device (yes, be secured)
{
_on_device_list_changed_free_data (); // free data
g_object_unref (pDevice); // unref, we no longer need it...
// update state: get all devices and all info
CDSharedMemory *pSharedMemory = g_new0 (CDSharedMemory, 1);
pSharedMemory->pBatteryDeviceList = g_list_delete_link (myData.pBatteryDeviceList, pOldDevice);
pSharedMemory->pUPowerClient = pClient;
_cd_upower_update_state (pSharedMemory);
}
CD_APPLET_LEAVE ();
}
#ifdef CD_UPOWER_0_99 // one more param
static void _on_device_changed (G_GNUC_UNUSED UpDevice *pDevice, G_GNUC_UNUSED GParamSpec *pSpec, G_GNUC_UNUSED gpointer data)
#else
static void _on_device_changed (G_GNUC_UNUSED UpDevice *pDevice, G_GNUC_UNUSED gpointer data)
#endif
{
// The applet is removed just before an update...
if (myApplet == NULL)
return;
CD_APPLET_ENTER;
cd_debug ("battery properties changed");
// the client object is already up-to-date, just fetch its values.
_fetch_current_values (myData.pBatteryDeviceList);
// and update the icon.
update_icon ();
CD_APPLET_LEAVE ();
}
// Can be launched the first time (with the Task) or when a device is added/removed after.
static gboolean _cd_upower_update_state (CDSharedMemory *pSharedMemory)
{
CD_APPLET_ENTER;
if (pSharedMemory->pUPowerClient == NULL) // no UPower available, try to find the battery by ourselves.
{
cd_debug ("no UPower available");
cd_check_power_files ();
}
else // UPower is available, fetch the values we got from it.
{
// fetch the current values we got on the devices
_fetch_current_values (pSharedMemory->pBatteryDeviceList);
// fetch static values of the devices, and watch for any change
UpDevice *pDevice;
GList *pItem;
gint iSignalID;
GString *sTechnology = NULL, *sVendor = NULL, *sModel = NULL;
const gchar *cTechnology;
gchar *cVendor, *cModel;
gdouble fMaxAvailableCapacity = 0., fTmp;
UpDeviceTechnology iTechnology;
gboolean bFirst = TRUE;
for (pItem = pSharedMemory->pBatteryDeviceList ; pItem != NULL ; pItem = g_list_next (pItem))
{
pDevice = pItem->data;
g_object_get (pDevice, "technology", &iTechnology, NULL);
g_object_get (pDevice, "vendor", &cVendor, NULL);
g_object_get (pDevice, "model", &cModel, NULL);
g_object_get (pDevice, "capacity", &fTmp, NULL);
fMaxAvailableCapacity += fTmp;
cTechnology = up_device_technology_to_string (iTechnology);
cd_debug ("New Battery: %s, %s, %s, %f", cTechnology, cVendor, cModel, fTmp);
if (bFirst)
{
sTechnology = g_string_new (cTechnology);
sVendor = g_string_new (cVendor);
sModel = g_string_new (cModel);
}
else
{
g_string_append_printf (sTechnology, " & %s", cTechnology);
g_string_append_printf (sVendor, " & %s", cVendor);
g_string_append_printf (sModel, " & %s", cModel);
}
g_free (cVendor);
g_free (cModel);
if (myData.pTask != NULL // only the first time
|| myData.pBatteryDeviceList == NULL // or if it's a new device
|| g_list_find (myData.pBatteryDeviceList, pDevice) == NULL)
// or compare the up_device_get_object_path (pDevice) ?
{
/* watch for any change. A priori, no need to watch the
* "onBattery" signal on the client, since we can deduce this
* property from the device state.
* A battery not present is still a valid device. So if we could
* find a battery device, it will stay here forever, so we don't
* need to watch for the destruction/creation of a battery device.
*/
#ifdef CD_UPOWER_0_99 // Now called notify
iSignalID = g_signal_connect (pDevice, "notify", G_CALLBACK (_on_device_changed), NULL);
#else
iSignalID = g_signal_connect (pDevice, "changed", G_CALLBACK (_on_device_changed), NULL);
#endif
myData.pSignalIDList = g_list_append (myData.pSignalIDList, GINT_TO_POINTER (iSignalID));
}
bFirst = FALSE;
}
myData.fMaxAvailableCapacity = fMaxAvailableCapacity; // Add all capacities
if (! bFirst) // at least one battery, strings have been defined
{
myData.cTechnology = g_string_free (sTechnology, FALSE);
myData.cVendor = g_string_free (sVendor, FALSE);
myData.cModel = g_string_free (sModel, FALSE);
}
if (myData.pTask != NULL // only the first time
|| pSharedMemory->pUPowerClient != myData.pUPowerClient) // or a new client (should not happen...)
{
myData.iSignalIDAdded = g_signal_connect (pSharedMemory->pUPowerClient,
"device-added", G_CALLBACK (_on_device_added), NULL);
myData.iSignalIDRemoved = g_signal_connect (pSharedMemory->pUPowerClient,
"device-removed", G_CALLBACK (_on_device_removed), NULL);
// Note: these signals (removed and added) are also send when resuming from suspend...
}
// keep our client and devices.
myData.pUPowerClient = pSharedMemory->pUPowerClient;
pSharedMemory->pUPowerClient = NULL;
myData.pBatteryDeviceList = pSharedMemory->pBatteryDeviceList;
pSharedMemory->pBatteryDeviceList = NULL; // so we won't unref it in the destroy callback of the task.
}
// in any case, update the icon to show the current state we are in.
update_icon ();
if (myData.pTask != NULL)
{
gldi_task_discard (myData.pTask);
myData.pTask = NULL;
}
CD_APPLET_LEAVE (FALSE);
}
static void _free_shared_memory (CDSharedMemory *pSharedMemory)
{
if (pSharedMemory->pUPowerClient)
g_object_unref (pSharedMemory->pUPowerClient);
if (pSharedMemory->pBatteryDeviceList)
g_list_foreach (pSharedMemory->pBatteryDeviceList, (GFunc) g_object_unref, NULL); // remove the ref we took on it.
g_free (pSharedMemory);
}
void cd_powermanager_start (void)
{
if (myData.pTask != NULL)
{
gldi_task_discard (myData.pTask);
myData.pTask = NULL;
}
CDSharedMemory *pSharedMemory = g_new0 (CDSharedMemory, 1);
myData.pTask = gldi_task_new_full (0,
(GldiGetDataAsyncFunc) _cd_upower_connect_async,
(GldiUpdateSyncFunc) _cd_upower_update_state,
(GFreeFunc) _free_shared_memory,
pSharedMemory);
gldi_task_launch (myData.pTask);
}
void cd_upower_stop (void)
{
if (myData.pUPowerClient != NULL)
{
g_object_unref (myData.pUPowerClient);
myData.pUPowerClient = NULL;
}
if (myData.pSignalIDList)
{
g_list_foreach (myData.pSignalIDList, (GFunc) g_source_remove, NULL);
g_list_free (myData.pSignalIDList);
myData.pSignalIDList = NULL;
}
if (myData.pBatteryDeviceList)
{
g_list_foreach (myData.pBatteryDeviceList, (GFunc) g_object_unref, NULL); // remove the ref we took on the device. it may or not destroy the object, that's why we disconnected manually the signal above.
g_list_free (myData.pBatteryDeviceList);
myData.pBatteryDeviceList = NULL;
}
if (myData.iSignalIDAdded != 0)
{
g_source_remove (myData.iSignalIDAdded);
myData.iSignalIDAdded = 0;
}
if (myData.iSignalIDRemoved != 0)
{
g_source_remove (myData.iSignalIDRemoved);
myData.iSignalIDRemoved = 0;
}
}
#else // code without libupower
void cd_powermanager_start (void)
{
cd_check_power_files ();
}
void cd_upower_stop (void)
{
}
#endif