examples/tinyds-launch.c

   1 #include <libds-tizen/launch.h>
   2
   3 #include "tinyds-common.h"
   4 #include "tinyds-launch.h"
   5 #include "tinyds-tdm.h"
   6
   7 struct tinyds_launch
   8 {
   9     launch_free_cb free_cb;
  10     void *data;
  11
  12     struct ds_tizen_launch_effect *effect;
  13     struct ds_tizen_launch_splash *splash;
  14
  15     struct wl_listener effect_destroy;
  16     struct wl_listener effect_type_set;
  17     struct wl_listener effect_type_unset;
  18     struct wl_listener new_splash;
  19     struct wl_listener splash_owner;
  20
  21     struct tinyds_server *server;
  22 };
  23
  24 static void
  25 launch_effect_handle_destroy(struct wl_listener *listener, void *data TINYDS_UNUSED)
  26 {
  27     struct tinyds_launch *launch =
  28         wl_container_of(listener, launch, effect_destroy);
  29
  30     launch->free_cb(data);
  31
  32     wl_list_remove(&launch->effect_destroy.link);
  33     wl_list_remove(&launch->effect_type_set.link);
  34     wl_list_remove(&launch->effect_type_unset.link);
  35     wl_list_remove(&launch->new_splash.link);
  36
  37     launch->effect = NULL;
  38 }
  39
  40 static void
  41 launch_effect_handle_type_set(struct wl_listener *listener, void *data)
  42 {
  43     struct tinyds_launch *launch;
  44     struct ds_tizen_launch_effect_event_type_set *event = data;
  45     struct tinyds_view *view = NULL;
  46     bool existing = false;
  47
  48     launch = wl_container_of(listener, launch, effect_type_set);
  49
  50     ds_inf("Launch effect. type_set: pid(%u) type:%s", event->pid, (event->effect_type == 1) ? "depth-in" : "launch");
  51
  52     wl_list_for_each(view, &launch->server->views, link) {
  53         if (view->pid == event->pid) {
  54             view->effect_type = event->effect_type;
  55             existing = true;
  56             ds_inf("Launch effect. existing pid");
  57         }
  58     }
  59     if (existing) {
  60         ds_tizen_launch_effect_unset_effect_type(launch->effect, event->pid);
  61     } else {
  62         ds_tizen_launch_effect_set_effect_type(launch->effect, event->pid, event->effect_type);
  63     }
  64 }
  65
  66 static void
  67 launch_effect_handle_type_unset(struct wl_listener *listener, void *data)
  68 {
  69     struct tinyds_launch *launch;
  70     struct ds_tizen_launch_effect_event_type_unset *event = data;
  71     struct tinyds_view *view = NULL;
  72
  73     launch = wl_container_of(listener, launch, effect_type_unset);
  74
  75     ds_inf("Launch effect. type_unset: pid(%u)", event->pid);
  76
  77     wl_list_for_each(view, &launch->server->views, link) {
  78         if (view->pid == event->pid) {
  79             view->effect_type = -1;
  80             ds_inf("Launch effect. pid found");
  81         }
  82     }
  83     ds_tizen_launch_effect_unset_effect_type(launch->effect, event->pid);
  84 }
  85
  86 static void
  87 launch_splash_handle_owner(struct wl_listener *listener, void *data)
  88 {
  89     struct tinyds_launch *launch;
  90     struct ds_tizen_launch_splash_event_owner *event = data;
  91     struct tinyds_view *view = NULL;
  92
  93     launch = wl_container_of(listener, launch, splash_owner);
  94
  95     ds_inf("Splash owner. pid(%u)", event->pid);
  96
  97     wl_list_for_each(view, &launch->server->views, link) {
  98         if (view->pid == event->pid) {
  99             if (event->pid == ds_tizen_launch_splash_get_pid(launch->splash))
 100                 ;//
 101             else {
 102                 ds_tizen_launch_splash_set_pid(launch->splash, event->pid);
 103             }
 104         }
 105     }
 106 }
 107
 108 static void
 109 launch_effect_handle_new_splash(struct wl_listener *listener, void *data)
 110 {
 111     struct tinyds_launch *launch;
 112     struct ds_tizen_launch_splash *splash = data;
 113     struct tinyds_view *view = NULL;
 114
 115     launch = wl_container_of(listener, launch, new_splash);
 116
 117     ds_inf("Launch new splash. splash(%p)", splash);
 118     if (!splash) return;
 119
 120     launch->splash = splash;
 121
 122     // new view for "Launchscreen"
 123     view = calloc(1, sizeof *view);
 124     assert(view);
 125
 126     wl_list_insert(launch->server->views.prev, &view->link);
 127     view->pid = ds_tizen_launch_splash_get_pid(splash);
 128
 129     launch->splash_owner.notify = launch_splash_handle_owner;
 130     ds_tizen_launch_splash_add_owner_listener(launch->splash,
 131             &launch->splash_owner);
 132 }
 133
 134 struct tinyds_launch *
 135 tinyds_launch_init(struct wl_display *display, launch_free_cb free_cb, void *data)
 136 {
 137     struct tinyds_launch *launch;
 138
 139     launch = calloc(1, sizeof *launch);
 140     if (!launch)
 141         return NULL;
 142
 143     launch->free_cb = free_cb;
 144     data = data;
 145
 146     launch->effect = ds_tizen_launch_effect_create(display);
 147     if (!launch->effect) {
 148         return NULL;
 149     }
 150
 151     launch->effect_destroy.notify = launch_effect_handle_destroy;
 152     ds_tizen_launch_effect_add_destroy_listener(launch->effect,
 153             &launch->effect_destroy);
 154
 155     launch->effect_type_set.notify = launch_effect_handle_type_set;
 156     ds_tizen_launch_effect_add_type_set_listener(launch->effect,
 157             &launch->effect_type_set);
 158
 159     launch->effect_type_unset.notify = launch_effect_handle_type_unset;
 160     ds_tizen_launch_effect_add_type_unset_listener(launch->effect,
 161             &launch->effect_type_unset);
 162
 163     launch->new_splash.notify = launch_effect_handle_new_splash;
 164     ds_tizen_launch_effect_add_new_splash_listener(launch->effect,
 165             &launch->new_splash);
 166
 167     launch->server = (struct tinyds_server *)data;
 168
 169     ds_inf("Launch (%p) created", launch);
 170
 171     return launch;
 172 }
 173
 174 int
 175 tinyds_launch_get_effect_type(struct tinyds_launch *launch, uint32_t pid)
 176 {
 177     return ds_tizen_launch_effect_get_effect_type(launch->effect, pid);
 178 }
 179
 180 void
 181 tinyds_launch_unset_effect_type(struct tinyds_launch *launch, uint32_t pid)
 182 {
 183     ds_tizen_launch_effect_unset_effect_type(launch->effect, pid);
 184 }