src/libalarm.h

Go to the documentation of this file.

#ifndef LIBALARM_H_
#define LIBALARM_H_

#include <stdint.h>
#include <stdarg.h>
#include <time.h>

#ifdef __cplusplus
extern "C" {
#elif 0
} /* fool JED indentation ... */
#endif

/* Crude preprocessor tricks to make direct access to
 * some member variables more visible - used for alarmd
 * compilation, hidden from doxygen scanner */

#ifndef DOXYGEN_SHOULD_SKIP_THIS
# ifdef ALARMD_MANGLE_MEMBERS
#  define ALARMD_CAT2(a,b) a##b
#  define ALARMD_PRIVATE(x) ALARMD_CAT2(x,_private)
# else
#  define ALARMD_PRIVATE(x) x
# endif
#endif

#pragma GCC visibility push(default)

typedef long cookie_t;

/* ------------------------------------------------------------------------- *
 * alarm_attr_t
 * ------------------------------------------------------------------------- */

typedef struct alarm_attr_t
{
  char *attr_name;

  int   attr_type;

  union
  {
    char  *sval;
    time_t tval;
    int    ival;
  } attr_data;
} alarm_attr_t;

typedef enum alarmattrtype
{
  ALARM_ATTR_NULL,
  ALARM_ATTR_INT,
  ALARM_ATTR_TIME,
  ALARM_ATTR_STRING,
} alarmattrtype;


void          alarm_attr_ctor      (alarm_attr_t *self);

void          alarm_attr_dtor      (alarm_attr_t *self);

void          alarm_attr_set_null  (alarm_attr_t *self);

void          alarm_attr_set_string(alarm_attr_t *self, const char *val);

void          alarm_attr_set_int   (alarm_attr_t *self, int val);

void          alarm_attr_set_time  (alarm_attr_t *self, time_t val);

const char   *alarm_attr_get_string(alarm_attr_t *self);

int           alarm_attr_get_int   (alarm_attr_t *self);

time_t        alarm_attr_get_time  (alarm_attr_t *self);

alarm_attr_t *alarm_attr_create    (const char *name);

void          alarm_attr_delete    (alarm_attr_t *self);

void          alarm_attr_delete_cb (void *self);

typedef enum alarmactionflags
{
  // 0                   1                   2                   3
  // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  // x x x x x x x x x x x x x x x x

  // ---- WHAT ----

  ALARM_ACTION_TYPE_NOP       = 0,

  ALARM_ACTION_TYPE_SNOOZE    = 1 << 0,

  ALARM_ACTION_TYPE_DBUS      = 1 << 1,

  ALARM_ACTION_TYPE_EXEC      = 1 << 2,

#if ALARMD_ACTION_BOOTFLAGS

  ALARM_ACTION_TYPE_DESKTOP   = 1 << 3,

  ALARM_ACTION_TYPE_ACTDEAD   = 1 << 8,
#endif

  ALARM_ACTION_TYPE_DISABLE   = 1 << 10,

  // ---- WHEN ----

  ALARM_ACTION_WHEN_QUEUED    = 1 << 4,

  ALARM_ACTION_WHEN_DELAYED   = 1 << 11,

  ALARM_ACTION_WHEN_TRIGGERED = 1 << 5,

  ALARM_ACTION_WHEN_DISABLED  = 1 << 9,

  ALARM_ACTION_WHEN_RESPONDED = 1 << 6,

  ALARM_ACTION_WHEN_DELETED   = 1 << 7,

  // ---- DBUS ----

  ALARM_ACTION_DBUS_USE_ACTIVATION = 1 << 12,

  ALARM_ACTION_DBUS_USE_SYSTEMBUS  = 1 << 13,

  ALARM_ACTION_DBUS_ADD_COOKIE     = 1 << 14,

  // ---- EXEC ----

  ALARM_ACTION_EXEC_ADD_COOKIE     = 1 << 15,

  // ---- MASKS ----

  ALARM_ACTION_TYPE_MASK = (ALARM_ACTION_TYPE_SNOOZE |
                            ALARM_ACTION_TYPE_DISABLE|
                            ALARM_ACTION_TYPE_DBUS   |
                            ALARM_ACTION_TYPE_EXEC   |
#if ALARMD_ACTION_BOOTFLAGS
                            ALARM_ACTION_TYPE_DESKTOP|
                            ALARM_ACTION_TYPE_ACTDEAD|
#endif
                            0),

  ALARM_ACTION_WHEN_MASK = (ALARM_ACTION_WHEN_QUEUED    |
                            ALARM_ACTION_WHEN_DELAYED   |
                            ALARM_ACTION_WHEN_TRIGGERED |
                            ALARM_ACTION_WHEN_DISABLED  |
                            ALARM_ACTION_WHEN_RESPONDED |
                            ALARM_ACTION_WHEN_DELETED),

} alarmactionflags;

typedef struct alarm_action_t
{
  unsigned  flags;

  char     *label;

  char     *exec_command;

  char     *dbus_interface;

  char     *dbus_service;

  char     *dbus_path;

  char     *dbus_name;

  char     *dbus_args;

} alarm_action_t;

/* ------------------------------------------------------------------------- *
 * alarm_action_t
 * ------------------------------------------------------------------------- */


void            alarm_action_ctor     (alarm_action_t *self);
void            alarm_action_dtor     (alarm_action_t *self);
alarm_action_t *alarm_action_create   (void);
void            alarm_action_delete   (alarm_action_t *self);
void            alarm_action_delete_cb(void *self);

int alarm_action_is_button(const alarm_action_t *self);

int             alarm_action_set_dbus_args       (alarm_action_t *self, int type, ...);

void            alarm_action_del_dbus_args       (alarm_action_t *self);

int             alarm_action_set_dbus_args_valist(alarm_action_t *self, int type, va_list va);

const char     *alarm_action_get_label           (const alarm_action_t *self);

const char     *alarm_action_get_exec_command    (const alarm_action_t *self);

const char     *alarm_action_get_dbus_interface  (const alarm_action_t *self);

const char     *alarm_action_get_dbus_service    (const alarm_action_t *self);

const char     *alarm_action_get_dbus_path       (const alarm_action_t *self);

const char     *alarm_action_get_dbus_name       (const alarm_action_t *self);

void            alarm_action_set_label           (alarm_action_t *self, const char *label);

void            alarm_action_set_exec_command    (alarm_action_t *self, const char *exec_command);

void            alarm_action_set_dbus_interface  (alarm_action_t *self, const char *dbus_interface);

void            alarm_action_set_dbus_service    (alarm_action_t *self, const char *dbus_service);

void            alarm_action_set_dbus_path       (alarm_action_t *self, const char *dbus_path);

void            alarm_action_set_dbus_name       (alarm_action_t *self, const char *dbus_name);

typedef struct alarm_recur_t
{
  // NOTE: bit indexing is struct tm compatible

  uint64_t mask_min;    // 0 .. 59

  uint32_t mask_hour;   // 0 .. 23

  uint32_t mask_mday;   // 1 .. 31   1=first

  uint32_t mask_wday;   // 0 .. 6    0=sunday
  uint32_t mask_mon;    // 0 .. 11   0=january

  uint32_t special;

} alarm_recur_t;

typedef enum alarmrecurflags
{
  ALARM_RECUR_MIN_DONTCARE  = 0,
  ALARM_RECUR_MIN_ALL       = (1ull << 60) - 1,

  ALARM_RECUR_HOUR_DONTCARE = 0,
  ALARM_RECUR_HOUR_ALL      = (1u << 24) - 1,

  ALARM_RECUR_MDAY_DONTCARE = 0,
  ALARM_RECUR_MDAY_ALL      = ~1u,
  ALARM_RECUR_MDAY_EOM      =  1u,

  ALARM_RECUR_WDAY_DONTCARE = 0,
  ALARM_RECUR_WDAY_ALL      = (1u << 7) - 1,
  ALARM_RECUR_WDAY_SUN      = (1u << 0),
  ALARM_RECUR_WDAY_MON      = (1u << 1),
  ALARM_RECUR_WDAY_TUE      = (1u << 2),
  ALARM_RECUR_WDAY_WED      = (1u << 3),
  ALARM_RECUR_WDAY_THU      = (1u << 4),
  ALARM_RECUR_WDAY_FRI      = (1u << 5),
  ALARM_RECUR_WDAY_SAT      = (1u << 6),
  ALARM_RECUR_WDAY_MONFRI   = ALARM_RECUR_WDAY_SAT - ALARM_RECUR_WDAY_MON,
  ALARM_RECUR_WDAY_SATSUN   = ALARM_RECUR_WDAY_SAT | ALARM_RECUR_WDAY_SUN,

  ALARM_RECUR_MON_DONTCARE = 0,
  ALARM_RECUR_MON_ALL       = (1u << 12) - 1,
  ALARM_RECUR_MON_JAN       = (1u <<  0),
  ALARM_RECUR_MON_FEB       = (1u <<  1),
  ALARM_RECUR_MON_MAR       = (1u <<  2),
  ALARM_RECUR_MON_APR       = (1u <<  3),
  ALARM_RECUR_MON_MAY       = (1u <<  4),
  ALARM_RECUR_MON_JUN       = (1u <<  5),
  ALARM_RECUR_MON_JUL       = (1u <<  6),
  ALARM_RECUR_MON_AUG       = (1u <<  7),
  ALARM_RECUR_MON_SEP       = (1u <<  8),
  ALARM_RECUR_MON_OCT       = (1u <<  9),
  ALARM_RECUR_MON_NOW       = (1u << 10),
  ALARM_RECUR_MON_DEC       = (1u << 11),

  ALARM_RECUR_SPECIAL_NONE      = 0,
  ALARM_RECUR_SPECIAL_BIWEEKLY  = 1,
  ALARM_RECUR_SPECIAL_MONTHLY   = 2,
  ALARM_RECUR_SPECIAL_YEARLY    = 3,
} alarmrecurflags;


void           alarm_recur_ctor           (alarm_recur_t *self);

void           alarm_recur_dtor           (alarm_recur_t *self);

alarm_recur_t *alarm_recur_create         (void);

void           alarm_recur_delete         (alarm_recur_t *self);

void           alarm_recur_init_from_tm   (alarm_recur_t *self, const struct tm *tm);

void           alarm_recur_delete_cb      (void *self);

time_t         alarm_recur_align          (const alarm_recur_t *self, struct tm *trg, const char *tz);

time_t         alarm_recur_next           (const alarm_recur_t *self, struct tm *trg, const char *tz);

typedef enum alarmeventflags
{
  // 0                   1                   2                   3
  // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  // - - - x x x x x - x x x x - - - R R R R R R R R R R R R R R R R

  ALARM_EVENT_BOOT             = 1 << 3,

  ALARM_EVENT_ACTDEAD          = 1 << 4,

  ALARM_EVENT_SHOW_ICON        = 1 << 5,

  ALARM_EVENT_CONNECTED        = 1 << 7,

  ALARM_EVENT_RUN_DELAYED      = 1 << 6,

  ALARM_EVENT_POSTPONE_DELAYED = 1 << 9,

  ALARM_EVENT_DISABLE_DELAYED  = 1 << 12,

  ALARM_EVENT_BACK_RESCHEDULE  = 1 << 10,

  ALARM_EVENT_DISABLED         = 1 << 11,

  ALARM_EVENT_CLIENT_BITS      = 16,

  ALARM_EVENT_CLIENT_MASK      = (1 << ALARM_EVENT_CLIENT_BITS) - 1,

} alarmeventflags;

#define ALARM_RECURRING_SECONDS(n) (n)

#define ALARM_RECURRING_MINUTES(n) ((n)*60)

#define ALARM_RECURRING_HOURS(n)   ((n)*60*60)

typedef struct alarm_event_t
{
  cookie_t       ALARMD_PRIVATE(cookie);

  time_t         ALARMD_PRIVATE(trigger);

  char          *title;

  char          *message;

  char          *sound;

  char          *icon;

  unsigned       flags;

  char          *alarm_appid;

  time_t         alarm_time;

  struct tm      alarm_tm;

  char          *alarm_tz;

  time_t         snooze_secs;

  time_t         snooze_total;

  size_t         action_cnt;

  alarm_action_t *action_tab;

  int            response;

  int             recur_count;

  time_t          recur_secs;

  size_t          recurrence_cnt;
  alarm_recur_t  *recurrence_tab;

  size_t          attr_cnt;
  alarm_attr_t  **attr_tab;

  /* - - - - - - - - - - - - - - - - - - - *
   * changes to this structure -> check also:
   *
   * event.c:
   *   alarm_event_ctor()
   *   alarm_event_dtor()
   *
   * codec.c:
   *   encode_event()
   *   decode_event()
   *
   * queue.c:
   *   queue_save_to_memory()
   *   queue_load_from_path()
   *
   * - - - - - - - - - - - - - - - - - - - */

} alarm_event_t;

/* ------------------------------------------------------------------------- *
 * alarm_event_t
 * ------------------------------------------------------------------------- */


void alarm_event_delete(alarm_event_t *self);

alarm_event_t *alarm_event_create(void);

alarm_event_t *alarm_event_create_ex(size_t actions);

void alarm_event_delete_cb(void *self);

void alarm_event_ctor(alarm_event_t *self);

void alarm_event_dtor(alarm_event_t *self);

cookie_t alarm_event_get_cookie(const alarm_event_t *self);

void alarm_event_set_cookie(alarm_event_t *self, cookie_t cookie);

time_t alarm_event_get_trigger(const alarm_event_t *self);

void alarm_event_set_trigger(alarm_event_t *self, time_t trigger);

const char     *alarm_event_get_title           (const alarm_event_t *self);

void            alarm_event_set_title           (alarm_event_t *self, const char *title);

const char     *alarm_event_get_message           (const alarm_event_t *self);

void            alarm_event_set_message           (alarm_event_t *self, const char *message);

const char     *alarm_event_get_sound           (const alarm_event_t *self);

void            alarm_event_set_sound           (alarm_event_t *self, const char *sound);

const char     *alarm_event_get_icon           (const alarm_event_t *self);

void            alarm_event_set_icon           (alarm_event_t *self, const char *icon);

const char     *alarm_event_get_alarm_appid           (const alarm_event_t *self);

void            alarm_event_set_alarm_appid           (alarm_event_t *self, const char *alarm_appid);

const char     *alarm_event_get_alarm_tz           (const alarm_event_t *self);

void            alarm_event_set_alarm_tz           (alarm_event_t *self, const char *alarm_tz);

int             alarm_event_is_recurring(const alarm_event_t *self);

alarm_action_t *alarm_event_add_actions(alarm_event_t *self, size_t count);

alarm_action_t *alarm_event_get_action(const alarm_event_t *self, int index);

void alarm_event_del_actions(alarm_event_t *self);

int alarm_event_set_action_dbus_args(const alarm_event_t *self, int index, int type, ...);

const char *alarm_event_get_action_dbus_args(const alarm_event_t *self, int index);

void alarm_event_del_action_dbus_args(const alarm_event_t *self, int index);

alarm_recur_t *alarm_event_add_recurrences(alarm_event_t *self, size_t count);

alarm_recur_t *alarm_event_get_recurrence(const alarm_event_t *self, int index);

void alarm_event_del_recurrences(alarm_event_t *self);

void alarm_event_set_time(alarm_event_t *self, const struct tm *tm);

void alarm_event_get_time(const alarm_event_t *self, struct tm *tm);

int alarm_event_is_sane(const alarm_event_t *self);

void            alarm_event_del_attrs           (alarm_event_t *self);

void            alarm_event_rem_attr            (alarm_event_t *self, const char *name);

alarm_attr_t   *alarm_event_get_attr            (alarm_event_t *self, const char *name);

int             alarm_event_has_attr            (alarm_event_t *self, const char *name);

alarm_attr_t   *alarm_event_add_attr            (alarm_event_t *self, const char *name);

void            alarm_event_set_attr_int        (alarm_event_t *self, const char *name, int val);

void            alarm_event_set_attr_time       (alarm_event_t *self, const char *name, time_t val);

void            alarm_event_set_attr_string     (alarm_event_t *self, const char *name, const char *val);

int             alarm_event_get_attr_int        (alarm_event_t *self, const char *name, int def);

time_t          alarm_event_get_attr_time       (alarm_event_t *self, const char *name, time_t def);

const char     *alarm_event_get_attr_string     (alarm_event_t *self, const char *name, const char *def);

/* ------------------------------------------------------------------------- *
 * alarmd functions
 * ------------------------------------------------------------------------- */


cookie_t alarmd_event_add(const alarm_event_t *event);

cookie_t alarmd_event_add_with_dbus_params(const alarm_event_t *event,
                                           int type, ...);

int alarmd_event_del(cookie_t cookie);

cookie_t alarmd_event_update(const alarm_event_t *event);

cookie_t *alarmd_event_query(const time_t first, const time_t last,
                             int32_t flag_mask, int32_t flags,
                             const char *appid);

alarm_event_t *alarmd_event_get(cookie_t cookie);

int alarmd_set_default_snooze(unsigned int snooze);

unsigned int alarmd_get_default_snooze(void);

cookie_t alarmd_event_add_valist(const alarm_event_t *event, int type, va_list va);

/* ------------------------------------------------------------------------- *
 * systemui functions
 * ------------------------------------------------------------------------- */


int alarmd_ack_dialog(cookie_t cookie, int button);

int alarmd_ack_queue(cookie_t *cookies, int count);

/* ------------------------------------------------------------------------- *
 * debug functions
 * ------------------------------------------------------------------------- */


int alarmd_set_debug(unsigned mask_set, unsigned mask_clr,
                     unsigned flag_set, unsigned flag_clr);

#pragma GCC visibility pop

#ifdef __cplusplus
};
#endif

#endif /* LIBALARM_H_ */

---