TDE
/
tdepowersave
6
0
Atdalīts 1
Kods Problēmas 2 Izmaiņu pieprasījumi 1 Laidieni Vikivietne Aktivitāte

Switch from dbus-tqt do dbus-1-tqt

Pārlūkot izejas kodu 
Add systemd session and inhibit support
Cleanup unused methods
This partially resolves Bug 1597
pull/1/head
Slávek Banko pirms 10 gadiem
vecāks 5c45c1a222
revīzija c68a1bac04
13 mainītis faili ar 332 papildinājumiem un 989 dzēšanām
Rādīt statistiku Lejupielādēt ielāpa failu Lejupielādēt izmaiņu failu

6
ConfigureChecks.cmake
Atkodēt Parādīt failu

@ -51,10 +51,10 @@ if( NOT DBUS_FOUND )
endif( )
# check for dbus-tqt
pkg_search_module( DBUS_TQT dbus-tqt )
# check for dbus-1-tqt
pkg_search_module( DBUS_TQT dbus-1-tqt )
if( NOT DBUS_TQT_FOUND )
tde_message_fatal( "dbus-tqt is required, but was not found on your system" )
tde_message_fatal( "dbus-1-tqt is required, but was not found on your system" )
endif( )
# check for msgfmt

4
src/CMakeLists.txt
Atkodēt Parādīt failu

@ -16,8 +16,8 @@ include_directories(
${CMAKE_BINARY_DIR}
${TDE_INCLUDE_DIR}
${TQT_INCLUDE_DIRS}
${DBUS_INCLUDE_DIRS}
${DBUS_TQT_INCLUDE_DIRS}
${HAL_INCLUDE_DIRS}
)
link_directories(
@ -48,6 +48,6 @@ tde_add_tdeinit_executable( tdepowersave AUTOMOC
tdepowersave.skel log_viewer.ui logviewer.cpp main.cpp
screen.cpp settings.cpp suspenddialog.cpp suspend_Dialog.ui
LINK
${DBUS_TQT_LIBRARIES} tdeio-shared ${HAL_LIBRARIES}
${DBUS_TQT_LIBRARIES} tdeio-shared
${XEXT_LIBRARIES} ${XTST_LIBRARIES} ${XSCRNSAVER_LIBRARIES}
)

1
src/Makefile.am
Atkodēt Parādīt failu

@ -21,7 +21,6 @@ noinst_HEADERS = \
infodialog.h \
tdepowersave.h \
logviewer.h \
privileges.h \
screen.h \
settings.h \
suspenddialog.h

769
src/dbusInterface.cpp
Atkodēt Parādīt failu

@ -19,38 +19,52 @@
/*!
* \file dbusInterface.cpp
* \brief In this file can be found the functionality to connect to
* the HAL daemon via D-Bus, to handle D-Bus calls/events and to
* provide wrapper to HAL lib and functions
* \brief In this file can be found the functionality to connect to
* the D-Bus, to handle D-Bus session management
* \author Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>
* \date 2006-2007
*/
// KDE Header
// QT - Header
#include <tqtimer.h>
// KDE Header
#include <tdelocale.h>
// DBUS - Header
#include "dbus/dbus-shared.h"
#include "dbusInterface.h"
#include <tqdbusdatalist.h>
#include <tqdbusdatamap.h>
#include <tqdbuserror.h>
#include <tqdbusmessage.h>
#include <tqdbusvariant.h>
// system headers
#include <iostream>
#include <unistd.h>
#define DBUS_CONN_NAME "TDEPowersave"
static void* myInstance = 0;
/*! The default constructor of the class dbusInterface. */
dbusInterface::dbusInterface(){
dbusInterface::dbusInterface():
dBusConn(),
dBusWatch(0),
dBusLocal(0),
systemdSession(),
systemdSeat(0),
systemdInhibit(-1),
consolekitSession(),
consolekitSeat(0)
{
kdDebugFuncIn(trace);
dbus_is_connected = false;
acquiredPolicyPower = false;
// add pointer to this for filter_function()
myInstance=this;
// init connection to dbus
if(!initDBUS()) {
kdError() << "Can't connect to D-Bus" << endl;
m_dBusQtConnection = NULL;
}
initDBUS();
kdDebugFuncOut(trace);
}
@ -72,30 +86,19 @@ dbusInterface::~dbusInterface(){
* \retval false if disconnected
*/
bool dbusInterface::isConnectedToDBUS() {
return dbus_is_connected;
}
/*!
* This function return information if the org.freedesktop.Policy.Power
* interface was claimed.
* \return boolean with the status of claim the interface
* \retval true if acquired
* \retval false if not
*/
bool dbusInterface::acquiredPolicyPowerInterface() {
return acquiredPolicyPower;
return dBusConn.isConnected();
}
/*!
* This function try a reconnect to D-Bus and HAL daemon.
* This function try a reconnect to D-Bus.
* \return boolean with the result of the operation
* \retval true if successful reconnected to D-Bus and HAL
* \retval true if successful reconnected to D-Bus
* \retval false if unsuccessful
*/
bool dbusInterface::reconnect() {
// close D-Bus connection
close();
// init D-Bus conntection and HAL context
// init D-Bus conntection
return (initDBUS());
}
@ -106,18 +109,24 @@ bool dbusInterface::reconnect() {
* \retval false if any problems
*/
bool dbusInterface::close() {
if ( m_dBusQtConnection != NULL ) {
releasePolicyPowerIface();
m_dBusQtConnection->close();
m_dBusQtConnection = NULL;
if( dBusConn.isConnected() ) {
if( dBusWatch ) {
delete dBusWatch;
}
if( dBusLocal ) {
delete dBusLocal;
}
if( systemdSeat ) {
delete systemdSeat;
}
if( consolekitSeat ) {
delete consolekitSeat;
}
}
dbus_is_connected = false;
dBusConn.closeConnection(DBUS_CONN_NAME);
return true;
}
/* ----> D-Bus section :: START <---- */
/*!
* This function initialise the connection to the D-Bus daemon.
* \return boolean with the result of the operation
@ -127,528 +136,260 @@ bool dbusInterface::close() {
bool dbusInterface::initDBUS(){
kdDebugFuncIn(trace);
dbus_is_connected = false;
DBusError error;
dbus_error_init(&error);
dbus_connection = dbus_bus_get( DBUS_BUS_SYSTEM, &error );
dBusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus, DBUS_CONN_NAME);
if (dbus_connection == NULL){
kdError() << "Failed to open connection to system message bus: " << error.message << endl;
dbus_error_free (&error);
if( !dBusConn.isConnected() ) {
kdError() << "Failed to open connection to system message bus: " << dBusConn.lastError().message() << endl;
TQTimer::singleShot(4000, this, TQT_SLOT(reconnect()));
return false;
}
if ( dbus_error_is_set( &error ) ) {
kdError() << "Failed to register connection with system message bus: " << error.message << endl;
return false;
}
acquirePolicyPowerIface();
dbus_connection_set_exit_on_disconnect( dbus_connection, false );
/* add the filter function which should be executed on events on the bus */
if ( ! dbus_connection_add_filter( dbus_connection, filterFunction, this, NULL) ) {
kdFatal() << "Error: Not enough memory to add filter to dbus connection" << endl;
exit(EXIT_FAILURE);
}
/* add a match rule to catch all signals going through the bus with D-Bus interface */
dbus_bus_add_match( dbus_connection, "type='signal',"
"interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'", NULL);
/* add a match rule to catch all signals going through the bus with ConsoleKit Interface */
dbus_bus_add_match( dbus_connection, "type='signal',"
"interface='org.freedesktop.ConsoleKit.Session',"
"member='ActiveChanged'", NULL);
m_dBusQtConnection = new DBusQt::Connection(this);
m_dBusQtConnection->dbus_connection_setup_with_qt_main(dbus_connection);
dbus_is_connected = true;
kdDebugFuncOut(trace);
return true;
}
/*!
* This function acquire the org.freedesktop.Policy.Power interface
* \return boolean with the result of the operation
* \retval true if successful acquired the interface
* \retval false if unsuccessful
*/
bool dbusInterface::acquirePolicyPowerIface(){
kdDebugFuncIn(trace);
if (dbus_connection == NULL) {
kdDebugFuncOut(trace);
return false;
// watcher for NameOwnerChanged signals
dBusWatch = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
TQObject::connect(dBusWatch, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
// watcher for Disconnect signal
dBusLocal = new TQT_DBusProxy(DBUS_SERVICE_DBUS, DBUS_PATH_LOCAL, DBUS_INTERFACE_LOCAL, dBusConn);
TQObject::connect(dBusLocal, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
// find already running SystemD
TQT_DBusProxy checkSystemD(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
if( checkSystemD.canSend() ) {
TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromString(SYSTEMD_LOGIN1_SERVICE);
TQT_DBusMessage reply = checkSystemD.sendWithReply("NameHasOwner", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 && reply[0].toBool() ) {
onServiceRegistered(SYSTEMD_LOGIN1_SERVICE);
}
}
DBusError err;
dbus_error_init(&err);
int ret = dbus_bus_request_name(dbus_connection, "org.freedesktop.Policy.Power",
DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
kdWarning() << "Acquire org.freedesktop.Policy.Power interface failed with error: " << err.message << endl;
dbus_error_free(&err);
}
switch (ret) {
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
kdDebug() << "Acquired org.freedesktop.Policy.Power interface" << endl;
acquiredPolicyPower = true;
break;
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
kdWarning() << "Queued to acquire org.freedesktop.Policy.Power interface" << endl;
acquiredPolicyPower = false;
break;
default:
acquiredPolicyPower = false;
break;
// find already running ConsoleKit
TQT_DBusProxy checkConsoleKit(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, dBusConn);
if( checkConsoleKit.canSend() ) {
TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromString(CK_SERVICE);
TQT_DBusMessage reply = checkConsoleKit.sendWithReply("NameHasOwner", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 && reply[0].toBool() ) {
onServiceRegistered(CK_SERVICE);
}
}
kdDebugFuncOut(trace);
return acquiredPolicyPower;
return true;
}
/*!
* This function release the org.freedesktop.Policy.Power interface
* \return boolean with the result of the operation
* \retval true if successful acquired the interface
* \retval false if unsuccessful
* This function handles signals from the D-Bus daemon.
*/
bool dbusInterface::releasePolicyPowerIface(){
kdDebugFuncIn(trace);
int result;
bool retval = false;
DBusError error;
if (dbus_connection == NULL) {
kdDebugFuncOut(trace);
return false;
void dbusInterface::handleDBusSignal(const TQT_DBusMessage& msg) {
// dbus terminated
if( msg.path() == DBUS_PATH_LOCAL
&& msg.interface() == DBUS_INTERFACE_LOCAL
&& msg.member() == "Disconnected" ) {
close();
TQTimer::singleShot(1000, this, TQT_SLOT(reconnect()));
return;
}
dbus_error_init(&error);
result = dbus_bus_release_name(dbus_connection, "org.freedesktop.Policy.Power", &error);
if ( dbus_error_is_set( &error ) ) {
kdError() << "Failed to release org.freedesktop.Policy.Power: " << error.message << endl;
dbus_error_free(&error);
} else {
switch (result) {
case DBUS_RELEASE_NAME_REPLY_RELEASED:
kdDebug() << "Released org.freedesktop.Policy.Power interface" << endl;
retval = true;
acquiredPolicyPower = false;
break;
case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
kdWarning() << "Couldn't release org.freedesktop.Policy.Power, not the owner" << endl;
break;
case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
kdWarning() << "Couldn't release org.freedesktop.Policy.Power, Iface not existing" << endl;
break;
default:
kdWarning() << "Couldn't release org.freedesktop.Policy.Power, unknown error" << endl;
break;
// service registered / unregistered
if( msg.path() == DBUS_PATH_DBUS
&& msg.interface() == DBUS_INTERFACE_DBUS
&& msg.member() == "NameOwnerChanged" ) {
if( msg[1].toString().isEmpty() ) {
// old-owner is empty
onServiceRegistered(msg[0].toString());
}
if( msg[2].toString().isEmpty() ) {
// new-owner is empty
onServiceUnregistered(msg[0].toString());
}
return;
}
return retval;
kdDebugFuncOut(trace);
}
/*!
* This function check if the org.freedesktop.Policy.Power
* interface is owned by someone
* \return boolean with the result of the operation
* \retval true if the interface is owned by someone
* \retval false if else
*/
bool dbusInterface::isPolicyPowerIfaceOwned(){
kdDebugFuncIn(trace);
bool retval = false;
DBusError error;
if (dbus_connection == NULL) {
kdDebugFuncOut(trace);
return false;
// systemd session changed
if( systemdSeat && systemdSeat->canSend()
&& msg.path() == systemdSeat->path()
&& msg.interface() == DBUS_INTERFACE_PROPERTIES
&& msg.member() == "PropertiesChanged"
&& msg[0].toString() == SYSTEMD_LOGIN1_SEAT_IFACE) {
bool activeSessionProperty = false;
TQT_DBusDataMap<TQString> map = msg[1].toStringKeyMap();
TQT_DBusDataMap<TQString>::const_iterator it = map.begin();
for (; !activeSessionProperty && it != map.end(); ++it) {
if( it.key() != "ActiveSession" ) {
activeSessionProperty = true;
}
}
TQValueList<TQString> list = msg[2].toList().toStringList();
TQValueList<TQString>::const_iterator it1 = list.begin();
for (; !activeSessionProperty && it1 != list.end(); ++it1) {
if( (*it1) == "ActiveSession" ) {
activeSessionProperty = true;
}
}
if( activeSessionProperty ) {
emit activeSessionChanged(checkActiveSession());
}
return;
}
dbus_error_init(&error);
retval = dbus_bus_name_has_owner(dbus_connection, "org.freedesktop.Policy.Power", &error);
if ( dbus_error_is_set( &error ) ) {
kdError() << "Failed to check if org.freedesktop.Policy.Power has an owner: " << error.message << endl;
dbus_error_free(&error);
// consolekit session changed
if( consolekitSeat && consolekitSeat->canSend()
&& msg.path() == consolekitSeat->path()
&& msg.interface() == CK_SEAT_IFACE
&& msg.member() == "ActiveSessionChanged") {
emit activeSessionChanged(msg[0].toString() == TQString(consolekitSession));
return;
}
kdDebugFuncOut(trace);
return retval;
}
/* ----> DBUS section :: END <---- */
/* ----> D-Bus methode calls functions :: START <---- */
/*!
* This function call a D-Bus method
* \param interface TQString with te dbus interface
* \param path TQString with the object path
* \param object TQString with the object name
* \param method TQString with the name of the methode
* \param first_arg_type integer with the dbus type of the first argument
* \param ... more arguments
* \return If the query was successful or not
*/
bool dbusInterface::dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
int first_arg_type, ... ) {
kdDebugFuncIn(trace);
bool _ret = false;
va_list var_args;
va_start(var_args, first_arg_type);
_ret = dbusMethodCall( interface, path, object, method, DBUS_BUS_SYSTEM,
NULL, -1, first_arg_type, var_args);
va_end(var_args);
kdDebugFuncOut(trace);
return _ret;
}
/*!
* This overloaded function call a D-Bus method on the D-Bus system bus with a return value
* \param interface TQString with the dbus interface
* \param path TQString with the object path
* \param object TQString with the object name
* \param method TQString with the name of the method
* \param retvalue void pointer to arguments, if NULL we make a simple call
* \param retval_type Integer with the dbus type of the return value, set to -1 if retvalue is NULL
* \param first_arg_type Integer with the dbus type of the first argument followed by the value
* \return If the query was successful or not
*/
bool dbusInterface::dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
void *retvalue, int retval_type, int first_arg_type, ... ) {
kdDebugFuncIn(trace);
bool _ret = false;
va_list var_args;
va_start(var_args, first_arg_type);
_ret = dbusMethodCall( interface, path, object, method, DBUS_BUS_SYSTEM,
retvalue, retval_type, first_arg_type, var_args);
va_end(var_args);
kdDebugFuncOut(trace);
return _ret;
}
/*!
* This function call a D-Bus method with a return value
* \param interface TQString with the dbus interface
* \param path TQString with the object path
* \param object TQString with the object name
* \param method TQString with the name of the method
* \param dbus_type DBusBusType with the D-Bus BUS Type
* \param retvalue void pointer to arguments, if NULL we make a simple call
* \param retval_type Integer with the dbus type of the return value, set to -1 if retvalue is NULL
* \param first_arg_type Integer with the dbus type of the first argument followed by the value
* \param var_args va_list with more arguments
* \return If the query was successful or not
/*!
* This function handles dBus service registering
*/
bool dbusInterface::dbusMethodCall( TQString interface, TQString path, TQString object, TQString method,
DBusBusType dbus_type, void *retvalue, int retval_type, int first_arg_type,
va_list var_args ) {
kdDebugFuncIn(trace);
DBusMessage *message;
DBusMessage *reply;
DBusError error;
bool ret = false;
dbus_error_init(&error);
dbus_connection = dbus_bus_get(dbus_type, &error);
if (dbus_error_is_set(&error)) {
kdError() << "Could not get dbus connection: " << error.message << endl;
dbus_error_free(&error);
goto out;
}
message = dbus_message_new_method_call( interface.ascii(), path.ascii(), object.ascii(), method.ascii() );
dbus_message_append_args_valist(message, first_arg_type, var_args);
void dbusInterface::onServiceRegistered(const TQString& service) {
if( service == SYSTEMD_LOGIN1_SERVICE ) {
// get current session
TQT_DBusProxy managerIface(SYSTEMD_LOGIN1_SERVICE, SYSTEMD_LOGIN1_PATH, SYSTEMD_LOGIN1_MANAGER_IFACE, dBusConn);
systemdSession = TQT_DBusObjectPath();
if( managerIface.canSend() ) {
TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromUInt32( getpid() );
TQT_DBusMessage reply = managerIface.sendWithReply("GetSessionByPID", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
systemdSession = reply[0].toObjectPath();
}
}
if( !systemdSession.isValid() ) {
kdWarning() << "The session is not registered with systemd" << endl;
return;
}
if (retvalue == NULL) {
if (!dbus_connection_send(dbus_connection, message, NULL)) {
kdError() << "Could not send method call." << endl;
dbus_message_unref( message );
goto out;
// get session seat
TQT_DBusProxy sessionProperties(SYSTEMD_LOGIN1_SERVICE, systemdSession, DBUS_INTERFACE_PROPERTIES, dBusConn);
TQT_DBusObjectPath seat;
if( sessionProperties.canSend() ) {
TQValueList<TQT_DBusData> params;
params
<< TQT_DBusData::fromString( SYSTEMD_LOGIN1_SESSION_IFACE )
<< TQT_DBusData::fromString( "Seat" );
TQT_DBusMessage reply = sessionProperties.sendWithReply("Get", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
seat = reply[0].toVariant().value.toStruct()[1].toObjectPath();
}
}
} else {
reply = dbus_connection_send_with_reply_and_block(dbus_connection, message, -1, &error);
if (dbus_error_is_set(&error)) {
kdError() << "Could not send dbus message: " << error.message << endl;
dbus_message_unref(message);
dbus_error_free(&error);
goto out;
if( !seat.isValid() ) {
kdWarning() << "Unable to associate systemd session with a seat" << endl;
return;
}
int type = dbus_message_get_type(reply);
if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
if (!dbus_message_get_args(reply, &error, retval_type, retvalue, DBUS_TYPE_INVALID)){
if (dbus_error_is_set(&error)) {
kdError() << "Could not get argument from reply: "
<< error.message << endl;
dbus_error_free(&error);
}
dbus_message_unref(reply);
dbus_message_unref(message);
goto out;
// watch session changes
systemdSeat = new TQT_DBusProxy(SYSTEMD_LOGIN1_SERVICE, seat, DBUS_INTERFACE_PROPERTIES, dBusConn);
TQObject::connect(systemdSeat, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
// inhibit systemd handling of power/sleep/hibernate/lid buttons
// http://www.freedesktop.org/wiki/Software/systemd/inhibit
if( !systemdInhibit.isValid() && managerIface.canSend() ) {
TQValueList<TQT_DBusData> params;
params
<< TQT_DBusData::fromString("handle-power-key:handle-suspend-key:handle-hibernate-key:handle-lid-switch") // what
<< TQT_DBusData::fromString("TDEPowersave") // who
<< TQT_DBusData::fromString("TDE handles power events") // why
<< TQT_DBusData::fromString("block"); // mode
TQT_DBusMessage reply = managerIface.sendWithReply("Inhibit", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
systemdInhibit = reply[0].toUnixFd();
}
} else {
kdError() << "Revieved invalid DBUS_MESSAGE_TYPE: " << type
<< "expected: " << DBUS_MESSAGE_TYPE_METHOD_RETURN << endl;
dbus_message_unref(reply);
dbus_message_unref(message);
goto out;
}
return;
}
if( service == CK_SERVICE ) {
// get current session
TQT_DBusProxy managerIface(CK_SERVICE, CK_MANAGER_OBJECT, CK_MANAGER_IFACE, dBusConn);
consolekitSession = TQT_DBusObjectPath();
if( managerIface.canSend() ) {
TQValueList<TQT_DBusData> params;
params << TQT_DBusData::fromUInt32( getpid() );
TQT_DBusMessage reply = managerIface.sendWithReply("GetSessionForUnixProcess", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
consolekitSession = reply[0].toObjectPath();
}
}
if( !consolekitSession.isValid() ) {
kdWarning() << "The session is not registered with consolekit" << endl;
return;
}
ret = true; // if we are here, everything should be okay
dbus_message_unref(message);
dbus_connection_flush(dbus_connection);
out:
kdDebugFuncOut(trace);
return ret;
}
/* ----> D-Bus methode calls functions :: END <---- */
/* ---> PolicyKit method call section :: START <--- */
/*!
* Check if the user is privileged to a special privilege
* \param privilege TQString with the name of the requested privilege
* \param udi TQString with the UDI.
* \param ressource TQString with the name of the ressource
* \param user TQString with the name of the user. If empty the current user is used.
* \return int with info if the user is allowed or not.
* \retval 0 if not allowed
* \retval 1 if allowed
* \retval -1 if a error occurs or we could not query the interface
*/
int dbusInterface::isUserPrivileged(TQString privilege, TQString udi, TQString ressource, TQString user) {
kdDebugFuncIn(trace);
// get session seat
TQT_DBusObjectPath seat;
if( dBusConn.isConnected() ) {
TQT_DBusMessage msg = TQT_DBusMessage::methodCall(CK_SERVICE, consolekitSession, CK_SESSION_IFACE, "GetSeatId");
TQT_DBusMessage reply = dBusConn.sendWithReply(msg);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
seat = reply[0].toObjectPath();
}
}
if( !seat.isValid() ) {
kdWarning() << "Unable to associate consolekit session with a seat" << endl;
return;
}
const char *_unique_name;
const char *_user;
const char *_privilege;
int retval = -1;
if (user.isEmpty() || user.isNull())
_user = getenv("USER");
else
_user = user.latin1();
if (_user == NULL || privilege.isEmpty())
goto out;
_unique_name = dbus_bus_get_unique_name(dbus_connection);
_privilege = privilege.latin1();
// not sure if we need this, but to avoid problems
dbus_bool_t _retval;
const char *_ressource;
_ressource = ressource.latin1();
if (!dbusSystemMethodCall( "org.freedesktop.PolicyKit",
"/org/freedesktop/PolicyKit/Manager",
"org.freedesktop.PolicyKit.Manager",
"IsUserPrivileged",
&_retval, DBUS_TYPE_BOOLEAN,
DBUS_TYPE_STRING, &_unique_name,
DBUS_TYPE_STRING, &_user,
DBUS_TYPE_STRING, &_privilege,
DBUS_TYPE_STRING, &_ressource,
DBUS_TYPE_INVALID)) {
retval = -1; // only to be sure we have no changes trough the call
} else {
retval = (int) _retval;
// watch session changes
consolekitSeat = new TQT_DBusProxy(CK_SERVICE, seat, CK_SEAT_IFACE, dBusConn);
TQObject::connect(consolekitSeat, TQT_SIGNAL(dbusSignal(const TQT_DBusMessage&)),
this, TQT_SLOT(handleDBusSignal(const TQT_DBusMessage&)));
return;
}
out:
kdDebugFuncOut(trace);
return retval;
}
/* ---> PolicyKit method call section :: END <--- */
/*!
* Use this TQT_SLOT to emit a reviced messages to the tdepowersave.
* NOTE: Because of the filter function this need to be a public function.
* Don't use this function in any other place than this class.
* \param type enum with the type of the message
* \param message String with the message
* \param string String with additional info
* This function handles dBus service unregistering
*/
void dbusInterface::emitMsgReceived( msg_type type, TQString message, TQString string ) {
if (message.startsWith("dbus.terminate"))
dbus_is_connected = false;
if (type == POLICY_POWER_OWNER_CHANGED) {
if (message.startsWith("NOW_OWNER"))
acquiredPolicyPower = true;
else
acquiredPolicyPower = false;
void dbusInterface::onServiceUnregistered(const TQString& service) {
if( service == SYSTEMD_LOGIN1_SERVICE ) {
systemdSession = TQT_DBusObjectPath();
if( systemdSeat ) {
delete systemdSeat;
}
return;
}
if( service == CK_SERVICE ) {
consolekitSession = TQT_DBusObjectPath();
if( consolekitSeat ) {
delete consolekitSeat;
}
return;
}
emit msgReceived_withStringString( type, message, string );
}
#include "dbusInterface.moc"
// --> functions which are not member of the class ...
/*!
* This function is needed filter function for the D-Bus connection to filter
* all needed messages from the bus which are needful for TDEPowersave.
* \param connection existing connection to the D-Bus daemon
* \param message the recieved message from the D-Bus daemon
* \param data void pointer (see dbus bindings for more information)
* \return DBusHandlerResult
/*!
* This functions is used to check if session is active
*/
DBusHandlerResult
filterFunction (DBusConnection *connection, DBusMessage *message, void */*data*/) {
kdDebugFuncIn(trace);
bool reply_wanted;
char *value;
TQString ifaceType;
DBusError error;
dbus_error_init( &error );
if (dbus_message_is_signal (message,
DBUS_INTERFACE_LOCAL,
"Disconnected")){
((dbusInterface*) myInstance)->emitMsgReceived( DBUS_EVENT, "dbus.terminate", 0 );
dbus_connection_unref(connection);
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if ( dbus_message_get_type( message ) != DBUS_MESSAGE_TYPE_SIGNAL ) {
if (trace) kdDebug() << "recieved message, but wasn't from type DBUS_MESSAGE_TYPE_SIGNAL" << endl;
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
ifaceType = dbus_message_get_interface( message );
if (ifaceType == NULL) {
kdDebug() << "Received message from invalid interface" << endl;
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
reply_wanted = !dbus_message_get_no_reply( message );
if (ifaceType.startsWith(DBUS_INTERFACE_DBUS)) {
if(trace) kdDebug() << "Received from DBUS_INTERFACE_DBUS" << endl;
/* get the name of the signal */
const char *signal = dbus_message_get_member( message );
/* get the first argument. This must be a string at the moment */
dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &value, DBUS_TYPE_INVALID );
if ( dbus_error_is_set( &error ) ) {
kdWarning() << "Received signal " << error.message << " but no string argument" << endl;
dbus_error_free( &error );
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_HANDLED;
bool dbusInterface::checkActiveSession() {
if( systemdSeat && systemdSeat->canSend() ) {
TQT_DBusObjectPath activeSession;
TQValueList<TQT_DBusData> params;
params
<< TQT_DBusData::fromString( SYSTEMD_LOGIN1_SEAT_IFACE )
<< TQT_DBusData::fromString( "ActiveSession" );
TQT_DBusMessage reply = systemdSeat->sendWithReply("Get", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
activeSession = reply[0].toVariant().value.toStruct()[1].toObjectPath();
return (activeSession == systemdSession);
}
if (trace) kdDebug() << "filter_function::SIGNAL=" << signal << " VALUE=" << value << endl;
/* our name is... */
if ( ! strcmp( signal, "NameAcquired" ) ) {
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_HANDLED;
}
else if ( ! strcmp( signal, "NameOwnerChanged" )) {
char *service;
char *old_owner;
char *new_owner;
if (dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &service,
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner, DBUS_TYPE_INVALID)) {
if (!strcmp(service, "org.freedesktop.Policy.Power")) {
const char *own_name;
own_name = dbus_bus_get_unique_name(((dbusInterface*) myInstance)->get_DBUS_connection());
if (!strcmp(new_owner, own_name)) {
kdDebug() << "=== now owner of org.freedesktop.Policy.Power ===" << endl;
// we have now again the ower of the name!
((dbusInterface*) myInstance)->emitMsgReceived( POLICY_POWER_OWNER_CHANGED,
"NOW_OWNER",
NULL );
} else {
// some other has now the interface
kdDebug() << "=== someone owner of org.freedesktop.Policy.Power ===" << endl;
((dbusInterface*) myInstance)->emitMsgReceived( POLICY_POWER_OWNER_CHANGED,
"OTHER_OWNER",
NULL );
}
}
}
}
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (ifaceType.startsWith("org.freedesktop.ConsoleKit.Session")) {
kdDebug() << "Received from org.freedesktop.ConsoleKit.Session" << endl;
const char *session = dbus_message_get_path (message);
const char *signal = dbus_message_get_member( message );
if (! strcmp(signal, "ActiveChanged")) {
dbus_bool_t active;
if (dbus_message_get_args( message, &error, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID )) {
((dbusInterface*) myInstance)->emitMsgReceived( CONSOLEKIT_SESSION_ACTIVE,
session, TQString("%1").arg((int)active));
} else {
if (dbus_error_is_set( &error )) dbus_error_free( &error );
}
} else {
kdDebug() << "Received unknown signal from org.freedesktop.ConsoleKit.Session: "
<< signal << endl;
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if( consolekitSeat && consolekitSeat->canSend() ) {
TQT_DBusObjectPath activeSession;
TQValueList<TQT_DBusData> params;
TQT_DBusMessage reply = consolekitSeat->sendWithReply("GetActiveSession", params);
if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1 ) {
activeSession = reply[0].toObjectPath();
return (activeSession == consolekitSession);
}
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_HANDLED;
} else {
kdDebugFuncOut(trace);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return false;
}
// --> some functions to get private members
//! to get the current connection to D-Bus
DBusConnection * dbusInterface::get_DBUS_connection() {
return dbus_connection;
}
#include "dbusInterface.moc"

118
src/dbusInterface.h
Atkodēt Parādīt failu

@ -23,13 +23,13 @@
*/
/*!
* \class dbusInterface
* \brief class for connection to HAL via D-Bus
* \brief class for connection to D-Bus
* \author Danny Kukawka, <dkukawka@suse.de>, <danny.kukawka@web.de>
* \date 2006-2007
*/
#ifndef _DBUSHAL_H_
#define _DBUSHAL_H_
#ifndef _DBUS_INTERFACE_H_
#define _DBUS_INTERFACE_H_
#ifndef DBUS_API_SUBJECT_TO_CHANGE
#define DBUS_API_SUBJECT_TO_CHANGE
@ -41,12 +41,14 @@
#endif
// QT - Header
#include <tqobject.h>
#include <tqstring.h>
// D-Bus Header
#include <dbus/dbus.h> // needed for dbus_bool_t
#include <dbus/message.h>
#include <dbus/connection.h>
#include <tqdbusconnection.h>
#include <tqdbusobjectpath.h>
#include <tqdbusproxy.h>
#include <tqdbusunixfd.h>
// tdepowersave - Header
#include "tdepowersave_debug.h"
@ -55,16 +57,13 @@
#define CK_MANAGER_IFACE "org.freedesktop.ConsoleKit.Manager"
#define CK_MANAGER_OBJECT "/org/freedesktop/ConsoleKit/Manager"
#define CK_SESSION_IFACE "org.freedesktop.ConsoleKit.Session"
#define CK_SEAT_IFACE "org.freedesktop.ConsoleKit.Seat"
enum msg_type {
ACPI_EVENT,
DBUS_EVENT,
HAL_DEVICE,
HAL_PROPERTY_CHANGED,
HAL_CONDITION,
CONSOLEKIT_SESSION_ACTIVE,
POLICY_POWER_OWNER_CHANGED
};
#define SYSTEMD_LOGIN1_SERVICE "org.freedesktop.login1"
#define SYSTEMD_LOGIN1_PATH "/org/freedesktop/login1"
#define SYSTEMD_LOGIN1_MANAGER_IFACE "org.freedesktop.login1.Manager"
#define SYSTEMD_LOGIN1_SESSION_IFACE "org.freedesktop.login1.Session"
#define SYSTEMD_LOGIN1_SEAT_IFACE "org.freedesktop.login1.Seat"
class dbusInterface : public TQObject{
Q_OBJECT
@ -72,35 +71,32 @@ class dbusInterface : public TQObject{
private:
//! QT connection to D-Bus
DBusQt::Connection* m_dBusQtConnection;
//! real connection to D-Bus
DBusConnection *dbus_connection;
//! to store information if TDEPowersave is connected to D-Bus
/*!
* This boolean represent information about the state of the connection to D-Bus
* \li true: if connected
* \li false: if disconnected
*/
bool dbus_is_connected;
//! if we could claim the org.freedesktop.Policy.Power interface
/*!
* This boolean represent information if TDEPowersave could claim the
* org.freedesktop.Policy.Power interface from the D-Bus
* \li true: if acquired
* \li false: if not
*/
bool acquiredPolicyPower;
//! TQt connection to D-Bus
TQT_DBusConnection dBusConn;
//! TQt D-Bus proxy for watching signals
TQT_DBusProxy* dBusWatch;
TQT_DBusProxy* dBusLocal;
TQT_DBusObjectPath systemdSession;
TQT_DBusProxy* systemdSeat;
TQT_DBusUnixFd systemdInhibit;
TQT_DBusObjectPath consolekitSession;
TQT_DBusProxy* consolekitSeat;
/* D-Bus helper functions */
//! to initialise the connection to D-Bus
bool initDBUS();
//! to call a methode on a dbus interface with reply
bool dbusMethodCall( TQString interface, TQString path, TQString object, TQString method,
DBusBusType dbus_type, void *retvalue, int retval_type,
int first_arg_type, va_list var_args);
//! handles signal service registred/unregistered
void onServiceRegistered(const TQString&);
void onServiceUnregistered(const TQString&);
private slots:
//! to reconnect to D-Bus
bool reconnect();
public:
@ -109,52 +105,24 @@ public:
//! default destructor
~dbusInterface();
//! to reconnect to D-Bus and HAL
bool reconnect();
//! to close the connection to D-Bus and HAL
//! to close the connection to D-Bus
bool close();
//! to acquire the org.freedesktop.Policy.Power interface
bool acquirePolicyPowerIface();
//! to release the org.freedesktop.Policy.Power interface
bool releasePolicyPowerIface();
//! to check if the org.freedesktop.Policy.Power interface has an owner
bool isPolicyPowerIfaceOwned();
// --- helper to get private members of the class --- //
//! to get information if TDEPowersave is connected to D-Bus
bool isConnectedToDBUS();
//! to get info about claim org.freedesktop.Policy.Power interface
bool acquiredPolicyPowerInterface();
//! return the current DBus connection
DBusConnection *get_DBUS_connection();
//! to check active session state
bool checkActiveSession();
/* D-Bus helper functions */
public slots:
/* functions to call methodes */
//! to call a methode on a dbus system bus method without reply
bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
int first_arg_type, ... );
//! to call a methode on a dbus system bus method with reply
bool dbusSystemMethodCall( TQString interface, TQString path, TQString object, TQString method,
void *retvalue, int retval_type, int first_arg_type, ... );
void handleDBusSignal(const TQT_DBusMessage&);
/* PolicyKit call helper */
//! check if the user has a requested privilege
int isUserPrivileged( TQString privilege, TQString udi, TQString ressource = "", TQString user = TQString());
signals:
//! wrapper to emit a signal with a event from HAL
void emitMsgReceived( msg_type type, TQString message, TQString string );
void activeSessionChanged(bool);
signals:
//! signal with message to forward from D-Bus to HAL
void msgReceived_withStringString( msg_type, TQString, TQString );
//! signal if we resumed!
void backFromSuspend( int result );
};
//! filter function to filter out needed information from D-Bus messages
DBusHandlerResult filterFunction (DBusConnection *connection, DBusMessage *message, void *data);
#endif

269
src/hardware.cpp
Atkodēt Parādīt failu

@ -37,7 +37,6 @@
// include own header
#include "hardware.h"
#include "tdepowersave_debug.h"
#include "privileges.h"
// #define USE_EVENT_DEVICES_DIRECTLY 1
@ -51,7 +50,6 @@ HardwareInfo::HardwareInfo() {
laptop = false;
brightness = false;
brightness_in_hardware = false;
schedPowerSavings = false;
sessionIsActive = true; // assume as first we are active
// initialize connection to the TDE hardware library
@ -79,20 +77,15 @@ HardwareInfo::HardwareInfo() {
primaryBatteries = new BatteryCollection(BAT_PRIMARY);
setPrimaryBatteriesWarningLevel(); // force default settings
// connect to D-Bus and HAL
dbus_HAL = new dbusInterface();
if (dbus_HAL->isConnectedToDBUS()) {
dbus_terminated = false;
} else {
kdError() << "Could not connect to D-Bus & HAL" << endl;
}
// connect to D-Bus
dbus_iface = new dbusInterface();
sessionIsActive = dbus_iface->checkActiveSession();
connect(dbus_iface, TQT_SIGNAL(activeSessionChanged(bool)), this, TQT_SLOT(handleSessionState(bool)));
checkConsoleKitSession();
checkPowermanagement();
checkIsLaptop();
checkBrightness();
checkCPUFreq();
// getSchedPowerSavings();
checkSuspend();
intialiseHWInfo();
@ -141,15 +134,26 @@ bool HardwareInfo::reinitHardwareInfos () {
checkCPUFreq();
checkSuspend();
intialiseHWInfo();
// getSchedPowerSavings();
updatePrimaryBatteries();
kdDebugFuncOut(trace);
return true;
}
/*!
* This funtion is used to parse changed hardware nofifications from the TDE hardware library
* \b TQT_SLOT called if the state of the current session change
* \param state boolean represent the state of the session
*/
void HardwareInfo::handleSessionState( bool state ) {
if( state != sessionIsActive ) {
sessionIsActive = state;
TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
}
}
/*!
* This function is used to parse changed hardware nofifications from the TDE hardware library
* \param device a \ref TDEGenericDevice* which should be processed
*/
void HardwareInfo::processHardwareChangedEvent (TDEGenericDevice* device) {
@ -215,99 +219,6 @@ void HardwareInfo::processKeyPressEvent(unsigned int keycode, TDEEventDevice* ed
kdDebugFuncOut(trace);
}
/*!
* This funtion is used to parse a message from D-Bus for the different
* messagetypes and events.
* \param type a \ref msg_type which should be parse/processed
* \param message the message
* \param value an optional message value as e.g. message string
*/
void HardwareInfo::processMessage (msg_type type, TQString message, TQString value) {
kdDebugFuncIn(trace);
switch(type) {
case ACPI_EVENT:
// we don't handle acpi events here atm
break;
case HAL_DEVICE:
// --> we can maybe ignore these events except for batteries, not shure atm
int _type;
if (message.startsWith("DeviceAdded")) {
if (checkIfHandleDevice(value, &_type)) {
switch (_type) {
case BATTERY:
case AC_ADAPTER:
case BUTTON_SLEEP:
case BUTTON_POWER:
case LID:
// TODO: handle code if needed actually not
break;
case LAPTOP_PANEL:
checkBrightness();
break;
default:
kdDebug() << "New device added Device udi: "
<< value << "type: " << _type << endl;
break;
}
}
} else if (message.startsWith("DeviceRemoved")) {
if (allUDIs.contains(value)) {
if (checkIfHandleDevice(value, &_type)) {
switch (_type) {
case BATTERY:
case AC_ADAPTER:
case BUTTON_SLEEP:
case BUTTON_POWER:
case LID:
// TODO: handle code if needed
break;
case LAPTOP_PANEL:
checkBrightness();
break;
default:
kdDebug() << "Couldn't handle unknown device" << endl;
break;
}
}
} else {
kdDebug() << "Not monitored device removed: " << value << endl;
}
} else {
kdDebug() << "Unknown HAL_DEVICE message: " << message << endl;
}
break;
case CONSOLEKIT_SESSION_ACTIVE:
if (!message.isEmpty() && !value.isEmpty()) {
if (message == consoleKitSession) {
if (value == "1") {
sessionIsActive = true;
} else {
sessionIsActive = false;
}
TQTimer::singleShot(50, this, TQT_SLOT(emitSessionActiveState()));
} else {
if (trace)
kdDebug() << "CONSOLEKIT_SESSION_ACTIVE: not our session" << endl;
}
}
break;
case POLICY_POWER_OWNER_CHANGED:
if (message.startsWith("NOW_OWNER")) {
// TODO: add code
} else if (message.startsWith("OTHER_OWNER")){
// TODO: add code
}
break;
default:
kdDebug() << "Recieved unknown package type: " << type << endl;
break;
}
kdDebugFuncOut(trace);
}
/*!
* This TQT_SLOT is used to fetch the resume signal and multiplex. If needed some
* actions after resume, do this here.
@ -330,61 +241,6 @@ void HardwareInfo::handleResumeSignal (int result) {
kdDebugFuncOut(trace);
}
/*!
* This function checks the session for the running TDEPowersave instance
* \return Boolean with result of operation
* \retval true if the query/check could get finished
* \retval false on every error
*/
bool HardwareInfo::checkConsoleKitSession () {
kdDebugFuncIn(trace);
bool retval = false;
if (dbus_HAL->isConnectedToDBUS()) {
char *reply;
char *cookie = getenv("XDG_SESSION_COOKIE");
if (cookie == NULL) {
kdDebug() << "Could not get XDG_SESSION_COOKIE from environment" << endl;
sessionIsActive = true;
} else {
if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, CK_MANAGER_OBJECT,
CK_MANAGER_IFACE, "GetSessionForCookie",
&reply, DBUS_TYPE_OBJECT_PATH,
DBUS_TYPE_STRING, &cookie,
DBUS_TYPE_INVALID)) {
if (trace)
kdDebug() << "GetSessionForCookie returned: " << reply << endl;
if (reply != NULL) {
dbus_bool_t i_reply;
consoleKitSession = reply;
if (dbus_HAL->dbusSystemMethodCall( CK_SERVICE, consoleKitSession,
CK_SESSION_IFACE, "IsActive",
&i_reply, DBUS_TYPE_BOOLEAN,
DBUS_TYPE_INVALID)) {
sessionIsActive = ((i_reply != 0) ? true: false);
if (trace)
kdDebug() << "IsActive returned: " << sessionIsActive << endl;
retval = true;
} else {
kdError() << "Could get session cookie and session name, but not "
<< "but not the status of the session. Assume for now "
<< "the Session is inactive!" << endl;
sessionIsActive = false;
}
}
}
}
}
kdDebugFuncOut(trace);
return retval;
}
/*!
* This function check for a given UDI, if we should handle a device
* \param _udi TQString with the UDI of the device
@ -1090,7 +946,6 @@ bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) {
TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);
if (hwlist.count() > 0) {
dbus_bool_t consider = (dbus_bool_t) getAcAdapter();
TQStringList dynamic;
if (checkCurrentCPUFreqPolicy() == cpufreq) {
@ -1122,20 +977,6 @@ bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) {
}
}
#if 0
// FIXME
// What does "SetCPUFreqConsiderNice" actually do??!?!
// correct set ondemand
if (!dbus_HAL->dbusSystemMethodCall( HAL_SERVICE, HAL_COMPUTER_UDI,
HAL_CPUFREQ_IFACE,
"SetCPUFreqConsiderNice",
DBUS_TYPE_BOOLEAN, &consider,
DBUS_TYPE_INVALID)) {
kdError() << "Couldn't set SetCPUFreqConsiderNice for DYNAMIC" << endl;
}
#endif
// Set performance limits on all CPUs
TDEGenericDevice *hwdevice;
TDECPUDevice *cpudevice;
@ -1185,7 +1026,6 @@ bool HardwareInfo::setCPUFreq ( cpufreq_type cpufreq, int limit ) {
bool HardwareInfo::setCPUFreqGovernor( const char *governor ) {
kdDebugFuncIn(trace);
int reply;
bool ret = true;
TDEGenericHardwareList hwlist = m_hwdevices->listByDeviceClass(TDEGenericDeviceType::CPU);
@ -1205,61 +1045,6 @@ bool HardwareInfo::setCPUFreqGovernor( const char *governor ) {
}
/*!
* Function to set the powersave mode (incl. e.g. disk settings) via TDE hardware library.
* \param on boolean which tell if enable/disable powersave mode
* \return boolean with result of the operation
* \retval true if successful
* \retval false else, if a error occurs
*/
bool HardwareInfo::setPowerSave( bool on ) {
kdDebugFuncIn(trace);
bool retval = false;
// FIXME
// Set up power saving to the best of our ability using "raw" functions
printf("[FIXME] HardwareInfo::setPowerSave unimplemented!\n"); fflush(stdout);
kdDebugFuncOut(trace);
return retval;
}
/*!
* Function to call GetSchedPowerSavings() via TDE hardware library.
* \return boolean with result of the operation
* \retval true if successful
* \retval false else, if a error occurs
*/
bool HardwareInfo::getSchedPowerSavings() {
kdDebugFuncIn(trace);
bool returnval = false;
// What does the HAL method GetSchedPowerSavings actually do?!?!?
kdDebugFuncOut(trace);
return returnval;
}
/*!
* Function to call SetSchedPowerSavings() via TDE hardware library.
* Note: this would only work on multiprocessor/-core machines.
* \return boolean with result of the operation
* \retval true if successful
* \retval false else, if a error occurs
*/
bool HardwareInfo::setSchedPowerSavings( bool enable ) {
kdDebugFuncIn(trace);
bool retval = false;
// What does the HAL method SetCPUFreqPerformance actually do?!?!?
kdDebugFuncOut(trace);
return retval;
}
// --> TDE hardware library method call (trigger actions) section -- END <---
@ -1304,16 +1089,6 @@ void HardwareInfo::emitS2diskButtonPressed() {
* Function to emit the signal about changes in the session state
*/
void HardwareInfo::emitSessionActiveState() {
if (sessionIsActive) {
if (!dbus_HAL->acquiredPolicyPowerInterface()) {
dbus_HAL->acquirePolicyPowerIface();
}
} else {
if (dbus_HAL->acquiredPolicyPowerInterface()) {
dbus_HAL->releasePolicyPowerIface();
}
}
emit desktopSessionIsActive(sessionIsActive);
}
@ -1635,16 +1410,6 @@ int HardwareInfo::isCpuFreqAllowed () {
return cpuFreqAllowed;
}
/*! check if the org.freedesktop.Policy.Power interface has an owner
* \return boolean with info if org.freedesktop.Policy.Power interface has an owner or not
* \retval true if there is a owner
* \retval false else
*/
bool HardwareInfo::isPolicyPowerIfaceOwned () {
return dbus_HAL->isPolicyPowerIfaceOwned();
}
// --> get private members section -- END <---
#include "hardware.moc"

44
src/hardware.h
Atkodēt Parādīt failu

@ -76,12 +76,6 @@ enum device_type {
UNKNOWN_DEVICE
};
enum ERROR_MSG {
DBUS_NO_RIGHTS,
DBUS_NOT_RUNNING,
DBUS_RUNNING
};
//! hold information if suspend/standby/pm actions are supported and allowed
/*!
* This dictionary contains information about the available pm capabilities and
@ -138,7 +132,7 @@ private:
TDEHardwareDevices *m_hwdevices;
//! pointer to the dbusInterface connection class
dbusInterface *dbus_HAL;
dbusInterface *dbus_iface;
//! hold udis of special hardware execpt batteries represented by a TQString pairs (name,udi)
/*!
@ -225,14 +219,6 @@ private:
* \li false: else
*/
bool cpuFreq;
//! if the machine support change *SchedPowerSavings methodes via TDE hardware library
/*!
* This boolean represent information if the machine support change the
* SchedPowerSavings methodes via TDE hardware library.
* \li true: if supported
* \li false: else
*/
bool schedPowerSavings;
//! if the machine support change brightness
/*!
* This boolean represent information if the machine support brightness changes.
@ -315,24 +301,18 @@ private:
bool intialiseHWInfo();
//! reinit all hardware information
bool reinitHardwareInfos();
//! to check the current ConsoleKit session
bool checkConsoleKitSession();
//! to check if we should handle a device
bool checkIfHandleDevice ( TQString _udi, int *type );
//! to set the CPUFreq governor
bool setCPUFreqGovernor( const char *governor );
//! to get the state of SchedPowerSave setting of kernel/TDE hardware library
bool getSchedPowerSavings();
//! to set the state of SchedPowerSave setting of kernel/TDE hardware library
bool setSchedPowerSavings( bool enable );
//! find and update a battery information
void updateBatteryValues (TDEGenericDevice* device);
private slots:
//! to fetch events from D-Bus and handle them
void processMessage (msg_type type, TQString message, TQString value);
//! handle changes of the session state
void handleSessionState (bool state);
//! to fetch events from the TDE hardware library and handle them
void processHardwareChangedEvent (TDEGenericDevice*);
//! to fetch keypresses from the TDE hardware library and handle them
@ -392,10 +372,6 @@ signals:
void batteryWARNState(int type, int state);
// Error signals
//! signal if the HAL daemon terminate and restart
void halRunning( bool );
//! signal if the D-Bus daemon terminate and restart
void dbusRunning( int );
//! signal if the IsActive state of
void desktopSessionIsActive (bool);
@ -428,15 +404,6 @@ public:
*/
bool update_info_primBattery_changed;
//! boolean which tell us if the D-Bus daemon was terminated
/*!
* This boolean contains information if the D-Bus daemon terminated and
* we recieved "dbus.terminate"
* \li true: If D-Bus terminated
* \li false: If D-Bus not terminated
*/
bool dbus_terminated;
// --> functions
//! default constructor
HardwareInfo();
@ -463,9 +430,6 @@ public:
//! if the user is allowed to change CPU Freq PolicyKit
int isCpuFreqAllowed ();
//! if org.freedesktop.Policy.Power has a owner
bool isPolicyPowerIfaceOwned();
//! get state of the AC adapter
bool getAcAdapter() const;
//! get the state of the lid button
@ -498,8 +462,6 @@ public:
bool setBrightnessUp(int percentageStep = -1);
//! set the CPU frequency policy/speed
bool setCPUFreq ( cpufreq_type cpufreq, int limit = 51 );
//! call SetPowerSave method on TDE hardware library.
bool setPowerSave( bool on );
//! function to set warning states for the primary battery collection
void setPrimaryBatteriesWarningLevel (int _warn = -1, int _low = -1, int _crit = -1 );

29
src/hardware_battery.cpp
Atkodēt Parādīt failu

@ -279,35 +279,6 @@ bool Battery::checkBatteryType () {
// For now just report any batteries as primary...
type = BAT_PRIMARY;
return true;
#if 0
if (dbus_HAL->halGetPropertyString(udi,"battery.type", &tmp_qstring)) {
if (tmp_qstring.compare("primary") == 0) {
type = BAT_PRIMARY;
} else if (tmp_qstring.compare("mouse") == 0) {
type = BAT_MOUSE;
} else if (tmp_qstring.compare("keyboard") == 0) {
type = BAT_KEYBOARD;
} else if (tmp_qstring.compare("keyboard_mouse") == 0) {
type = BAT_KEY_MOUSE;
} else if (tmp_qstring.compare("camera") == 0) {
type = BAT_CAMERA;
} else if (tmp_qstring.compare("ups") == 0) {
type = BAT_UPS;
} else {
//anything else will currently be "UNKNOWN"
type = BAT_UNKNOWN;
}
kdDebugFuncOut(trace);
return true;
} else {
//query was not successfull
kdWarning() << "Query of battery.type of " << udi << " was not successfull." << endl;
type = BAT_UNKNOWN;
kdDebugFuncOut(trace);
return false;
}
#endif
}
//! to check battery.technology

2
src/hardware_battery.h
Atkodēt Parādīt failu

@ -45,7 +45,7 @@
// TDE hardware library
#include <tdehardwaredevices.h>
#include "dbusInterface.h"
#include "tdepowersave_debug.h"
class Battery : public TQObject {

46
src/privileges.h
Atkodēt Parādīt failu

@ -1,46 +0,0 @@
/***************************************************************************
* Copyright (C) 2007 by Danny Kukawka *
* <dkukawka@suse.de, danny.kukawka@web.de> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of version 2 of the GNU General Public License *
* as published by the Free Software Foundation. *
* *
* 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, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
/*!
* \file privileges.h
* \brief Headerfile containing defines for privileges
* \author Danny Kukawka, <dkukawka@suse.de, danny.kukawka@web.de>
* \date 2007
*/
#ifndef _PRIVILEGES_H_
#define _PRIVILEGES_H_
#ifdef HAVE_HAL_0_5_10
#define PRIV_SUSPEND "org.freedesktop.hal.power-management.suspend"
#define PRIV_HIBERNATE "org.freedesktop.hal.power-management.hibernate"
#define PRIV_STANDBY "org.freedesktop.hal.power-management.standby"
#define PRIV_CPUFREQ "org.freedesktop.hal.power-management.cpufreq"
#define PRIV_LAPTOP_PANEL "org.freedesktop.hal.power-management.lcd-panel"
#define PRIV_SETPOWERSAVE "org.freedesktop.hal.power-management.set-powersave"
#else
#define PRIV_SUSPEND "hal-power-suspend"
#define PRIV_HIBERNATE "hal-power-hibernate"
#define PRIV_STANDBY "hal-power-standby"
#define PRIV_CPUFREQ "hal-power-cpufreq"
#define PRIV_LAPTOP_PANEL "hal-power-lcd-panel"
#define PRIV_SETPOWERSAVE "hal-power-set-powersave"
#endif
#endif

3
src/settings.cpp
Atkodēt Parādīt failu

@ -61,7 +61,6 @@ Settings::~Settings()
bool Settings::load_scheme_settings(TQString schemeName){
tdeconfig->reparseConfiguration();
bool setToDefault = false;
if( schemeName == "Performance" || schemeName == i18n("Performance"))
schemeName = "Performance";
@ -78,7 +77,6 @@ bool Settings::load_scheme_settings(TQString schemeName){
// fallback to 'default-scheme'
tdeconfig->setGroup("default-scheme");
schemeName = "default-scheme";
setToDefault = true;
}
currentScheme = schemeName;
@ -250,7 +248,6 @@ bool Settings::load_general_settings(){
psMsgAsPassivePopup = tdeconfig->readBoolEntry("psMsgAsPassivePopup",false);
forceDpmsOffOnLidClose = tdeconfig->readBoolEntry("forceDpmsOffOnLidClose",false);
unmountExternalOnSuspend = tdeconfig->readBoolEntry("unmountExternalOnSuspend",true);
callSetPowerSaveOnAC = tdeconfig->readBoolEntry("callSetPowerSaveOnAC",true);
lockmethod = tdeconfig->readEntry("lockMethod", "NULL");
if(lockmethod == "NULL") lockmethod = "automatic";

8
src/settings.h
Atkodēt Parādīt failu

@ -200,14 +200,6 @@ public:
* \li false: if not
*/
bool forceDpmsOffOnLidClose;
//! if tdepowersave should call SetPowerSave() on HAL
/*!
* This boolean tells if tdepowersave should call SetPowerSave on HAL depending
* on the AC state.
* \li true: if should call
* \li false: if not
*/
bool callSetPowerSaveOnAC;
//! time after resume to fake keyevent
/*!

22
src/tdepowersave.cpp
Atkodēt Parādīt failu

@ -1790,14 +1790,6 @@ void tdepowersave::setSchemeSettings(){
}
}
// call setPowerSave() depending on AC state
if (settings->callSetPowerSaveOnAC) {
if (hwinfo->getAcAdapter())
hwinfo->setPowerSave(false);
else
hwinfo->setPowerSave(true);
}
// --> set autosuspend settings
if(settings->autoSuspend) {
setAutoSuspend(false);
@ -2176,10 +2168,12 @@ void tdepowersave::handleActionCall ( action action, int value , bool checkAC, b
break;
}
} else if (batWarnCall) {
if (!hwinfo->isPolicyPowerIfaceOwned()) {
// FIXME
// Is there a way to check if is active power manager on currently active session?
if (true) {
switch (action) {
case GO_SHUTDOWN:
// to be shure if we really need the shutdown
// to be sure if we really need the shutdown
if ((checkAC && !hwinfo->getAcAdapter()) || !checkAC ) {
DCOPRef shutdown = DCOPRef( "ksmserver", "ksmserver" );
shutdown.send("logout", 0, 2, 2);
@ -2509,7 +2503,7 @@ TQString tdepowersave::currentScheme (){
if(hwinfo->isOnline()) {
return settings->currentScheme;
} else {
return "ERROR: D-Bus and/or HAL not running";
return "ERROR: D-Bus not running";
}
kdDebugFuncOut(trace);
@ -2540,7 +2534,7 @@ TQString tdepowersave::currentCPUFreqPolicy() {
}
return _cpuFreq;
} else {
return "ERROR: HAL or/and DBus not running";
return "ERROR: DBus not running";
}
kdDebugFuncOut(trace);
@ -2630,7 +2624,7 @@ TQStringList tdepowersave::allowed_sleepingStates(){
}
}
else {
sleepList.append("ERROR: D-Bus and/or HAL not running");
sleepList.append("ERROR: D-Bus not running");
}
kdDebugFuncOut(trace);
@ -2651,7 +2645,7 @@ TQStringList tdepowersave::listSchemes(){
}
}
else {
_schemeList.append("ERROR: D-Bus and/or HAL not running");
_schemeList.append("ERROR: D-Bus not running");
}
kdDebugFuncOut(trace);

Rakstīt Priekšskatītījums
Notiek ielāde…
Atcelt
Saglabāt