476908a92c76c8a37db533244bf95c8a3a4797c5
[profile/ivi/weston-ivi-shell.git] / ivi-shell / ivi-shell.c
1 /*
2  * Copyright (C) 2013 DENSO CORPORATION
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and
5  * its documentation for any purpose is hereby granted without fee, provided
6  * that the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation, and that the name of the copyright holders not be used in
9  * advertising or publicity pertaining to distribution of the software
10  * without specific, written prior permission.  The copyright holders make
11  * no representations about the suitability of this software for any
12  * purpose.  It is provided "as is" without express or implied warranty.
13  *
14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21  */
22
23 /*
24  * ivi-shell supports a type of shell for In-Vehicle Infotainment system.
25  * In-Vehicle Infotainment system traditionally manages surfaces with global
26  * identification. A protocol, ivi_application, supports such a feature
27  * by implementing a request, ivi_application::surface_creation defined in
28  * ivi_application.xml.
29  *
30  *  The ivi-shell explicitly loads a module to add business logic like how to
31  *  layout surfaces by using internal ivi-layout APIs.
32  */
33 #include "config.h"
34
35 #include <sys/wait.h>
36 #include <unistd.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <linux/input.h>
41 #include <dlfcn.h>
42 #include <limits.h>
43 #include <assert.h>
44
45 #include "ivi-shell.h"
46 #include "ivi-application-server-protocol.h"
47 #include "ivi-layout-private.h"
48
49 #include "../shared/os-compatibility.h"
50
51 /* Representation of ivi_surface protocol object. */
52 struct ivi_shell_surface
53 {
54         struct wl_resource* resource;
55         struct ivi_shell *shell;
56         struct ivi_layout_surface *layout_surface;
57
58         struct weston_surface *surface;
59         struct wl_listener surface_destroy_listener;
60
61         uint32_t id_surface;
62
63         int32_t width;
64         int32_t height;
65
66         struct wl_list link;
67
68         struct wl_listener configured_listener;
69 };
70
71 struct ivi_shell_setting
72 {
73         char *ivi_module;
74 };
75
76 /*
77  * Implementation of ivi_surface
78  */
79
80 static void
81 surface_configure_notify(struct wl_listener *listener, void *data)
82 {
83         struct ivi_layout_surface *layout_surf =
84                 (struct ivi_layout_surface *)data;
85
86         struct ivi_shell_surface *shell_surf =
87                 container_of(listener,
88                              struct ivi_shell_surface,
89                              configured_listener);
90
91         int32_t dest_width = 0;
92         int32_t dest_height = 0;
93         shell_surf->shell->ivi_layout->get_surface_dimension(layout_surf,
94                                           &dest_width, &dest_height);
95
96         if (shell_surf->resource)
97                 ivi_surface_send_configure(shell_surf->resource,
98                                            dest_width, dest_height);
99 }
100
101 static void
102 ivi_shell_surface_configure(struct weston_surface *, int32_t, int32_t);
103
104 static struct ivi_shell_surface *
105 get_ivi_shell_surface(struct weston_surface *surface)
106 {
107         if (surface->configure == ivi_shell_surface_configure)
108                 return surface->configure_private;
109
110         return NULL;
111 }
112
113 static void
114 ivi_shell_surface_configure(struct weston_surface *surface,
115                             int32_t sx, int32_t sy)
116 {
117         struct ivi_shell_surface *ivisurf = get_ivi_shell_surface(surface);
118         struct weston_view *view;
119         float from_x;
120         float from_y;
121         float to_x;
122         float to_y;
123
124         if (surface->width == 0 || surface->height == 0 || ivisurf == NULL)
125                 return;
126
127         view = ivisurf->shell->ivi_layout->get_weston_view(ivisurf->layout_surface);
128         if (view == NULL)
129                 return;
130
131         if (ivisurf->width != surface->width ||
132             ivisurf->height != surface->height) {
133                 ivisurf->width  = surface->width;
134                 ivisurf->height = surface->height;
135
136                 weston_view_to_global_float(view, 0, 0, &from_x, &from_y);
137                 weston_view_to_global_float(view, sx, sy, &to_x, &to_y);
138
139                 weston_view_set_position(view,
140                                          view->geometry.x + to_x - from_x,
141                                          view->geometry.y + to_y - from_y);
142                 weston_view_update_transform(view);
143
144                 ivisurf->shell->ivi_layout->surface_configure(ivisurf->layout_surface,
145                                               surface->width, surface->height);
146         }
147 }
148
149 /*
150  * The ivi_surface wl_resource destructor.
151  *
152  * Gets called via ivi_surface.destroy request or automatic wl_client clean-up.
153  */
154 static void
155 shell_destroy_shell_surface(struct wl_resource *resource)
156 {
157         struct ivi_shell_surface *ivisurf = wl_resource_get_user_data(resource);
158         if (ivisurf != NULL) {
159                 ivisurf->resource = NULL;
160         }
161 }
162
163 /* Gets called through the weston_surface destroy signal. */
164 static void
165 shell_handle_surface_destroy(struct wl_listener *listener, void *data)
166 {
167         struct ivi_shell_surface *ivisurf =
168                         container_of(listener, struct ivi_shell_surface,
169                                      surface_destroy_listener);
170
171         assert(ivisurf != NULL);
172
173         if (ivisurf->surface!=NULL) {
174                 ivisurf->surface->configure = NULL;
175                 ivisurf->surface->configure_private = NULL;
176                 ivisurf->surface = NULL;
177         }
178
179         wl_list_remove(&ivisurf->surface_destroy_listener.link);
180         wl_list_remove(&ivisurf->link);
181
182         if (ivisurf->resource != NULL) {
183                 wl_resource_set_user_data(ivisurf->resource, NULL);
184                 ivisurf->resource = NULL;
185         }
186         free(ivisurf);
187
188 }
189
190 /* Gets called, when a client sends ivi_surface.destroy request. */
191 static void
192 surface_destroy(struct wl_client *client, struct wl_resource *resource)
193 {
194         /*
195          * Fires the wl_resource destroy signal, and then calls
196          * ivi_surface wl_resource destructor: shell_destroy_shell_surface()
197          */
198         wl_resource_destroy(resource);
199 }
200
201 static const struct ivi_surface_interface surface_implementation = {
202         surface_destroy,
203 };
204
205 static struct shell_surface*
206 create_shell_surface(void *shell,
207                      struct weston_surface *weston_surface,
208                      const struct weston_shell_client *client)
209 {
210         struct ivi_shell_surface *ivisurf;
211         struct ivi_layout_surface *layout_surface;
212         static uint32_t id_surface = 0xffffffff; // FIXME
213
214         ivisurf = zalloc(sizeof *ivisurf);
215         if (ivisurf == NULL) {
216         weston_log("no memory\n");
217                 return NULL;
218         }
219
220         layout_surface = ((struct ivi_shell*)shell)
221                 ->ivi_layout->surface_create(weston_surface, id_surface);
222
223         wl_list_init(&ivisurf->link);
224         wl_list_insert(&((struct ivi_shell*)shell)->ivi_surface_list, &ivisurf->link);
225
226         ivisurf->shell = shell;
227         ivisurf->id_surface = id_surface;
228
229         ivisurf->resource = NULL;
230         ivisurf->width = 0;
231         ivisurf->height = 0;
232         ivisurf->layout_surface = layout_surface;
233         ivisurf->configured_listener.notify = surface_configure_notify;
234         ((struct ivi_shell*)shell)->ivi_layout->add_surface_configured_listener(
235                                         layout_surface, &ivisurf->configured_listener);
236
237         ivisurf->surface = weston_surface;
238
239         weston_surface->configure = ivi_shell_surface_configure;
240         weston_surface->configure_private = ivisurf;
241
242         id_surface--;
243
244         return NULL;
245 }
246
247 static struct weston_view*
248 get_primary_view(void *shell,
249                  struct shell_surface *shsurf)
250 {
251         return NULL;
252 }
253
254 static void
255 set_toplevel(struct shell_surface *shsurf)
256 {
257         /*
258          * non support for ivi-shell
259          * this shall not be done by client request.
260          */
261 }
262
263 static void
264 set_transient(struct shell_surface *shsurf,
265               struct weston_surface *parent,
266               int x, int y, uint32_t flags)
267 {
268         /*
269          * non support for ivi-shell
270          * this shall not be done by client request.
271          */
272 }
273
274 static void
275 set_fullscreen(struct shell_surface *shsurf,
276                uint32_t method,
277                uint32_t framerate,
278                struct weston_output *output)
279 {
280         /*
281          * non support for ivi-shell
282          * this shall not be done by client request.
283          */
284 }
285
286 static void
287 set_xwayland(struct shell_surface *shsurf,
288              int x, int y, uint32_t flags)
289 {
290         /*
291          * non support for ivi-shell
292          * this shall not be done by client request.
293          */
294 }
295
296 static int
297 move(struct shell_surface *shsurf, struct weston_seat *ws)
298 {
299         /*
300          * non support for ivi-shell
301          * this shall not be done by client request.
302          */
303
304         return 0; // success
305 }
306
307 static int
308 resize(struct shell_surface *shsurf, struct weston_seat *ws, uint32_t edges)
309 {
310         /*
311          * non support for ivi-shell
312          * this shall not be done by client request.
313          */
314
315         return 0; // success
316 }
317
318 static void
319 set_title(struct shell_surface *shsurf, const char *title)
320 {
321         /*
322          * title is not supported by ivi-shell
323          */
324 }
325
326 static void
327 set_window_geometry(struct shell_surface *shsurf,
328                     int32_t x, int32_t y, int32_t width, int32_t height)
329 {
330         /*
331          * non support for ivi-shell
332          * this shall not be done by client request.
333          */
334 }
335
336 /**
337  * Request handler for ivi_application.surface_create.
338  *
339  * Creates an ivi_surface protocol object associated with the given wl_surface.
340  * ivi_surface protocol object is represented by struct ivi_shell_surface.
341  *
342  * \param client The client.
343  * \param resource The ivi_application protocol object.
344  * \param id_surface The IVI surface ID.
345  * \param surface_resource The wl_surface protocol object.
346  * \param id The protocol object id for the new ivi_surface protocol object.
347  *
348  * The wl_surface is given the ivi_surface role and associated with a unique
349  * IVI ID which is used to identify the surface in a controller
350  * (window manager).
351  */
352 static void
353 application_surface_create(struct wl_client *client,
354                            struct wl_resource *resource,
355                            uint32_t id_surface,
356                            struct wl_resource *surface_resource,
357                            uint32_t id)
358 {
359         struct ivi_shell *shell = wl_resource_get_user_data(resource);
360         struct ivi_shell_surface *ivisurf;
361         struct ivi_layout_surface *layout_surface;
362         struct weston_surface *weston_surface =
363                 wl_resource_get_user_data(surface_resource);
364         struct wl_resource *res;
365
366         if (weston_surface_set_role(weston_surface, "ivi_surface",
367                                     resource, IVI_APPLICATION_ERROR_ROLE) < 0)
368                 return;
369
370         layout_surface = shell->ivi_layout->surface_create(weston_surface,
371                                                     id_surface);
372
373         /* check if id_ivi is already used for wl_surface*/
374         if (layout_surface == NULL){
375                 wl_resource_post_error(resource,
376                                        IVI_APPLICATION_ERROR_IVI_ID,
377                                        "surface_id is already assigned "
378                                        "by another app");
379                 return;
380         }
381
382         ivisurf = zalloc(sizeof *ivisurf);
383         if (ivisurf == NULL) {
384                 wl_resource_post_no_memory(resource);
385                 return;
386         }
387
388         wl_list_init(&ivisurf->link);
389         wl_list_insert(&shell->ivi_surface_list, &ivisurf->link);
390
391         ivisurf->shell = shell;
392         ivisurf->id_surface = id_surface;
393
394         ivisurf->width = 0;
395         ivisurf->height = 0;
396         ivisurf->layout_surface = layout_surface;
397         ivisurf->configured_listener.notify = surface_configure_notify;
398         ivisurf->shell->ivi_layout->add_surface_configured_listener(layout_surface,
399                                                 &ivisurf->configured_listener);
400
401         /*
402          * The following code relies on wl_surface destruction triggering
403          * immediateweston_surface destruction
404          */
405         ivisurf->surface_destroy_listener.notify = shell_handle_surface_destroy;
406         wl_signal_add(&weston_surface->destroy_signal,
407                       &ivisurf->surface_destroy_listener);
408
409         ivisurf->surface = weston_surface;
410
411         weston_surface->configure = ivi_shell_surface_configure;
412         weston_surface->configure_private = ivisurf;
413
414         res = wl_resource_create(client, &ivi_surface_interface, 1, id);
415         if (res == NULL) {
416                 wl_client_post_no_memory(client);
417                 return;
418         }
419
420         ivisurf->resource = res;
421
422         wl_resource_set_implementation(res, &surface_implementation,
423                                        ivisurf, shell_destroy_shell_surface);
424 }
425
426 static const struct ivi_application_interface application_implementation = {
427         application_surface_create
428 };
429
430 /*
431  * Handle wl_registry.bind of ivi_application global singleton.
432  */
433 static void
434 bind_ivi_application(struct wl_client *client,
435                      void *data, uint32_t version, uint32_t id)
436 {
437         struct ivi_shell *shell = data;
438         struct wl_resource *resource;
439
440         resource = wl_resource_create(client, &ivi_application_interface,
441                                       1, id);
442
443         wl_resource_set_implementation(resource,
444                                        &application_implementation,
445                                        shell, NULL);
446 }
447
448 struct weston_view *
449 get_default_view(struct weston_surface *surface)
450 {
451         struct ivi_shell_surface *shsurf;
452         struct weston_view *view;
453
454         if (!surface || wl_list_empty(&surface->views))
455                 return NULL;
456
457         shsurf = get_ivi_shell_surface(surface);
458         if (shsurf && shsurf->layout_surface) {
459                 view = shsurf->shell->ivi_layout->get_weston_view(shsurf->layout_surface);
460                 if (view)
461                         return view;
462         }
463
464         wl_list_for_each(view, &surface->views, surface_link) {
465                 if (weston_view_is_mapped(view))
466                         return view;
467         }
468
469         return container_of(surface->views.next,
470                             struct weston_view, surface_link);
471 }
472
473 /*
474  * Called through the compositor's destroy signal.
475  */
476 static void
477 shell_destroy(struct wl_listener *listener, void *data)
478 {
479         struct ivi_shell *shell =
480                 container_of(listener, struct ivi_shell, destroy_listener);
481         struct ivi_shell_surface *ivisurf, *next;
482
483         input_panel_destroy(shell);
484
485         wl_list_for_each_safe(ivisurf, next, &shell->ivi_surface_list, link) {
486                 wl_list_remove(&ivisurf->link);
487                 free(ivisurf);
488         }
489
490         free(shell);
491 }
492
493 static void
494 init_ivi_shell(struct weston_compositor *compositor, struct ivi_shell *shell)
495 {
496         shell->compositor = compositor;
497
498         wl_list_init(&shell->ivi_surface_list);
499
500         weston_layer_init(&shell->input_panel_layer, NULL);
501
502         compositor->shell_interface.shell = shell;
503         compositor->shell_interface.create_shell_surface = create_shell_surface;
504         compositor->shell_interface.get_primary_view = get_primary_view;
505         compositor->shell_interface.set_toplevel = set_toplevel;
506         compositor->shell_interface.set_transient = set_transient;
507         compositor->shell_interface.set_fullscreen = set_fullscreen;
508         compositor->shell_interface.set_xwayland = set_xwayland;
509         compositor->shell_interface.move = move;
510         compositor->shell_interface.resize = resize;
511         compositor->shell_interface.set_title = set_title;
512         compositor->shell_interface.set_window_geometry = set_window_geometry;
513 }
514
515 static int
516 ivi_shell_setting_create(struct ivi_shell_setting *dest,
517                          struct weston_compositor *compositor)
518 {
519         int result = 0;
520         struct weston_config *config = compositor->config;
521         struct weston_config_section *section;
522
523         if (NULL == dest)
524                 return -1;
525
526         section = weston_config_get_section(config, "ivi-shell", NULL, NULL);
527
528         if (weston_config_section_get_string(
529                 section, "ivi-module", &dest->ivi_module, NULL) != 0)
530         {
531                 result = -1;
532         }
533
534         return result;
535 }
536
537 /*
538  * Initialization of ivi-shell.
539  */
540 static int
541 ivi_load_modules(struct weston_compositor *compositor, const char *modules,
542                  int *argc, char *argv[])
543 {
544         const char *p, *end;
545         char buffer[256];
546         int (*module_init)(struct weston_compositor *compositor,
547                            int *argc, char *argv[]);
548
549         if (modules == NULL)
550                 return 0;
551
552         p = modules;
553         while (*p) {
554                 end = strchrnul(p, ',');
555                 snprintf(buffer, sizeof buffer, "%.*s", (int)(end - p), p);
556
557                 module_init = weston_load_module(buffer, "module_init");
558                 if (module_init)
559                         module_init(compositor, argc, argv);
560
561                 p = end;
562                 while (*p == ',')
563                         p++;
564         }
565
566         return 0;
567 }
568
569 WL_EXPORT int
570 module_init(struct weston_compositor *compositor,
571             int *argc, char *argv[])
572 {
573         struct ivi_shell *shell;
574         char ivi_layout_path[PATH_MAX];
575         void *module;
576         struct ivi_shell_setting setting = { };
577
578         shell = zalloc(sizeof *shell);
579         if (shell == NULL)
580                 return -1;
581
582         init_ivi_shell(compositor, shell);
583
584         shell->destroy_listener.notify = shell_destroy;
585         wl_signal_add(&compositor->destroy_signal, &shell->destroy_listener);
586
587         if (input_panel_setup(shell) < 0)
588                 return -1;
589
590         if (wl_global_create(compositor->wl_display,
591                              &ivi_application_interface, 1,
592                              shell, bind_ivi_application) == NULL)
593                 return -1;
594
595         if (ivi_shell_setting_create(&setting, compositor) != 0)
596                 return -1;
597
598         /*
599          * load module:ivi-layout
600          * ivi_layout_interface is referred by ivi-shell to use ivi-layout.
601          * The reason why the following code is written newly without
602          * using weston_load_module is it doesn't open library with
603          * RTLD_GLOBAL option.
604          */
605         snprintf(ivi_layout_path, sizeof ivi_layout_path,
606                  "%s/%s", MODULEDIR, "ivi-layout.so");
607         module = dlopen(ivi_layout_path, RTLD_NOW | RTLD_NOLOAD);
608         if (module) {
609                 weston_log("ivi-shell: Module '%s' already loaded\n",
610                            ivi_layout_path);
611                 dlclose(module);
612                 return -1;
613         }
614
615         weston_log("ivi-shell: Loading module '%s'\n", ivi_layout_path);
616         module = dlopen(ivi_layout_path, RTLD_NOW | RTLD_GLOBAL);
617         if (!module) {
618                 weston_log("ivi-shell: Failed to load module: %s\n", dlerror());
619                 return -1;
620         }
621
622         shell->ivi_layout = dlsym(module,"ivi_layout_interface");
623         if (!shell->ivi_layout){
624                 weston_log("ivi-shell: couldn't find ivi_layout_interface in '%s'\n", ivi_layout_path);
625                 free(setting.ivi_module);
626                 dlclose(module);
627                 return -1;
628         }
629
630         shell->ivi_layout->init_with_compositor(compositor);
631
632         /* Call module_init of ivi-modules which are defined in weston.ini */
633         if (ivi_load_modules(compositor, setting.ivi_module, argc, argv) < 0) {
634                 free(setting.ivi_module);
635                 dlclose(module);
636                 return -1;
637         }
638
639         free(setting.ivi_module);
640         return 0;
641 }