[AGL/meta-agl.git] /

From 0d114839f299b6a9e3f504e75c22d636222c3b20 Mon Sep 17 00:00:00 2001
From: Wataru Mizuno <wmizuno@jp.adit-jv.com>
Date: Tue, 10 Apr 2018 15:23:02 +0900
Subject: [PATCH 3/3] transmitter: transmitter plugin for waltham protocol

The transmitter plugin enables weston to communicate with
remote site compositor over the ethernet.
Communication is done with waltham protocol which is the
wayland like IPC protocol.

Signed-off-by: Wataru Mizuno <wmizuno@jp.adit-jv.com>
---
 Makefile.am                        |  11 +-
 configure.ac                       |  12 +
 transmitter/README                 | 108 +++--
 transmitter/input.c                | 783 ++++++++++++++++++++++++++++++++-
 transmitter/output.c               | 139 +++++-
 transmitter/plugin.c               | 875 ++++++++++++++++++++++++++-----------
 transmitter/plugin.h               | 140 +++++-
 transmitter/transmitter_api.h      |  26 +-
 transmitter/weston.ini.transmitter |  21 +
 9 files changed, 1763 insertions(+), 352 deletions(-)
 create mode 100644 transmitter/weston.ini.transmitter

diff --git a/Makefile.am b/Makefile.am
index 6cca875..2cb1920 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -306,6 +306,11 @@ westoninclude_HEADERS +=                           \
        ivi-shell/ivi-layout-export.h
 endif
 
+if ENABLE_SURFACE_REMOTING
+westoninclude_HEADERS +=                               \
+       transmitter/transmitter_api.h
+endif
+
 if ENABLE_EGL
 libweston_module_LTLIBRARIES += gl-renderer.la
 gl_renderer_la_LDFLAGS = -module -avoid-version
@@ -507,8 +512,10 @@ module_LTLIBRARIES += transmitter.la
 transmitter_la_LDFLAGS = -module -avoid-version
 transmitter_la_CFLAGS =                                \
        $(COMPOSITOR_CFLAGS)                    \
-       $(AM_CFLAGS)
-transmitter_la_LIBADD = $(COMPOSITOR_LIBS)
+       $(AM_CFLAGS)                            \
+       $(WALTHAM_CFLAGS)
+transmitter_la_LIBADD = $(COMPOSITOR_LIBS) \
+                       -lwaltham
 transmitter_la_SOURCES =                       \
        transmitter/plugin.c                    \
        transmitter/plugin.h                    \
diff --git a/configure.ac b/configure.ac
index 6cf2883..4819e08 100644
--- a/configure.ac
+++ b/configure.ac
@@ -543,6 +543,18 @@ AC_ARG_ENABLE(surface-remoting,
               AS_HELP_STRING([--enable-surface-remoting],
                              [support for surface remoting over network]),,
              enable_surface_remoting=no)
+if test "x$enable_surface_remoting" != "xno"; then
+       PKG_CHECK_MODULES(WALTHAM,
+                         waltham >= 0.1.0,
+                         have_waltham=yes,
+                         have_waltham=no)
+       if test "x$have_waltham" = "xno" -a "x$enable_surface_remoting" = "xyes"; then
+         AC_MSG_ERROR([surface_remoting support explicitly requested, but waltham couldn't be found])
+       fi
+       if test "x$have_waltham" = "xyes"; then
+            enable_surface_remoting=yes
+       fi
+fi
 AM_CONDITIONAL(ENABLE_SURFACE_REMOTING, test "x$enable_surface_remoting" = "xyes")
 
 
diff --git a/transmitter/README b/transmitter/README
index a7977ba..af80574 100644
--- a/transmitter/README
+++ b/transmitter/README
@@ -1,45 +1,84 @@
-Testing Transmitter with ivi-shell
+Transmitter plugin 
 
 The current implementation of Transmitter is a stub which interfaces to
 other Weston parts appropriately, but all networking is just a mockup.
 
+Sections in this file describe:
+- How to build
+- How to write weston.ini
+- How to test
 
+How to build
+============
 Configure Weston with --enable-surface-remoting to build the Transmitter
 plugin.
 
-In weston.ini, add 'transmitter.so' to the 'modules' key under '[core]', and
-make sure the 'shell' is 'ivi-shell.so'. Follow the ivi-shell example
-weston.ini for everything else.
-
-When you start weston, the log should contain something like this:
-
-[13:13:54.799] Loading module '/home/pq/local/lib/weston/ivi-shell.so'
-[13:13:54.799] launching '/home/pq/local/libexec/weston-keyboard'
-[13:13:54.799] Loading module '/home/pq/local/lib/weston/hmi-controller.so'
-[13:13:54.799] Loading module '/home/pq/local/lib/weston/transmitter.so'
-[13:13:54.799] Registered plugin API 'transmitter_v1' of size 48
-[13:13:54.799] Registered plugin API 'transmitter_ivi_v1' of size 16
-[13:13:54.799] Transmitter initialized.
-[13:13:54.799] ivi-layout: Transmitter enabled.
-[13:13:54.799] launching '/home/pq/build/weston/weston-ivi-shell-user-interface'
-[13:13:54.799] hmi-controller: Transmitter enabled.
-[13:13:54.799] Transmitter connecting to 0.0.0.0:66...
-[13:13:55.800] Transmitter connected to 0.0.0.0:66.
-[13:13:55.800] hmi-controller: connection status 0
-[13:13:55.800] Transmitter created output 'transmitter-0.0.0.0:66-1': Weston-Transmitter, transmitter-0.0.0.0:66-1, 0
-[13:13:55.800] Transmitter created seat=0x1c37bd0 'transmitter-0.0.0.0:66-default'
-[13:13:55.800] Transmitter created pointer=0x1c38430 for seat 0x1c37bd0
-[13:13:55.800] transmitter_start_repaint_loop(transmitter-0.0.0.0:66-1)
-
-
-If you have edited a client to have ivi-id >= 0xfaa01000, when you start that
-client it should be "remoted" automatically and not appear on screen.
-
-You can also manually start remoting:
+How to write weston.ini
+=======================
+To load transmitter plugin to weston, add 'transmitter.so' to the 'modules' 
+key under '[core]', and make sure the 'shell' is 'ivi-shell.so'. 
+
+The destination of remoting is configured in weston.ini.
+Add output name, server address, port number, output's width and height key
+under '[remote-output]'.
+You can speficy multiple [remote-output].
+
+In details, see 'weston.ini.transmitter'.
+
+How to test
+===========
+You can use server side test application in waltham repository.
+
+If you set 'WALTHAM_DEBUG=1' to your environment valuable, you can
+see the log like this:
+
+ [06:12:41.238] Loading module '/usr/lib64/weston/ivi-shell.so'
+ [06:12:41.245] launching '/usr/libexec/weston-keyboard'
+ [06:12:41.247] Loading module '/usr/lib64/weston/ivi-controller.so'
+ [06:12:41.252] Loading module '/usr/lib64/weston/ivi-input-controller.so'
+ [06:12:41.253] ivi-input-controller module loaded successfully!
+ [06:12:41.255] Loading module '/usr/lib64/weston/transmitter.so'
+ [06:12:41.260] Registered plugin API 'transmitter_v1' of size 88
+ [06:12:41.260] Registered plugin API 'transmitter_ivi_v1' of size 16
+ [06:12:41.260] Transmitter initialized.
+ [06:12:41.260] ivi-layout: Transmitter enabled.
+ [06:12:41.260] Transmitter weston_seat 0x14f8010
+ [06:12:41.260] Transmitter created pointer=0x139a440 for seat 0x14f8010
+ [06:12:41.261] Transmitter created keyboard=0x14f8160 for seat 0x14f8010
+ [06:12:41.261] Transmitter created touch=0x1508750 for seat 0x14f8010
+
+The connection is established, you can see following debug messages:
+
+ root@gr-mrb-64:~# debug: wth_connection_insert_new_object: new object id: 1
+ debug: wth_connection_insert_new_object: new object id: 2
+ 2017-07-19T06:14:31Z 00001000030000000100000002000000 wth_display_get_registry
+ debug: wth_connection_insert_new_object: new object id: 3
+ 2017-07-19T06:14:31Z 00001000020000000100000003000000 wth_display_sync
+ debug: Message received on conn 0x1560340: (9) 40 bytes
+ debug: wthp_registry_send_global(2, 1, [variable type const char *], 4) (opcode 9) called.
+ debug: wth_connection_insert_new_object: new object id: 4
+ 2017-07-19T06:14:31Z 00002c000800000002000000010000000400000010000000777468705f636f6d706f7369746f720001000000 wthp_registry_bind
+ debug: Message received on conn 0x1560340: (9) 44 bytes
+ debug: wthp_registry_send_global(2, 1, [variable type const char *], 4) (opcode 9) called.
+ debug: wth_connection_insert_new_object: new object id: 5
+ 2017-07-19T06:14:31Z 000030000800000002000000010000000500000012000000777468705f626c6f625f666163746f72790001000000 wthp_registry_bind
+ debug: Message received on conn 0x1560340: (9) 48 bytes
+ debug: wthp_registry_send_global(2, 1, [variable type const char *], 1) (opcode 9) called.
+ debug: wth_connection_insert_new_object: new object id: 6
+ 2017-07-19T06:14:31Z 000034000800000002000000010000000600000015000000777468705f6976695f6170706c69636174696f6e0001000000 wthp_registry_bind
+ debug: Message received on conn 0x1560340: (11) 16 bytes
+ debug: wthp_callback_send_done(3, 0) (opcode 11) called.
+ sending wth_display.sync...
+ debug: wth_connection_insert_new_object: new object id: 7
+ 2017-07-19T06:14:31Z 00001000020000000100000007000000 wth_display_sync
+ debug: Message received on conn 0x1560340: (11) 16 bytes
+ debug: wthp_callback_send_done(7, 0) (opcode 11) called.
+ ...sync done.
+
+Start remoting :
 - Start an IVI application.
-- Move pointer onto the application window.
-- Press Mod+Shift+space, and then 'k'.
-- The window should disappear.
+- Put surface on backend output
+- Put surface on transmitter output
 
 Weston log will indicate remoting has started:
 
@@ -48,6 +87,3 @@ Weston log will indicate remoting has started:
 [13:18:24.572] transmitter_surface_set_ivi_id(0x1c3dad0, 0x9ff6)
 [13:18:24.972] Transmitter: surface 0x1c3dad0 entered output transmitter-0.0.0.0:66-1
 
-Once remoting has started, the mockup code will generate fake pointer input for
-the window. This can be seen with e.g. weston-eventdemo, or running an
-application with WAYLAND_DEBUG=client.
diff --git a/transmitter/input.c b/transmitter/input.c
index 0ba04d4..eeb7452 100644
--- a/transmitter/input.c
+++ b/transmitter/input.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016 DENSO CORPORATION
+ * Copyright (C) 2017 Advanced Driver Information Technology GmbH, Advanced Driver Information Technology Corporation, Robert Bosch GmbH, Robert Bosch Car Multimedia GmbH, DENSO Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -129,6 +130,79 @@ static const struct weston_pointer_grab_interface pointer_grab_impl = {
        pointer_cancel_grab_handler,
 };
 
+static void
+keyboard_grab_key(struct weston_keyboard_grab *grab,
+                 uint32_t time,
+                 uint32_t key,
+                 uint32_t state)
+{
+}
+
+static void
+keyboard_grab_modifiers(struct weston_keyboard_grab *grab,
+                       uint32_t serial,
+                       uint32_t mods_depressed,
+                       uint32_t mods_latched,
+                       uint32_t mods_locked,
+                       uint32_t group)
+{
+}
+
+static void
+keyboard_grab_cancel(struct weston_keyboard_grab *grab)
+{
+}
+
+static const struct weston_keyboard_grab_interface keyborad_grab_impl = {
+       keyboard_grab_key,
+       keyboard_grab_modifiers,
+       keyboard_grab_cancel
+};
+
+static void
+touch_grab_down_handler(struct weston_touch_grab *grab,
+                       uint32_t time,
+                       int touch_id,
+                       wl_fixed_t x,
+                       wl_fixed_t y)
+{
+}
+
+static void
+touch_grab_up_handler(struct weston_touch_grab *grab,
+                     uint32_t time,
+                     int touch_id)
+{
+}
+
+static void
+touch_grab_motion_handler(struct weston_touch_grab *grab,
+                         uint32_t time,
+                         int touch_id,
+                         wl_fixed_t x,
+                         wl_fixed_t y)
+{
+}
+
+static void
+touch_grab_frame_handler(struct weston_touch_grab *grab)
+{
+}
+
+static void
+touch_grab_cancel_handler(struct weston_touch_grab *grab)
+{
+}
+
+static const struct weston_touch_grab_interface touch_grab_impl = {
+       touch_grab_down_handler,
+       touch_grab_up_handler,
+       touch_grab_motion_handler,
+       touch_grab_frame_handler,
+       touch_grab_cancel_handler,
+};
+
+
 /* The different ways to get pointer focus on a remoted surface:
  *
  * 1. Transmitter seat has pointer. The client has wl_pointer. Transmitter
@@ -207,7 +281,7 @@ seat_get_pointer_handler(struct wl_listener *listener, void *data)
        if (wl_resource_get_client(surface) != client)
                return;
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
        assert(pointer); /* guaranteed by having pointer_focus */
        pointer_client = weston_pointer_get_pointer_client(pointer, client);
 
@@ -235,13 +309,9 @@ transmitter_seat_create_pointer(struct weston_transmitter_seat *seat)
        seat->pointer_focus = NULL;
        wl_list_init(&seat->pointer_focus_destroy_listener.link);
 
-       weston_seat_init_pointer(&seat->base);
-
-       seat->get_pointer_listener.notify = seat_get_pointer_handler;
-       wl_signal_add(&seat->base.get_pointer_signal,
-                     &seat->get_pointer_listener);
+       weston_seat_init_pointer(seat->base);
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
 
        /* not exported:
         * weston_pointer_set_default_grab(pointer, &pointer_grab_impl); */
@@ -252,7 +322,7 @@ transmitter_seat_create_pointer(struct weston_transmitter_seat *seat)
        wl_list_init(&pointer->output_destroy_listener.link);
 
        weston_log("Transmitter created pointer=%p for seat %p\n",
-                  pointer, &seat->base);
+                  pointer, seat->base);
 }
 
 static void
@@ -279,7 +349,7 @@ transmitter_seat_pointer_enter(struct weston_transmitter_seat *seat,
        struct wl_list *focus_resource_list;
        struct wl_resource *resource;
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
        assert(pointer);
 
        assert(txs->surface);
@@ -299,8 +369,6 @@ transmitter_seat_pointer_enter(struct weston_transmitter_seat *seat,
        seat->pointer_surface_x = surface_x;
        seat->pointer_surface_y = surface_y;
 
-       pointer->focus_client = weston_pointer_get_pointer_client(pointer,
-                                                                 client);
        pointer->focus_serial = serial;
 
        /* pointer->focus is not used, because it is a weston_view, while
@@ -347,7 +415,7 @@ transmitter_seat_pointer_leave(struct weston_transmitter_seat *seat,
        assert(txs->surface);
        surface_resource = txs->surface->resource;
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
        assert(pointer);
        if (!pointer->focus_client)
                return;
@@ -373,7 +441,7 @@ transmitter_seat_pointer_motion(struct weston_transmitter_seat *seat,
        struct wl_resource *resource;
        struct weston_transmitter_surface *txs;
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
        assert(pointer);
 
        seat->pointer_surface_x = surface_x;
@@ -401,7 +469,27 @@ transmitter_seat_pointer_button(struct weston_transmitter_seat *seat,
                                uint32_t button,
                                uint32_t state)
 {
-       assert(!"TODO");
+       struct weston_pointer *pointer;
+       struct wl_list *focus_resource_list;
+       struct wl_resource *resource;
+       struct weston_transmitter_surface *txs;
+
+       pointer = weston_seat_get_pointer(seat->base);
+       assert(pointer);
+
+       if (!pointer->focus_client)
+               return;
+
+       txs = seat->pointer_focus;
+       if (txs)
+               assert(wl_resource_get_client(txs->surface->resource) ==
+                      pointer->focus_client->client);
+
+       focus_resource_list = &pointer->focus_client->pointer_resources;
+       wl_resource_for_each(resource, focus_resource_list) {
+               wl_pointer_send_button(resource, serial, time,
+                                      button, state);
+        }
 }
 
 void
@@ -410,7 +498,27 @@ transmitter_seat_pointer_axis(struct weston_transmitter_seat *seat,
                              uint32_t axis,
                              wl_fixed_t value)
 {
-       assert(!"TODO");
+       struct weston_pointer *pointer;
+       struct wl_list *focus_resource_list;
+       struct wl_resource *resource;
+       struct weston_transmitter_surface *txs;
+
+       pointer = weston_seat_get_pointer(seat->base);
+       assert(pointer);
+
+       if (!pointer->focus_client)
+               return;
+
+       txs = seat->pointer_focus;
+       if (txs)
+               assert(wl_resource_get_client(txs->surface->resource) ==
+                      pointer->focus_client->client);
+
+       focus_resource_list = &pointer->focus_client->pointer_resources;
+       wl_resource_for_each(resource, focus_resource_list) {
+               wl_pointer_send_axis(resource, time,
+                                    axis, value);
+       }
 }
 
 void
@@ -418,7 +526,7 @@ transmitter_seat_pointer_frame(struct weston_transmitter_seat *seat)
 {
        struct weston_pointer *pointer;
 
-       pointer = weston_seat_get_pointer(&seat->base);
+       pointer = weston_seat_get_pointer(seat->base);
        if (pointer)
                weston_pointer_send_frame(pointer);
 }
@@ -427,7 +535,7 @@ void
 transmitter_seat_pointer_axis_source(struct weston_transmitter_seat *seat,
                                     uint32_t axis_source)
 {
-       assert(!"TODO");
+       /* ToDo : implement axis event handling */
 }
 
 void
@@ -435,7 +543,7 @@ transmitter_seat_pointer_axis_stop(struct weston_transmitter_seat *seat,
                                   uint32_t time,
                                   uint32_t axis)
 {
-       assert(!"TODO");
+       /* ToDo : implement axis event handling */
 }
 
 void
@@ -443,7 +551,222 @@ transmitter_seat_pointer_axis_discrete(struct weston_transmitter_seat *seat,
                                       uint32_t axis,
                                       int32_t discrete)
 {
-       assert(!"TODO");
+       /* ToDo : implement axis event handling */
+}
+
+static void
+transmitter_seat_create_keyboard(struct weston_transmitter_seat *seat)
+{
+       struct weston_keyboard *keyboard;
+
+       seat->keyboard_focus = NULL;
+       weston_seat_init_keyboard(seat->base, NULL);
+
+       keyboard = weston_seat_get_keyboard(seat->base);
+
+       keyboard->default_grab.interface = &keyborad_grab_impl;
+
+       weston_log("Transmitter created keyboard=%p for seat %p\n",
+                  keyboard, seat->base);
+}
+
+static void
+transmitter_seat_keyboard_enter(struct weston_transmitter_seat *seat,
+                               uint32_t serial,
+                               struct weston_transmitter_surface *txs,
+                               struct wl_array *keys)
+{
+       struct weston_keyboard *keyboard;
+       struct wl_resource *resource = NULL;
+       struct wl_resource *surface_resource;
+
+       keyboard = weston_seat_get_keyboard(seat->base);
+       assert(keyboard);
+
+       assert(txs->surface);
+       surface_resource = txs->surface->resource;
+
+       seat->keyboard_focus = txs;
+       wl_array_copy(&keyboard->keys, keys);
+
+       wl_resource_for_each(resource, &keyboard->resource_list) {
+               if (wl_resource_get_client(resource) == wl_resource_get_client(surface_resource)) {
+                       wl_keyboard_send_enter(resource,
+                                              serial,
+                                              surface_resource,
+                                              &keyboard->keys);
+               }
+       }
+}
+
+static void
+transmitter_seat_keyboard_leave(struct weston_transmitter_seat *seat,
+                               uint32_t serial,
+                               struct weston_transmitter_surface *txs)
+{
+       struct weston_keyboard *keyboard;
+       struct wl_resource *resource = NULL;
+       struct wl_resource *surface_resource;
+
+       keyboard = weston_seat_get_keyboard(seat->base);
+       assert(keyboard);
+
+       assert(txs->surface);
+       surface_resource = txs->surface->resource;
+
+       wl_resource_for_each(resource, &keyboard->resource_list) {
+               if (wl_resource_get_client(resource) == wl_resource_get_client(surface_resource)) {
+                       wl_keyboard_send_leave(resource,
+                                              serial,
+                                              surface_resource);
+               }
+       }
+}
+
+static void
+transmitter_seat_keyboard_key(struct weston_transmitter_seat *seat,
+       uint32_t serial,
+       uint32_t time,
+       uint32_t key,
+       uint32_t state)
+{
+       struct weston_keyboard *keyboard;
+       struct wl_resource *resource = NULL;
+
+       keyboard = weston_seat_get_keyboard(seat->base);
+       assert(keyboard);
+
+       wl_resource_for_each(resource, &keyboard->resource_list) {
+               if (wl_resource_get_client(resource) ==
+                   wl_resource_get_client(seat->keyboard_focus->surface->resource)) {
+                       wl_keyboard_send_key(resource,
+                                            serial,
+                                            time,
+                                            key,
+                                            state);
+               }
+       }
+}
+
+static void
+transmitter_seat_create_touch(struct weston_transmitter_seat *seat)
+{
+       struct weston_touch *touch;
+
+       seat->touch_focus = NULL;
+       weston_seat_init_touch(seat->base);
+
+       touch = weston_seat_get_touch(seat->base);
+
+       touch->default_grab.interface = &touch_grab_impl;
+
+       weston_log("Transmitter created touch=%p for seat %p\n",
+                  touch, seat->base);
+}
+
+static void
+transmitter_seat_touch_down (struct weston_transmitter_seat *seat,
+                            uint32_t serial,
+                            uint32_t time,
+                            struct weston_transmitter_surface *txs,
+                            int32_t touch_id,
+                            wl_fixed_t x,
+                            wl_fixed_t y)
+{
+       struct weston_touch *touch;
+       struct wl_resource *resource = NULL;
+       struct wl_resource *surface_resource;
+
+       touch = weston_seat_get_touch(seat->base);
+       assert(touch);
+
+       assert(txs->surface);
+       surface_resource = txs->surface->resource;
+
+       seat->touch_focus = txs;
+
+       wl_resource_for_each(resource, &touch->resource_list) {
+               if (wl_resource_get_client(resource) == wl_resource_get_client(surface_resource)) {
+                       wl_touch_send_down(resource, serial, time,
+                                          surface_resource,
+                                          touch_id, x, y);
+               }
+       }
+}
+
+static void
+transmitter_seat_touch_up (struct weston_transmitter_seat *seat,
+                          uint32_t serial,
+                          uint32_t time,
+                          int32_t touch_id)
+{
+       struct weston_touch *touch;
+       struct wl_resource *resource = NULL;
+
+       touch = weston_seat_get_touch(seat->base);
+       assert(touch);
+
+       wl_resource_for_each(resource, &touch->resource_list) {
+               if (wl_resource_get_client(resource) ==
+                   wl_resource_get_client(seat->touch_focus->surface->resource)) {
+                       wl_touch_send_up(resource, serial, time, touch_id);
+               }
+       }
+}
+
+static void
+transmitter_seat_touch_motion (struct weston_transmitter_seat *seat,
+                              uint32_t time,
+                              int32_t touch_id,
+                              wl_fixed_t x,
+                              wl_fixed_t y)
+{
+       struct weston_touch *touch;
+       struct wl_resource *resource = NULL;
+
+       touch = weston_seat_get_touch(seat->base);
+       assert(touch);
+
+       wl_resource_for_each(resource, &touch->resource_list) {
+               if (wl_resource_get_client(resource) ==
+                   wl_resource_get_client(seat->touch_focus->surface->resource)) {
+                       wl_touch_send_motion(resource, time, touch_id, x, y);
+               }
+       }
+}
+
+static void
+transmitter_seat_touch_frame (struct weston_transmitter_seat *seat)
+{
+       struct weston_touch *touch;
+       struct wl_resource *resource = NULL;
+
+       touch = weston_seat_get_touch(seat->base);
+       assert(touch);
+
+       wl_resource_for_each(resource, &touch->resource_list) {
+               if (wl_resource_get_client(resource) ==
+                   wl_resource_get_client(seat->touch_focus->surface->resource)) {
+                       wl_touch_send_frame(resource);
+               }
+       }
+}
+
+static void
+transmitter_seat_touch_cancel (struct weston_transmitter_seat *seat)
+{
+       struct weston_touch *touch;
+       struct wl_resource *resource = NULL;
+
+       touch = weston_seat_get_touch(seat->base);
+       assert(touch);
+
+       wl_resource_for_each(resource, &touch->resource_list) {
+               if (wl_resource_get_client(resource) ==
+                   wl_resource_get_client(seat->touch_focus->surface->resource)) {
+                       wl_touch_send_cancel(resource);
+               }
+       }
 }
 
 static char *
@@ -462,9 +785,7 @@ transmitter_seat_destroy(struct weston_transmitter_seat *seat)
 {
        wl_list_remove(&seat->link);
 
-       weston_log("Transmitter destroy seat=%p\n", &seat->base);
-
-       weston_seat_release(&seat->base);
+       weston_log("Transmitter destroy seat=%p\n", seat->base);
 
        wl_list_remove(&seat->get_pointer_listener.link);
        wl_list_remove(&seat->pointer_focus_destroy_listener.link);
@@ -475,11 +796,406 @@ transmitter_seat_destroy(struct weston_transmitter_seat *seat)
        free(seat);
 }
 
+static void
+pointer_handle_enter(struct wthp_pointer *wthp_pointer,
+                    uint32_t serial,
+                    struct wthp_surface *surface,
+                    wth_fixed_t surface_x,
+                    wth_fixed_t surface_y)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_pointer);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+       struct weston_transmitter_surface *txs;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               if (txs->wthp_surf == surface) {
+                       if (txs != seat->pointer_focus)
+                               transmitter_seat_pointer_leave(seat, serial, seat->pointer_focus);
+                       transmitter_seat_pointer_enter(seat, serial, txs,
+                                                      surface_x, surface_y);
+               }
+       }
+}
+
+static void
+pointer_handle_leave(struct wthp_pointer *wthp_pointer,
+                    uint32_t serial,
+                    struct wthp_surface *surface)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_pointer);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+       struct weston_transmitter_surface *txs;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               if (txs->wthp_surf == surface) {
+                       transmitter_seat_pointer_leave(seat, serial, txs);
+               }
+       }
+}
+
+static void
+pointer_handle_motion(struct wthp_pointer *wthp_pointer,
+                     uint32_t time,
+                     wth_fixed_t surface_x,
+                     wth_fixed_t surface_y)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_pointer);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_pointer_motion(seat, time,
+                                       surface_x,
+                                       surface_y);
+}
+
+static void
+pointer_handle_button(struct wthp_pointer *wthp_pointer,
+                     uint32_t serial,
+                     uint32_t time,
+                     uint32_t button,
+                     uint32_t state)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_pointer);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_pointer_button(seat, serial,
+                                       time, button,
+                                       state);
+}
+
+static void
+pointer_handle_axis(struct wthp_pointer *wthp_pointer,
+                   uint32_t time,
+                   uint32_t axis, wth_fixed_t value)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_pointer);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_pointer_axis(seat, time,
+                                     axis, value);
+}
+
+static void
+pointer_handle_frame(struct wthp_pointer *wthp_pointer)
+{
+       /* ToDo : implement pointer handle frame */
+}
+
+static void
+pointer_handle_axis_source(struct wthp_pointer *wthp_pointer,
+                          uint32_t axis_source)
+{
+       /* ToDo : implement pointer handle axis source */
+}
+
+static void
+pointer_handle_axis_stop(struct wthp_pointer *wthp_pointer,
+                        uint32_t time,
+                        uint32_t axis)
+{
+       /* ToDo : implement pointer handle axis stop */
+}
+
+static void
+pointer_handle_axis_discrete(struct wthp_pointer *wthp_pointer,
+                            uint32_t axis,
+                            int32_t discrete)
+{
+       /* ToDo : implement pointer handle axis discrete */
+}
+
+static const struct wthp_pointer_listener pointer_listener = {
+       pointer_handle_enter,
+       pointer_handle_leave,
+       pointer_handle_motion,
+       pointer_handle_button,
+       pointer_handle_axis,
+       pointer_handle_frame,
+       pointer_handle_axis_source,
+       pointer_handle_axis_stop,
+       pointer_handle_axis_discrete
+};
+
+static void
+keyboard_handle_keymap(struct wthp_keyboard * wthp_keyboard,
+       uint32_t format,
+       uint32_t keymap_sz,
+       void * keymap)
+{
+       /* ToDo : implement keyboard handle keymap */
+}
+
+static void
+keyboard_handle_enter(struct wthp_keyboard *wthp_keyboard,
+       uint32_t serial,
+       struct wthp_surface *surface,
+       struct wth_array *keys)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_keyboard);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+       struct weston_transmitter_surface *txs;
+       struct wl_array *wl_key = (struct wl_array *)malloc(sizeof(struct wl_array));
+
+       wl_key->size = keys->size;
+       wl_key->alloc = keys->alloc;
+       wl_key->data = keys->data;
+       
+       seat = container_of(seat_list->next,
+       struct weston_transmitter_seat, link);
+
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               if (txs->wthp_surf == surface) {
+                       //transmitter_seat_keyboard_enter(seat, serial, txs, keys);
+                       transmitter_seat_keyboard_enter(seat, serial, txs, wl_key);
+               }
+       }
+       free(wl_key);
+}
+
+static void
+keyboard_handle_leave(struct wthp_keyboard *wthp_keyboard,
+       uint32_t serial,
+       struct wthp_surface *surface)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_keyboard);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+       struct weston_transmitter_surface *txs;
+
+       seat = container_of(seat_list->next,
+       struct weston_transmitter_seat, link);
+
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               if (txs->wthp_surf == surface) {
+                       transmitter_seat_keyboard_leave(seat, serial, txs);
+               }
+       }
+}
+
+static void
+keyboard_handle_key(struct wthp_keyboard *wthp_keyboard,
+       uint32_t serial,
+       uint32_t time,
+       uint32_t key,
+       uint32_t state)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_keyboard);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+       struct weston_transmitter_seat, link);
+
+       transmitter_seat_keyboard_key(seat, serial, time, key, state);
+}
+
+static void
+keyboard_handle_modifiers(struct wthp_keyboard *wthp_keyboard,
+       uint32_t serial,
+       uint32_t mods_depressed,
+       uint32_t mods_latched,
+       uint32_t mods_locked,
+       uint32_t group)
+{
+       weston_log("keyboard_handle_modifiers\n");
+}
+
+static void
+keyboard_handle_repeat_info(struct wthp_keyboard *wthp_keyboard,
+       int32_t rate,
+       int32_t delay)
+{
+       weston_log("keyboard_handle_repeat_info\n");
+}
+
+static const struct wthp_keyboard_listener keyboard_listener = {
+       keyboard_handle_keymap,
+       keyboard_handle_enter,
+       keyboard_handle_leave,
+       keyboard_handle_key,
+       keyboard_handle_modifiers,
+       keyboard_handle_repeat_info
+};
+
+static void
+touch_handle_down (struct wthp_touch * wthp_touch,
+                  uint32_t serial,
+                  uint32_t time,
+                  struct wthp_surface * surface,
+                  int32_t id,
+                  wth_fixed_t x,
+                  wth_fixed_t y)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_touch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+       struct weston_transmitter_surface *txs;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               if (txs->wthp_surf == surface) {
+                       transmitter_seat_touch_down(seat, serial, time,
+                                                   txs, id, x, y);
+               }
+       }
+}
+
+static void
+touch_handle_up (struct wthp_touch * wthp_touch,
+                uint32_t serial,
+                uint32_t time,
+                int32_t id)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_touch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_touch_up(seat, serial, time, id);
+}
+
+static void
+touch_handle_motion (struct wthp_touch * wthp_touch,
+                    uint32_t time,
+                    int32_t id,
+                    wth_fixed_t x,
+                    wth_fixed_t y)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_touch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_touch_motion(seat, time, id, x, y);
+}
+
+
+static void
+touch_handle_frame (struct wthp_touch * wthp_touch)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_touch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_touch_frame(seat);
+}
+
+static void
+touch_handle_cancel (struct wthp_touch * wthp_touch)
+{
+       struct waltham_display *dpy =
+               wth_object_get_user_data((struct wth_object *)wthp_touch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       struct wl_list *seat_list = &remote->seat_list;
+       struct weston_transmitter_seat *seat;
+
+       seat = container_of(seat_list->next,
+                           struct weston_transmitter_seat, link);
+
+       transmitter_seat_touch_cancel(seat);
+}
+
+
+static const struct wthp_touch_listener touch_listener = {
+       touch_handle_down,
+       touch_handle_up,
+       touch_handle_motion,
+       touch_handle_frame,
+       touch_handle_cancel
+};
+
+void
+seat_capabilities(struct wthp_seat *wthp_seat,
+                 enum wthp_seat_capability caps)
+{
+       struct waltham_display *dpy = wth_object_get_user_data((struct wth_object *)wthp_seat);
+
+       weston_log("seat_capabilities\n");
+
+       if ((caps & WTHP_SEAT_CAPABILITY_POINTER) && !dpy->pointer)
+       {
+               weston_log("WTHP_SEAT_CAPABILITY_POINTER\n");
+               dpy->pointer = wthp_seat_get_pointer(dpy->seat);
+               wthp_pointer_set_listener(dpy->pointer, &pointer_listener, dpy);
+       }
+       if ((caps & WTHP_SEAT_CAPABILITY_KEYBOARD) && !dpy->keyboard)
+       {
+               weston_log("WTHP_SEAT_CAPABILITY_KEYBOARD\n");
+               dpy->keyboard = wthp_seat_get_keyboard(dpy->seat);
+               wthp_keyboard_set_listener(dpy->keyboard, &keyboard_listener, dpy);
+       }
+       if ((caps & WTHP_SEAT_CAPABILITY_TOUCH) && !dpy->touch)
+       {
+               weston_log("WTHP_SEAT_CAPABILITY_TOUCH\n");
+               dpy->touch = wthp_seat_get_touch(dpy->seat);
+               wthp_touch_set_listener(dpy->touch, &touch_listener, dpy);
+       }
+}
+
 int
 transmitter_remote_create_seat(struct weston_transmitter_remote *remote)
 {
        struct weston_transmitter_seat *seat = NULL;
        char *name = NULL;
+       struct weston_seat *weston_seat = NULL;
 
        seat = zalloc(sizeof *seat);
        if (!seat)
@@ -493,6 +1209,24 @@ transmitter_remote_create_seat(struct weston_transmitter_remote *remote)
        if (!name)
                goto fail;
 
+
+       if (wl_list_empty(&remote->transmitter->compositor->seat_list)) {
+               weston_seat = zalloc(sizeof *weston_seat);
+               if (!weston_seat)
+                       goto fail;
+
+               weston_seat_init(weston_seat, remote->transmitter->compositor, name);
+               seat->base = weston_seat;
+               weston_log("Transmitter created seat=%p \n", &seat->base);
+       } else {
+               wl_list_for_each(weston_seat, &remote->transmitter->compositor->seat_list, link) {
+                       weston_log("Transmitter weston_seat %p\n", weston_seat);
+                       seat->base = weston_seat;
+               }
+       }
+
+       free(name);
+#if DEBUG
        weston_seat_init(&seat->base, remote->transmitter->compositor, name);
        free(name);
 
@@ -515,9 +1249,12 @@ transmitter_remote_create_seat(struct weston_transmitter_remote *remote)
 
        weston_log("Transmitter created seat=%p '%s'\n",
                   &seat->base, seat->base.seat_name);
+#endif
 
        /* XXX: mirror remote capabilities */
        transmitter_seat_create_pointer(seat);
+       transmitter_seat_create_keyboard(seat);
+       transmitter_seat_create_touch(seat);
 
        wl_list_insert(&remote->seat_list, &seat->link);
 
@@ -582,7 +1319,7 @@ transmitter_seat_fake_pointer_input(struct weston_transmitter_seat *seat,
 
        if (!seat->pointer_timer) {
                /* schedule timer for motion */
-               loop = wl_display_get_event_loop(seat->base.compositor->wl_display);
+               loop = wl_display_get_event_loop(seat->base->compositor->wl_display);
                seat->pointer_timer = wl_event_loop_add_timer(loop,
                                                fake_pointer_timer_handler, seat);
                wl_event_source_timer_update(seat->pointer_timer, 100);
diff --git a/transmitter/output.c b/transmitter/output.c
index 6a78721..a3f8ed1 100644
--- a/transmitter/output.c
+++ b/transmitter/output.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016 DENSO CORPORATION
+ * Copyright (C) 2017 Advanced Driver Information Technology GmbH, Advanced Driver Information Technology Corporation, Robert Bosch GmbH, Robert Bosch Car Multimedia GmbH, DENSO Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -73,7 +74,7 @@ make_model(struct weston_transmitter_remote *remote, int name)
 {
        char *str;
 
-       if (asprintf(&str, "transmitter-%s-%d", remote->addr, name) < 0)
+       if (asprintf(&str, "transmitter-%s:%s-%d", remote->addr, remote->port, name) < 0)
                return NULL;
 
        return str;
@@ -124,8 +125,6 @@ free_mode_list(struct wl_list *mode_list)
 void
 transmitter_output_destroy(struct weston_transmitter_output *output)
 {
-       weston_log("Transmitter destroying output '%s'\n", output->base.name);
-
        wl_list_remove(&output->link);
 
        free_mode_list(&output->base.mode_list);
@@ -145,46 +144,150 @@ transmitter_output_destroy_(struct weston_output *base)
        transmitter_output_destroy(output);
 }
 
+
 static void
 transmitter_start_repaint_loop(struct weston_output *base)
 {
-       weston_log("%s(%s)\n", __func__, base->name);
+       struct timespec ts;
+       struct weston_transmitter_output *output = to_transmitter_output(base);
+
+       weston_compositor_read_presentation_clock(output->base.compositor, &ts);
+       weston_output_finish_frame(&output->base, &ts, 0);
+}
+
+static int
+transmitter_check_output(struct weston_transmitter_surface *txs,
+                        struct weston_compositor *compositor)
+{
+       struct weston_output *def_output = container_of(compositor->output_list.next,
+                                                       struct weston_output, link);
+       struct weston_view *view;
+
+       wl_list_for_each_reverse(view, &compositor->view_list, link) {
+               if (view->output == def_output) {
+                       if (view->surface == txs->surface)
+                               return 1;
+               }
+       }
+
+       return 0;
 }
 
 static int
 transmitter_output_repaint(struct weston_output *base,
                           pixman_region32_t *damage)
 {
-       weston_log("%s(%s)\n", __func__, base->name);
+       struct weston_transmitter_output* output = to_transmitter_output(base);
+       struct weston_transmitter_remote* remote = output->remote;
+       struct weston_transmitter* txr = remote->transmitter;
+       struct weston_transmitter_api* transmitter_api = 
+               weston_get_transmitter_api(txr->compositor);
+       struct weston_transmitter_surface* txs;
+       struct weston_compositor *compositor = base->compositor;
+       struct weston_view *view;
+       bool found_output = false;
+
+       if (!output->from_frame_signal)
+               return 0;
+
+       output->from_frame_signal = false;
+
+       /* 
+        * Pick up weston_view in transmitter_output and check weston_view's surface
+        * If the surface hasn't been conbined to weston_transmitter_surface, 
+        * then call push_to_remote.
+        * If the surface has already been combined, call gather_state.
+        */
+       if (wl_list_empty(&compositor->view_list))
+               goto out;
+
+       wl_list_for_each_reverse(view, &compositor->view_list, link) {
+               bool found_surface = false;
+               if (view->output == &output->base) {
+                       found_output = true;
+                       wl_list_for_each(txs, &remote->surface_list, link) {
+                               if (txs->surface == view->surface) {
+                                       found_surface = true;
+                                       if (!transmitter_check_output(txs, compositor))
+                                               break;
+
+                                       if (!txs->wthp_surf)
+                                               transmitter_api->surface_push_to_remote
+                                                       (view->surface, remote, NULL);
+                                       transmitter_api->surface_gather_state(txs);
+                                       break;
+                               }
+                       }
+                       if (!found_surface)
+                               transmitter_api->surface_push_to_remote(view->surface, 
+                                                                       remote, NULL);
+               }
+       }
+       if (!found_output)
+               goto out;
 
-       return -1;
+       return 0;
+
+out:
+       transmitter_start_repaint_loop(base);
+
+       return 0;
+}
+
+static void
+transmitter_output_enable(struct weston_output *base)
+{
+       struct weston_transmitter_output *output = to_transmitter_output(base);
+
+       
+       output->base.assign_planes = NULL;
+       output->base.set_backlight = NULL;
+       output->base.set_dpms = NULL;
+       output->base.switch_mode = NULL;
+}
+
+static void
+transmitter_output_frame_handler(struct wl_listener *listener, void *data)
+{
+       struct weston_transmitter_output *output;
+       int ret;
+
+       output = container_of(listener, struct weston_transmitter_output,
+                             frame_listener);
+       output->from_frame_signal = true;
+
+       ret = transmitter_output_repaint(&output->base, NULL);
 }
 
 int
-transmitter_remote_create_output(
-       struct weston_transmitter_remote *remote,
-       const struct weston_transmitter_output_info *info)
+transmitter_remote_create_output(struct weston_transmitter_remote *remote,
+                                const struct weston_transmitter_output_info *info)
 {
        struct weston_transmitter_output *output;
+       struct weston_transmitter *txr = remote->transmitter;
+       struct weston_output *def_output;
 
        output = zalloc(sizeof *output);
        if (!output)
                return -1;
 
+       output->parent.draw_initial_frame = true;
+
        output->base.subpixel = info->subpixel;
 
        output->base.name = make_model(remote, 1);
        output->base.make = strdup(WESTON_TRANSMITTER_OUTPUT_MAKE);
        output->base.model = make_model(remote, 1);
        output->base.serial_number = strdup("0");
-
+       /* x and y is fake value */
        wl_list_init(&output->base.mode_list);
        if (make_mode_list(&output->base.mode_list, info) < 0)
                goto fail;
 
        output->base.current_mode = get_current_mode(&output->base.mode_list);
+       output->base.height = output->base.current_mode->height;
+       output->base.width = output->base.current_mode->width;
        /* WL_OUTPUT_MODE_CURRENT already set */
-
        weston_output_init(&output->base, remote->transmitter->compositor);
 
        /*
@@ -200,7 +303,7 @@ transmitter_remote_create_output(
         * for this output, since we must not involve input device management
         * or color management or any kind of local management.
         */
-
+       output->base.enable = transmitter_output_enable;
        output->base.start_repaint_loop = transmitter_start_repaint_loop;
        output->base.repaint = transmitter_output_repaint;
        output->base.destroy = transmitter_output_destroy_;
@@ -212,13 +315,19 @@ transmitter_remote_create_output(
 
        output->base.native_mode = output->base.current_mode;
        output->base.native_scale = output->base.current_scale;
+       output->base.scale = 1;
+       output->base.transform = WL_OUTPUT_TRANSFORM_NORMAL;
 
        output->remote = remote;
        wl_list_insert(&remote->output_list, &output->link);
 
-       weston_log("Transmitter created output '%s': %s, %s, %s\n",
-                  output->base.name, output->base.make, output->base.model,
-                  output->base.serial_number);
+       weston_output_enable(&output->base);
+
+       output->frame_listener.notify = transmitter_output_frame_handler;
+       def_output = container_of(txr->compositor->output_list.next,
+                                 struct weston_output, link);
+       wl_signal_add(&def_output->frame_signal, &output->frame_listener);
+       output->from_frame_signal = false;
 
        return 0;
 
diff --git a/transmitter/plugin.c b/transmitter/plugin.c
index c5e56d3..1ebd1ef 100644
--- a/transmitter/plugin.c
+++ b/transmitter/plugin.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016 DENSO CORPORATION
+ * Copyright (C) 2017 Advanced Driver Information Technology GmbH, Advanced Driver Information Technology Corporation, Robert Bosch GmbH, Robert Bosch Car Multimedia GmbH, DENSO Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -34,8 +35,23 @@
 #include "helpers.h"
 #include "timespec-util.h"
 
+#include "compositor/weston.h"
 #include "plugin.h"
 #include "transmitter_api.h"
+#include "plugin-registry.h"
+#include "ivi-shell/ivi-layout-export.h"
+
+/* waltham */
+#include <errno.h>
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <waltham-object.h>
+#include <waltham-client.h>
+#include <waltham-connection.h>
+
+#define MAX_EPOLL_WATCHES 2
+#define ESTABLISH_CONNECTION_PERIOD 2000
+#define RETRY_CONNECTION_PERIOD 5000
 
 /* XXX: all functions and variables with a name, and things marked with a
  * comment, containing the word "fake" are mockups that need to be
@@ -69,63 +85,6 @@ transmitter_surface_ivi_resize(struct weston_transmitter_surface *txs,
        txs->resize_handler(txs->resize_handler_data, width, height);
 }
 
-static int
-frame_callback_handler(void *data) /* fake */
-{
-       struct weston_transmitter_surface *txs = data;
-       struct weston_frame_callback *cb, *cnext;
-       struct weston_output *output;
-       struct weston_compositor *compositor;
-       uint32_t frame_time;
-       uint32_t presented_flags;
-       int32_t refresh_nsec;
-       struct timespec stamp;
-
-       compositor = txs->remote->transmitter->compositor;
-       output = txs->sync_output;
-
-       /* wl_surface.enter should arrive before any frame callbacks,
-        * but remote might send frame callbacks for non-visible too.
-        */
-       if (!output)
-               return 0;
-
-       /* XXX: eeeew */
-       frame_time = weston_compositor_get_time();
-
-       wl_list_for_each_safe(cb, cnext, &txs->frame_callback_list, link) {
-               wl_callback_send_done(cb->resource, frame_time);
-               wl_resource_destroy(cb->resource);
-       }
-
-       presented_flags = 0;
-       refresh_nsec = millihz_to_nsec(output->current_mode->refresh);
-       /* XXX: waaahhhahaa */
-       weston_compositor_read_presentation_clock(compositor, &stamp);
-       weston_presentation_feedback_present_list(&txs->feedback_list,
-                                                 output, refresh_nsec, &stamp,
-                                                 output->msc,
-                                                 presented_flags);
-
-       return 0;
-}
-
-static void
-fake_frame_callback(struct weston_transmitter_surface *txs)
-{
-       struct weston_transmitter *txr = txs->remote->transmitter;
-       struct wl_event_loop *loop;
-
-       if (!txs->frame_timer) {
-               loop = wl_display_get_event_loop(txr->compositor->wl_display);
-               txs->frame_timer =
-                       wl_event_loop_add_timer(loop,
-                                               frame_callback_handler, txs);
-       }
-
-       wl_event_source_timer_update(txs->frame_timer, 85);
-}
-
 static void
 transmitter_surface_configure(struct weston_transmitter_surface *txs,
                              int32_t dx, int32_t dy)
@@ -139,37 +98,75 @@ transmitter_surface_configure(struct weston_transmitter_surface *txs,
 }
 
 static void
-transmitter_surface_gather_state(struct weston_transmitter_surface *txs)
+buffer_send_complete(struct wthp_buffer *b, uint32_t serial)
 {
-       weston_log("Transmitter: update surface %p (%d, %d), %d cb\n",
-                  txs->surface, txs->attach_dx, txs->attach_dy,
-                  wl_list_length(&txs->surface->frame_callback_list));
-
-       wl_list_insert_list(&txs->frame_callback_list,
-                           &txs->surface->frame_callback_list);
-       wl_list_init(&txs->surface->frame_callback_list);
-
-       wl_list_insert_list(&txs->feedback_list, &txs->surface->feedback_list);
-       wl_list_init(&txs->surface->feedback_list);
-
-       /* TODO: transmit surface state to remote */
-
-       txs->attach_dx = 0;
-       txs->attach_dy = 0;
+       if (b)
+               wthp_buffer_destroy(b);
 }
 
-/** weston_surface apply state signal handler */
+static const struct wthp_buffer_listener buffer_listener = {
+       buffer_send_complete
+};
+
 static void
-transmitter_surface_apply_state(struct wl_listener *listener, void *data)
+transmitter_surface_gather_state(struct weston_transmitter_surface *txs)
 {
-       struct weston_transmitter_surface *txs =
-               container_of(listener, struct weston_transmitter_surface,
-                            apply_state_listener);
-
-       assert(data == NULL);
+       struct weston_transmitter_remote *remote = txs->remote;
+       struct waltham_display *dpy = remote->display;
 
-       transmitter_surface_gather_state(txs);
-       fake_frame_callback(txs);
+       if(!dpy->running) {
+               if(remote->status != WESTON_TRANSMITTER_CONNECTION_DISCONNECTED) {
+                       remote->status = WESTON_TRANSMITTER_CONNECTION_DISCONNECTED;
+                       wl_event_source_timer_update(remote->retry_timer, 1);
+               }
+       }
+       else {
+               /* TODO: transmit surface state to remote */
+               /* The buffer must be transmitted to remote side */
+               
+               /* waltham */
+               struct weston_surface *surf = txs->surface;
+               struct weston_compositor *comp = surf->compositor;
+               int32_t width = 100;
+               int32_t height = 100;
+               int32_t stride;
+               int ret = 0;
+               void *pixels;
+
+//             stride = surf->width * (PIXMAN_FORMAT_BPP(comp->read_format) / 8);
+               stride = width * (PIXMAN_FORMAT_BPP(comp->read_format) / 8);
+//             weston_log("width  %d\n", surf->width);
+//             weston_log("height %d\n", surf->height);
+//             weston_log("stride %d\n", stride);
+               pixels = malloc(stride * height);
+               
+               ret = weston_surface_copy_content(surf, pixels,
+                                                 (stride * height), 0, 0,
+                                                 width, height);
+               if(ret < 0)
+                       fprintf(stderr, "failed to get surface content\n");
+
+               /* fake sending buffer */
+               txs->wthp_buf = wthp_blob_factory_create_buffer(remote->display->blob_factory,
+                                                               (stride * height),
+                                                               pixels,
+                                                               width,
+                                                               height,
+                                                               stride,
+                                                               PIXMAN_FORMAT_BPP(comp->read_format));
+               
+               wthp_buffer_set_listener(txs->wthp_buf, &buffer_listener, txs);
+               
+               wthp_surface_attach(txs->wthp_surf, txs->wthp_buf, txs->attach_dx, txs->attach_dy);
+               //wthp_surface_damage(txs->wthp_surf, txs->attach_dx, txs->attach_dy, surf->width, surf->height);
+               wthp_surface_damage(txs->wthp_surf, txs->attach_dx, txs->attach_dy, width, height);
+               wthp_surface_commit(txs->wthp_surf);
+
+               wth_connection_flush(remote->display->connection);
+               
+               txs->attach_dx = 0;
+               txs->attach_dy = 0;
+       }
 }
 
 /** Mark the weston_transmitter_surface dead.
@@ -181,8 +178,7 @@ transmitter_surface_apply_state(struct wl_listener *listener, void *data)
 static void
 transmitter_surface_zombify(struct weston_transmitter_surface *txs)
 {
-       struct weston_frame_callback *framecb, *cnext;
-
+       struct weston_transmitter_remote *remote;
        /* may be called multiple times */
        if (!txs->surface)
                return;
@@ -190,20 +186,17 @@ transmitter_surface_zombify(struct weston_transmitter_surface *txs)
        wl_signal_emit(&txs->destroy_signal, txs);
 
        wl_list_remove(&txs->surface_destroy_listener.link);
-       weston_log("Transmitter unbound surface %p.\n", txs->surface);
        txs->surface = NULL;
 
        wl_list_remove(&txs->sync_output_destroy_listener.link);
-       wl_list_remove(&txs->apply_state_listener.link);
-
-       if (txs->map_timer)
-               wl_event_source_remove(txs->map_timer);
-       if (txs->frame_timer)
-               wl_event_source_remove(txs->frame_timer);
 
-       weston_presentation_feedback_discard_list(&txs->feedback_list);
-       wl_list_for_each_safe(framecb, cnext, &txs->frame_callback_list, link)
-               wl_resource_destroy(framecb->resource);
+       remote = txs->remote;
+       if (!remote->display->compositor)
+               weston_log("remote->compositor is NULL\n");
+       if (txs->wthp_surf)
+               wthp_surface_destroy(txs->wthp_surf);
+       if (txs->wthp_ivi_surface)
+               wthp_ivi_surface_destroy(txs->wthp_ivi_surface);
 
        /* In case called from destroy_transmitter() */
        txs->remote = NULL;
@@ -231,25 +224,6 @@ transmitter_surface_destroyed(struct wl_listener *listener, void *data)
        transmitter_surface_zombify(txs);
 }
 
-static struct weston_transmitter_surface *
-transmitter_surface_get(struct weston_surface *ws)
-{
-       struct wl_listener *listener;
-       struct weston_transmitter_surface *txs;
-
-       listener = wl_signal_get(&ws->destroy_signal,
-                                transmitter_surface_destroyed);
-
-       if (!listener)
-               return NULL;
-
-       txs = container_of(listener, struct weston_transmitter_surface,
-                          surface_destroy_listener);
-       assert(ws == txs->surface);
-
-       return txs;
-}
-
 static void
 sync_output_destroy_handler(struct wl_listener *listener, void *data)
 {
@@ -265,84 +239,48 @@ sync_output_destroy_handler(struct wl_listener *listener, void *data)
 }
 
 static void
-fake_input(struct weston_transmitter_surface *txs)
-{
-       struct wl_list *seat_list = &txs->remote->seat_list;
-       struct weston_transmitter_seat *seat;
-
-       assert(wl_list_length(seat_list) == 1);
-       seat = container_of(seat_list->next,
-                           struct weston_transmitter_seat, link);
-
-       transmitter_seat_fake_pointer_input(seat, txs);
-}
-
-/* fake receiving wl_surface.enter(output) */
-static int
-map_timer_handler(void *data)
-{
-       struct weston_transmitter_surface *txs = data;
-       struct weston_transmitter_output *output;
-
-       assert(!wl_list_empty(&txs->remote->output_list));
-
-       output = container_of(txs->remote->output_list.next,
-                             struct weston_transmitter_output, link);
-
-       txs->sync_output = &output->base;
-       txs->sync_output_destroy_listener.notify = sync_output_destroy_handler;
-       wl_list_remove(&txs->sync_output_destroy_listener.link);
-       wl_signal_add(&txs->sync_output->destroy_signal,
-                     &txs->sync_output_destroy_listener);
-
-       weston_surface_force_output(txs->surface, txs->sync_output);
-
-       weston_log("Transmitter: surface %p entered output %s\n",
-                  txs->surface, txs->sync_output->name);
-
-       fake_frame_callback(txs);
-       fake_input(txs);
-
-       return 0;
-}
-
-/* Fake a delay for the remote end to map the surface to an output */
-static void
-fake_output_mapping(struct weston_transmitter_surface *txs)
-{
-       struct weston_transmitter *txr = txs->remote->transmitter;
-       struct wl_event_loop *loop;
-
-       loop = wl_display_get_event_loop(txr->compositor->wl_display);
-       txs->map_timer = wl_event_loop_add_timer(loop, map_timer_handler, txs);
-       wl_event_source_timer_update(txs->map_timer, 400);
-}
-
-/* Fake getting "connection established" from the content streamer. */
-static void
-fake_stream_opening_handler(void *data)
-{
-       struct weston_transmitter_surface *txs = data;
-
-       /* ...once the connection is up: */
-       txs->status = WESTON_TRANSMITTER_STREAM_LIVE;
-       wl_signal_emit(&txs->stream_status_signal, txs);
-
-       /* need to create the surface on the remote and set all state */
-       transmitter_surface_gather_state(txs);
-
-       fake_output_mapping(txs);
-}
-
-/* Fake a callback from content streamer. */
-static void
-fake_stream_opening(struct weston_transmitter_surface *txs)
+transmitter_surface_set_ivi_id(struct weston_transmitter_surface *txs)
 {
-       struct weston_transmitter *txr = txs->remote->transmitter;
-       struct wl_event_loop *loop;
-
-       loop = wl_display_get_event_loop(txr->compositor->wl_display);
-       wl_event_loop_add_idle(loop, fake_stream_opening_handler, txs);
+        struct weston_transmitter_remote *remote = txs->remote;
+       struct waltham_display *dpy = remote->display;
+       struct weston_surface *ws;
+       struct ivi_layout_surface **pp_surface = NULL;
+       struct ivi_layout_surface *ivi_surf = NULL;
+       int32_t surface_length = 0;
+       int32_t ret = 0;
+       int32_t i = 0;
+
+       ret = txs->lyt->get_surfaces(&surface_length, &pp_surface);
+       if(!ret)
+               weston_log("No ivi_surface\n");
+
+       ws = txs->surface;
+
+       for(i = 0; i < surface_length; i++) {
+               ivi_surf = pp_surface[i];
+               if (ivi_surf->surface == ws) {
+                       assert(txs->surface);
+                       if (!txs->surface)
+                               return;
+                       if(!dpy)
+                               weston_log("no content in waltham_display\n");
+                       if(!dpy->compositor)
+                               weston_log("no content in compositor object\n");
+                       if(!dpy->seat)
+                               weston_log("no content in seat object\n");
+                       if(!dpy->application)
+                               weston_log("no content in ivi-application object\n");
+                       
+                       txs->wthp_ivi_surface = wthp_ivi_application_surface_create
+                               (dpy->application, ivi_surf->id_surface,  txs->wthp_surf);
+                       weston_log("surface ID %d\n", ivi_surf->id_surface);
+                       if(!txs->wthp_ivi_surface){
+                               weston_log("Failed to create txs->ivi_surf\n");
+                       }
+               }
+       }
+       free(pp_surface);
+       pp_surface = NULL;
 }
 
 static struct weston_transmitter_surface *
@@ -350,39 +288,58 @@ transmitter_surface_push_to_remote(struct weston_surface *ws,
                                   struct weston_transmitter_remote *remote,
                                   struct wl_listener *stream_status)
 {
+       struct weston_transmitter *txr = remote->transmitter;
        struct weston_transmitter_surface *txs;
+       bool found = false;
 
-       if (transmitter_surface_get(ws)) {
-               weston_log("Transmitter: surface %p already bound.\n", ws);
+       if (remote->status != WESTON_TRANSMITTER_CONNECTION_READY)
+       {
                return NULL;
        }
 
-       txs = zalloc(sizeof (*txs));
-       if (!txs)
-               return NULL;
+       wl_list_for_each(txs, &remote->surface_list, link) {
+               if (txs->surface == ws) {
+                       found = true;
+                       break;
+               }
+       }
 
-       txs->remote = remote;
-       wl_signal_init(&txs->destroy_signal);
-       wl_list_insert(&remote->surface_list, &txs->link);
+       if (!found) {
+               txs = NULL;
+               txs = zalloc(sizeof (*txs));
+               if (!txs)
+                       return NULL;
 
-       txs->status = WESTON_TRANSMITTER_STREAM_INITIALIZING;
-       wl_signal_init(&txs->stream_status_signal);
-       wl_signal_add(&txs->stream_status_signal, stream_status);
+               txs->remote = remote;
+               wl_signal_init(&txs->destroy_signal);
+               wl_list_insert(&remote->surface_list, &txs->link);
 
-       txs->surface = ws;
-       txs->surface_destroy_listener.notify = transmitter_surface_destroyed;
-       wl_signal_add(&ws->destroy_signal, &txs->surface_destroy_listener);
+               txs->status = WESTON_TRANSMITTER_STREAM_INITIALIZING;
+               wl_signal_init(&txs->stream_status_signal);
+               if (stream_status)
+                       wl_signal_add(&txs->stream_status_signal, stream_status);
 
-       txs->apply_state_listener.notify = transmitter_surface_apply_state;
-       wl_signal_add(&ws->apply_state_signal, &txs->apply_state_listener);
+               txs->surface = ws;
+               txs->surface_destroy_listener.notify = transmitter_surface_destroyed;
+               wl_signal_add(&ws->destroy_signal, &txs->surface_destroy_listener);
 
-       wl_list_init(&txs->sync_output_destroy_listener.link);
+               wl_list_init(&txs->sync_output_destroy_listener.link);
 
-       wl_list_init(&txs->frame_callback_list);
-       wl_list_init(&txs->feedback_list);
+               wl_list_init(&txs->frame_callback_list);
+               wl_list_init(&txs->feedback_list);
+
+               txs->lyt = weston_plugin_api_get(txr->compositor, 
+                                                IVI_LAYOUT_API_NAME, sizeof(txs->lyt));
+       }
 
        /* TODO: create the content stream connection... */
-       fake_stream_opening(txs);
+       if (!remote->display->compositor)
+               weston_log("remote->compositor is NULL\n");
+       if (!txs->wthp_surf) {
+               weston_log("txs->wthp_surf is NULL\n");
+               txs->wthp_surf = wthp_compositor_create_surface(remote->display->compositor);
+               transmitter_surface_set_ivi_id(txs);
+       }
 
        return txs;
 }
@@ -393,17 +350,53 @@ transmitter_surface_get_stream_status(struct weston_transmitter_surface *txs)
        return txs->status;
 }
 
-static int
-conn_timer_handler(void *data) /* fake */
+/* waltham */
+/* The server advertises a global interface.
+ * We can store the ad for later and/or bind to it immediately
+ * if we want to.
+ * We also need to keep track of the globals we bind to, so that
+ * global_remove can be handled properly (not implemented).
+ */
+static void
+registry_handle_global(struct wthp_registry *registry,
+                      uint32_t name,
+                      const char *interface,
+                      uint32_t version)
 {
-       struct weston_transmitter_remote *remote = data;
+       struct waltham_display *dpy = wth_object_get_user_data((struct wth_object *)registry);
+       
+       if (strcmp(interface, "wthp_compositor") == 0) {
+               assert(!dpy->compositor); 
+               dpy->compositor = (struct wthp_compositor *)wthp_registry_bind(registry, name, interface, 1);
+               /* has no events to handle */
+       } else if (strcmp(interface, "wthp_blob_factory") == 0) {
+               assert(!dpy->blob_factory); 
+               dpy->blob_factory = (struct wthp_blob_factory *)wthp_registry_bind(registry, name, interface, 1);
+               /* has no events to handle */
+       } else if (strcmp(interface, "wthp_seat") == 0) {
+               assert(!dpy->seat); 
+               dpy->seat = (struct wthp_seat *)wthp_registry_bind(registry, name, interface, 1);
+               wthp_seat_set_listener(dpy->seat, &seat_listener, dpy);
+       } else if (strcmp(interface, "wthp_ivi_application") == 0) {
+               assert(!dpy->application);
+               dpy->application = (struct wthp_ivi_application *)wthp_registry_bind(registry, name, interface, 1);
+       }
+}
+
+/* notify connection ready */
+static void
+conn_ready_notify(struct wl_listener *l, void *data)
+{
+       struct weston_transmitter_remote *remote =
+         container_of(l, struct weston_transmitter_remote, 
+                      establish_listener);
        struct weston_transmitter_output_info info = {
                WL_OUTPUT_SUBPIXEL_NONE,
                WL_OUTPUT_TRANSFORM_NORMAL,
                1,
                0, 0,
                300, 200,
-               "fake",
+               strdup(remote->model),
                {
                        WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED,
                        800, 600,
@@ -411,52 +404,303 @@ conn_timer_handler(void *data) /* fake */
                        { NULL, NULL }
                }
        };
-
-       weston_log("Transmitter connected to %s.\n", remote->addr);
-       remote->status = WESTON_TRANSMITTER_CONNECTION_READY;
-       wl_signal_emit(&remote->connection_status_signal, remote);
-
-       wl_event_source_remove(remote->conn_timer);
-       remote->conn_timer = NULL;
-
+       if(remote->width != 0) {
+               if(remote->height != 0) {
+                       info.mode.width = remote->width;
+                       info.mode.height = remote->height;
+               }
+       }
        /* Outputs and seats are dynamic, do not guarantee they are all
         * present when signalling connection status.
         */
        transmitter_remote_create_output(remote, &info);
        transmitter_remote_create_seat(remote);
+}
+
+/* waltham */
+/* The server removed a global.
+ * We should destroy everything we created through that global,
+ * and destroy the objects we created by binding to it.
+ * The identification happens by global's name, so we need to keep
+ * track what names we bound.
+ * (not implemented)
+ */
+static void
+registry_handle_global_remove(struct wthp_registry *wthp_registry,
+                             uint32_t name)
+{
+       if (wthp_registry)
+               wthp_registry_free(wthp_registry);
+}
+
+static const struct wthp_registry_listener registry_listener = {
+       registry_handle_global,
+       registry_handle_global_remove
+};
+
+static void
+connection_handle_data(struct watch *w, uint32_t events)
+{
+       struct waltham_display *dpy = container_of(w, struct waltham_display, conn_watch);
+       struct weston_transmitter_remote *remote = dpy->remote;
+       int ret;
+
+
+       if (!dpy->running) {
+               weston_log("This server is not running yet. %s:%s\n", remote->addr, remote->port);
+               return;
+       }
+
+       if (events & EPOLLERR) {
+               weston_log("Connection errored out.\n");
+               dpy->running = false;
+
+               return;
+       }
+
+       if (events & EPOLLOUT) {
+               /* Flush out again. If the flush completes, stop
+                * polling for writable as everything has been written.
+                */
+               ret = wth_connection_flush(dpy->connection);
+       }
+
+       if (events & EPOLLIN) {
+               /* Do not ignore EPROTO */
+               ret = wth_connection_read(dpy->connection);
+               if (ret < 0) {
+                       weston_log("Connection read error %s:%s\n", remote->addr, remote->port);
+                       perror("Connection read error\n");
+                       dpy->running = false;
+                       perror("EPOLL_CTL_DEL\n");
+
+                       return;
+               }
+       }
+
+       if (events & EPOLLHUP) {
+               fprintf(stderr, "Connection hung up.\n");
+               dpy->running = false;
+
+               return;
+       }
+}
+
+static void
+waltham_mainloop(int fd, uint32_t mask, void *data)
+{
+       struct weston_transmitter_remote *remote = data;
+       struct watch *w;
+       int count;
+       int i;
+       int ret;
+       int running_display;
+       running_display = 0;
+
+       struct waltham_display *dpy = remote->display;
+       w = &dpy->conn_watch;
+       if (!dpy)
+               goto not_running;
+       
+       if (!dpy->connection)
+               goto not_running;
+       
+       if (!dpy->running)
+               goto not_running;
+       
+       running_display++;
+       /* Dispatch queued events. */
+       
+       ret = wth_connection_dispatch(dpy->connection);
+       if (ret < 0)
+               dpy->running = false;
+       if (!dpy->running)
+               goto not_running;
+
+       /* Run any application idle tasks at this point. */
+       /* (nothing to run so far) */
+       
+       /* Flush out buffered requests. If the Waltham socket is
+        * full, poll it for writable too, and continue flushing then.
+        */
+       ret = wth_connection_flush(dpy->connection);
+
+       if (0 < running_display) {
+               /* Waltham events only read in the callback, not dispatched,
+                * if the Waltham socket signalled readable. If it signalled
+                * writable, flush more. See connection_handle_data().
+                */
+               w->cb(w, mask);
+       }
+       wl_event_source_remove(remote->source);
+       remote->source = wl_event_loop_add_fd(remote->transmitter->loop,
+                                             remote->display->conn_watch.fd,
+                                             WL_EVENT_READABLE, 
+                                             waltham_mainloop, remote);
+
+not_running:
+       ;
+}
+
+/* A one-off asynchronous open-coded roundtrip handler. */
+static void
+bling_done(struct wthp_callback *cb, uint32_t arg)
+{
+       fprintf(stderr, "...sync done.\n");
+
+       wthp_callback_free(cb);
+}
+
+static const struct wthp_callback_listener bling_listener = {
+       bling_done
+};
+
+static int
+waltham_client_init(struct waltham_display *dpy)
+{
+       if (!dpy)
+               return -1;
+       /*
+        * get server_address from controller (adrress is set to weston.ini)
+        */
+       dpy->connection = wth_connect_to_server(dpy->remote->addr, dpy->remote->port);
+       if(!dpy->connection) {
+               return -2;
+       }
+       else {
+               dpy->remote->status = WESTON_TRANSMITTER_CONNECTION_READY;
+               wl_signal_emit(&dpy->remote->connection_status_signal, dpy->remote);
+       }
+
+       dpy->conn_watch.display = dpy;
+       dpy->conn_watch.cb = connection_handle_data;
+       dpy->conn_watch.fd = wth_connection_get_fd(dpy->connection);
+
+       dpy->display = wth_connection_get_display(dpy->connection);
+       /* wth_display_set_listener() is already done by waltham, as
+        * all the events are just control messaging.
+        */
+
+       /* Create a registry so that we will get advertisements of the
+        * interfaces implemented by the server.
+        */
+       dpy->registry = wth_display_get_registry(dpy->display);
+       wthp_registry_set_listener(dpy->registry, &registry_listener, dpy);
+
+       /* Roundtrip ensures all globals' ads have been received. */
+       if (wth_connection_roundtrip(dpy->connection) < 0) {
+               fprintf(stderr, "Roundtrip failed.\n");
+               return -1;
+       }
+
+       if (!dpy->compositor) {
+               fprintf(stderr, "Did not find wthp_compositor, quitting.\n");
+               return -1;
+       }
+
+       /* A one-off asynchronous roundtrip, just for fun. */
+       fprintf(stderr, "sending wth_display.sync...\n");
+       dpy->bling = wth_display_sync(dpy->display);
+       wthp_callback_set_listener(dpy->bling, &bling_listener, dpy);
+
+       dpy->running = true;
 
        return 0;
 }
 
-static struct weston_transmitter_remote *
-transmitter_connect_to_remote(struct weston_transmitter *txr,
-                             const char *addr,
-                             struct wl_listener *status)
+static int
+establish_timer_handler(void *data)
 {
-       struct weston_transmitter_remote *remote;
-       struct wl_event_loop *loop;
+       struct weston_transmitter_remote *remote = data;
+       int ret;
 
-       remote = zalloc(sizeof (*remote));
-       if (!remote)
-               return NULL;
+       ret = waltham_client_init(remote->display);
+       if(ret == -2) {
+               wl_event_source_timer_update(remote->establish_timer, 
+                                            ESTABLISH_CONNECTION_PERIOD);
+               return 0;
+       }
+       remote->status = WESTON_TRANSMITTER_CONNECTION_READY;
+       wl_signal_emit(&remote->connection_status_signal, remote);
+       return 0;
+}
 
-       remote->transmitter = txr;
-       wl_list_insert(&txr->remote_list, &remote->link);
-       remote->addr = strdup(addr);
-       remote->status = WESTON_TRANSMITTER_CONNECTION_INITIALIZING;
-       wl_signal_init(&remote->connection_status_signal);
-       wl_signal_add(&remote->connection_status_signal, status);
-       wl_list_init(&remote->output_list);
-       wl_list_init(&remote->surface_list);
-       wl_list_init(&remote->seat_list);
+static void
+init_globals(struct waltham_display *dpy)
+{
+       dpy->compositor = NULL;
+       dpy->blob_factory = NULL;
+       dpy->seat = NULL;
+       dpy->application = NULL;
+       dpy->pointer = NULL;
+       dpy->keyboard = NULL;
+       dpy->touch = NULL;
+}
+
+static void
+disconnect_surface(struct weston_transmitter_remote *remote)
+{
+       struct weston_transmitter_surface *txs;
+       wl_list_for_each(txs, &remote->surface_list, link)
+       {
+               free(txs->wthp_ivi_surface);
+               free(txs->wthp_surf);
+               txs->wthp_ivi_surface = NULL;
+               txs->wthp_surf = NULL;
+       }
+}
 
-       /* XXX: actually start connecting */
-       weston_log("Transmitter connecting to %s...\n", addr);
-       /* fake it with a one second timer */
-       loop = wl_display_get_event_loop(txr->compositor->wl_display);
-       remote->conn_timer = wl_event_loop_add_timer(loop, conn_timer_handler,
-                                                    remote);
-       wl_event_source_timer_update(remote->conn_timer, 1000);
+static int
+retry_timer_handler(void *data)
+{
+       struct weston_transmitter_remote *remote = data;
+       struct waltham_display *dpy = remote->display;
+
+       if(!dpy->running)
+       {
+               registry_handle_global_remove(dpy->registry, 1);
+               init_globals(dpy);
+               disconnect_surface(remote);
+               wl_event_source_timer_update(remote->establish_timer, 
+                                            ESTABLISH_CONNECTION_PERIOD);
+
+               return 0;
+       }
+       else
+               wl_event_source_timer_update(remote->retry_timer, 
+                                            RETRY_CONNECTION_PERIOD);
+       return 0;
+}
+
+static struct weston_transmitter_remote *
+transmitter_connect_to_remote(struct weston_transmitter *txr)
+{
+       struct weston_transmitter_remote *remote;
+       struct wl_event_loop *loop_est, *loop_retry;
+       int ret;
+       
+       wl_list_for_each_reverse(remote, &txr->remote_list, link) {
+               /* XXX: actually start connecting */
+               /* waltham */
+               remote->display = zalloc(sizeof *remote->display);
+               if (!remote->display)
+                       return NULL;
+               remote->display->remote = remote;
+               /* set connection establish timer */
+               loop_est = wl_display_get_event_loop(txr->compositor->wl_display);
+               remote->establish_timer = 
+                       wl_event_loop_add_timer(loop_est, establish_timer_handler, remote);
+               wl_event_source_timer_update(remote->establish_timer, 1);
+               /* set connection retry timer */
+               loop_retry = wl_display_get_event_loop(txr->compositor->wl_display);
+               remote->retry_timer = 
+                       wl_event_loop_add_timer(loop_retry, retry_timer_handler, remote);
+               if (ret < 0) {
+                       weston_log("Fatal: Transmitter waltham connecting failed.\n");
+                       return NULL;
+               }
+               wl_signal_emit(&remote->conn_establish_signal, NULL);
+       }
 
        return remote;
 }
@@ -481,10 +725,6 @@ transmitter_remote_destroy(struct weston_transmitter_remote *remote)
         * the desctruction order between the shell and Transmitter is
         * undefined.
         */
-       weston_log("Transmitter disconnecting from %s.\n", remote->addr);
-
-       if (remote->conn_timer)
-               wl_event_source_remove(remote->conn_timer);
 
        if (!wl_list_empty(&remote->surface_list))
                weston_log("Transmitter warning: surfaces remain in %s.\n",
@@ -502,6 +742,8 @@ transmitter_remote_destroy(struct weston_transmitter_remote *remote)
        free(remote->addr);
        wl_list_remove(&remote->link);
 
+       wl_event_source_remove(remote->source);
+
        free(remote);
 }
 
@@ -531,7 +773,6 @@ transmitter_compositor_destroyed(struct wl_listener *listener, void *data)
         */
        wl_list_remove(&txr->remote_list);
 
-       weston_log("Transmitter terminating.\n");
        free(txr);
 }
 
@@ -553,6 +794,19 @@ transmitter_get(struct weston_compositor *compositor)
        return txr;
 }
 
+static void
+transmitter_register_connection_status(struct weston_transmitter *txr,
+                                      struct wl_listener *connected_listener)
+{
+       wl_signal_add(&txr->connected_signal, connected_listener);
+}
+
+static struct weston_surface *
+transmitter_get_weston_surface(struct weston_transmitter_surface *txs)
+{
+       return txs->surface;
+}
+
 static const struct weston_transmitter_api transmitter_api_impl = {
        transmitter_get,
        transmitter_connect_to_remote,
@@ -562,20 +816,12 @@ static const struct weston_transmitter_api transmitter_api_impl = {
        transmitter_surface_get_stream_status,
        transmitter_surface_destroy,
        transmitter_surface_configure,
+       transmitter_surface_gather_state,
+       transmitter_register_connection_status,
+       transmitter_get_weston_surface,
 };
 
 static void
-transmitter_surface_set_ivi_id(struct weston_transmitter_surface *txs,
-                              uint32_t ivi_id)
-{
-       assert(txs->surface);
-       if (!txs->surface)
-               return;
-
-       weston_log("%s(%p, %#x)\n", __func__, txs->surface, ivi_id);
-}
-
-static void
 transmitter_surface_set_resize_callback(
        struct weston_transmitter_surface *txs,
        weston_transmitter_ivi_resize_handler_t cb,
@@ -586,10 +832,108 @@ transmitter_surface_set_resize_callback(
 }
 
 static const struct weston_transmitter_ivi_api transmitter_ivi_api_impl = {
-       transmitter_surface_set_ivi_id,
        transmitter_surface_set_resize_callback,
 };
 
+static int
+transmitter_create_remote(struct weston_transmitter *txr,
+                         const char *model,
+                         const char *addr,
+                         const char *port,
+                         const char *width,
+                         const char *height)
+{
+       struct weston_transmitter_remote *remote;
+
+       remote = zalloc(sizeof (*remote));
+       if (!remote)
+               return -1;
+
+       remote->transmitter = txr;
+       wl_list_insert(&txr->remote_list, &remote->link);
+       remote->model = strdup(model);
+       remote->addr = strdup(addr);
+       remote->port = strdup(port);
+       remote->width = atoi(width);
+       remote->height = atoi(height);
+       remote->status = WESTON_TRANSMITTER_CONNECTION_INITIALIZING;
+       wl_signal_init(&remote->connection_status_signal);
+       wl_list_init(&remote->output_list);
+       wl_list_init(&remote->surface_list);
+       wl_list_init(&remote->seat_list);
+       wl_signal_init(&remote->conn_establish_signal);
+       remote->establish_listener.notify = conn_ready_notify;
+       wl_signal_add(&remote->conn_establish_signal, &remote->establish_listener);
+
+       return 0;
+}
+
+static void
+transmitter_get_server_config(struct weston_transmitter *txr)
+{
+       struct weston_config *config = wet_get_config(txr->compositor);
+       struct weston_config_section *section;
+       const char *name = NULL;
+       char *model = NULL;
+       char *addr = NULL;
+       char *port = NULL;
+       char *width = '0';
+       char *height = '0';
+       int ret;
+
+       section = weston_config_get_section(config, "remote", NULL, NULL);
+
+       while (weston_config_next_section(config, &section, &name)) {
+               if (0 == strcmp(name, "remote-output")) {
+                       if (0 != weston_config_section_get_string(section, "output-name",
+                                                                 &model, 0))
+                               continue;
+
+                       if (0 != weston_config_section_get_string(section, "server-address",
+                                                                 &addr, 0))
+                               continue;
+
+                       if (0 != weston_config_section_get_string(section, "port",
+                                                                 &port, 0))
+                               continue;
+
+                       if (0 != weston_config_section_get_string(section, "width",
+                                                                 &width, 0))
+                               continue;
+
+                       if (0 != weston_config_section_get_string(section, "height",
+                                                                 &height, 0))
+                               continue;
+                       ret = transmitter_create_remote(txr, model, addr,
+                                                       port, width, height);
+                       if (ret < 0) {
+                               weston_log("Fatal: Transmitter create_remote failed.\n");
+                       }
+               }
+       }
+}
+
+static void
+transmitter_post_init(void *data)
+{
+       struct weston_transmitter *txr = data;
+       struct weston_transmitter_remote *remote;
+       
+       if (!txr) {
+               weston_log("Transmitter disabled\n");
+       } else {
+               transmitter_get_server_config(txr);
+               transmitter_connect_to_remote(txr);
+
+               wl_list_for_each(remote, &txr->remote_list, link) {
+                       remote->source = wl_event_loop_add_fd(txr->loop,
+                                                          remote->display->conn_watch.fd,
+                                                          WL_EVENT_READABLE, 
+                                                          waltham_mainloop, remote);
+               }
+       }
+}
+
 WL_EXPORT int
 wet_module_init(struct weston_compositor *compositor, int *argc, char *argv[])
 {
@@ -628,6 +972,9 @@ wet_module_init(struct weston_compositor *compositor, int *argc, char *argv[])
 
        weston_log("Transmitter initialized.\n");
 
+       txr->loop = wl_display_get_event_loop(compositor->wl_display);
+       wl_event_loop_add_idle(txr->loop, transmitter_post_init, txr);
+
        return 0;
 
 fail:
diff --git a/transmitter/plugin.h b/transmitter/plugin.h
index 710b543..48f49b8 100644
--- a/transmitter/plugin.h
+++ b/transmitter/plugin.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016 DENSO CORPORATION
+ * Copyright (C) 2017 Advanced Driver Information Technology GmbH, Advanced Driver Information Technology Corporation, Robert Bosch GmbH, Robert Bosch Car Multimedia GmbH, DENSO Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -32,33 +33,109 @@
  */
 
 #include <stdint.h>
+#include <wayland-client.h>
 
 #include "compositor.h"
 #include "transmitter_api.h"
+#include "ivi-shell/ivi-layout-export.h"
+
+#include <waltham-client.h>
+
+
+struct waltham_display;
+
+enum wthp_seat_capability {
+       /**
+        * the seat has pointer devices
+        */
+       WTHP_SEAT_CAPABILITY_POINTER = 1,
+       /**
+        * the seat has one or more keyboards
+        */
+       WTHP_SEAT_CAPABILITY_KEYBOARD = 2,
+       /**
+        * the seat has touch devices
+        */
+       WTHP_SEAT_CAPABILITY_TOUCH = 4,
+};
+
+/* epoll structure */
+struct watch { 
+       struct waltham_display *display;
+       int fd;
+       void (*cb)(struct watch *w, uint32_t events);
+};
+
+struct waltham_display {
+       struct wth_connection *connection;
+       struct watch conn_watch;
+       struct wth_display *display;
+
+       bool running;
+
+       struct wthp_registry *registry;
+
+       struct wthp_callback *bling;
+
+       struct wthp_compositor *compositor;
+       struct wthp_blob_factory *blob_factory;
+       struct wthp_seat *seat;
+       struct wthp_pointer *pointer;
+       struct wthp_keyboard *keyboard;
+       struct wthp_touch *touch;
+        struct wthp_ivi_application *application;
+       struct wtimer *fiddle_timer;
+
+       struct weston_transmitter_remote *remote;
+       char *addr;
+       char *port;
+};
+
+/* a timerfd based timer */
+struct wtimer {
+       struct watch watch;
+       void (*func)(struct wtimer *, void *);
+       void *data;
+};
 
 struct weston_transmitter {
        struct weston_compositor *compositor;
        struct wl_listener compositor_destroy_listener;
 
        struct wl_list remote_list; /* transmitter_remote::link */
+
+       struct wl_listener stream_listener;
+       struct wl_signal connected_signal;
+       struct wl_event_loop *loop;
 };
 
 struct weston_transmitter_remote {
        struct weston_transmitter *transmitter;
        struct wl_list link;
-
+       char *model;
        char *addr;
+       char *port;
+       int32_t width;
+       int32_t height;
 
        enum weston_transmitter_connection_status status;
        struct wl_signal connection_status_signal;
+        struct wl_signal conn_establish_signal;
 
        struct wl_list output_list; /* weston_transmitter_output::link */
        struct wl_list surface_list; /* weston_transmitter_surface::link */
        struct wl_list seat_list; /* weston_transmitter_seat::link */
 
-       struct wl_event_source *conn_timer; /* fake */
+        struct wl_listener establish_listener;
+
+        struct wl_event_source *establish_timer; /* for establish connection */
+       struct wl_event_source *retry_timer; /* for retry connection */
+
+       struct waltham_display *display; /* waltham */
+       struct wl_event_source *source;
 };
 
+
 struct weston_transmitter_surface {
        struct weston_transmitter_remote *remote;
        struct wl_list link; /* weston_transmitter_remote::surface_list */
@@ -69,7 +146,7 @@ struct weston_transmitter_surface {
 
        struct weston_surface *surface;
        struct wl_listener surface_destroy_listener;
-       struct wl_listener apply_state_listener;
+       const struct ivi_layout_interface *lyt;
 
        weston_transmitter_ivi_resize_handler_t resize_handler;
        void *resize_handler_data;
@@ -77,13 +154,17 @@ struct weston_transmitter_surface {
        struct weston_output *sync_output;
        struct wl_listener sync_output_destroy_listener;
 
-       struct wl_event_source *map_timer; /* fake */
-       struct wl_event_source *frame_timer; /* fake */
-
        int32_t attach_dx; /**< wl_surface.attach(buffer, dx, dy) */
        int32_t attach_dy; /**< wl_surface.attach(buffer, dx, dy) */
        struct wl_list frame_callback_list; /* weston_frame_callback::link */
        struct wl_list feedback_list; /* weston_presentation_feedback::link */
+
+       /* waltham */
+       struct wthp_surface *wthp_surf;
+       struct wthp_blob_factory *wthp_blob;
+       struct wthp_buffer *wthp_buf;
+        struct wthp_ivi_surface *wthp_ivi_surface;
+        struct wthp_ivi_application *wthp_ivi_application;
 };
 
 struct weston_transmitter_output_info {
@@ -103,12 +184,28 @@ struct weston_transmitter_output_info {
 struct weston_transmitter_output {
        struct weston_output base;
 
+       struct {
+               bool draw_initial_frame;
+               struct wl_surface *surface;
+               struct wl_output *output;
+               struct wl_display *display;
+               int configure_width, configure_height;
+               bool wait_for_configure;
+       } parent;
+
        struct weston_transmitter_remote *remote;
        struct wl_list link; /* weston_transmitter_remote::output_list */
+
+       struct frame *frame;
+
+       struct wl_callback *frame_cb;
+       struct wl_listener frame_listener;
+
+       bool from_frame_signal;
 };
 
 struct weston_transmitter_seat {
-       struct weston_seat base;
+       struct weston_seat *base;
        struct wl_list link;
 
        /* pointer */
@@ -124,8 +221,28 @@ struct weston_transmitter_seat {
        double pointer_phase; /* fake */
 
        /* keyboard */
+       struct weston_transmitter_surface *keyboard_focus;
 
        /* touch */
+       struct weston_transmitter_surface *touch_focus;
+};
+
+struct ivi_layout_surface {
+       struct wl_list link;    /* ivi_layout::surface_list */
+       struct wl_signal property_changed;
+       int32_t update_count;
+       uint32_t id_surface;
+
+       struct ivi_layout *layout;
+       struct weston_surface *surface;
+
+       struct ivi_layout_surface_properties prop;
+
+       struct {
+               struct ivi_layout_surface_properties prop;
+       } pending;
+
+       struct wl_list view_list;       /* ivi_layout_view::surf_link */
 };
 
 void
@@ -203,5 +320,14 @@ int
 transmitter_seat_fake_pointer_input(struct weston_transmitter_seat *seat,
                                    struct weston_transmitter_surface *txs);
 
+void
+seat_capabilities(struct wthp_seat *wthp_seat,
+                  enum wthp_seat_capability caps);
+
+static const struct wthp_seat_listener seat_listener = {
+       seat_capabilities,
+       NULL
+};
+
 
 #endif /* WESTON_TRANSMITTER_PLUGIN_H */
diff --git a/transmitter/transmitter_api.h b/transmitter/transmitter_api.h
index 95d82ec..b28f946 100644
--- a/transmitter/transmitter_api.h
+++ b/transmitter/transmitter_api.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2016 DENSO CORPORATION
+ * Copyright (C) 2017 Advanced Driver Information Technology GmbH, Advanced Driver Information Technology Corporation, Robert Bosch GmbH, Robert Bosch Car Multimedia GmbH, DENSO Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -90,7 +91,6 @@ struct weston_transmitter_api {
         * Connect to a remote server via Transmitter.
         *
         * \param txr The Transmitter context.
-        * \param addr Address of the remote server.
         * \param status Listener to inform of connection status changes.
         * \return A handle to the remote connection, or NULL on failure.
         *
@@ -102,12 +102,9 @@ struct weston_transmitter_api {
         * returned by this function. Use remote_get_status() to fetch the
         * current status.
         *
-        * The address argument is a string in the form "host:port".
         */
        struct weston_transmitter_remote *
-       (*connect_to_remote)(struct weston_transmitter *txr,
-                            const char *addr,
-                            struct wl_listener *status);
+       (*connect_to_remote)(struct weston_transmitter *txr);
 
        /**
         * Retrieve the connection status.
@@ -191,6 +188,25 @@ struct weston_transmitter_api {
        void
        (*surface_configure)(struct weston_transmitter_surface *txs,
                             int32_t dx, int32_t dy);
+
+       void
+       (*surface_gather_state)(struct weston_transmitter_surface *txs);
+
+       /** Notify that surface is connected to receiver
+        *
+        * \param txr The Transmitter context.
+        * \param connected_listener Listener for connected_signal.
+        */
+       void
+       (*register_connection_status)(struct weston_transmitter *txr,
+                                     struct wl_listener *connected_listener);
+
+       /** get weston_surface from weston_transmitter_surface
+        *
+        * \param txs The Transmitter surface.
+        */
+       struct weston_surface *
+       (*get_weston_surface)(struct weston_transmitter_surface *txs);
 };
 
 static inline const struct weston_transmitter_api *
diff --git a/transmitter/weston.ini.transmitter b/transmitter/weston.ini.transmitter
new file mode 100644
index 0000000..1aff0b2
--- /dev/null
+++ b/transmitter/weston.ini.transmitter
@@ -0,0 +1,21 @@
+[core]
+shell=ivi-shell.so
+modules=transmitter.so
+
+[ivi-shell]
+ivi-module=ivi-controller.so
+ivi-input-module=ivi-input-controller.so
+
+[remote-output]
+output-name=transmitter_1
+server-address=192.168.2.11
+port=34400
+width=1920
+height=1080
+
+[remote-output]
+output-name=transmitter_2
+server-address=192.168.2.12
+port=34400
+width=1920
+height=1080
-- 
2.7.4