/**
* This file is a part of the Cairo-Dock project
*
* Copyright : (C) see the 'copyright' file.
* 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 "powermanager-struct.h"
#include "powermanager-proc-acpi.h"
#include "powermanager-sys-class.h"
#include "powermanager-draw.h"
#include "powermanager-common.h"
static double cd_compute_current_rate (void)
{
double fPresentRate = 0.;
if (myData.iPrevPercentage > 0)
{
if (myData.iStatPercentageBegin != 0)
myData.iStatTimeCount += myConfig.iCheckInterval;
if (myData.iPrevPercentage != myData.iPercentage) // we compute the rate from 2 changing points.
{
if (myData.iStatPercentageBegin == 0)
{
myData.iStatPercentageBegin = myData.iPercentage;
myData.iStatTimeCount= 0;
myData.iStatTime = 0;
}
else
{
myData.iStatPercentage = myData.iPercentage;
myData.iStatTime = myData.iStatTimeCount;
}
}
if (myData.iStatPercentage != 0)
fPresentRate = (double)fabs (myData.iStatPercentage - myData.iStatPercentageBegin) / myData.iStatTime * 36.;
cd_message ("instant rate : %.1f -> %.1f (%ds) => %.3f", (double)myData.iStatPercentageBegin, (double)myData.iStatPercentage, myData.iStatTime, fPresentRate);
/**
fPresentRate = (myData.iPrevPercentage - myData.iPercentage) * 36. * myData.iCapacity / myConfig.iCheckInterval;
cd_message ("instant rate : %.2f -> %.2f => %.2f", (double)myData.iPrevPercentage, (double)myData.iPercentage, fPresentRate);
if (fPresentRate != 0)
{
myData.fRateHistory[myData.iCurrentIndex] = fPresentRate;
double fMeanRate = 0.;
int nb_values=0;
double fNextValue = 0.;
int iNbStackingValues = 0;
int i, k;
for (k = 0; k < myData.iIndexMax; k ++)
{
if (myData.iIndexMax == PM_NB_VALUES)
i = (myData.iCurrentIndex + 1 + k) % PM_NB_VALUES;
else
i = k;
if (myData.fRateHistory[i] != 0)
{
if (fNextValue != 0)
{
nb_values += iNbStackingValues;
fMeanRate += fNextValue;
}
fNextValue = myData.fRateHistory[i];
iNbStackingValues = 1;
}
else
{
iNbStackingValues ++;
}
}
if (nb_values != 0)
fPresentRate = fabs (fMeanRate) / nb_values;
cd_message ("mean calculated on %d value(s) : %.2f (current index:%d/%d)", nb_values, fPresentRate, myData.iCurrentIndex, myData.iIndexMax);
myData.iCurrentIndex ++;
if (myData.iIndexMax < PM_NB_VALUES)
myData.iIndexMax = myData.iCurrentIndex;
if (myData.iCurrentIndex == PM_NB_VALUES)
myData.iCurrentIndex = 0;
}*/
}
return fPresentRate;
}
static void cd_store_current_rate (double fPresentRate)
{
if (myData.bOnBattery)
{
myData.fDischargeMeanRate = (myData.fDischargeMeanRate * myData.iNbDischargeMeasures + fPresentRate) / (myData.iNbDischargeMeasures + 1);
myData.iNbDischargeMeasures ++;
cd_debug ("fDischargeMeanRate : %.3f (%d)", myData.fDischargeMeanRate, myData.iNbDischargeMeasures);
if (myConfig.fLastDischargeMeanRate == 0 || (double) fabs (myConfig.fLastDischargeMeanRate - myData.fDischargeMeanRate) / myConfig.fLastDischargeMeanRate > .01) // l'ecart avec la valeur stockee en conf est devenue grande, on met a jour cette derniere.
{
cd_debug ("write discharge rate : %.2f -> %.2f", myConfig.fLastDischargeMeanRate, myData.fDischargeMeanRate);
cairo_dock_update_conf_file (CD_APPLET_MY_CONF_FILE,
G_TYPE_DOUBLE, "Configuration", "discharge rate", myConfig.fLastDischargeMeanRate,
G_TYPE_INVALID);
myConfig.fLastDischargeMeanRate = myData.fDischargeMeanRate;
}
}
else
{
myData.fChargeMeanRate = (myData.fChargeMeanRate * myData.iNbChargeMeasures + fPresentRate) / (myData.iNbChargeMeasures + 1);
myData.iNbChargeMeasures ++;
cd_debug ("fChargeMeanRate : %.3f (%d)", myData.fChargeMeanRate, myData.iNbChargeMeasures);
if (myConfig.fLastChargeMeanRate == 0 || (double) fabs (myConfig.fLastChargeMeanRate - myData.fChargeMeanRate) / myConfig.fLastChargeMeanRate > .01) // l'ecart avec la valeur stockee en conf est devenue grande, on met a jour cette derniere.
{
cd_debug ("charge rate : %.2f -> %.2f", myConfig.fLastChargeMeanRate, myData.fChargeMeanRate);
cairo_dock_update_conf_file (CD_APPLET_MY_CONF_FILE,
G_TYPE_DOUBLE, "Configuration", "charge rate", myConfig.fLastChargeMeanRate,
G_TYPE_INVALID);
myConfig.fLastChargeMeanRate = myData.fChargeMeanRate;
}
}
}
static double cd_compute_time (double fPresentRate)
{
double time = 0.;
if (myData.iPercentage < 99.9) // not charged or almost charged.
{
if (myData.bOnBattery) // time before discharged.
{
if (fPresentRate > 0)
{
time = 36. * myData.iPercentage / fPresentRate;
}
}
else // time before charged
{
if (fPresentRate > 0)
{
time = 36. * (100. - myData.iPercentage) / fPresentRate;
}
}
}
return time;
}
int cd_estimate_time (void)
{
//\_______________ compute the variation rate.
double fPresentRate = cd_compute_current_rate ();
//\_______________ store this value in conf if it has changed too much.
if (fPresentRate > 0)
{
cd_store_current_rate (fPresentRate);
}
else if (myData.bOnBattery || myData.iPercentage < 99.9) // if we are on sector and fully charged, the rate is of course 0.
{
cd_debug ("no rate, using last know values : %.2f ; %.2f", myConfig.fLastDischargeMeanRate, myConfig.fLastChargeMeanRate);
fPresentRate = (myData.bOnBattery ? myConfig.fLastDischargeMeanRate : myConfig.fLastChargeMeanRate);
}
//\_______________ now compute the time.
return cd_compute_time (fPresentRate);
}
static gboolean _update_stats (void)
{
if (myData.bProcAcpiFound)
cd_get_stats_from_proc_acpi ();
else
cd_get_stats_from_sys_class ();
update_icon ();
return (myData.cBatteryStateFilePath != NULL);
}
static gboolean _update_stats_loop (void)
{
CD_APPLET_ENTER;
gboolean bContinue = _update_stats ();
if (! bContinue)
myData.checkLoop = 0;
CD_APPLET_LEAVE (bContinue);
}
void cd_check_power_files (void)
{
// try to find the battery
myData.bProcAcpiFound = cd_find_battery_proc_acpi ();
if (! myData.bProcAcpiFound)
myData.bSysClassFound = cd_find_battery_sys_class ();
// if found, get the current stats.
if (myData.cBatteryStateFilePath != NULL)
_update_stats ();
// and keep them up-to-date.
if (myData.cBatteryStateFilePath != NULL)
{
myData.fDischargeMeanRate = myConfig.fLastDischargeMeanRate;
myData.fChargeMeanRate = myConfig.fLastChargeMeanRate;
myData.checkLoop = g_timeout_add_seconds (myConfig.iCheckInterval, (GSourceFunc) _update_stats_loop, (gpointer) NULL);
}
}
void cd_powermanager_change_loop_frequency (gint iSeconds)
{
if (myData.checkLoop != 0)
{
g_source_remove (myData.checkLoop);
myData.checkLoop = g_timeout_add_seconds (iSeconds, (GSourceFunc) _update_stats_loop, (gpointer) NULL);
}
}