ubports-volte/libmce-glib
1
0
Fork 0
forked from ubports/core_hybris-support_libmce-glib-repowerd-stub
Code Pull Requests Activity

Merge pull request #1 from spiiroin/jb60550_inactivity

Browse Source 
[libmce-glib] Add MceInactivity object
This commit is contained in:
Simo Piiroinen
2023-05-08 10:43:33 +03:00
committed by GitHub
parent 5a848146b4 7e0b708217
commit b65226eea5
9 changed files with 727 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -11,3 +11,5 @@ documentation.list
installroot
build
RPMS
examples/example
examples/example.o

1
Makefile
View File

@@ -41,6 +41,7 @@ SRC = \
mce_battery.c \
mce_charger.c \
mce_display.c \
mce_inactivity.c \
mce_proxy.c \
mce_tklock.c
GEN_SRC = \

15
examples/Makefile Normal file
View File

@@ -0,0 +1,15 @@
.PHONY: build clean mostlyclean
build::
clean:: mostlyclean
mostlyclean:: ; $(RM) *.o *~ *.bak
PKG_NAMES += glib-2.0
PKG_NAMES += libmce-glib
CPPFLAGS += -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64
CFLAGS += -Wall -Wextra -Os -g -std=c99
LDFLAGS += -g
LDLIBS += -Wl,--as-needed
CFLAGS += $(shell pkg-config --cflags $(PKG_NAMES))
LDLIBS += $(shell pkg-config --libs $(PKG_NAMES))
example : example.o
build:: example
clean:: ; $(RM) example

278
examples/example.c Normal file
View File

@@ -0,0 +1,278 @@
/*
* Copyright (c) 2023 Jolla Ltd.
*
* You may use this file under the terms of BSD license as follows:
*
* 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 above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the names of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDERS OR CONTRIBUTORS
* 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.
*
* The views and conclusions contained in the software and documentation
* are those of the authors and should not be interpreted as representing
* any official policies, either expressed or implied.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <glib.h>
#include <glib-unix.h>
#include <mce_battery.h>
#include <mce_charger.h>
#include <mce_display.h>
#include <mce_inactivity.h>
#include <mce_tklock.h>
/* ========================================================================= *
* MAINLOOP
* ========================================================================= */
static int mainloop_result = EXIT_SUCCESS;
static GMainLoop *mainloop_handle = NULL;
static void mainloop_exit(int exitcode)
{
if( mainloop_result < exitcode )
mainloop_result = exitcode;
if( !mainloop_handle )
exit(mainloop_result);
g_main_loop_quit(mainloop_handle);
}
static void mainloop_quit(void)
{
mainloop_exit(EXIT_SUCCESS);
}
static int mainloop_run(void)
{
mainloop_handle = g_main_loop_new(NULL, false);
g_main_loop_run(mainloop_handle);
g_main_loop_unref(mainloop_handle),
mainloop_handle = NULL;
return mainloop_result;
}
/* ========================================================================= *
* STATUS
* ========================================================================= */
static const char *bool_repr(bool value)
{
return value ? "true" : "false";
}
static const char *battery_status_repr(MCE_BATTERY_STATUS status)
{
static const char * const lut[] = {
[MCE_BATTERY_UNKNOWN] = "unknown",
[MCE_BATTERY_EMPTY] = "empty",
[MCE_BATTERY_LOW] = "low",
[MCE_BATTERY_OK] = "ok",
[MCE_BATTERY_FULL] = "full",
};
return lut[status];
}
static const char *charger_state_repr(MCE_CHARGER_STATE state)
{
static const char * const lut[] = {
[MCE_CHARGER_UNKNOWN] = "unknown",
[MCE_CHARGER_ON] = "on",
[MCE_CHARGER_OFF] = "off",
};
return lut[state];
}
static const char *display_state_repr(MCE_DISPLAY_STATE state)
{
static const char * const lut[] = {
[MCE_DISPLAY_STATE_OFF] = "off",
[MCE_DISPLAY_STATE_DIM] = "dim",
[MCE_DISPLAY_STATE_ON] = "on",
};
return lut[state];
}
static const char *tklock_mode_repr(MCE_TKLOCK_MODE mode)
{
static const char * const lut[] = {
[MCE_TKLOCK_MODE_LOCKED] = "locked",
[MCE_TKLOCK_MODE_SILENT_LOCKED] = "silent_locked",
[MCE_TKLOCK_MODE_LOCKED_DIM] = "locked_dim",
[MCE_TKLOCK_MODE_LOCKED_DELAY] = "locked_delay",
[MCE_TKLOCK_MODE_SILENT_LOCKED_DIM] = "silent_locked_dim",
[MCE_TKLOCK_MODE_UNLOCKED] = "unlocked",
[MCE_TKLOCK_MODE_SILENT_UNLOCKED] = "silent_unlocked",
};
return lut[mode];
}
static void battery_cb(MceBattery *battery, void *arg)
{
const char *what_changed = arg;
printf("battery: valid=%s level=%d status=%s (%s changed)\n",
bool_repr(battery->valid),
battery->level,
battery_status_repr(battery->status),
what_changed);
}
static void charger_cb(MceCharger *charger, void *arg)
{
const char *what_changed = arg;
printf("charger: valid=%s state=%s (%s changed)\n",
bool_repr(charger->valid),
charger_state_repr(charger->state),
what_changed);
}
static void display_cb(MceDisplay *display, void *arg)
{
const char *what_changed = arg;
printf("display: valid=%s state=%s (%s changed)\n",
bool_repr(display->valid),
display_state_repr(display->state),
what_changed);
}
static void tklock_cb(MceTklock *tklock, void *arg)
{
const char *what_changed = arg;
printf("tklock: valid=%s mode=%s locked=%s (%s changed)\n",
bool_repr(tklock->valid),
tklock_mode_repr(tklock->mode),
bool_repr(tklock->locked),
what_changed);
}
static void inactivity_cb(MceInactivity *inactivity, void *arg)
{
const char *what_changed = arg;
printf("inactivity: valid=%s status=%s (%s changed)\n",
bool_repr(inactivity->valid),
bool_repr(inactivity->status),
what_changed);
}
/* ========================================================================= *
* MAIN_ENTRY
* ========================================================================= */
static gboolean quit_cb(gpointer aptr)
{
printf("quit\n");
mainloop_quit();
guint *id_ptr = aptr;
*id_ptr = 0;
return G_SOURCE_REMOVE;
}
int
main(int argc, char **argv)
{
printf("startup\n");
int exitcode = EXIT_FAILURE;
MceBattery *battery = mce_battery_new();
gulong battery_valid_id =
mce_battery_add_valid_changed_handler(battery, battery_cb, "valid");
gulong battery_level_id =
mce_battery_add_level_changed_handler(battery, battery_cb, "level");
gulong battery_status_id =
mce_battery_add_status_changed_handler(battery, battery_cb, "status");
MceCharger *charger = mce_charger_new();
gulong charger_valid_id =
mce_charger_add_valid_changed_handler(charger, charger_cb, "valid");
gulong charger_state_id =
mce_charger_add_state_changed_handler(charger, charger_cb, "state");
MceDisplay *display = mce_display_new();
gulong display_valid_id =
mce_display_add_valid_changed_handler(display, display_cb, "valid");
gulong display_state_id =
mce_display_add_state_changed_handler(display, display_cb, "state");
MceTklock *tklock = mce_tklock_new();
gulong tklock_valid_id =
mce_tklock_add_valid_changed_handler(tklock, tklock_cb, "valid");
gulong tklock_mode_id =
mce_tklock_add_mode_changed_handler(tklock, tklock_cb, "mode");
gulong tklock_locked_id =
mce_tklock_add_locked_changed_handler(tklock, tklock_cb, "locked");
MceInactivity *inactivity = mce_inactivity_new();
gulong inactivity_valid_id =
mce_inactivity_add_valid_changed_handler(inactivity, inactivity_cb, "valid");
gulong inactivity_status_id =
mce_inactivity_add_status_changed_handler(inactivity, inactivity_cb, "status");
guint timeout_id = 0;
gint timeout_s = (argc > 1) ? strtol(argv[1], NULL, 0) : 0;
if( timeout_s > 0)
timeout_id = g_timeout_add(timeout_s * 1000, quit_cb, &timeout_id);
guint sigterm_id = g_unix_signal_add(SIGTERM, quit_cb, &sigterm_id);
guint sigint_id = g_unix_signal_add(SIGINT, quit_cb, &sigint_id);
printf("mainloop\n");
exitcode = mainloop_run();
printf("cleanup\n");
if( sigterm_id )
g_source_remove(sigterm_id);
if( sigint_id )
g_source_remove(sigint_id);
if( timeout_id )
g_source_remove(timeout_id);
mce_battery_remove_handler(battery, battery_valid_id);
mce_battery_remove_handler(battery, battery_level_id);
mce_battery_remove_handler(battery, battery_status_id);
mce_battery_unref(battery);
mce_charger_remove_handler(charger, charger_valid_id);
mce_charger_remove_handler(charger, charger_state_id);
mce_charger_unref(charger);
mce_display_remove_handler(display, display_valid_id);
mce_display_remove_handler(display, display_state_id);
mce_display_unref(display);
mce_tklock_remove_handler(tklock, tklock_valid_id);
mce_tklock_remove_handler(tklock, tklock_mode_id);
mce_tklock_remove_handler(tklock, tklock_locked_id);
mce_tklock_unref(tklock);
mce_inactivity_remove_handler(inactivity, inactivity_valid_id);
mce_inactivity_remove_handler(inactivity, inactivity_status_id);
mce_inactivity_unref(inactivity);
printf("exit\n");
return exitcode;
}

107
include/mce_inactivity.h Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (c) 2016 - 2023 Jolla Ltd.
*
* You may use this file under the terms of BSD license as follows:
*
* 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 above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the names of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDERS OR CONTRIBUTORS
* 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.
*
* The views and conclusions contained in the software and documentation
* are those of the authors and should not be interpreted as representing
* any official policies, either expressed or implied.
*/
#ifndef MCE_INACTIVITY_H
#define MCE_INACTIVITY_H
#include "mce_types.h"
#include <glib-object.h>
G_BEGIN_DECLS
typedef struct mce_inactivity_priv MceInactivityPriv;
struct mce_inactivity {
GObject object;
MceInactivityPriv* priv;
gboolean valid;
gboolean status;
}; /* MceInactivity */
typedef void
(*MceInactivityFunc)(
MceInactivity* inactivity,
void* arg);
MceInactivity*
mce_inactivity_new(
void);
MceInactivity*
mce_inactivity_ref(
MceInactivity* inactivity);
void
mce_inactivity_unref(
MceInactivity* inactivity);
gulong
mce_inactivity_add_valid_changed_handler(
MceInactivity* inactivity,
MceInactivityFunc fn,
void* arg);
gulong
mce_inactivity_add_status_changed_handler(
MceInactivity* inactivity,
MceInactivityFunc fn,
void* arg);
void
mce_inactivity_remove_handler(
MceInactivity* inactivity,
gulong id);
void
mce_inactivity_remove_handlers(
MceInactivity* inactivity,
gulong* ids,
guint count);
#define mce_inactivity_remove_all_handlers(t, ids) \
mce_inactivity_remove_handlers(t, ids, G_N_ELEMENTS(ids))
G_END_DECLS
#endif /* MCE_INACTIVITY_H */
/*
* Local Variables:
* mode: C
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*/

5
include/mce_types.h
View File

@@ -1,6 +1,6 @@
/*
* Copyright (C) 2016-2022 Jolla Ltd.
* Copyright (C) 2016-2022 Slava Monich <slava.monich@jolla.com>
* Copyright (c) 2016 - 2023 Jolla Ltd.
* Copyright (c) 2016 - 2022 Slava Monich <slava.monich@jolla.com>
*
* You may use this file under the terms of BSD license as follows:
*
@@ -44,6 +44,7 @@ G_BEGIN_DECLS
typedef struct mce_battery MceBattery;
typedef struct mce_charger MceCharger;
typedef struct mce_display MceDisplay;
typedef struct mce_inactivity MceInactivity;
typedef struct mce_tklock MceTklock;
G_END_DECLS

3
spec/com.nokia.mce.request.xml
View File

@@ -19,5 +19,8 @@
<method name="get_charger_state">
<arg direction="out" name="charger_state" type="s"/>
</method>
<method name="get_inactivity_status">
<arg direction="out" name="device_inactive" type="b"/>
</method>
</interface>
</node>

3
spec/com.nokia.mce.signal.xml
View File

@@ -19,5 +19,8 @@
<signal name="charger_state_ind">
<arg name="charger_state" type="s"/>
</signal>
<signal name="system_inactivity_ind">
<arg name="device_inactive" type="b"/>
</signal>
</interface>
</node>

315
src/mce_inactivity.c Normal file
View File

@@ -0,0 +1,315 @@
/*
* Copyright (c) 2016 - 2023 Jolla Ltd.
*
* You may use this file under the terms of BSD license as follows:
*
* 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 above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the names of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDERS OR CONTRIBUTORS
* 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.
*
* The views and conclusions contained in the software and documentation
* are those of the authors and should not be interpreted as representing
* any official policies, either expressed or implied.
*/
#include "mce_inactivity.h"
#include "mce_proxy.h"
#include "mce_log_p.h"
#include <mce/dbus-names.h>
#include <mce/mode-names.h>
#include <gutil_misc.h>
/* Generated headers */
#include "com.nokia.mce.request.h"
#include "com.nokia.mce.signal.h"
struct mce_inactivity_priv {
MceProxy* proxy;
gulong proxy_valid_id;
gulong inactivity_status_ind_id;
};
enum mce_inactivity_signal {
SIGNAL_VALID_CHANGED,
SIGNAL_STATUS_CHANGED,
SIGNAL_COUNT
};
#define SIGNAL_VALID_CHANGED_NAME "mce-inactivity-valid-changed"
#define SIGNAL_STATUS_CHANGED_NAME "mce-inactivity-mode-changed"
static guint mce_inactivity_signals[SIGNAL_COUNT] = { 0 };
typedef GObjectClass MceInactivityClass;
G_DEFINE_TYPE(MceInactivity, mce_inactivity, G_TYPE_OBJECT)
#define PARENT_CLASS mce_inactivity_parent_class
#define MCE_INACTIVITY_TYPE (mce_inactivity_get_type())
#define MCE_INACTIVITY(obj) (G_TYPE_CHECK_INSTANCE_CAST(obj,\
MCE_INACTIVITY_TYPE,MceInactivity))
/*==========================================================================*
* Implementation
*==========================================================================*/
static
void
mce_inactivity_status_update(
MceInactivity* self,
gboolean status)
{
MceInactivityPriv* priv = self->priv;
const gboolean prev_status = self->status;
self->status = status;
if (self->status != prev_status) {
g_signal_emit(self, mce_inactivity_signals[SIGNAL_STATUS_CHANGED], 0);
}
if (priv->proxy->valid && !self->valid) {
self->valid = TRUE;
g_signal_emit(self, mce_inactivity_signals[SIGNAL_VALID_CHANGED], 0);
}
}
static
void
mce_inactivity_status_query_done(
GObject* proxy,
GAsyncResult* result,
gpointer arg)
{
GError* error = NULL;
gboolean status = FALSE;
MceInactivity* self = MCE_INACTIVITY(arg);
if (com_nokia_mce_request_call_get_inactivity_status_finish(
COM_NOKIA_MCE_REQUEST(proxy), &status, result, &error)) {
GDEBUG("inactivlty is currently %s", status ? "true" : "false");
mce_inactivity_status_update(self, status);
} else {
/*
* We could retry but it's probably not worth the trouble.
* There is signal broadcast on mce startup / when inactivity
* state changes.
* Until then, this object stays invalid.
*/
GWARN("Failed to query inactivity status %s", GERRMSG(error));
g_error_free(error);
}
mce_inactivity_unref(self);
}
static
void
mce_inactivity_status_ind(
ComNokiaMceSignal* proxy,
gboolean status,
gpointer arg)
{
GDEBUG("status is %s", status ? "true" : "false");
mce_inactivity_status_update(MCE_INACTIVITY(arg), status);
}
static
void
mce_inactivity_status_query(
MceInactivity* self)
{
MceInactivityPriv* priv = self->priv;
MceProxy* proxy = priv->proxy;
/*
* proxy->signal and proxy->request may not be available at the
* time when MceInactivity is created. In that case we have to wait
* for the valid signal before we can connect the inactivity status
* signal and submit the initial query.
*/
if (proxy->signal && !priv->inactivity_status_ind_id) {
priv->inactivity_status_ind_id = g_signal_connect(proxy->signal,
MCE_INACTIVITY_SIG, G_CALLBACK(mce_inactivity_status_ind), self);
}
if (proxy->request && proxy->valid) {
com_nokia_mce_request_call_get_inactivity_status(proxy->request, NULL,
mce_inactivity_status_query_done, mce_inactivity_ref(self));
}
}
static
void
mce_inactivity_valid_changed(
MceProxy* proxy,
void* arg)
{
MceInactivity* self = MCE_INACTIVITY(arg);
if (proxy->valid) {
mce_inactivity_status_query(self);
} else {
if (self->valid) {
self->valid = FALSE;
g_signal_emit(self, mce_inactivity_signals[SIGNAL_VALID_CHANGED], 0);
}
}
}
/*==========================================================================*
* API
*==========================================================================*/
MceInactivity*
mce_inactivity_new()
{
static MceInactivity* mce_inactivity_instance = NULL;
if (mce_inactivity_instance) {
mce_inactivity_ref(mce_inactivity_instance);
} else {
mce_inactivity_instance = g_object_new(MCE_INACTIVITY_TYPE, NULL);
mce_inactivity_status_query(mce_inactivity_instance);
g_object_add_weak_pointer(G_OBJECT(mce_inactivity_instance),
(gpointer*)(&mce_inactivity_instance));
}
return mce_inactivity_instance;
}
MceInactivity*
mce_inactivity_ref(
MceInactivity* self)
{
if (G_LIKELY(self)) {
g_object_ref(MCE_INACTIVITY(self));
}
return self;
}
void
mce_inactivity_unref(
MceInactivity* self)
{
if (G_LIKELY(self)) {
g_object_unref(MCE_INACTIVITY(self));
}
}
gulong
mce_inactivity_add_valid_changed_handler(
MceInactivity* self,
MceInactivityFunc fn,
void* arg)
{
return (G_LIKELY(self) && G_LIKELY(fn)) ? g_signal_connect(self,
SIGNAL_VALID_CHANGED_NAME, G_CALLBACK(fn), arg) : 0;
}
gulong
mce_inactivity_add_status_changed_handler(
MceInactivity* self,
MceInactivityFunc fn,
void* arg)
{
return (G_LIKELY(self) && G_LIKELY(fn)) ? g_signal_connect(self,
SIGNAL_STATUS_CHANGED_NAME, G_CALLBACK(fn), arg) : 0;
}
void
mce_inactivity_remove_handler(
MceInactivity* self,
gulong id)
{
if (G_LIKELY(self) && G_LIKELY(id)) {
g_signal_handler_disconnect(self, id);
}
}
void
mce_inactivity_remove_handlers(
MceInactivity* self,
gulong* ids,
guint count)
{
gutil_disconnect_handlers(self, ids, count);
}
/*==========================================================================*
* Internals
*==========================================================================*/
static
void
mce_inactivity_init(
MceInactivity* self)
{
MceInactivityPriv* priv = G_TYPE_INSTANCE_GET_PRIVATE(self, MCE_INACTIVITY_TYPE,
MceInactivityPriv);
self->priv = priv;
self->status = FALSE;
priv->proxy = mce_proxy_new();
priv->proxy_valid_id = mce_proxy_add_valid_changed_handler(priv->proxy,
mce_inactivity_valid_changed, self);
}
static
void
mce_inactivity_finalize(
GObject* object)
{
MceInactivity* self = MCE_INACTIVITY(object);
MceInactivityPriv* priv = self->priv;
if (priv->inactivity_status_ind_id) {
g_signal_handler_disconnect(priv->proxy->signal,
priv->inactivity_status_ind_id);
}
mce_proxy_remove_handler(priv->proxy, priv->proxy_valid_id);
mce_proxy_unref(priv->proxy);
G_OBJECT_CLASS(PARENT_CLASS)->finalize(object);
}
static
void
mce_inactivity_class_init(
MceInactivityClass* klass)
{
GObjectClass* object_class = G_OBJECT_CLASS(klass);
object_class->finalize = mce_inactivity_finalize;
g_type_class_add_private(klass, sizeof(MceInactivityPriv));
mce_inactivity_signals[SIGNAL_VALID_CHANGED] =
g_signal_new(SIGNAL_VALID_CHANGED_NAME,
G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL, G_TYPE_NONE, 0);
mce_inactivity_signals[SIGNAL_STATUS_CHANGED] =
g_signal_new(SIGNAL_STATUS_CHANGED_NAME,
G_OBJECT_CLASS_TYPE(klass), G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL, G_TYPE_NONE, 0);
}
/*
* Local Variables:
* status: C
* c-basic-offset: 4
* indent-tabs-status: nil
* End:
*/