LayerManagerService: Updating Release Notes

TcpIpcModule: updated to new IpcModule API, added notification support

Added support for creating and sending notifications.

Improved handling of incoming message data structure.

removed destroyMessage:
was only used for DBusIpcModule, but lifecycle of received messages
is now handled internally. The external call is not required any more.

DbusIpcModule: updated to new IpcModule API, added notification support

Send and Receive have been reimplemented to support asynchronous sending
and receiving of events. This enables the use of DBus signals as transport
for client notifications.

The implementation now features a DBus main loop based on DBusWatches,
select(), DBus filters and dbus_connection_dispatch().

Note: Layer- & SurfaceNotification messages are detected and the DBus
signal handlers are setup as required inside the DbusIpcModule.

removed destroyMessage:
was only used for DBusIpcModule, but lifecycle of received messages
is now handled internally. The external call is not required any more.

GenericCommunicator: added notification support

Updated to use new IpcModule API.

Manages internal list of registered notifications. This list is used
to remove notifications on client disconnect.

After processing an incoming command, the list of client notifications
is processed: each notification is created using the IpcModule and
sent to the appropriate list of clients.

removed destroyMessage:
was only used for DBusIpcModule, but lifecycle of received messages
is now handled internally. The external call is not required any more.

ilmClient: added internal thread, updated IpcModule API, updated tests

This patch adds an internal thread thread which implements a receive loop.
The internal thread is required to process any incoming notification event
independent of the current client state.

Inside the client API a list of callbacks is stored to support different
callbacks for different layer and surface notification.

The behavior of the API is unchanged, but additionally asynchronous callbacks
can be supported.

add notification tests:
tests all possible individual notification targets for layers
and surfaces and some combinations aswell.

remove destroyMessage:
was only used for DBusIpcModule, but lifecycle of received messages
is now handled internally. The external call is not required any more.

added thread for notification delivery:
the receive thread used to execute notification callbacks directly,
but this allowed a client to block the receive loop.
Now the receive thread adds all received notifications to a queue.
This queue is processed by the new notification thread, which
triggers the callbacks for incoming notifications.
if a client blocks the notification thread, it will only affect incoming
notifications, but the receive thread will continue working.
If the notification queue is full, the receive thread discards incoming
notifications.

IpcModuleLoader: updated IpcMpodule API to support client notifications

removed destroyMessage:
was only used for DBusIpcModule, but lifecycle of received messages
is now handled internally. The external call is not required any more.

LayerManagerCommands: enabled notifications for surface and layer property changes

Commands that change properties of layers or surfaces now add notifications
to the list of notifications.

LayerManagerService: added internal notification queue

The executor now has an interface to add client notifications.
This enables commands to trigger client notifications, if they
have changed a property of a graphical object.

LayerManagerControl: added watch layer/surface function

This feature allows watching all notifications sent for changes
of a layer or surface.
This basically enables monitoring the state changes of a layer or surface.

Additionally the ilmClient init and destroy was improved.

ilmClient: added notification API

added API functions for adding and removing notifications
for layers and surfaces.

Renderer: fixed issues detected by Coverity

LayerManagerService: Add signal SIGABRT to catch asserts

LayerManagerClient: Cleanup of Chromakey Implementation

- Removing do while loop in layerSetChromakey
- Removing do while loop in surfaceSetChromakey

ChromaKeyExample : Adapting to new shm protocol of wayland 0.95

- the shm interfaces has changed in wayland 0.95
- this patch correct the behaviour.

LayerManagerControl: added chromakey support

- set chromakey value for surface and layer
- disable chromakey for surface and layer

WLChromakeyExample:Fixed path of include header of ilm_client.h

Add test code of chromakey for layer to IlmCommandTest and GraphicalObjectTest

Add implementation of chromakey for layer to LayerManagerPlugin

GLESGraphicSystem:
-If chromakey for layer is enabled, creates temporary buffer and render surfaces to it.
-and then the buffer is texturized and composite.

Add implementation of chromakey for layer

LayerManagerClient:
-Add members into structure of ilmLayerProperties to get status of chromakey by ilm_getPropertiesOfLayer
-ilm_layerSetChromaKey and modification of ilm_getPropertiesOfLayer to get properties of chromakey

GenericCommunicator:
-Add SetLayerChromaKey and GetPropertiesOfLayer

LayerManagerCommands:
-Add LayerSetChromaKeyCommand

LayerManagerExamples: Add Example application for chromakey

LayerManagerClient: Add test code of chromakey to IlmCOmmandTest and GraphicalObjectTest

Add implmentation of chromakey for surface by shader program to LayerMangerPlugin

LayerManagerService:
-Add parameter of chromakey to ShaderProgram in order to set chromakey to shaders

X11GLESRenderer:
-renderer_frag_add_uchromakey. If chromakey and fragment color are same, the pixel is ignored.

GLESGraphicSystem:
-If chromakey is enabled, shader for chromakey is enabled.

Add implmentation of chromakey for surface

LayerManagerClient:
-Add members into structure of ilmSurfaceProperties to get status of chromakey by ilm_getPropertiesOfSurface
-ilm_surfaceSetChromaKey and Modification of ilm_getPropertiesOfSurface to get properties of chromakey

GenericCommunicator:
-Add SetSurfaceChromaKey and GetPropertiesOfSurface

LayerManagerService
-Add colorkey's methods and valiables to GraphicalObject

LayerManagerPlugins
-Add SurfaceSetChromakeyCommand

LayerManagerService: Updating release notes

ilmClient: fixed memory leak, error messages were not released

destroyMessage() was only called for messages, if typecheck for "Command"
was successful. If type was "Error", destroy was omitted.

This patch changes the behavior to release all received events.

IpcModule: Fix Memory Leak therefore introducing destroyMessage functionality

- This patch will fix a huge memory leak on both client
  and generic communicator
- This memory leak will not occur on all ipc module only if dbus is used.
- To guarantee that the ipc message is successfull destroyed
  destroyMessage functionality is added.

LayerManagerService: Updating Release Notes

X11WindowSystem: Slight changes in inheritance behaviour

- All WindowSystems which are derived from the X11WindowSystem
  can now overwrite the calculateSurfaceFps and calculateFps Method.

Log: Introducing diagnostic callback injection

- On the OEM side it is needed to introduce diagnostic callbacks
- Therefore it is possible to control the platform specific plugIn
  by message injection from the dlt-deamon
- Currently the functionality is complete working WITH_DLT=ON
  otherwise only the callback registration is working, but no
  callback will occur.

X11WindowSystem : Fixing wrong composition.

- If a running application will be destroyed or the window
  will be unmapped, there was an issue that the composition will
  display garbage at top of any surfaces.

- Due to the fact that enableRendering and disableRendering is introduced
  that issue is fixed.

WaylandBaseWindowSystem: fixing build issue.

Renderers: refactor recomposition methods

- Adds support in GraphicSystem for accepting a LayerList to
  render, instead of only one Layer.  This enables future
  optimizations that change the rendering order.
      eg. - reverse render order to utilize depth test culling
          - draw multiple layers/surfaces at once (multitexturing)

  also includes a 'clear' flag so the background clear can be
  optimized as well.
      eg. - no need to clear obscurred pixels

- Don't reset any damage flags until after rendering has taken
  place.  Detailed damage information could be useful to the
  GraphicSystem when it is rendering.  Wait until after
  recomposition, then clear all flags. Share the routine to
  clear damage flags in the BaseWindowSystem.

LayerManagerService : Adding Global Object search path during Plugin Load.

- extending the dlopen call by RTLD_GLOBAL, due to the fact that
  there is a bug in libwayland-server / client which is currently not
  working with only RTLD_NOW.

- this shoud have no side effects on other plugins.

WindowSystem : Updating WaylandBaseWindowSystem.

- Update WaylandBaseWindowSystem to support wayland version 0.95
- removing functions which not needed anymore.

Graphic: Changing Log and Startup behaviour to condition signaling.

- Condition signaling has to be merged with master to speed up
  layermanagement startup

RenderUtil: Activating Binary Shader support

LayerManagerCommands: Adding code to calculate surface target values

- If Source and Destination Region of a Layer / Surface has changed,
  the surface targetposition has to be calculated.

ViewportTransform : Calculation moved to surface object

- Due to this calculation the renderer does have to update
  these value every render loop.
- The target source and destination region, has only be calculated if
  the corresponding value have changed.
- ViewportTransform moved to LayerManagerService

LayerManagerControl: added input properties to "get surface <surfaceid>" and "get scene"

toolchain.cmake: Improve sample file to demonstrate cross compilation

This patch show the mandatory cmake variables to use when one need to cross compile LayerManager.
It also correct the type of other cmake variables.

X11WindowSystem: Remove EGL context switching

A lot of EGL context switching was going on always to support a rare
case of creating a custom shader in a different thread. Added a
spin-lock mechanism to counter the multi-threading problem. Now
context switch only happens when a shader is being created. This
gives a 2% performance improvements.

GLESGraphicsystem: Remove some redundant state changes

GLXApplicationExample: Demonstrate new IPC for Input Events

This patch show how to use the newly added IPC for the LM input framework.
It can serve as example for client applications.

Make InputManager.h installable

This patch ensure InputManager.h can be installed on a system. It removes dependencies toward config.h

Improve plugin search over specific filesystem type

"man readdir" explains that only few filesystem type support a good filling of  "struct dirent.d_type". (nfs does not for instance)
To be POSIX compliant, we should use stat() instead to look if a file is a regular file.

This patch update getSharedLibrariesFromDirectory() to use  stat() when necessary & follow symlinks until reaching the real target.

WaylandRenderer: Fixed broken build of Wayland Renderer

TcpIpcModule: fix signal handling

GenericCommunicator: refactored header file dependencies, logging

Add keyboard support to GLXApplicationExample

This patch adds keyboard support to the sample application GLXApplicationExample (Just print stuffs on std ouput when a key is pressed or released).
It can be used for input framework validation.

Add input event support for X11WindowSystem

This patch adds support for pointer & keyboard events to X11 window system.
It can serve as example to introduce input events support for other window system.

Note that MultiTouch is _not_ yet supported for the following reasons:
 1- I don't have any plateform runing a recent X11, which is needed for validation
 2- We would need to upgrade the whole X11WindowSystem to use XInput2, & I don't have the time for the moment
I've added comments in X11WindowSystem.cpp to indicate what has to be done. If someone wants to takeover this task .. ;)

Update layerManagerControl with new IPCs

Unit tests for new IPC

This patch adds unit tests for the new IPC introduced by the Input Event framework. DBUSCommunicatorTest & IlmCommandTest have been completed.

Add new ipc for Input Events management from client

This patch adds 3 new IPC :
 + SurfaceSetKeyboardFocusOn()
   -> Synchronous
   -> Set the keyboard focus on a particular surface
 + SurfaceGetKeyboardFocus()
   -> Synchronous
   -> Get the identifier of the surface which currently hold the keyboard focus
 +SurfaceUpdateInputEventAcceptanceOn()
   -> Asynchronous
   -> Indicate from which input devices type a surface can accept input events.

The patch also updates the IPC SurfaceGetProperties() so that it now returns the list of type of devices from which a surface can accept input events.

Modules changed are :
 + LayerManagerCommands : Add the 3 new commands
 + GenericCommunicator : Add support for the new commands
 + ilmClient : Make the new commands available for the clients

Add Unit Tests for InputManager

Add new input event framework

This patch adds the new input event framework to LayerManager:
 + InputManager : New class created to centralized all input management.
 + Irenderer: New method getInputManager() has been added. Will be used later on by LM commands to access to InputManager
 + BaseRenderer: Instanciate automatically the InputManager to be used by concrete renderer.
 + BaseWindowSystem: New attribute to hold a pointer to the InputManager. This pointer is filled at construct time. Concrete WindowSystems will receive the InputManager from their concrete renderer.
 + GraphicalSurface: DestToSourceCoordinates() now takes int instead of unsigned int as in/out coordinates. If the coordinates are outside the surface, negative values are returned.
 + Surface: New thread safe methods updateInputEventAcceptanceFrom() & isInputEventAcceptedFrom() to control which input events are accepted by the Surface

Remove cmake flag WITH_INPUT_EVENTS

Input events are now activated permanently to LayerManager. This won't add any rutime overhead with the new Input frameworkt as long as the methods report[Key/Pointer/Touch] events are not called. Thus, no impact for people that do not wan't to use input events.

Remove previous input event management

Scene & X11WindowSystem are now clean from input events management, waiting for the new framework to be introduced.

LayerManagerSerivce: removed some minor compiler warnings

GLXlibrary: fixed linker settings in build system

GLXlibrary was not linked to required libraries as X11.

TcpIpcModule: support multiple data buffers for send/receive

This is a preparation to introduce asynchronous client notifications.

Having multiple buffers is required in these situations:
- a client is just creating a message and is about to send it
- a client notification is received, overwriting the clients message

or:
- a message was received, the client is just about to read the data from it
- a client notification is received, overwriting the clients message

To handle these situations, 1 sendBuffer and 2 separate receive buffer have been created.

Cleaning: Remove compiler warning for LayerManagerService_Test

Cleaning: Remove compiler warning on X11WindowSystem.cpp

LayerManagement: fixed plugin path handling

The generic communicator and the GLESGraphicSystem now use
the configuration flag CMAKE_INSTALL_PREFIX to
determine the default plugin search path.

Additionally the GeniviDemo.sh script was updated, since exporting
LM_PLUGIN_PATH is not required any more.
The script still contains a hint, that the plugin search path may
be modified.

TextureBinders: Remove redundant texture uploads on every texture bind

EGLImages can be created once and reused so we don't need to specify
& upload them every time we use them.

WindowSystem: Forced composition should also redraw HW layers

WaylandWindowSystems: Correct a previous overwritten method name change

Change checkForNewSurface function name to checkForNewSurfaceNativeContent

This change was overwritten during the wayland window system
refactoring.

X11GLESRenderer: fixed shader file search path

The renderer now uses the configuration flag CMAKE_INSTALL_PREFIX to
determine it's default shader search path.

Update default plugin directory search path to match CMAKE_INSTALL_PREFIX

Currently default plugin directory is hard coded to /usr/lib in several places. This patch takes into consideration the installation directory specified with cmake.
IpcModuleLoader.cpp has also been slightly modified to avoid compiler warnings

Config: removed Log dependency from autogenerated config.h file

config.h now contains a string array with the build configuration,
that is logged by the LayerManagerService is required.
Additionally for each flag the log level is defined.

GenericCommunicator: fixed crash during shutdown, if no ipcModule was loaded

the GenericCommunicator always tried to destroy the ipcModule. this failed
and resulted in a crash, if no ipcModule was loaded during startup.

Clean type sharing between ilm types & internal types

ilmClient types are used internally to LM, so let's include them by default

DbusIpcModules: Fixes wrong message unreferencing

- This fixes an issue inside of the send error method
- The wrong message was unreferenced

GenericCommunicator: Fixing String allocation.

- During the CreateShader call, a segmentation fault occurs
- String is now intialised correctly
- DBUSCommunicatorTest is up and running, one test is disabled, due
  to the lack of implementation in the new generic communication approach

Release : Release Notes updated

- Release Note updated.
- default version switched to 0.9.7.release_candiate

Demo: Genivi Demo script update.

- The demo script includes now start of the layer manager too.

ViewportTransform: Change order of texture coordinates

Change order of texture coordinates returned by
transformRectangleToTextureCoordinates() to be consistent with the
rest of the code.

Before: {x1, x2, y1, y2}
Now: {x1, y1, x2, y2}

GLESGraphicSystem: Simplify the vertex shader calculations

The current vertex shader has complicated vertex/texture conversions
which change coordinate systems multiple times. Simplified the same.

This would also increase the vertex shader performance.

ViewportTransform: Fix precision loss

All the transform calculationis are being done with integers which
could lead to precision loss. Instead we should be using floats.

ViewportTransform: Simplify and fix bugs in applyLayerSource

X11WindowSystem: Fix swapinterval=1

Using a non-default visual results in a redirected pixmap for the
root window which does not respect VSYNC.

Also use default screen instead of hard-coded screen 0.

LayerManagerCommands: Add SurfaceRemoveNativeContentCommand

Using this command a client can remove the native content associated
with a surface. This can be used if multiple windows need to be used
with the same surface.

TODO: The backend for wayland needs to be filled in.

WindowSystems: Fix bugs in screenshot

1. Clear needs to be done after graphics context has been activated.

2. Recent HW layer change made neccessary that m_damaged be set for
drawing in RedrawAllLayers() and hence broke display screenshot.
Fix that by drawing every layer in screenshot method itself.

Also removed redundant graphics context activate/release in
CheckRedrawAllLayers()

Remove failing tests SceneTest.getSurfaceAt

Scene: Bugfix in createSurfaceGroup() / createLayerGroup()

LayerManagerPlugins: Merge CopyGLES and EglImage to GLESTexture for WaylandPlugins

LayerManagerPlugins: refinement of Wayland Plugins.

- WindowSystems:

  - WaylandBaseWindowSystem:
    -support calculateSurfaceFps and calculateFps
    -change debug of information from INFO to DEBUG
    -improve deallocation method of wayland surface resources
    -add macro:WL_OMIT_CLEAR_GB to disable calling clearbackground
    -add macro:WL_LOG_DETAIL_TIMER to get detail performance value of wayland plutin
    -remove unnecesary codes
    -remove modifying m_damaged in Redraw()

  - WaylandDrmWindowSystem:
  - WaylandFbdevWindowsystem:
  - WaylandX11WindowSystem:
    -remove dependency on EGL. Because no all composition method are dependent on EGL.

- WaylandGLESRenderer:
  - remove dependency on EGL from init method.

LayerManagement: VIVANTE GAL switch removed

- VIVANTE GAL switch removed which was wrongly include  in
  commit LayerManagement: improved build system

LayerManagerControl: implemented first version

- command line tool to debug and modify layermanager scene
- design goals:
-- adding new commands should be as easy as possible
-- command syntax should be human readable

ilmClient / GenericCommunicator: updated layer and surface properties

layer properties now additionally contain
- layer type

surface properties now additionally contain
- pixelformat
- native surface handle
- draw counter
- update counter

LayerManagement: removed obsolete path references from build system

these paths have been changed in the project, but the build system
still had references to them. This resulted in some warnings during
build in some build environments.

TcpIpcModule: added ipc module for tcp socket communication

- implemented in C
- depends on socket libraries
- implements low-level tcp socket communication
- unit tests prepared, but not implemented
- set environment variable LM_TCP_HOST to override IP address of LayerManagerService instance
- set environment variable LM_TCP_PORT to set TCP port for communication

DBUSCommunicator: removed DBUS specific communciator

DBUs Communication is now handled by GenericCommunicator using
the DBUSIpcModule.

GenericCommunicator: added new LayerManager Communicator based on ipc modules

- implemented in C++
- implements ICommunicator Interface
- communication technology independent
- loaded by LayerManagerService the same way as DBUSCommunicator
- uses IpcModules for communication
- uses IpcModuleLoader to load IpcModules
- implements messaging on LayerManagerService side

ilmClient: updated to use ipc modules via ipc module loader

- implemented in C
- same interface as previous version (ilm_client.h unchanged)
- communication technology independent
- uses IpcModules for communication
- uses IpcModuleLoader to load IpcModules
- implements messaging on client side
- remove old interface ICommunicatorClient, which was never used (not available in C)

IpcModuleLoader: added ipc module loader library

- implemented in C
- common implementation to find, check and load IpcModules
- communication technology independent
- returns a struct of function pointers to use IpcModule

DbusIpcModule: created DBUS ipc module

- implemented in C
- depends on dbus libraries
- implements low-level dbus communication
- implements dbus introspection

Add generic HW layer support

Add basic support & optimizations for HW layers. The function
renderHWLayer() will need to be extended to add vendor specific
implementations.

MockNavigation: fixed default value for opacity

LayerManagement: fixed issues detected by Coverity Scan