int
main ()
{
NotifyNotification *n;
DBusConnection *conn;
if (!notify_init ("Default Action Test"))
exit (1);
conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
loop = g_main_loop_new (NULL, FALSE);
dbus_connection_setup_with_g_main (conn, NULL);
n = notify_notification_new ("Matt is online", "", NULL, NULL);
notify_notification_set_timeout (n, NOTIFY_EXPIRES_DEFAULT);
notify_notification_add_action (n,
"default",
"Do Default Action",
(NotifyActionCallback) callback,
NULL,
NULL);
notify_notification_set_category (n, "presence.online");
if (!notify_notification_show (n, NULL)) {
fprintf (stderr, "failed to send notification\n");
return 1;
}
g_main_loop_run (loop);
return 0;
}
static void
on_account_added (MailmeTelepathy *tp_provider,
MailmeTelepathyAccount *account,
gpointer user_data)
{
/* Translators: button on a "unread mail" notification, will open
a web page (e.g. gmail.com inbox) or a mail client */
char *title = _("Open");
NotifyNotification *notification;
notification = notify_notification_new ("", NULL, NULL);
notify_notification_set_category (notification, "email.arrived");
notify_notification_add_action (notification,
"open", title,
on_open_action,
account, NULL);
g_object_set_data_full (G_OBJECT (account), "notification",
notification, g_object_unref);
g_object_set_data (G_OBJECT (account), "last-unread-count",
GUINT_TO_POINTER(0));
g_signal_connect (account,
"notify::unread-count",
G_CALLBACK (on_unread_count_changed),
NULL);
}
static void _do_notify_message(
const char * const source, const char * const message, int win) {
#ifdef HAVE_LIBNOTIFY
if (notify_is_initted()) {
GString *title = g_string_new("");
g_string_append(title, source);
g_string_append_printf(title, " (Profanity %d)", win);
NotifyNotification *notification =
notify_notification_new(title->str, message, NULL);
notify_notification_set_timeout(notification, 3000);
notify_notification_set_category(notification, "incoming message");
notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);
GError *error = NULL;
gboolean notify_success = notify_notification_show(notification, &error);
if (!notify_success) {
log_error("Error sending desktop notification:");
log_error(" -> Message : %s", message);
log_error(" -> Error : %s", error->message);
}
g_string_free(title, TRUE);
} else {
log_error("Libnotify initialisation error.");
}
#endif
}
static void
show_notification(MnpAlarmInstance *alarm)
{
MnpAlarmInstancePrivate *priv = ALARM_INSTANCE_PRIVATE(alarm);
gboolean once = FALSE;
NotifyNotification *notify;
char *string;
MnpAlarmItem *item = priv->item;
if (!once) {
once = TRUE;
notify_init(_("Alarm Notify"));
}
string = g_strdup_printf(_("Alarm at %d:%.2d %s"), item->hour, item->minute, item->am_pm ? _("am") : _("pm"));
#ifdef HAVE_NOTIFY_0_7
notify = notify_notification_new(_("Dawati Alarm Notify"), string, NULL);
#else
notify = notify_notification_new(_("Dawati Alarm Notify"), string, NULL, NULL);
#endif
notify_notification_set_timeout(notify,10000);
notify_notification_set_category(notify,_("AlarmNotifications"));
notify_notification_set_urgency (notify,NOTIFY_URGENCY_CRITICAL);
notify_notification_show(notify,NULL);
g_free(string);
}
void DesktopNotifierLinux::showNotification(const std::string& notification_title, const std::string& notification_message, const std::string& notification_type)
{
LL_INFOS("DesktopNotifierLinux") << "New notification title: " << notification_title << LL_ENDL;
LL_INFOS("DesktopNotifierLinux") << "New notification message: " << notification_message << LL_ENDL;
LL_INFOS("DesktopNotifierLinux") << "New notification type: " << notification_type << LL_ENDL;
static NotifyNotification* notification = notify_notification_new(
"Emerald Viewer",//(gchar*)notification_title.c_str(),
NULL,//(gchar*)notification_message.c_str(),
icon_wholename,
NULL
);
notify_notification_update(
notification,
(gchar*)notification_title.c_str(),
(gchar*)notification_message.c_str(),
icon_wholename
);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_LOW);
notify_notification_set_category(notification, (gchar*)notification_type.c_str());
notify_notification_set_timeout(notification, NOTIFICATION_TIMEOUT_MS); // NotifyOSD ignores this, sadly.
GError* error = NULL;
if (notify_notification_show(notification, &error)) {
LL_INFOS("DesktopNotifierLinux") << "Linux desktop notification type " << notification_type << "sent." << LL_ENDL;
} else {
LL_WARNS("DesktopNotifierLinux") << "Linux desktop notification FAILED to send. " << error->message << LL_ENDL;
}
}
void notify (void) {
NotifyNotification *notify;
GError *error_notify = NULL;
entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
if(g_strcmp0 (entry_text, "Notification text") != 0)
notify = notify_notification_new (entry_text, NULL, "clocks");
else
notify = notify_notification_new (_("Time is up!"), NULL, "clocks");
notify_notification_set_category (notify, "GTimeUtils");
notify_notification_set_urgency (notify, NOTIFY_URGENCY_NORMAL);
notify_notification_show (notify, &error_notify);
if(error_notify)
g_fprintf (stderr, "Can not initialize notification: %s\n", error_notify->message);
ca_context_play(sound, 0, CA_PROP_APPLICATION_NAME, "Gtimer", CA_PROP_EVENT_ID, "complete-copy", CA_PROP_MEDIA_ROLE, "notification", CA_PROP_APPLICATION_ICON_NAME, "clocks", CA_PROP_CANBERRA_CACHE_CONTROL, "never", NULL);
}
void lassi_tray_show_notification(LassiTrayInfo *i, char *summary, char *body, LassiTrayNotificationIcon icon) {
static const char * const icon_name[] = {
[LASSI_TRAY_NOTIFICATION_WELCOME] = "user-desktop",
[LASSI_TRAY_NOTIFICATION_LEFT] = "go-previous",
[LASSI_TRAY_NOTIFICATION_RIGHT] = "go-next"
};
NotifyNotification *n;
n = notify_notification_new_with_status_icon(summary, body, icon_name[icon], i->status_icon);
notify_notification_set_timeout(n, 10000);
notify_notification_set_urgency(n, NOTIFY_URGENCY_LOW);
notify_notification_set_category(n, "network");
notify_notification_show(n, NULL);
}
void Notification::show()
{
assert(note == nullptr);
assert(name.size());
notify_init(name.c_str());
note = notify_notification_new(name.c_str(), content.c_str(), icon.c_str());
notify_notification_set_timeout(note, timeout.count());
notify_notification_set_category(note, "Testing Notifications");
notify_notification_set_urgency(note, NOTIFY_URGENCY_NORMAL);
GError* error = nullptr;
notify_notification_show(note, &error);
if (error != nullptr)
{
throw std::runtime_error("error during 'notify_notification_show");
}
}
static void
progress_ui_handler_ensure_notification (NautilusProgressUIHandler *self)
{
NotifyNotification *notify;
if (self->priv->progress_notification) {
return;
}
notify = notify_notification_new (_("File Operations"),
NULL, NULL);
self->priv->progress_notification = notify;
notify_notification_set_category (notify, "transfer");
notify_notification_set_hint (notify, "resident",
g_variant_new_boolean (TRUE));
notify_notification_add_action (notify, ACTION_DETAILS,
_("Show Details"),
notification_show_details_cb,
self,
NULL);
}
/*** msg_handler ***/
int msg_handler (struct sockaddr_nl *nl, struct nlmsghdr *msg) {
int rc = EXIT_FAILURE;
char *notifystr = NULL;
unsigned int errcount = 0;
GError *error = NULL;
struct ifaddrmsg *ifa;
struct ifinfomsg *ifi;
struct rtattr *rth;
int rtl;
char buf[INET6_ADDRSTRLEN];
NotifyNotification *tmp_notification = NULL, *notification = NULL;
char *icon = NULL;
ifa = (struct ifaddrmsg *) NLMSG_DATA (msg);
ifi = (struct ifinfomsg *) NLMSG_DATA (msg);
/* make sure we have alloced memory for NotifyNotification and addresses_seen struct array */
if (maxinterface < ifi->ifi_index) {
ifs = realloc(ifs, (ifi->ifi_index + 1) * sizeof(struct ifs));
while(maxinterface < ifi->ifi_index) {
maxinterface++;
if (verbose > 0)
printf("%s: Initializing interface %d: ", program, maxinterface);
/* get interface name and store it
* in case the interface does no longer exist this may fail,
* use static string '(unknown)' instead */
if (if_indextoname(maxinterface, ifs[maxinterface].name) == NULL)
strcpy(ifs[maxinterface].name, "(unknown)");
if (verbose > 0)
printf("%s\n", ifs[maxinterface].name);
ifs[maxinterface].state = -1;
ifs[maxinterface].deleted = 0;
ifs[maxinterface].notification =
# if NOTIFY_CHECK_VERSION(0, 7, 0)
notify_notification_new(TEXT_TOPIC, NULL, NULL);
# else
notify_notification_new(TEXT_TOPIC, NULL, NULL, NULL);
# endif
notify_notification_set_category(ifs[maxinterface].notification, PROGNAME);
notify_notification_set_urgency(ifs[maxinterface].notification, NOTIFY_URGENCY_NORMAL);
notify_notification_set_timeout(ifs[maxinterface].notification, notification_timeout);
ifs[maxinterface].addresses_seen = NULL;
}
} else if (ifs[ifi->ifi_index].deleted == 1) {
if (verbose > 0)
printf("%s: Ignoring event for deleted interface %d.\n", program, ifi->ifi_index);
rc = EXIT_SUCCESS;
goto out;
}
/* make notification point to the array element, will be overwritten
* later when needed for address notification */
notification = ifs[ifi->ifi_index].notification;
/* get interface name and store it
* in case the interface does no longer exist this may fail, but it does not overwrite */
if_indextoname(ifi->ifi_index, ifs[ifi->ifi_index].name);
if (verbose > 1)
printf("%s: Event for interface %s (%d): flags = %x, msg type = %d\n",
program, ifs[ifi->ifi_index].name, ifi->ifi_index, ifa->ifa_flags, msg->nlmsg_type);
switch (msg->nlmsg_type) {
/* just return for cases we want to ignore
* use break if a notification has to be displayed */
case RTM_NEWADDR:
rth = IFA_RTA (ifa);
rtl = IFA_PAYLOAD (msg);
while (rtl && RTA_OK (rth, rtl)) {
if ((rth->rta_type == IFA_LOCAL /* IPv4 */
|| rth->rta_type == IFA_ADDRESS /* IPv6 */)
&& ifa->ifa_scope == RT_SCOPE_UNIVERSE /* no IPv6 scope link */) {
inet_ntop(ifa->ifa_family, RTA_DATA (rth), buf, sizeof(buf));
/* check if we already notified about this address */
if (match_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen)) {
if (verbose > 0)
printf("%s: Address %s/%d already known for %s, ignoring.\n",
program, buf, ifa->ifa_prefixlen, ifs[ifi->ifi_index].name);
break;
}
/* add address to struct */
ifs[ifi->ifi_index].addresses_seen =
add_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen);
if (verbose > 1)
list_addresses(ifs[ifi->ifi_index].addresses_seen, ifs[ifi->ifi_index].name);
/* display notification */
notifystr = newstr_addr(ifs[ifi->ifi_index].name,
ifa->ifa_family, buf, ifa->ifa_prefixlen);
/* we are done, no need to run more loops */
break;
}
rth = RTA_NEXT (rth, rtl);
}
/* we did not find anything to notify */
if (notifystr == NULL) {
rc = EXIT_SUCCESS;
goto out;
}
/* do we want new notification, not update the notification about link status */
tmp_notification =
# if NOTIFY_CHECK_VERSION(0, 7, 0)
notify_notification_new(TEXT_TOPIC, NULL, NULL);
# else
notify_notification_new(TEXT_TOPIC, NULL, NULL, NULL);
# endif
notify_notification_set_category(tmp_notification, PROGNAME);
notify_notification_set_urgency(tmp_notification, NOTIFY_URGENCY_NORMAL);
notify_notification_set_timeout(tmp_notification, notification_timeout);
notification = tmp_notification;
icon = ICON_NETWORK_ADDRESS;
break;
case RTM_DELADDR:
rth = IFA_RTA (ifa);
rtl = IFA_PAYLOAD (msg);
while (rtl && RTA_OK (rth, rtl)) {
if ((rth->rta_type == IFA_LOCAL /* IPv4 */
|| rth->rta_type == IFA_ADDRESS /* IPv6 */)
&& ifa->ifa_scope == RT_SCOPE_UNIVERSE /* no IPv6 scope link */) {
inet_ntop(ifa->ifa_family, RTA_DATA (rth), buf, sizeof(buf));
ifs[ifi->ifi_index].addresses_seen =
remove_address(ifs[ifi->ifi_index].addresses_seen, buf, ifa->ifa_prefixlen);
if (verbose > 1)
list_addresses(ifs[ifi->ifi_index].addresses_seen, ifs[ifi->ifi_index].name);
/* we are done, no need to run more loops */
break;
}
rth = RTA_NEXT (rth, rtl);
}
rc = EXIT_SUCCESS;
goto out;
case RTM_NEWROUTE:
rc = EXIT_SUCCESS;
goto out;
case RTM_DELROUTE:
rc = EXIT_SUCCESS;
goto out;
case RTM_NEWLINK:
/* ignore if state did not change */
if ((ifi->ifi_flags & CHECK_CONNECTED) == ifs[ifi->ifi_index].state) {
rc = EXIT_SUCCESS;
goto out;
}
ifs[ifi->ifi_index].state = ifi->ifi_flags & CHECK_CONNECTED;
notifystr = newstr_link(ifs[ifi->ifi_index].name, ifi->ifi_flags);
icon = ifi->ifi_flags & CHECK_CONNECTED ? ICON_NETWORK_UP : ICON_NETWORK_DOWN;
/* free only if interface goes down */
if (!(ifi->ifi_flags & CHECK_CONNECTED)) {
free_addresses(ifs[ifi->ifi_index].addresses_seen);
ifs[ifi->ifi_index].addresses_seen = NULL;
}
break;
case RTM_DELLINK:
notifystr = newstr_away(ifs[ifi->ifi_index].name);
icon = ICON_NETWORK_AWAY;
free_addresses(ifs[ifi->ifi_index].addresses_seen);
/* marking interface deleted makes events for this interface to be ignored */
ifs[ifi->ifi_index].deleted = 1;
break;
default:
/* we should not get here... */
fprintf(stderr, "msg_handler: Unknown netlink nlmsg_type %d.\n", msg->nlmsg_type);
goto out;
}
if (verbose > 0)
printf("%s: %s\n", program, notifystr);
notify_notification_update(notification, TEXT_TOPIC, notifystr, icon);
while (notify_notification_show(notification, &error) == FALSE) {
if (errcount > 1) {
fprintf(stderr, "%s: Looks like we can not reconnect to notification daemon... Exiting.\n", program);
goto out;
} else {
g_printerr("%s: Error \"%s\" while trying to show notification. Trying to reconnect.\n", program, error->message);
errcount++;
g_error_free(error);
error = NULL;
notify_uninit();
usleep (500 * 1000);
if (notify_init(PROGNAME) == FALSE) {
fprintf(stderr, "%s: Can't create notify.\n", program);
goto out;
}
}
}
rc = EXIT_SUCCESS;
out:
if (tmp_notification)
g_object_unref(G_OBJECT(tmp_notification));
errcount = 0;
free(notifystr);
return rc;
}
int main(int argc, char **argv)
{
typedef int bool;
NotifyUrgency urgency;
/* Default timeout-value is: 60 min (int timeout = 3600*1000;)
After this time the desktop notification disappears */
int timeout = 3600*1000;
/* Restricts the number of packages which should be included in the desktop notification.*/
int max_number_out = 30;
/* Sets the urgency-level to normal. */
urgency = NOTIFY_URGENCY_NORMAL;
/* The default command to get a list of packages to update. */
char *command = "/usr/bin/pacman -Qu";
/* The default icon to show: none */
gchar *icon = NULL;
/* We parse the commandline options. */
int i;
for (i=1;i<argc;i++)
{
if ( strcmp(argv[i],"--help") == 0 )
{
print_help(argv[0]);
}
else if ( strcmp(argv[i],"--version") == 0 )
{
print_version();
}
else if ( strcmp(argv[i],"--timeout") == 0 || strcmp(argv[i],"-t") == 0 )
{
/* If argv[i] is not the last command line option (because
if it is, there's no place left for the value) and the next
value is a digit, we take this as new value */
if ( (argc-1 != i) && isdigit(*argv[i+1]) )
{
timeout = atoi(argv[i+1])*1000;
}
}
else if ( strcmp(argv[i],"--maxentries") == 0 || strcmp(argv[i],"-m") == 0 )
{
if ( (argc-1 != i) && isdigit(*argv[i+1]) )
{
max_number_out = atoi(argv[i+1]);
}
}
else if ( strcmp(argv[i],"--urgency") == 0 || strcmp(argv[i],"-u") == 0 )
{
if ( (argc-1 != i) )
{
if ( strcmp(argv[i+1],"low") == 0 )
{
urgency=NOTIFY_URGENCY_LOW;
}
else if ( strcmp(argv[i+1],"normal") == 0 )
{
urgency=NOTIFY_URGENCY_NORMAL;
}
else if ( strcmp(argv[i+1],"critical") == 0 )
{
urgency=NOTIFY_URGENCY_CRITICAL;
}
}
}
else if ( strcmp(argv[i],"--command") == 0 || strcmp(argv[i],"-c") == 0 )
{
if ( (argc-1 != i) )
{
command = argv[i+1];
}
}
else if ( strcmp(argv[i],"--uid") == 0 || strcmp(argv[i],"-i") == 0 )
{
if ( (argc-1 != i) && isdigit(*argv[i+1]) )
{
if ( setuid(atoi(argv[i+1])) != 0 )
{
printf("Couldn't change to the given uid!\n");
exit(1);
}
}
}
else if ( strcmp(argv[i],"--icon") == 0 || strcmp(argv[i],"-p") == 0 )
{
if ( (argc-1 != i) )
{
icon = argv[i+1];
}
}
}
/* Those are needed by libnotify. */
char *name = "arch_update_check";
char *category = "update";
NotifyNotification *my_notify;
GError *error = NULL;
/* Those are needed for the output. */
char *output_string=malloc(23);
sprintf(output_string,"There are updates for:\n");
bool got_updates = FALSE;
/* Those are needed for getting the list of updates. */
FILE *pac_out;
int llen = 0;
char line[BUFSIZ];
/* We get stdout of pacman -Qu into the pac_out stream.
Remember we can't use fseek(stream,0,SEEK_END) with
popen-streams, thus we are reading BUFSIZ sized lines
and allocate dynamically more memory for our output. */
pac_out = popen(command,"r");
i = 0;
while (fgets(line,BUFSIZ,pac_out))
{
/* We leave the loop if we have more updates than we want to show in the notification. */
if (i >= max_number_out)
{
break;
}
i++;
/* If we are in this loop, we got updates waiting. */
got_updates = TRUE;
/* We get the length of the current line. */
llen = strlen(line);
/* We allocate that much more memory+2 bytes for the "- "+1 byte as delimiter. */
output_string = (char *)realloc(output_string,strlen(output_string)+1+llen+2);
/* We add the line to the output string. */
strncat(output_string,"- ",2);
strncat(output_string,line,llen);
}
/* We close the popen stream if we don't need it anymore. */
pclose(pac_out);
/* If we got updates we are showing them in a notification */
if (got_updates == TRUE)
{
/* Initiates the libnotify. */
notify_init(name);
/* Removes the last newlinefeed of the output_string, if the last sign is a newlinefeed. */
if ( output_string[strlen(output_string)-1] == '\n' )
{
output_string[strlen(output_string)-1] = '\0';
}
/* Constructs the notification. */
my_notify = notify_notification_new("New updates for Archlinux available!",output_string,icon);
/* Sets the timeout until the notification disappears. */
notify_notification_set_timeout(my_notify,timeout);
/* We set the category.*/
notify_notification_set_category(my_notify,category);
/* We set the urgency, which can be changed with a commandline option */
notify_notification_set_urgency (my_notify,urgency);
/* We finally show the notification, */
notify_notification_show(my_notify,&error);
/* and deinitialize the libnotify afterwards. */
notify_uninit();
/* Should be safe now */
free(output_string);
}
return(0);
}
static gboolean
ldsm_notify_for_mount (LdsmMountInfo *mount,
gboolean multiple_volumes,
gboolean other_usable_volumes)
{
gchar *name, *program;
gint64 free_space;
gint response;
gboolean has_trash;
gboolean has_disk_analyzer;
gboolean retval = TRUE;
gchar *path;
/* Don't show a notice if one is already displayed */
if (dialog != NULL || notification != NULL)
return retval;
name = g_unix_mount_guess_name (mount->mount);
free_space = (gint64) mount->buf.f_frsize * (gint64) mount->buf.f_bavail;
has_trash = ldsm_mount_has_trash (mount);
path = g_strdup (g_unix_mount_get_mount_path (mount->mount));
program = g_find_program_in_path (DISK_SPACE_ANALYZER);
has_disk_analyzer = (program != NULL);
g_free (program);
if (server_has_actions ()) {
char *free_space_str;
char *summary;
char *body;
free_space_str = g_format_size (free_space);
if (multiple_volumes) {
summary = g_strdup_printf (_("Low Disk Space on \"%s\""), name);
if (has_trash) {
body = g_strdup_printf (_("The volume \"%s\" has only %s disk space remaining. You may free up some space by emptying the trash."),
name,
free_space_str);
} else {
body = g_strdup_printf (_("The volume \"%s\" has only %s disk space remaining."),
name,
free_space_str);
}
} else {
summary = g_strdup (_("Low Disk Space"));
if (has_trash) {
body = g_strdup_printf (_("This computer has only %s disk space remaining. You may free up some space by emptying the trash."),
free_space_str);
} else {
body = g_strdup_printf (_("This computer has only %s disk space remaining."),
free_space_str);
}
}
g_free (free_space_str);
notification = notify_notification_new (summary, body, "drive-harddisk-symbolic");
g_free (summary);
g_free (body);
g_signal_connect (notification,
"closed",
G_CALLBACK (on_notification_closed),
NULL);
notify_notification_set_app_name (notification, _("Disk space"));
notify_notification_set_hint (notification, "transient", g_variant_new_boolean (TRUE));
notify_notification_set_urgency (notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_set_timeout (notification, NOTIFY_EXPIRES_DEFAULT);
if (has_disk_analyzer) {
notify_notification_add_action (notification,
"examine",
_("Examine"),
(NotifyActionCallback) examine_callback,
g_strdup (path),
g_free);
}
if (has_trash) {
notify_notification_add_action (notification,
"empty-trash",
_("Empty Trash"),
(NotifyActionCallback) empty_trash_callback,
NULL,
NULL);
}
notify_notification_add_action (notification,
"ignore",
_("Ignore"),
(NotifyActionCallback) ignore_callback,
NULL,
NULL);
notify_notification_set_category (notification, "device");
if (!notify_notification_show (notification, NULL)) {
g_warning ("failed to send disk space notification\n");
}
} else {
dialog = csd_ldsm_dialog_new (other_usable_volumes,
multiple_volumes,
has_disk_analyzer,
has_trash,
free_space,
name,
path);
g_object_ref (G_OBJECT (dialog));
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
dialog = NULL;
switch (response) {
case GTK_RESPONSE_CANCEL:
retval = FALSE;
break;
case CSD_LDSM_DIALOG_RESPONSE_ANALYZE:
retval = FALSE;
ldsm_analyze_path (path);
break;
case CSD_LDSM_DIALOG_RESPONSE_EMPTY_TRASH:
retval = TRUE;
csd_ldsm_show_empty_trash ();
break;
case GTK_RESPONSE_NONE:
case GTK_RESPONSE_DELETE_EVENT:
retval = TRUE;
break;
default:
g_assert_not_reached ();
}
}
g_free (name);
g_free (path);
return retval;
}
int
main (int argc, char *argv[])
{
static const char *summary = NULL;
char *body;
static const char *type = NULL;
static char *app_name = NULL;
static char *icon_str = NULL;
static char *icons = NULL;
static char **n_text = NULL;
static char **hints = NULL;
static gboolean do_version = FALSE;
static gboolean hint_error = FALSE;
static glong expire_timeout = NOTIFY_EXPIRES_DEFAULT;
GOptionContext *opt_ctx;
NotifyNotification *notify;
GError *error = NULL;
gboolean retval;
static const GOptionEntry entries[] = {
{"urgency", 'u', 0, G_OPTION_ARG_CALLBACK,
g_option_arg_urgency_cb,
N_("Specifies the urgency level (low, normal, critical)."),
N_("LEVEL")},
{"expire-time", 't', 0, G_OPTION_ARG_INT, &expire_timeout,
N_
("Specifies the timeout in milliseconds at which to expire the "
"notification."), N_("TIME")},
{"app-name", 'a', 0, G_OPTION_ARG_STRING, &app_name,
N_("Specifies the app name for the icon"), N_("APP_NAME")},
{"icon", 'i', 0, G_OPTION_ARG_FILENAME, &icons,
N_("Specifies an icon filename or stock icon to display."),
N_("ICON[,ICON...]")},
{"category", 'c', 0, G_OPTION_ARG_FILENAME, &type,
N_("Specifies the notification category."),
N_("TYPE[,TYPE...]")},
{"hint", 'h', 0, G_OPTION_ARG_FILENAME_ARRAY, &hints,
N_
("Specifies basic extra data to pass. Valid types are int, double, string and byte."),
N_("TYPE:NAME:VALUE")},
{"version", 'v', 0, G_OPTION_ARG_NONE, &do_version,
N_("Version of the package."),
NULL},
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY,
&n_text, NULL,
NULL},
{NULL}
};
body = NULL;
g_type_init ();
g_set_prgname (argv[0]);
g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
opt_ctx = g_option_context_new (N_("<SUMMARY> [BODY] - "
"create a notification"));
g_option_context_add_main_entries (opt_ctx, entries, GETTEXT_PACKAGE);
retval = g_option_context_parse (opt_ctx, &argc, &argv, &error);
g_option_context_free (opt_ctx);
if (!retval) {
fprintf (stderr, "%s\n", error->message);
g_error_free (error);
exit (1);
}
if (do_version) {
g_printf ("%s %s\n", g_get_prgname (), VERSION);
exit (0);
}
if (n_text != NULL && n_text[0] != NULL && *n_text[0] != '\0')
summary = n_text[0];
if (summary == NULL) {
fprintf (stderr, "%s\n", N_("No summary specified."));
exit (1);
}
if (n_text[1] != NULL) {
body = g_strcompress (n_text[1]);
if (n_text[2] != NULL) {
fprintf (stderr, "%s\n",
N_("Invalid number of options."));
exit (1);
}
}
if (icons != NULL) {
char *c;
/* XXX */
if ((c = strchr (icons, ',')) != NULL)
*c = '\0';
icon_str = icons;
}
if (!notify_init ("notify-send"))
exit (1);
notify = notify_notification_new (summary,
body,
icon_str);
notify_notification_set_category (notify, type);
notify_notification_set_urgency (notify, urgency);
notify_notification_set_timeout (notify, expire_timeout);
notify_notification_set_app_name (notify, app_name);
g_free (body);
/* Set hints */
if (hints != NULL) {
gint i = 0;
gint l;
char *hint = NULL;
char **tokens = NULL;
while ((hint = hints[i++])) {
tokens = g_strsplit (hint, ":", -1);
l = g_strv_length (tokens);
if (l != 3) {
fprintf (stderr, "%s\n",
N_("Invalid hint syntax specified. "
"Use TYPE:NAME:VALUE."));
hint_error = TRUE;
} else {
retval = notify_notification_set_hint_variant (notify,
tokens[0],
tokens[1],
tokens[2],
&error);
if (!retval) {
fprintf (stderr, "%s\n", error->message);
g_error_free (error);
hint_error = TRUE;
}
}
g_strfreev (tokens);
if (hint_error)
break;
}
}
if (!hint_error)
notify_notification_show (notify, NULL);
g_object_unref (G_OBJECT (notify));
notify_uninit ();
exit (hint_error);
}
static gboolean notification_trayicon_popup_create(MsgInfo *msginfo,
NotificationFolderType nftype)
{
gchar *summary = NULL;
gchar *utf8_str = NULL;
GdkPixbuf *pixbuf;
GList *caps = NULL;
gboolean support_actions = FALSE;
/* init libnotify if necessary */
if(!notify_is_initted()) {
if(!notify_init("claws-mail")) {
debug_print("Notification Plugin: Failed to initialize libnotify. "
"No popups will be shown.\n");
return FALSE;
}
}
/* Count messages */
notification_trayicon_popup_count_msgs(nftype);
summary = notification_trayicon_popup_assemble_summary();
utf8_str = notification_trayicon_popup_assemble_body(msginfo);
#if NOTIFY_CHECK_VERSION(0, 7, 0)
popup.notification = notify_notification_new(summary, utf8_str, NULL);
#else
popup.notification = notify_notification_new(summary, utf8_str, NULL, NULL);
notify_notification_attach_to_status_icon(popup.notification, trayicon);
#endif
g_free(summary);
g_free(utf8_str);
caps = notify_get_server_caps();
if(caps != NULL) {
GList *c;
for(c = caps; c != NULL; c = c->next) {
if(strcmp((char*)c->data, "actions") == 0 ) {
support_actions = TRUE;
break;
}
}
g_list_foreach(caps, (GFunc)g_free, NULL);
g_list_free(caps);
}
/* Default action */
if (support_actions)
notify_notification_add_action(popup.notification,
"default", "Present main window",
(NotifyActionCallback)
notification_trayicon_popup_default_action_cb,
GINT_TO_POINTER(nftype),
notification_trayicon_popup_free_func);
if(popup.notification == NULL) {
debug_print("Notification Plugin: Failed to create a new notification.\n");
return FALSE;
}
/* Icon */
pixbuf = NULL;
#ifndef USE_NEW_ADDRBOOK
if(msginfo && msginfo->from) {
gchar *icon_path;
icon_path = addrindex_get_picture_file(msginfo->from);
if(is_file_exist(icon_path)) {
GError *error = NULL;
gint w, h;
gdk_pixbuf_get_file_info(icon_path, &w, &h);
if((w > 64) || (h > 64))
pixbuf = gdk_pixbuf_new_from_file_at_scale(icon_path,
64, 64, TRUE, &error);
else
pixbuf = gdk_pixbuf_new_from_file(icon_path, &error);
if(!pixbuf) {
debug_print("Could not load picture file: %s\n",
error ? error->message : "no details");
g_error_free(error);
}
}
else
debug_print("Picture path does not exist: %s\n",icon_path);
g_free(icon_path);
}
#endif
if(!pixbuf)
pixbuf = g_object_ref(notification_pixbuf_get(NOTIFICATION_CM_LOGO_64x64));
if(pixbuf) {
notify_notification_set_icon_from_pixbuf(popup.notification, pixbuf);
g_object_unref(pixbuf);
}
else /* This is not fatal */
debug_print("Notification plugin: Icon could not be loaded.\n");
/* timeout */
notify_notification_set_timeout(popup.notification, notify_config.trayicon_popup_timeout);
/* Category */
notify_notification_set_category(popup.notification, "email.arrived");
/* get notified on bubble close */
g_signal_connect(G_OBJECT(popup.notification), "closed", G_CALLBACK(popup_timeout_fun), NULL);
/* Show the popup */
notify_notification_set_hint_string(popup.notification, "desktop-entry", "claws-mail");
if(!notify_notification_show(popup.notification, &(popup.error))) {
debug_print("Notification Plugin: Failed to send notification: %s\n",
popup.error->message);
g_clear_error(&(popup.error));
g_object_unref(G_OBJECT(popup.notification));
popup.notification = NULL;
return FALSE;
}
/* Store path to message */
if(nftype == F_TYPE_MAIL) {
if(msginfo->folder && msginfo->folder) {
gchar *ident;
ident = folder_item_get_identifier(msginfo->folder);
popup.msg_path = g_strdup_printf("%s%s%u", ident,G_DIR_SEPARATOR_S,
msginfo->msgnum);
g_free(ident);
}
else
popup.msg_path = NULL;
}
debug_print("Notification Plugin: Popup created with libnotify.\n");
return TRUE;
}
static ERL_NIF_TERM
nif_notify(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary summary;
ErlNifBinary body;
ErlNifBinary icon;
ErlNifBinary category;
int urgency = NOTIFY_URGENCY_NORMAL;
int timeout = 0;
gchar *s_summary = NULL;
gchar *s_body = NULL;
gchar *s_icon = NULL;
gchar *s_category = NULL;
ERL_NIF_TERM hints;
ERL_NIF_TERM head;
ERL_NIF_TERM tail;
const ERL_NIF_TERM *array;
int arity = 0;
NotifyNotification *notify = NULL;
ERL_NIF_TERM rv = atom_ok;
if (!enif_inspect_iolist_as_binary(env, argv[0], &summary))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[1], &body))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[2], &icon))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[3], &category))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[4], &urgency))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[5], &timeout))
return enif_make_badarg(env);
if (!enif_is_list(env, argv[6]))
return enif_make_badarg(env);
hints = argv[6];
s_summary = stralloc(&summary);
s_body = stralloc(&body);
s_icon = stralloc(&icon);
s_category = stralloc(&category);
if ( (s_summary == NULL) || (s_body == NULL) ||
(s_icon == NULL) || (s_category == NULL)) {
rv = enif_make_tuple2(env, atom_error, atom_nomem);
goto ERR;
}
notify = notify_notification_new(s_summary, s_body, s_icon);
notify_notification_set_category(notify, s_category);
notify_notification_set_urgency(notify, urgency);
notify_notification_set_timeout(notify, timeout);
while (enif_get_list_cell(env, hints, &head, &tail)) {
ERL_NIF_TERM key;
ERL_NIF_TERM value = atom_undefined;
if (enif_get_tuple(env, head, &arity, &array)) {
switch (arity) {
case 2:
value = array[1];
key = array[0];
break;
default:
rv = enif_make_badarg(env);
goto ERR;
}
}
else if (enif_is_list(env, head)) {
arity = 0;
key = head;
}
else {
rv = enif_make_badarg(env);
goto ERR;
}
if (notify_hints_type(env, notify, arity, key, value) < 0) {
rv = enif_make_badarg(env);
goto ERR;
}
hints = tail;
}
notify_notification_show(notify, NULL);
ERR:
if (notify)
g_object_unref(G_OBJECT(notify));
strfree(s_summary);
strfree(s_body);
strfree(s_icon);
strfree(s_category);
return rv;
}
int main (int argc, char ** argv) {
struct udev * udev;
struct udev_device * dev;
char * device = NULL;
struct udev_monitor * mon = NULL;
fd_set readfds;
int fdcount, devnum, errcount = 0;
unsigned short int i, major, minor;
short int * maxminor;
char * notification = NULL;
char * icon = NULL;
NotifyNotification * netlink;
NotifyNotification *** netlinkref;
blkid_cache cache = NULL;
char *read = NULL;
blkid_tag_iterate iter;
const char *type, *value, *devname;
blkid_dev blkdev;
GError * error = NULL;
printf("%s: %s v%s (compiled: %s)\n", argv[0], PROGNAME, VERSION, DATE);
if(!notify_init("Udev-Block-Notification")) {
fprintf(stderr, "%s: Can't create notify.\n", argv[0]);
exit(EXIT_FAILURE);
}
udev = udev_new();
if(!udev) {
fprintf(stderr, "%s: Can't create udev.\n", argv[0]);
exit(EXIT_FAILURE);
}
mon = udev_monitor_new_from_netlink(udev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL);
udev_monitor_enable_receiving(mon);
netlinkref = malloc(256 * sizeof(size_t));
for(i = 0; i < 256; i++)
netlinkref[i] = NULL;
maxminor = malloc(256 * sizeof(short int));
for(i = 0; i < 256; i++)
maxminor[i] = -1;
while (1) {
FD_ZERO(&readfds);
if (mon != NULL)
FD_SET(udev_monitor_get_fd(mon), &readfds);
fdcount = select(udev_monitor_get_fd(mon) + 1, &readfds, NULL, NULL, NULL);
if ((mon != NULL) && FD_ISSET(udev_monitor_get_fd(mon), &readfds)) {
dev = udev_monitor_receive_device(mon);
if(dev) {
device = (char *) udev_device_get_sysname(dev);
devnum = udev_device_get_devnum(dev);
major = devnum / 256;
minor = devnum - (major * 256);
switch(udev_device_get_action(dev)[0]) {
case 'a':
// a: add
notification = (char *) malloc(strlen(TEXT_ADD) + strlen(device));
sprintf(notification, TEXT_ADD, device, major, minor);
icon = ICON_ADD;
break;
case 'r':
// r: remove
notification = (char *) malloc(strlen(TEXT_REMOVE) + strlen(device));
sprintf(notification, TEXT_REMOVE, device, major, minor);
icon = ICON_REMOVE;
break;
case 'm':
// m: move
notification = (char *) malloc(strlen(TEXT_MOVE) + strlen(device));
sprintf(notification, TEXT_MOVE, device, major, minor);
icon = ICON_MOVE;
break;
case 'c':
// c: change
notification = (char *) malloc(strlen(TEXT_CHANGE) + strlen(device));
sprintf(notification, TEXT_CHANGE, device, major, minor);
icon = ICON_CHANGE;
break;
default:
// we should never get here I think...
notification = (char *) malloc(strlen(TEXT_DEFAULT) + strlen(device));
sprintf(notification, TEXT_CHANGE, device, major, minor);
icon = ICON_DEFAULT;
}
blkid_get_cache(&cache, read);
blkdev = blkid_get_dev(cache, udev_device_get_devnode(dev), BLKID_DEV_NORMAL);
if (blkdev) {
iter = blkid_tag_iterate_begin(blkdev);
while (blkid_tag_next(iter, &type, &value) == 0) {
notification = (char *) realloc(notification, strlen(TEXT_TAG) + strlen(notification) + strlen(type) + strlen(value));
sprintf(notification, TEXT_TAG, notification, type, value);
}
blkid_tag_iterate_end(iter);
blkid_put_cache(cache);
}
printf("%s: %s\n", argv[0], notification);
if (maxminor[major] < minor) {
netlinkref[major] = realloc(netlinkref[major], (minor + 1) * sizeof(size_t));
while(maxminor[major] < minor)
netlinkref[major][++maxminor[major]] = NULL;
}
if (netlinkref[major][minor] == NULL) {
netlink = notify_notification_new("Udev-Block", notification, icon);
netlinkref[major][minor] = netlink;
} else {
netlink = netlinkref[major][minor];
notify_notification_update(netlink, "Udev-Block", notification, icon);
}
notify_notification_set_timeout(netlink, NOTIFICATION_TIMEOUT);
notify_notification_set_category(netlink, "Udev-Block");
notify_notification_set_urgency (netlink, NOTIFY_URGENCY_NORMAL);
while(!notify_notification_show(netlink, &error)) {
if (errcount > 1) {
fprintf(stderr, "%s: Looks like we can not reconnect to notification daemon... Exiting.\n", argv[0]);
exit(EXIT_FAILURE);
} else {
g_printerr("%s: Error \"%s\" while trying to show notification. Trying to reconnect.\n", argv[0], error->message);
errcount++;
g_error_free(error);
error = NULL;
notify_uninit();
usleep(500 * 1000);
if(!notify_init("Udev-Block-Notification")) {
fprintf(stderr, "%s: Can't create notify.\n", argv[0]);
exit(EXIT_FAILURE);
}
}
}
errcount = 0;
free(notification);
udev_device_unref(dev);
}
// This is not really needed... But we want to make shure not to eat 100% CPU if anything breaks. ;)
usleep(500 * 1000);
}
}
udev_unref(udev);
return EXIT_SUCCESS;
}
static gboolean notification_libnotify_create(MsgInfo *msginfo,
NotificationFolderType nftype)
{
GdkPixbuf *pixbuf;
NotificationPopup *ppopup;
gchar *summary = NULL;
gchar *text = NULL;
gchar *utf8_str = NULL;
gchar *subj = NULL;
gchar *from = NULL;
gchar *foldname = NULL;
GList *caps = NULL;
gboolean support_actions = FALSE;
g_return_val_if_fail(msginfo, FALSE);
ppopup = &(popup[nftype]);
/* init libnotify if necessary */
if(!notify_is_initted()) {
if(!notify_init("claws-mail")) {
debug_print("Notification Plugin: Failed to initialize libnotify. "
"No popup will be shown.\n");
return FALSE;
}
}
switch(nftype) {
case F_TYPE_MAIL:
summary = _("New Mail message");
from = notification_libnotify_sanitize_str(msginfo->from ?
msginfo->from : _("(No From)"));
subj = notification_libnotify_sanitize_str(msginfo->subject ?
msginfo->subject : _("(No Subject)"));
if (notify_config.popup_display_folder_name) {
foldname = notification_libnotify_sanitize_str(msginfo->folder->path);
text = g_strconcat(from,"\n\n", subj, "\n\n", foldname, NULL);
}
else
text = g_strconcat(from, "\n\n",subj, NULL);
/* Make sure text is valid UTF8 */
utf8_str = notification_validate_utf8_str(text);
g_free(text);
if(from) g_free(from);
if(subj) g_free(subj);
if(foldname) g_free(foldname);
break;
case F_TYPE_NEWS:
summary = _("New News post");
utf8_str = g_strdup(_("A new message arrived"));
break;
case F_TYPE_CALENDAR:
summary = _("New Calendar message");
utf8_str = g_strdup(_("A new calendar message arrived"));
break;
case F_TYPE_RSS:
summary = _("New RSS feed article");
utf8_str = g_strdup(_("A new article in a RSS feed arrived"));
break;
default:
summary = _("New unknown message");
utf8_str = g_strdup(_("Unknown message type arrived"));
break;
}
ppopup->notification = notify_notification_new(summary, utf8_str, NULL
#if !NOTIFY_CHECK_VERSION(0, 7, 0)
, NULL
#endif
);
g_free(utf8_str);
if(ppopup->notification == NULL) {
debug_print("Notification Plugin: Failed to create a new "
"notification.\n");
return FALSE;
}
caps = notify_get_server_caps();
if(caps != NULL) {
GList *c;
for(c = caps; c != NULL; c = c->next) {
if(strcmp((char*)c->data, "actions") == 0 ) {
support_actions = TRUE;
break;
}
}
g_list_foreach(caps, (GFunc)g_free, NULL);
g_list_free(caps);
}
/* Default action */
if (support_actions)
notify_notification_add_action(ppopup->notification,
"default", _("Present main window"),
(NotifyActionCallback)default_action_cb,
GINT_TO_POINTER(nftype),
notification_libnotify_free_func);
/* Icon */
pixbuf = NULL;
#ifndef USE_ALT_ADDRBOOK
if(msginfo && msginfo->from) {
gchar *icon_path;
icon_path = addrindex_get_picture_file(msginfo->from);
if(is_file_exist(icon_path)) {
GError *error = NULL;
gint w, h;
gdk_pixbuf_get_file_info(icon_path, &w, &h);
if((w > 64) || (h > 64))
pixbuf = gdk_pixbuf_new_from_file_at_scale(icon_path,
64, 64, TRUE, &error);
else
pixbuf = gdk_pixbuf_new_from_file(icon_path, &error);
if(!pixbuf) {
debug_print("Could not load picture file: %s\n",
error ? error->message : "no details");
g_error_free(error);
}
}
else
debug_print("Picture path does not exist: %s\n",icon_path);
g_free(icon_path);
}
#endif
if(!pixbuf)
pixbuf = g_object_ref(notification_pixbuf_get(NOTIFICATION_CM_LOGO_64x64));
if(pixbuf) {
notify_notification_set_icon_from_pixbuf(ppopup->notification, pixbuf);
g_object_unref(pixbuf);
}
else /* This is not fatal */
debug_print("Notification plugin: Icon could not be loaded.\n");
/* timeout */
notify_notification_set_timeout(ppopup->notification, notify_config.popup_timeout);
/* Category */
notify_notification_set_category(ppopup->notification, "email.arrived");
/* get notified on bubble close */
g_signal_connect(G_OBJECT(popup->notification), "closed", G_CALLBACK(popup_timeout_fun), NULL);
/* Show the popup */
notify_notification_set_hint_string(ppopup->notification, "desktop-entry", "claws-mail");
if(!notify_notification_show(ppopup->notification, &(ppopup->error))) {
debug_print("Notification Plugin: Failed to send notification: %s\n",
ppopup->error->message);
g_clear_error(&(ppopup->error));
g_object_unref(G_OBJECT(ppopup->notification));
ppopup->notification = NULL;
return FALSE;
}
debug_print("Notification Plugin: Popup created with libnotify.\n");
ppopup->count = 1;
/* Store path to message */
if(nftype == F_TYPE_MAIL) {
if(msginfo && msginfo->folder) {
gchar *ident;
ident = folder_item_get_identifier(msginfo->folder);
ppopup->msg_path = g_strdup_printf("%s%s%u", ident,G_DIR_SEPARATOR_S,
msginfo->msgnum);
g_free(ident);
}
else
ppopup->msg_path = NULL;
}
return TRUE;
}
static int data_cb(const struct nlmsghdr * nlh, void * data) {
struct nlattr * tb[IFLA_MAX + 1] = {};
struct ifinfomsg * ifm = mnl_nlmsg_get_payload(nlh);
char * notification = NULL;
const char * interface = NULL;
NotifyNotification * netlink = NULL;
unsigned int errcount = 0;
gboolean res = FALSE;
GError * error = NULL;
mnl_attr_parse(nlh, sizeof(* ifm), data_attr_cb, tb);
interface = mnl_attr_get_str(tb[IFLA_IFNAME]);
notification = malloc(strlen(interface) + strlen(NOTIFICATION_TEXT) + 1); // 2* %s is enough for "down", but we need an additional byte for \n
sprintf(notification, NOTIFICATION_TEXT, interface, (ifm->ifi_flags & IFF_RUNNING ? "up" : "down"));
printf(NOTIFICATION_TEXT_DEBUG, program, interface, ifm->ifi_index, (ifm->ifi_flags & IFF_RUNNING ? "up" : "down"));
if (netlinksize < ifm->ifi_index) {
netlinkref = realloc(netlinkref, (ifm->ifi_index + 1) * sizeof(size_t));
while(netlinksize < ifm->ifi_index)
netlinkref[++netlinksize] = 0;
}
if (netlinkref[ifm->ifi_index] == 0) {
netlink = notify_notification_new("Netlink", notification, (ifm->ifi_flags & IFF_RUNNING ? "network-transmit-receive" : "network-error"));
netlinkref[ifm->ifi_index] = (size_t)netlink;
} else {
netlink = (NotifyNotification *)netlinkref[ifm->ifi_index];
notify_notification_update(netlink, "Netlink", notification, (ifm->ifi_flags & IFF_RUNNING ? "network-transmit-receive" : "network-error"));
}
notify_notification_set_timeout(netlink, NOTIFICATION_TIMEOUT);
notify_notification_set_category(netlink, "Netlink");
notify_notification_set_urgency (netlink, NOTIFY_URGENCY_NORMAL);
while(!notify_notification_show(netlink, &error)) {
if (errcount > 1) {
fprintf(stderr, "%s: Looks like we can not reconnect to notification daemon... Exiting.\n", program);
exit(EXIT_FAILURE);
} else {
g_printerr("%s: Error \"%s\" while trying to show notification. Trying to reconnect.\n", program, error->message);
errcount++;
g_error_free(error);
error = NULL;
notify_uninit();
usleep(500 * 1000);
if(!notify_init("Udev-Net-Notification")) {
fprintf(stderr, "%s: Can't create notify.\n", program);
exit(EXIT_FAILURE);
}
}
}
errcount = 0;
free(notification);
return MNL_CB_OK;
}
void setNotificationCategory() {
if (notification) {
notify_notification_set_category(NOTIFY_NOTIFICATION(notification), QGSTRING(category));
}
}
/*** main ***/
int main(int argc, char ** argv) {
char * album = NULL, * artist = NULL, * icon = NULL, * notifystr = NULL, * title = NULL;
GError * error = NULL;
unsigned short int errcount = 0, state = MPD_STATE_UNKNOWN;
const char * mpd_host = MPD_HOST, * music_dir = NULL, * uri = NULL;;
unsigned mpd_port = MPD_PORT, mpd_timeout = MPD_TIMEOUT;
struct mpd_song * song = NULL;
unsigned int i;
program = argv[0];
music_dir = getenv("XDG_MUSIC_DIR");
/* get the verbose status */
while ((i = getopt_long(argc, argv, optstring, options_long, NULL)) != -1) {
switch (i) {
case 'v':
verbose++;
break;
}
}
/* reinitialize getopt() by resetting optind to 0 */
optind = 0;
/* say hello */
if (verbose > 0)
printf("%s: %s v%s (compiled: " __DATE__ ", " __TIME__ ")\n", program, PROGNAME, VERSION);
/* get command line options */
while ((i = getopt_long(argc, argv, optstring, options_long, NULL)) != -1) {
switch (i) {
case 'h':
fprintf(stderr, "usage: %s [-h] [-H HOST] [-p PORT] [-m MUSIC-DIR] [-v]\n", program);
return EXIT_SUCCESS;
case 'p':
mpd_port = atoi(optarg);
if (verbose > 0)
printf("%s: using port %d\n", program, mpd_port);
break;
case 'm':
music_dir = optarg;
if (verbose > 0)
printf("%s: using music-dir %s\n", program, music_dir);
break;
case 'H':
mpd_host = optarg;
if (verbose > 0)
printf("%s: using host %s\n", program, mpd_host);
break;
}
}
/* disable artwork stuff if we are connected to a foreign host */
if (mpd_host != NULL)
music_dir = NULL;
/* change directory to music base directory */
if (music_dir != NULL) {
if (chdir(music_dir) == -1) {
fprintf(stderr, "%s: Can not change directory to '%s'.\n", program, music_dir);
music_dir = NULL;
}
}
/* libav */
av_register_all();
conn = mpd_connection_new(mpd_host, mpd_port, mpd_timeout);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
fprintf(stderr,"%s: %s\n", program, mpd_connection_get_error_message(conn));
mpd_connection_free(conn);
exit(EXIT_FAILURE);
}
if(notify_init(PROGNAME) == FALSE) {
fprintf(stderr, "%s: Can't create notify.\n", program);
exit(EXIT_FAILURE);
}
notification =
# if NOTIFY_CHECK_VERSION(0, 7, 0)
notify_notification_new(TEXT_TOPIC, TEXT_NONE, ICON_SOUND);
# else
notify_notification_new(TEXT_TOPIC, TEXT_NONE, ICON_SOUND, NULL);
# endif
notify_notification_set_category(notification, PROGNAME);
notify_notification_set_urgency (notification, NOTIFY_URGENCY_NORMAL);
signal(SIGHUP, received_signal);
signal(SIGINT, received_signal);
signal(SIGTERM, received_signal);
signal(SIGUSR1, received_signal);
while(doexit == 0 && mpd_run_idle_mask(conn, MPD_IDLE_PLAYER)) {
mpd_command_list_begin(conn, true);
mpd_send_status(conn);
mpd_send_current_song(conn);
mpd_command_list_end(conn);
state = mpd_status_get_state(mpd_recv_status(conn));
if (state == MPD_STATE_PLAY) {
mpd_response_next(conn);
song = mpd_recv_song(conn);
uri = mpd_song_get_uri(song);
if (music_dir != NULL && uri != NULL)
icon = get_icon(music_dir, uri);
if (verbose > 0 && icon != NULL)
printf("%s: found icon: %s\n", program, icon);
if ((title = g_markup_escape_text(mpd_song_get_tag(song, MPD_TAG_TITLE, 0), -1)) == NULL)
title = strdup(TEXT_UNKNOWN);
if ((artist = g_markup_escape_text(mpd_song_get_tag(song, MPD_TAG_ARTIST, 0), -1)) == NULL)
artist = strdup(TEXT_UNKNOWN);
if ((album = g_markup_escape_text(mpd_song_get_tag(song, MPD_TAG_ALBUM, 0), -1)) == NULL)
album = strdup(TEXT_UNKNOWN);
notifystr = malloc(sizeof(TEXT_PLAY) + strlen(title) + strlen(artist) + strlen(album));
sprintf(notifystr, TEXT_PLAY, title, artist, album);
free(title);
free(artist);
free(album);
mpd_song_free(song);
} else if (state == MPD_STATE_PAUSE)
notifystr = TEXT_PAUSE;
else if (state == MPD_STATE_STOP)
notifystr = TEXT_STOP;
else
notifystr = TEXT_UNKNOWN;
if (verbose > 0)
printf("%s: %s\n", program, notifystr);
notify_notification_update(notification, TEXT_TOPIC, notifystr, icon ? icon : ICON_SOUND);
notify_notification_set_timeout(notification, NOTIFICATION_TIMEOUT);
while(notify_notification_show(notification, &error) == FALSE) {
if (errcount > 1) {
fprintf(stderr, "%s: Looks like we can not reconnect to notification daemon... Exiting.\n", program);
exit(EXIT_FAILURE);
} else {
g_printerr("%s: Error \"%s\" while trying to show notification. Trying to reconnect.\n", program, error->message);
errcount++;
g_error_free(error);
error = NULL;
notify_uninit();
usleep(500 * 1000);
if(notify_init(PROGNAME) == FALSE) {
fprintf(stderr, "%s: Can't create notify.\n", program);
exit(EXIT_FAILURE);
}
}
}
errcount = 0;
if (state == MPD_STATE_PLAY)
free(notifystr);
if (icon != NULL) {
free(icon);
icon = NULL;
}
mpd_response_finish(conn);
}
if (verbose > 0)
printf("Exiting...\n");
mpd_connection_free(conn);
g_object_unref(G_OBJECT(notification));
notify_uninit();
return EXIT_SUCCESS;
}
static void
notif_libnotify_node_has_new_items (nodePtr node, gboolean enforced)
{
itemSetPtr itemSet;
GList *iter;
NotifyNotification *n;
gchar *labelSummary_p;
gint item_count = 0;
gboolean show_popup_windows;
conf_get_bool_value(SHOW_POPUP_WINDOWS, &show_popup_windows);
if (!show_popup_windows && !enforced)
return;
/* Count updated feed */
itemSet = node_get_itemset (node);
iter = itemSet->ids;
while (iter) {
itemPtr item = item_load (GPOINTER_TO_UINT (iter->data));
if (item->popupStatus && !item->readStatus)
item_count++;
item_unload (item);
iter = g_list_next (iter);
}
itemset_free (itemSet);
if (item_count == 0)
return;
labelSummary_p = g_strdup_printf (ngettext ("<b>%s</b> has <b>%d</b> update", "<b>%s</b> has <b>%d</b> updates", item_count),
node_get_title (node), item_count);
n = notify_notification_new (_("Feed Update"), labelSummary_p, "liferea", NULL);
g_free (labelSummary_p);
if (supports_append) {
notify_notification_set_hint_string(n, "append", "allow");
} else {
notify_notification_set_icon_from_pixbuf (n, node_get_icon (node));
}
notify_notification_set_timeout (n, NOTIFY_EXPIRES_DEFAULT);
if (supports_actions) {
notify_notification_add_action (n, "show_details", _("Show details"),
(NotifyActionCallback)notif_libnotify_callback_show_details,
node->id, NULL);
notify_notification_add_action (n, "open", _("Open feed"),
(NotifyActionCallback)notif_libnotify_callback_open,
node->id, NULL);
notify_notification_add_action (n, "mark_read", _("Mark all as read"),
(NotifyActionCallback)notif_libnotify_callback_mark_read,
node->id, NULL);
}
notify_notification_set_category (n, "feed");
notify_notification_attach_to_status_icon (n, ui_tray_get_status_icon ());
if (!notify_notification_show (n, NULL))
g_warning ("notif_libnotify.c - failed to send notification via libnotify");
}
static void
notif_libnotify_callback_show_details (NotifyNotification *n, gchar *action, gpointer user_data)
{
nodePtr node_p;
GList *list_p;
itemPtr item_p;
gchar *labelText_p;
gchar *labelText_now_p = NULL;
gchar *labelText_prev_p;
gchar *labelHeadline_p;
const gchar *labelURL_p;
gint item_count = 0;
g_assert (action != NULL);
g_assert (strcmp(action, "show_details") == 0);
node_p = node_from_id (user_data);
if (node_p) {
itemSetPtr itemSet = node_get_itemset (node_p);
labelText_now_p = g_strdup ("");
/* Gather the feed's headlines */
list_p = itemSet->ids;
while (list_p) {
item_p = item_load (GPOINTER_TO_UINT (list_p->data));
if (item_p->popupStatus && !item_p->readStatus) {
item_p->popupStatus = FALSE;
item_count += 1;
labelHeadline_p = g_strdup (item_get_title (item_p));
if (labelHeadline_p == NULL ) {
labelHeadline_p = g_strdup_printf (_("This news entry has no headline"));
}
labelURL_p = item_get_base_url (item_p);
if (labelURL_p) {
labelText_p = g_strdup_printf ("%s <a href='%s'>%s</a>\n", labelHeadline_p, labelURL_p, _("Visit"));
} else {
labelText_p = g_strdup_printf ("%s\n", labelHeadline_p);
}
labelText_prev_p = labelText_now_p;
labelText_now_p = g_strconcat(labelText_now_p, labelText_p, NULL);
g_free(labelHeadline_p);
g_free(labelText_p);
g_free(labelText_prev_p);
}
item_unload (item_p);
list_p = g_list_next (list_p);
}
itemset_free (itemSet);
if (item_count == 0) {
g_free (labelText_now_p);
return;
}
} else {
ui_show_error_box(_("This feed does not exist anymore!"));
}
notify_notification_close (n, NULL);
if (node_p) {
// notify_notification_update ( n, node_get_title(node_p), labelText_now_p, NULL);
// notify_notification_clear_actions(n);
n = notify_notification_new (node_get_title (node_p), labelText_now_p, NULL, NULL);
notify_notification_set_icon_from_pixbuf (n, node_get_icon (node_p));
notify_notification_set_category (n, "feed");
notify_notification_set_timeout (n, NOTIFY_EXPIRES_NEVER);
if (supports_actions) {
notify_notification_add_action (n, "open", _("Open feed"),
(NotifyActionCallback)notif_libnotify_callback_open,
node_p->id, NULL);
notify_notification_add_action (n, "mark_read", _("Mark all as read"),
(NotifyActionCallback)notif_libnotify_callback_mark_read,
node_p->id, NULL);
}
notify_notification_attach_to_status_icon (n, ui_tray_get_status_icon ());
if (!notify_notification_show (n, NULL)) {
g_warning ("libnotify.c - failed to update notification via libnotify\n");
}
g_free (labelText_now_p);
}
}
static void
_notify(const char * const message, int timeout,
const char * const category)
{
#ifdef HAVE_LIBNOTIFY
if (notify_is_initted()) {
NotifyNotification *notification;
notification = notify_notification_new("Profanity", message, NULL);
notify_notification_set_timeout(notification, timeout);
notify_notification_set_category(notification, category);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);
GError *error = NULL;
gboolean notify_success = notify_notification_show(notification, &error);
if (!notify_success) {
log_error("Error sending desktop notification:");
log_error(" -> Message : %s", message);
log_error(" -> Error : %s", error->message);
}
} else {
log_error("Libnotify initialisation error.");
}
#endif
#ifdef PLATFORM_CYGWIN
NOTIFYICONDATA nid;
nid.cbSize = sizeof(NOTIFYICONDATA);
//nid.hWnd = hWnd;
nid.uID = 100;
nid.uVersion = NOTIFYICON_VERSION;
//nid.uCallbackMessage = WM_MYMESSAGE;
nid.hIcon = LoadIcon(NULL, IDI_APPLICATION);
strncpy(nid.szTip, "Tray Icon", 10);
nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
Shell_NotifyIcon(NIM_ADD, &nid);
// For a Ballon Tip
nid.uFlags = NIF_INFO;
strncpy(nid.szInfoTitle, "Profanity", 10); // Title
strncpy(nid.szInfo, message, 256); // Copy Tip
nid.uTimeout = timeout; // 3 Seconds
nid.dwInfoFlags = NIIF_INFO;
Shell_NotifyIcon(NIM_MODIFY, &nid);
#endif
#ifdef HAVE_OSXNOTIFY
GString *notify_command = g_string_new("terminal-notifier -title 'Profanity' -message '");
g_string_append(notify_command, message);
g_string_append(notify_command, "'");
char *term_name = getenv("TERM_PROGRAM");
char *app_id = NULL;
if (g_strcmp0(term_name, "Apple_Terminal") == 0) {
app_id = "com.apple.Terminal";
} else if (g_strcmp0(term_name, "iTerm.app") == 0) {
app_id = "com.googlecode.iterm2";
}
if (app_id != NULL) {
g_string_append(notify_command, " -sender ");
g_string_append(notify_command, app_id);
}
int res = system(notify_command->str);
if (res == -1) {
log_error("Could not send desktop notificaion.");
}
g_string_free(notify_command, TRUE);
#endif
}
static void
do_notify (RBNotificationPlugin *plugin,
guint timeout,
const char *primary,
const char *secondary,
const char *image_uri,
gboolean playback)
{
GError *error = NULL;
NotifyNotification *notification;
if (notify_is_initted () == FALSE) {
GList *caps;
if (notify_init ("Rhythmbox") == FALSE) {
g_warning ("libnotify initialization failed");
return;
}
/* ask the notification server if it supports actions */
caps = notify_get_server_caps ();
if (g_list_find_custom (caps, "actions", (GCompareFunc)g_strcmp0) != NULL) {
rb_debug ("notification server supports actions");
plugin->notify_supports_actions = TRUE;
if (g_list_find_custom (caps, "action-icons", (GCompareFunc)g_strcmp0) != NULL) {
rb_debug ("notifiction server supports icon buttons");
plugin->notify_supports_icon_buttons = TRUE;
}
} else {
rb_debug ("notification server does not support actions");
}
if (g_list_find_custom (caps, "persistence", (GCompareFunc)g_strcmp0) != NULL) {
rb_debug ("notification server supports persistence");
plugin->notify_supports_persistence = TRUE;
} else {
rb_debug ("notification server does not support persistence");
}
rb_list_deep_free (caps);
}
if (primary == NULL)
primary = "";
if (secondary == NULL)
secondary = "";
if (playback) {
notification = plugin->notification;
} else {
notification = plugin->misc_notification;
}
if (notification == NULL) {
notification = notify_notification_new (primary, secondary, RB_APP_ICON);
g_signal_connect_object (notification,
"closed",
G_CALLBACK (notification_closed_cb),
plugin, 0);
if (playback) {
plugin->notification = notification;
} else {
plugin->misc_notification = notification;
}
} else {
notify_notification_clear_hints (notification);
notify_notification_update (notification, primary, secondary, RB_APP_ICON);
}
notify_notification_set_timeout (notification, timeout);
if (image_uri != NULL) {
notify_notification_clear_hints (notification);
notify_notification_set_hint (notification,
"image_path",
g_variant_new_string (image_uri));
}
if (playback)
notify_notification_set_category (notification, "x-gnome.music");
notify_notification_set_hint (notification, "desktop-entry",
g_variant_new_string ("rhythmbox"));
notify_notification_clear_actions (notification);
if (playback && plugin->notify_supports_actions) {
gboolean rtl;
const char *play_icon;
rtl = (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL);
play_icon = rtl ? "media-playback-start-rtl" : "media-playback-start";
if (plugin->notify_supports_icon_buttons) {
gboolean playing = FALSE;
rb_shell_player_get_playing (plugin->shell_player, &playing, NULL);
notify_notification_add_action (notification,
rtl ? "media-skip-backward-rtl" : "media-skip-backward",
_("Previous"),
(NotifyActionCallback) notification_previous_cb,
plugin,
NULL);
notify_notification_add_action (notification,
playing ? "media-playback-pause" : play_icon,
playing ? _("Pause") : _("Play"),
(NotifyActionCallback) notification_playpause_cb,
plugin,
NULL);
notify_notification_set_hint (notification, "action-icons", g_variant_new_boolean (TRUE));
}
notify_notification_add_action (notification,
rtl ? "media-skip-forward-rtl" : "media-skip-forward",
_("Next"),
(NotifyActionCallback) notification_next_cb,
plugin,
NULL);
}
if (plugin->notify_supports_persistence) {
const char *hint;
if (playback) {
hint = "resident";
} else {
hint = "transient";
}
notify_notification_set_hint (notification, hint, g_variant_new_boolean (TRUE));
}
if (notify_notification_show (notification, &error) == FALSE) {
g_warning ("Failed to send notification (%s): %s", primary, error->message);
g_error_free (error);
}
}
