ivi-shell.c 12.6 KB
Newer Older
1 2 3
/*
 * Copyright (C) 2013 DENSO CORPORATION
 *
4 5 6 7 8 9 10
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
11
 *
12 13 14 15 16 17 18 19 20 21 22 23
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
24 25 26 27 28 29 30 31 32 33 34 35 36 37
 */

/*
 * ivi-shell supports a type of shell for In-Vehicle Infotainment system.
 * In-Vehicle Infotainment system traditionally manages surfaces with global
 * identification. A protocol, ivi_application, supports such a feature
 * by implementing a request, ivi_application::surface_creation defined in
 * ivi_application.xml.
 *
 *  The ivi-shell explicitly loads a module to add business logic like how to
 *  layout surfaces by using internal ivi-layout APIs.
 */
#include "config.h"

38
#include <stdint.h>
39 40 41 42
#include <string.h>
#include <dlfcn.h>
#include <limits.h>
#include <assert.h>
Pekka Paalanen's avatar
Pekka Paalanen committed
43
#include <linux/input.h>
44 45 46

#include "ivi-shell.h"
#include "ivi-application-server-protocol.h"
47
#include "ivi-layout-export.h"
48
#include "ivi-layout-shell.h"
49
#include "shared/helpers.h"
50
#include "compositor/weston.h"
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

/* Representation of ivi_surface protocol object. */
struct ivi_shell_surface
{
	struct wl_resource* resource;
	struct ivi_shell *shell;
	struct ivi_layout_surface *layout_surface;

	struct weston_surface *surface;
	struct wl_listener surface_destroy_listener;

	uint32_t id_surface;

	int32_t width;
	int32_t height;

	struct wl_list link;
};

/*
 * Implementation of ivi_surface
 */

static void
75
ivi_shell_surface_committed(struct weston_surface *, int32_t, int32_t);
76 77 78 79

static struct ivi_shell_surface *
get_ivi_shell_surface(struct weston_surface *surface)
{
80
	struct ivi_shell_surface *shsurf;
81

82
	if (surface->committed != ivi_shell_surface_committed)
83 84
		return NULL;

85
	shsurf = surface->committed_private;
86 87 88 89
	assert(shsurf);
	assert(shsurf->surface == surface);

	return shsurf;
90 91
}

92 93 94 95 96 97 98 99 100 101 102 103
struct ivi_layout_surface *
shell_get_ivi_layout_surface(struct weston_surface *surface)
{
	struct ivi_shell_surface *shsurf;

	shsurf = get_ivi_shell_surface(surface);
	if (!shsurf)
		return NULL;

	return shsurf->layout_surface;
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117
void
shell_surface_send_configure(struct weston_surface *surface,
			     int32_t width, int32_t height)
{
	struct ivi_shell_surface *shsurf;

	shsurf = get_ivi_shell_surface(surface);
	if (!shsurf)
		return;

	if (shsurf->resource)
		ivi_surface_send_configure(shsurf->resource, width, height);
}

118
static void
119
ivi_shell_surface_committed(struct weston_surface *surface,
120 121 122 123
			    int32_t sx, int32_t sy)
{
	struct ivi_shell_surface *ivisurf = get_ivi_shell_surface(surface);

124 125 126 127 128
	assert(ivisurf);
	if (!ivisurf)
		return;

	if (surface->width == 0 || surface->height == 0)
129 130 131 132 133 134 135
		return;

	if (ivisurf->width != surface->width ||
	    ivisurf->height != surface->height) {
		ivisurf->width  = surface->width;
		ivisurf->height = surface->height;

136 137
		ivi_layout_surface_configure(ivisurf->layout_surface,
					     surface->width, surface->height);
138 139 140
	}
}

141 142 143 144 145 146 147 148 149 150 151 152 153
static int
ivi_shell_surface_get_label(struct weston_surface *surface,
			    char *buf,
			    size_t len)
{
	struct ivi_shell_surface *shell_surf = get_ivi_shell_surface(surface);

	if (!shell_surf)
		return snprintf(buf, len, "unidentified window in ivi-shell");

	return snprintf(buf, len, "ivi-surface %#x", shell_surf->id_surface);
}

154 155 156 157 158 159 160 161
static void
layout_surface_cleanup(struct ivi_shell_surface *ivisurf)
{
	assert(ivisurf->layout_surface != NULL);

	ivi_layout_surface_destroy(ivisurf->layout_surface);
	ivisurf->layout_surface = NULL;

162 163
	ivisurf->surface->committed = NULL;
	ivisurf->surface->committed_private = NULL;
164
	weston_surface_set_label_func(ivisurf->surface, NULL);
165 166 167 168 169 170
	ivisurf->surface = NULL;

	// destroy weston_surface destroy signal.
	wl_list_remove(&ivisurf->surface_destroy_listener.link);
}

171 172 173 174 175 176 177 178 179
/*
 * The ivi_surface wl_resource destructor.
 *
 * Gets called via ivi_surface.destroy request or automatic wl_client clean-up.
 */
static void
shell_destroy_shell_surface(struct wl_resource *resource)
{
	struct ivi_shell_surface *ivisurf = wl_resource_get_user_data(resource);
180 181 182 183 184 185 186 187 188 189 190 191

	if (ivisurf == NULL)
		return;

	assert(ivisurf->resource == resource);

	if (ivisurf->layout_surface != NULL)
		layout_surface_cleanup(ivisurf);

	wl_list_remove(&ivisurf->link);

	free(ivisurf);
192 193 194 195 196 197 198 199 200 201 202 203
}

/* Gets called through the weston_surface destroy signal. */
static void
shell_handle_surface_destroy(struct wl_listener *listener, void *data)
{
	struct ivi_shell_surface *ivisurf =
			container_of(listener, struct ivi_shell_surface,
				     surface_destroy_listener);

	assert(ivisurf != NULL);

204 205
	if (ivisurf->layout_surface != NULL)
		layout_surface_cleanup(ivisurf);
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
}

/* Gets called, when a client sends ivi_surface.destroy request. */
static void
surface_destroy(struct wl_client *client, struct wl_resource *resource)
{
	/*
	 * Fires the wl_resource destroy signal, and then calls
	 * ivi_surface wl_resource destructor: shell_destroy_shell_surface()
	 */
	wl_resource_destroy(resource);
}

static const struct ivi_surface_interface surface_implementation = {
	surface_destroy,
};

/**
 * Request handler for ivi_application.surface_create.
 *
 * Creates an ivi_surface protocol object associated with the given wl_surface.
 * ivi_surface protocol object is represented by struct ivi_shell_surface.
 *
 * \param client The client.
 * \param resource The ivi_application protocol object.
 * \param id_surface The IVI surface ID.
 * \param surface_resource The wl_surface protocol object.
 * \param id The protocol object id for the new ivi_surface protocol object.
 *
 * The wl_surface is given the ivi_surface role and associated with a unique
 * IVI ID which is used to identify the surface in a controller
 * (window manager).
 */
static void
application_surface_create(struct wl_client *client,
			   struct wl_resource *resource,
			   uint32_t id_surface,
			   struct wl_resource *surface_resource,
			   uint32_t id)
{
	struct ivi_shell *shell = wl_resource_get_user_data(resource);
	struct ivi_shell_surface *ivisurf;
	struct ivi_layout_surface *layout_surface;
	struct weston_surface *weston_surface =
		wl_resource_get_user_data(surface_resource);
	struct wl_resource *res;

	if (weston_surface_set_role(weston_surface, "ivi_surface",
				    resource, IVI_APPLICATION_ERROR_ROLE) < 0)
		return;

257
	layout_surface = ivi_layout_surface_create(weston_surface, id_surface);
258 259

	/* check if id_ivi is already used for wl_surface*/
Dawid Gajownik's avatar
Dawid Gajownik committed
260
	if (layout_surface == NULL) {
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
		wl_resource_post_error(resource,
				       IVI_APPLICATION_ERROR_IVI_ID,
				       "surface_id is already assigned "
				       "by another app");
		return;
	}

	ivisurf = zalloc(sizeof *ivisurf);
	if (ivisurf == NULL) {
		wl_resource_post_no_memory(resource);
		return;
	}

	wl_list_init(&ivisurf->link);
	wl_list_insert(&shell->ivi_surface_list, &ivisurf->link);

	ivisurf->shell = shell;
	ivisurf->id_surface = id_surface;

	ivisurf->width = 0;
	ivisurf->height = 0;
	ivisurf->layout_surface = layout_surface;
283

284 285 286 287 288 289 290 291 292 293
	/*
	 * The following code relies on wl_surface destruction triggering
	 * immediateweston_surface destruction
	 */
	ivisurf->surface_destroy_listener.notify = shell_handle_surface_destroy;
	wl_signal_add(&weston_surface->destroy_signal,
		      &ivisurf->surface_destroy_listener);

	ivisurf->surface = weston_surface;

294 295
	weston_surface->committed = ivi_shell_surface_committed;
	weston_surface->committed_private = ivisurf;
296 297
	weston_surface_set_label_func(weston_surface,
				      ivi_shell_surface_get_label);
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342

	res = wl_resource_create(client, &ivi_surface_interface, 1, id);
	if (res == NULL) {
		wl_client_post_no_memory(client);
		return;
	}

	ivisurf->resource = res;

	wl_resource_set_implementation(res, &surface_implementation,
				       ivisurf, shell_destroy_shell_surface);
}

static const struct ivi_application_interface application_implementation = {
	application_surface_create
};

/*
 * Handle wl_registry.bind of ivi_application global singleton.
 */
static void
bind_ivi_application(struct wl_client *client,
		     void *data, uint32_t version, uint32_t id)
{
	struct ivi_shell *shell = data;
	struct wl_resource *resource;

	resource = wl_resource_create(client, &ivi_application_interface,
				      1, id);

	wl_resource_set_implementation(resource,
				       &application_implementation,
				       shell, NULL);
}

/*
 * Called through the compositor's destroy signal.
 */
static void
shell_destroy(struct wl_listener *listener, void *data)
{
	struct ivi_shell *shell =
		container_of(listener, struct ivi_shell, destroy_listener);
	struct ivi_shell_surface *ivisurf, *next;

343
	wl_list_remove(&shell->destroy_listener.link);
344 345
	wl_list_remove(&shell->wake_listener.link);

346 347 348 349 350 351 352 353
	wl_list_for_each_safe(ivisurf, next, &shell->ivi_surface_list, link) {
		wl_list_remove(&ivisurf->link);
		free(ivisurf);
	}

	free(shell);
}

354 355 356 357 358 359 360 361 362 363 364
/*
 * Called through the compositor's wake signal.
 */
static void
wake_handler(struct wl_listener *listener, void *data)
{
	struct weston_compositor *compositor = data;

	weston_compositor_damage_all(compositor);
}

Pekka Paalanen's avatar
Pekka Paalanen committed
365
static void
366
terminate_binding(struct weston_keyboard *keyboard, const struct timespec *time,
367
		  uint32_t key, void *data)
Pekka Paalanen's avatar
Pekka Paalanen committed
368 369 370
{
	struct weston_compositor *compositor = data;

371
	weston_compositor_exit(compositor);
Pekka Paalanen's avatar
Pekka Paalanen committed
372 373
}

374
static void
eucan's avatar
eucan committed
375
init_ivi_shell(struct weston_compositor *compositor, struct ivi_shell *shell)
376
{
eucan's avatar
eucan committed
377 378 379 380
	struct weston_config *config = wet_get_config(compositor);
	struct weston_config_section *section;
	int developermode;

381 382 383 384
	shell->compositor = compositor;

	wl_list_init(&shell->ivi_surface_list);

eucan's avatar
eucan committed
385 386 387 388 389 390
	section = weston_config_get_section(config, "ivi-shell", NULL, NULL);

	weston_config_section_get_bool(section, "developermode",
				       &developermode, 0);

	if (developermode) {
391
		weston_install_debug_key_binding(compositor, MODIFIER_SUPER);
Pekka Paalanen's avatar
Pekka Paalanen committed
392 393 394 395 396 397

		weston_compositor_add_key_binding(compositor, KEY_BACKSPACE,
						  MODIFIER_CTRL | MODIFIER_ALT,
						  terminate_binding,
						  compositor);
	}
398 399
}

400 401 402 403 404 405 406 407 408 409 410
static void
activate_binding(struct weston_seat *seat,
		 struct weston_view *focus_view)
{
	struct weston_surface *focus = focus_view->surface;
	struct weston_surface *main_surface =
		weston_surface_get_main_surface(focus);

	if (get_ivi_shell_surface(main_surface) == NULL)
		return;

411
	weston_seat_set_keyboard_focus(seat, focus);
412 413 414
}

static void
415 416
click_to_activate_binding(struct weston_pointer *pointer,
			  const struct timespec *time,
417 418 419 420 421 422 423 424 425 426 427
			  uint32_t button, void *data)
{
	if (pointer->grab != &pointer->default_grab)
		return;
	if (pointer->focus == NULL)
		return;

	activate_binding(pointer->seat, pointer->focus);
}

static void
428 429
touch_to_activate_binding(struct weston_touch *touch,
			  const struct timespec *time,
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
			  void *data)
{
	if (touch->grab != &touch->default_grab)
		return;
	if (touch->focus == NULL)
		return;

	activate_binding(touch->seat, touch->focus);
}

static void
shell_add_bindings(struct weston_compositor *compositor,
		   struct ivi_shell *shell)
{
	weston_compositor_add_button_binding(compositor, BTN_LEFT, 0,
					     click_to_activate_binding,
					     shell);
	weston_compositor_add_button_binding(compositor, BTN_RIGHT, 0,
					     click_to_activate_binding,
					     shell);
	weston_compositor_add_touch_binding(compositor, 0,
					    touch_to_activate_binding,
					    shell);
}

455 456 457 458
/*
 * Initialization of ivi-shell.
 */
WL_EXPORT int
459 460
wet_shell_init(struct weston_compositor *compositor,
	       int *argc, char *argv[])
461 462 463 464 465 466 467
{
	struct ivi_shell *shell;

	shell = zalloc(sizeof *shell);
	if (shell == NULL)
		return -1;

eucan's avatar
eucan committed
468
	init_ivi_shell(compositor, shell);
469 470 471 472

	shell->destroy_listener.notify = shell_destroy;
	wl_signal_add(&compositor->destroy_signal, &shell->destroy_listener);

473 474 475
	shell->wake_listener.notify = wake_handler;
	wl_signal_add(&compositor->wake_signal, &shell->wake_listener);

476 477 478
	if (wl_global_create(compositor->wl_display,
			     &ivi_application_interface, 1,
			     shell, bind_ivi_application) == NULL)
479
		goto err_shell;
480

481
	ivi_layout_init_with_compositor(compositor);
482
	shell_add_bindings(compositor, shell);
483

484
	return IVI_SUCCEEDED;
485

486 487 488 489
err_shell:
	free(shell);

	return IVI_FAILED;
490
}