libnotify/libnotify/notify.c

/**
 * @file libnotify/notify.c Notifications library
 *
 * @Copyright (C) 2004-2006 Christian Hammond <chipx86@chipx86.com>
 * @Copyright (C) 2004-2006 Mike Hearn <mike@navi.cx>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <libnotify/notify.h>
#include <libnotify/internal.h>
#include <libnotify/notify-marshal.h>

static gboolean _initted = FALSE;
static gchar *_app_name = NULL;
static DBusGProxy *_proxy = NULL;
static DBusGConnection *_dbus_gconn = NULL;
static GList *_active_notifications = NULL;

/**
 * notify_init:
 * @app_name: The name of the application initializing libnotify.
 *
 * Initialized libnotify. This must be called before any other functions.
 *
 * Returns: %TRUE if successful, or %FALSE on error.
 */
gboolean
notify_init(const char *app_name)
{
	GError *error = NULL;
	DBusGConnection *bus = NULL;

	g_return_val_if_fail(app_name != NULL, FALSE);
	g_return_val_if_fail(*app_name != '\0', FALSE);

	if (_initted)
		return TRUE;

	_app_name = g_strdup(app_name);

	g_type_init();

	bus = dbus_g_bus_get(DBUS_BUS_SESSION, &error);

	if (error != NULL)
	{
		g_message("Unable to get session bus: %s", error->message);
		g_error_free(error);
		return FALSE;
	}

	_proxy = dbus_g_proxy_new_for_name(bus,
									   NOTIFY_DBUS_NAME,
									   NOTIFY_DBUS_CORE_OBJECT,
									   NOTIFY_DBUS_CORE_INTERFACE);
	dbus_g_connection_unref(bus);

	dbus_g_object_register_marshaller(notify_marshal_VOID__UINT_UINT,
									  G_TYPE_NONE,
									  G_TYPE_UINT,
									  G_TYPE_UINT, G_TYPE_INVALID);

	dbus_g_object_register_marshaller(notify_marshal_VOID__UINT_STRING,
									  G_TYPE_NONE,
									  G_TYPE_UINT,
									  G_TYPE_STRING, G_TYPE_INVALID);

	dbus_g_proxy_add_signal(_proxy, "NotificationClosed",
							G_TYPE_UINT, G_TYPE_UINT, 
							G_TYPE_INVALID);
	dbus_g_proxy_add_signal(_proxy, "ActionInvoked",
							G_TYPE_UINT, G_TYPE_STRING,
							G_TYPE_INVALID);

	_initted = TRUE;

	return TRUE;
}

/**
 * notify_get_app_name:
 *
 * Gets the application name registered.
 *
 * Returns: The registered application name, passed to notify_init().
 */
const gchar *
notify_get_app_name(void)
{
	return _app_name;
}

/**
 * notify_uninit:
 *
 * Uninitialized libnotify.
 *
 * This should be called when the program no longer needs libnotify for
 * the rest of its lifecycle, typically just before exitting.
 */
void
notify_uninit(void)
{
	GList *l;

	if (!_initted)
		return;

	if (_app_name != NULL)
	{
		g_free(_app_name);
		_app_name = NULL;
	}

	for (l = _active_notifications; l != NULL; l = l->next)
	{
		NotifyNotification *n = NOTIFY_NOTIFICATION(l->data);

		if (_notify_notification_get_timeout(n) == 0 ||
			_notify_notification_has_nondefault_actions(n))
		{
			notify_notification_close(n, NULL);
		}
	}

	g_object_unref(_proxy);

	_initted = FALSE;
}

/**
 * notify_is_initted:
 *
 * Gets whether or not libnotify is initialized.
 *
 * Returns: %TRUE if libnotify is initialized, or %FALSE otherwise.
 */
gboolean
notify_is_initted(void)
{
	return _initted;
}

DBusGConnection *
_notify_get_dbus_g_conn(void)
{
	return _dbus_gconn;
}

DBusGProxy *
_notify_get_g_proxy(void)
{
	return _proxy;
}

/**
 * notify_get_server_caps:
 *
 * Queries the server for its capabilities and returns them in a #GList.
 *
 * Returns: A #GList of server capability strings.
 */
GList *
notify_get_server_caps(void)
{
	GError *error = NULL;
	char **caps = NULL, **cap;
	GList *result = NULL;
	DBusGProxy *proxy = _notify_get_g_proxy();

	g_return_val_if_fail(proxy != NULL, NULL);

	if (!dbus_g_proxy_call(proxy, "GetCapabilities", &error,
						   G_TYPE_INVALID,
						   G_TYPE_STRV, &caps, G_TYPE_INVALID))
	{
		g_message("GetCapabilities call failed: %s", error->message);
		g_error_free(error);
		return NULL;
	}

	for (cap = caps; *cap != NULL; cap++)
	{
		result = g_list_append(result, g_strdup(*cap));
	}

	g_strfreev(caps);

	return result;
}

/**
 * notify_get_server_info:
 * @ret_name: The resulting server name.
 * @ret_vendor: The resulting server vendor.
 * @ret_version: The resulting server version.
 * @ret_spec_version: The resulting version of the specification the server is
 *                    compliant with.
 *
 * Queries the server for its information, specifically, the name, vendor,
 * server version, and the version of the notifications specification that it
 * is compliant with.
 *
 * Returns: %TRUE if successful, and the variables passed will be set. %FALSE
 *          on failure.
 */
gboolean
notify_get_server_info(char **ret_name, char **ret_vendor,
					   char **ret_version, char **ret_spec_version)
{
	GError *error = NULL;
	DBusGProxy *proxy = _notify_get_g_proxy();
	char *name, *vendor, *version, *spec_version;

	g_return_val_if_fail(proxy != NULL, FALSE);

	if (!dbus_g_proxy_call(proxy, "GetServerInformation", &error,
						   G_TYPE_INVALID,
						   G_TYPE_STRING, &name,
						   G_TYPE_STRING, &vendor,
						   G_TYPE_STRING, &version,
						   G_TYPE_STRING, &spec_version,
						   G_TYPE_INVALID))
	{
		g_message("GetServerInformation call failed: %s", error->message);
		return FALSE;
	}

	if (ret_name != NULL)
		*ret_name = name;

	if (ret_vendor != NULL)
		*ret_vendor = vendor;

	if (ret_version != NULL)
		*ret_version = version;

	if (spec_version != NULL)
		*ret_spec_version = spec_version;

	return TRUE;
}

void
_notify_cache_add_notification(NotifyNotification *n)
{
	_active_notifications = g_list_prepend(_active_notifications, n);
}

void
_notify_cache_remove_notification(NotifyNotification *n)
{
	_active_notifications = g_list_remove(_active_notifications, n);
}