LayerManagement: fixed issues detected by valgrind

[profile/ivi/layer-management.git] / LayerManagerPlugins / Communicators / GenericCommunicator / src / GenericCommunicator.cpp

diff --git a/LayerManagerPlugins/Communicators/GenericCommunicator/src/GenericCommunicator.cpp b/LayerManagerPlugins/Communicators/GenericCommunicator/src/GenericCommunicator.cpp
index 99687d9..8386cd1 100644 (file)
--- a/LayerManagerPlugins/Communicators/GenericCommunicator/src/GenericCommunicator.cpp
+++ b/LayerManagerPlugins/Communicators/GenericCommunicator/src/GenericCommunicator.cpp
@@ -19,14 +19,14 @@
 
 #include "GenericCommunicator.h"
 #include "ilm_types.h"
+#include "LmScreen.h"
 #include "Log.h"
+#include "Configuration.h"
 
 #include "ICommandExecutor.h"
 #include "CommitCommand.h"
 #include "LayerCreateCommand.h"
-#include "LayergroupCreateCommand.h"
 #include "SurfaceCreateCommand.h"
-#include "SurfacegroupCreateCommand.h"
 #include "SurfaceGetDimensionCommand.h"
 #include "LayerGetDimensionCommand.h"
 #include "SurfaceGetOpacityCommand.h"
@@ -38,28 +38,18 @@
 #include "LayerRemoveSurfaceCommand.h"
 #include "LayerRemoveCommand.h"
 #include "SurfaceRemoveCommand.h"
-#include "LayergroupRemoveCommand.h"
-#include "SurfacegroupRemoveCommand.h"
 #include "SurfaceGetOrientationCommand.h"
 #include "LayerGetOrientationCommand.h"
-#include "LayergroupAddLayerCommand.h"
-#include "LayergroupRemoveLayerCommand.h"
 #include "LayerSetDestinationRectangleCommand.h"
 #include "SurfaceSetDestinationRectangleCommand.h"
 #include "LayerSetOpacityCommand.h"
-#include "LayergroupSetOpacityCommand.h"
 #include "SurfaceSetOpacityCommand.h"
-#include "SurfacegroupSetOpacityCommand.h"
 #include "LayerSetSourceRectangleCommand.h"
 #include "SurfaceSetSourceRectangleCommand.h"
 #include "LayerSetOrientationCommand.h"
 #include "SurfaceSetOrientationCommand.h"
-#include "SurfacegroupAddSurfaceCommand.h"
-#include "SurfacegroupRemoveSurfaceCommand.h"
 #include "LayerSetVisibilityCommand.h"
 #include "SurfaceSetVisibilityCommand.h"
-#include "LayergroupSetVisibilityCommand.h"
-#include "SurfacegroupSetVisibilityCommand.h"
 #include "DebugCommand.h"
 #include "ExitCommand.h"
 #include "ScreenSetRenderOrderCommand.h"
@@ -86,6 +76,8 @@
 #include "LayerSetChromaKeyCommand.h"
 #include "SetOptimizationModeCommand.h"
 #include "GetOptimizationModeCommand.h"
+#include "SetSynchronizedSurfacesCommand.h"
+#include "RemoveSynchronizedSurfacesCommand.h"
 #include <stdbool.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -94,115 +86,96 @@
 #include <string>
 #include <pthread.h>
 #include <signal.h>
+#include <vector>
 
 #define DEFAULT_SCREEN 0
 
-const char* RESOURCE_ALREADY_INUSE = "Ressource already in use";
-const char* INVALID_ARGUMENT = "Invalid argument";
-const char* RESOURCE_NOT_FOUND = "Ressource not found";
-const char* NOT_IMPLEMENTED = "Feature not implemented";
-
-
-GenericCommunicator::GenericCommunicator(ICommandExecutor* executor)
-: ICommunicator(executor)
+GenericCommunicator::GenericCommunicator(ICommandExecutor& executor, Configuration& config)
+: ICommunicator(&executor)
+, PluginBase(executor, config, Communicator_Api_v1)
 , m_running(ILM_FALSE)
 {
     MethodTable manager_methods[] =
     {
-        { "ServiceConnect",                   &GenericCommunicator::ServiceConnect },
-        { "ServiceDisconnect",                &GenericCommunicator::ServiceDisconnect },
-        { "Debug",                            &GenericCommunicator::Debug },
-        { "ScreenShot",                       &GenericCommunicator::ScreenShot },
-        { "ScreenShotOfLayer",                &GenericCommunicator::ScreenShotOfLayer },
-        { "ScreenShotOfSurface",              &GenericCommunicator::ScreenShotOfSurface },
-        { "GetScreenResolution",              &GenericCommunicator::GetScreenResolution },
-        { "GetNumberOfHardwareLayers",        &GenericCommunicator::GetNumberOfHardwareLayers },
-        { "GetScreenIDs",                     &GenericCommunicator::GetScreenIDs },
-        { "ListAllLayerIDS",                  &GenericCommunicator::ListAllLayerIDS },
-        { "ListAllLayerIDsOnScreen",          &GenericCommunicator::ListAllLayerIDsOnScreen },
-        { "ListAllSurfaceIDS",                &GenericCommunicator::ListAllSurfaceIDS },
-        { "ListAllLayerGroupIDS",             &GenericCommunicator::ListAllLayerGroupIDS },
-        { "ListAllSurfaceGroupIDS",           &GenericCommunicator::ListAllSurfaceGroupIDS },
-        { "ListSurfacesOfSurfacegroup",       &GenericCommunicator::ListSurfacesOfSurfacegroup },
-        { "ListLayersOfLayergroup",           &GenericCommunicator::ListLayersOfLayergroup },
-        { "ListSurfaceofLayer",               &GenericCommunicator::ListSurfaceofLayer },
-        { "GetPropertiesOfSurface",           &GenericCommunicator::GetPropertiesOfSurface },
-        { "GetPropertiesOfLayer",             &GenericCommunicator::GetPropertiesOfLayer },
-        { "CreateSurface",                    &GenericCommunicator::CreateSurface },
-        { "CreateSurfaceFromId",              &GenericCommunicator::CreateSurfaceFromId },
-        { "InitializeSurface",                &GenericCommunicator::InitializeSurface },
-        { "InitializeSurfaceFromId",          &GenericCommunicator::InitializeSurfaceFromId },
-        { "SetSurfaceNativeContent",          &GenericCommunicator::SetSurfaceNativeContent },
-        { "RemoveSurfaceNativeContent",       &GenericCommunicator::RemoveSurfaceNativeContent },
-        { "RemoveSurface",                    &GenericCommunicator::RemoveSurface },
-        { "CreateLayer",                      &GenericCommunicator::CreateLayer },
-        { "CreateLayerFromId",                &GenericCommunicator::CreateLayerFromId },
-        { "CreateLayerWithDimension",         &GenericCommunicator::CreateLayerWithDimension },
-        { "CreateLayerFromIdWithDimension",   &GenericCommunicator::CreateLayerFromIdWithDimension },
-        { "RemoveLayer",                      &GenericCommunicator::RemoveLayer },
-        { "AddSurfaceToSurfaceGroup",         &GenericCommunicator::AddSurfaceToSurfaceGroup },
-        { "RemoveSurfaceFromSurfaceGroup",    &GenericCommunicator::RemoveSurfaceFromSurfaceGroup },
-        { "AddLayerToLayerGroup",             &GenericCommunicator::AddLayerToLayerGroup },
-        { "RemoveLayerFromLayerGroup",        &GenericCommunicator::RemoveLayerFromLayerGroup },
-        { "AddSurfaceToLayer",                &GenericCommunicator::AddSurfaceToLayer },
-        { "RemoveSurfaceFromLayer",           &GenericCommunicator::RemoveSurfaceFromLayer },
-        { "CreateSurfaceGroup",               &GenericCommunicator::CreateSurfaceGroup },
-        { "CreateSurfaceGroupFromId",         &GenericCommunicator::CreateSurfaceGroupFromId },
-        { "RemoveSurfaceGroup",               &GenericCommunicator::RemoveSurfaceGroup },
-        { "CreateLayerGroup",                 &GenericCommunicator::CreateLayerGroup },
-        { "CreateLayerGroupFromId",           &GenericCommunicator::CreateLayerGroupFromId },
-        { "RemoveLayerGroup",                 &GenericCommunicator::RemoveLayerGroup },
-        { "SetSurfaceSourceRegion",           &GenericCommunicator::SetSurfaceSourceRegion },
-        { "SetLayerSourceRegion",             &GenericCommunicator::SetLayerSourceRegion },
-        { "SetSurfaceDestinationRegion",      &GenericCommunicator::SetSurfaceDestinationRegion },
-        { "SetSurfacePosition",               &GenericCommunicator::SetSurfacePosition },
-        { "GetSurfacePosition",               &GenericCommunicator::GetSurfacePosition },
-        { "SetSurfaceDimension",              &GenericCommunicator::SetSurfaceDimension },
-        { "SetLayerDestinationRegion",        &GenericCommunicator::SetLayerDestinationRegion },
-        { "SetLayerPosition",                 &GenericCommunicator::SetLayerPosition },
-        { "GetLayerPosition",                 &GenericCommunicator::GetLayerPosition },
-        { "SetLayerDimension",                &GenericCommunicator::SetLayerDimension },
-        { "GetLayerDimension",                &GenericCommunicator::GetLayerDimension },
-        { "GetSurfaceDimension",              &GenericCommunicator::GetSurfaceDimension },
-        { "SetSurfaceOpacity",                &GenericCommunicator::SetSurfaceOpacity },
-        { "SetLayerOpacity",                  &GenericCommunicator::SetLayerOpacity },
-        { "SetSurfacegroupOpacity",           &GenericCommunicator::SetSurfacegroupOpacity },
-        { "SetLayergroupOpacity",             &GenericCommunicator::SetLayergroupOpacity },
-        { "GetSurfaceOpacity",                &GenericCommunicator::GetSurfaceOpacity },
-        { "GetLayerOpacity",                  &GenericCommunicator::GetLayerOpacity },
-        { "SetSurfaceOrientation",            &GenericCommunicator::SetSurfaceOrientation },
-        { "GetSurfaceOrientation",            &GenericCommunicator::GetSurfaceOrientation },
-        { "SetLayerOrientation",              &GenericCommunicator::SetLayerOrientation },
-        { "GetLayerOrientation",              &GenericCommunicator::GetLayerOrientation },
-        { "GetSurfacePixelformat",            &GenericCommunicator::GetSurfacePixelformat },
-        { "SetSurfaceVisibility",             &GenericCommunicator::SetSurfaceVisibility },
-        { "SetLayerVisibility",               &GenericCommunicator::SetLayerVisibility },
-        { "GetSurfaceVisibility",             &GenericCommunicator::GetSurfaceVisibility },
-        { "GetLayerVisibility",               &GenericCommunicator::GetLayerVisibility },
-        { "SetSurfacegroupVisibility",        &GenericCommunicator::SetSurfacegroupVisibility },
-        { "SetLayergroupVisibility",          &GenericCommunicator::SetLayergroupVisibility },
-        { "SetRenderOrderOfLayers",           &GenericCommunicator::SetRenderOrderOfLayers },
+        { "ServiceConnect", &GenericCommunicator::ServiceConnect },
+        { "ServiceDisconnect", &GenericCommunicator::ServiceDisconnect },
+        { "Debug", &GenericCommunicator::Debug },
+        { "ScreenShot", &GenericCommunicator::ScreenShot },
+        { "ScreenShotOfLayer", &GenericCommunicator::ScreenShotOfLayer },
+        { "ScreenShotOfSurface", &GenericCommunicator::ScreenShotOfSurface },
+        { "GetScreenResolution", &GenericCommunicator::GetScreenResolution },
+        { "GetNumberOfHardwareLayers", &GenericCommunicator::GetNumberOfHardwareLayers },
+        { "GetScreenIDs", &GenericCommunicator::GetScreenIDs },
+        { "ListAllLayerIDS", &GenericCommunicator::ListAllLayerIDS },
+        { "ListAllLayerIDsOnScreen", &GenericCommunicator::ListAllLayerIDsOnScreen },
+        { "ListAllSurfaceIDS", &GenericCommunicator::ListAllSurfaceIDS },
+        { "ListSurfaceofLayer", &GenericCommunicator::ListSurfaceofLayer },
+        { "GetPropertiesOfSurface", &GenericCommunicator::GetPropertiesOfSurface },
+        { "GetPropertiesOfLayer", &GenericCommunicator::GetPropertiesOfLayer },
+        { "CreateSurface", &GenericCommunicator::CreateSurface },
+        { "CreateSurfaceFromId", &GenericCommunicator::CreateSurfaceFromId },
+        { "InitializeSurface", &GenericCommunicator::InitializeSurface },
+        { "InitializeSurfaceFromId", &GenericCommunicator::InitializeSurfaceFromId },
+        { "SetSurfaceNativeContent", &GenericCommunicator::SetSurfaceNativeContent },
+        { "RemoveSurfaceNativeContent", &GenericCommunicator::RemoveSurfaceNativeContent },
+        { "RemoveSurface", &GenericCommunicator::RemoveSurface },
+        { "CreateLayer", &GenericCommunicator::CreateLayer },
+        { "CreateLayerFromId", &GenericCommunicator::CreateLayerFromId },
+        { "CreateLayerWithDimension", &GenericCommunicator::CreateLayerWithDimension },
+        { "CreateLayerFromIdWithDimension", &GenericCommunicator::CreateLayerFromIdWithDimension },
+        { "RemoveLayer", &GenericCommunicator::RemoveLayer },
+        { "AddSurfaceToLayer", &GenericCommunicator::AddSurfaceToLayer },
+        { "RemoveSurfaceFromLayer", &GenericCommunicator::RemoveSurfaceFromLayer },
+        { "SetSurfaceSourceRegion", &GenericCommunicator::SetSurfaceSourceRegion },
+        { "SetLayerSourceRegion", &GenericCommunicator::SetLayerSourceRegion },
+        { "SetSurfaceDestinationRegion", &GenericCommunicator::SetSurfaceDestinationRegion },
+        { "SetSurfacePosition", &GenericCommunicator::SetSurfacePosition },
+        { "GetSurfacePosition", &GenericCommunicator::GetSurfacePosition },
+        { "SetSurfaceDimension", &GenericCommunicator::SetSurfaceDimension },
+        { "SetLayerDestinationRegion", &GenericCommunicator::SetLayerDestinationRegion },
+        { "SetLayerPosition", &GenericCommunicator::SetLayerPosition },
+        { "GetLayerPosition", &GenericCommunicator::GetLayerPosition },
+        { "SetLayerDimension", &GenericCommunicator::SetLayerDimension },
+        { "GetLayerDimension", &GenericCommunicator::GetLayerDimension },
+        { "GetSurfaceDimension", &GenericCommunicator::GetSurfaceDimension },
+        { "SetSurfaceOpacity", &GenericCommunicator::SetSurfaceOpacity },
+        { "SetLayerOpacity", &GenericCommunicator::SetLayerOpacity },
+        { "GetSurfaceOpacity", &GenericCommunicator::GetSurfaceOpacity },
+        { "GetLayerOpacity", &GenericCommunicator::GetLayerOpacity },
+        { "SetSurfaceOrientation", &GenericCommunicator::SetSurfaceOrientation },
+        { "GetSurfaceOrientation", &GenericCommunicator::GetSurfaceOrientation },
+        { "SetLayerOrientation", &GenericCommunicator::SetLayerOrientation },
+        { "GetLayerOrientation", &GenericCommunicator::GetLayerOrientation },
+        { "GetSurfacePixelformat", &GenericCommunicator::GetSurfacePixelformat },
+        { "SetSurfaceVisibility", &GenericCommunicator::SetSurfaceVisibility },
+        { "SetLayerVisibility", &GenericCommunicator::SetLayerVisibility },
+        { "GetSurfaceVisibility", &GenericCommunicator::GetSurfaceVisibility },
+        { "GetLayerVisibility", &GenericCommunicator::GetLayerVisibility },
+        { "SetRenderOrderOfLayers", &GenericCommunicator::SetRenderOrderOfLayers },
         { "SetSurfaceRenderOrderWithinLayer", &GenericCommunicator::SetSurfaceRenderOrderWithinLayer },
-        { "GetLayerType",                     &GenericCommunicator::GetLayerType },
-        { "GetLayertypeCapabilities",         &GenericCommunicator::GetLayertypeCapabilities },
-        { "GetLayerCapabilities",             &GenericCommunicator::GetLayerCapabilities },
-        { "Exit",                             &GenericCommunicator::Exit },
-        { "CommitChanges",                    &GenericCommunicator::CommitChanges },
-        { "CreateShader",                     &GenericCommunicator::CreateShader },
-        { "DestroyShader",                    &GenericCommunicator::DestroyShader },
-        { "SetShader",                        &GenericCommunicator::SetShader },
-        { "SetUniforms",                      &GenericCommunicator::SetUniforms },
-        { "SetKeyboardFocusOn",               &GenericCommunicator::SetKeyboardFocusOn },
-        { "GetKeyboardFocusSurfaceId",        &GenericCommunicator::GetKeyboardFocusSurfaceId },
-        { "UpdateInputEventAcceptanceOn",     &GenericCommunicator::UpdateInputEventAcceptanceOn },
-        { "SetSurfaceChromaKey",              &GenericCommunicator::SetSurfaceChromaKey },
-        { "SetLayerChromaKey",                &GenericCommunicator::SetLayerChromaKey },
-        { "LayerAddNotification",             &GenericCommunicator::LayerAddNotification },
-        { "SurfaceAddNotification",           &GenericCommunicator::SurfaceAddNotification },
-        { "LayerRemoveNotification",          &GenericCommunicator::LayerRemoveNotification },
-        { "SurfaceRemoveNotification",        &GenericCommunicator::SurfaceRemoveNotification },
-        { "SetOptimizationMode",              &GenericCommunicator::SetOptimizationMode },
-        { "GetOptimizationMode",              &GenericCommunicator::GetOptimizationMode }
+        { "GetLayerType", &GenericCommunicator::GetLayerType },
+        { "GetLayertypeCapabilities", &GenericCommunicator::GetLayertypeCapabilities },
+        { "GetLayerCapabilities", &GenericCommunicator::GetLayerCapabilities },
+        { "Exit", &GenericCommunicator::Exit },
+        { "CommitChanges", &GenericCommunicator::CommitChanges },
+        { "CreateShader", &GenericCommunicator::CreateShader },
+        { "DestroyShader", &GenericCommunicator::DestroyShader },
+        { "SetShader", &GenericCommunicator::SetShader },
+        { "SetUniforms", &GenericCommunicator::SetUniforms },
+        { "SetKeyboardFocusOn", &GenericCommunicator::SetKeyboardFocusOn },
+        { "GetKeyboardFocusSurfaceId", &GenericCommunicator::GetKeyboardFocusSurfaceId },
+        { "UpdateInputEventAcceptanceOn", &GenericCommunicator::UpdateInputEventAcceptanceOn },
+        { "SetSurfaceChromaKey", &GenericCommunicator::SetSurfaceChromaKey },
+        { "SetLayerChromaKey", &GenericCommunicator::SetLayerChromaKey },
+        { "LayerAddNotification", &GenericCommunicator::LayerAddNotification },
+        { "SurfaceAddNotification", &GenericCommunicator::SurfaceAddNotification },
+        { "LayerRemoveNotification", &GenericCommunicator::LayerRemoveNotification },
+        { "SurfaceRemoveNotification", &GenericCommunicator::SurfaceRemoveNotification },
+        { "SetOptimizationMode", &GenericCommunicator::SetOptimizationMode },
+        { "GetOptimizationMode", &GenericCommunicator::GetOptimizationMode },
+        { "GetPropertiesOfScreen", &GenericCommunicator::GetPropertiesOfScreen },
+        { "SetSynchronizedSurfaces", &GenericCommunicator::SetSynchronizedSurfaces },
+        { "RemoveSynchronizedSurfaces", &GenericCommunicator::RemoveSynchronizedSurfaces }
     };
 
     int entryCount = sizeof(manager_methods) / sizeof(MethodTable);
@@ -241,20 +214,26 @@ bool GenericCommunicator::start()
     LOG_DEBUG("GenericCommunicator", "Initializing IpcModule success.");
 
     m_running = ILM_TRUE;
-    setHealth(HealthRunning);
+    pluginSetHealth(HealthRunning);
+
+    threadCreate();
+    threadInit();
+    threadStart();
 
     return ILM_TRUE;
 }
 
 void GenericCommunicator::stop()
 {
-    LOG_INFO("GenericCommunicator","stopping");
+    LOG_INFO("GenericCommunicator", "stopping");
+
+    threadStop();
 
     if (m_running)
     {
         m_ipcModule.destroy();
     }
-    setHealth(HealthStopped);
+    pluginSetHealth(HealthStopped);
 }
 
 void GenericCommunicator::process(int timeout_ms)
@@ -269,37 +248,37 @@ void GenericCommunicator::process(int timeout_ms)
     t_ilm_const_string name = m_ipcModule.getMessageName(message);
     t_ilm_client_handle senderHandle = m_ipcModule.getSenderHandle(message);
 
-    switch(messageType)
+    switch (messageType)
     {
     case IpcMessageTypeCommand:
         if (m_callBackTable.end() != m_callBackTable.find(name))
         {
             LOG_DEBUG("GenericCommunicator", "received: " << name << " from "
-                       << m_executor->getSenderName(senderHandle)
-                       << "(" << m_executor->getSenderPid(senderHandle) << ")");
+                        << m_executor->getSenderName(senderHandle)
+                        << "(" << m_executor->getSenderPid(senderHandle) << ")");
             CallBackMethod method = m_callBackTable[name].function;
             (this->*method)(message);
         }
         else
         {
             LOG_WARNING("GenericCommunicator", "Received unknown command " << name
-                  << " from " << m_executor->getSenderName(senderHandle)
-                  << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
+                    << " from " << m_executor->getSenderName(senderHandle)
+                    << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
         }
         processNotificationQueue();
         break;
 
     case IpcMessageTypeConnect:
         LOG_DEBUG("GenericCommunicator", "client " << m_executor->getSenderName(senderHandle)
-                  << "(pid " << m_executor->getSenderPid(senderHandle) << ") connected");
+                    << "(pid " << m_executor->getSenderPid(senderHandle) << ") connected");
         break;
 
     case IpcMessageTypeDisconnect:
         LOG_DEBUG("GenericCommunicator", "client " << m_executor->getSenderName(senderHandle)
-                  << "(pid " << m_executor->getSenderPid(senderHandle) << ") disconnected");
+                    << "(pid " << m_executor->getSenderPid(senderHandle) << ") disconnected");
         {
             const LayerMap& layers = m_executor->getScene()->getAllLayers();
-            LayerMapConstIterator layerIter =  layers.begin();
+            LayerMapConstIterator layerIter = layers.begin();
             LayerMapConstIterator layerIterEnd = layers.end();
             for (; layerIter != layerIterEnd; ++layerIter)
             {
@@ -308,20 +287,21 @@ void GenericCommunicator::process(int timeout_ms)
             }
 
             const SurfaceMap& surfaces = m_executor->getScene()->getAllSurfaces();
-            SurfaceMapConstIterator surfaceIter =  surfaces.begin();
+            SurfaceMapConstIterator surfaceIter = surfaces.begin();
             SurfaceMapConstIterator surfaceIterEnd = surfaces.end();
             for (; surfaceIter != surfaceIterEnd; ++surfaceIter)
             {
                 Surface* surface = surfaceIter->second;
                 surface->removeNotification(senderHandle);
             }
+            m_executor->removeApplicationReference(senderHandle);
         }
         break;
 
     case IpcMessageTypeError:
         LOG_DEBUG("GenericCommunicator", "Received error message " << name << " from "
-                  << m_executor->getSenderName(senderHandle)
-                  << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
+                    << m_executor->getSenderName(senderHandle)
+                    << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
         break;
 
     case IpcMessageTypeShutdown:
@@ -330,8 +310,8 @@ void GenericCommunicator::process(int timeout_ms)
 
     default:
         LOG_DEBUG("GenericCommunicator", "Received unknown data from "
-                  << m_executor->getSenderName(senderHandle)
-                  << "(pid " << m_executor->getSenderPid(senderHandle) << "), Message type: " << messageType);
+                    << m_executor->getSenderName(senderHandle)
+                    << "(pid " << m_executor->getSenderPid(senderHandle) << "), Message type: " << messageType);
         break;
     }
     m_ipcModule.destroyMessage(message);
@@ -342,10 +322,19 @@ void GenericCommunicator::setdebug(bool onoff)
     (void)onoff; // TODO: remove, only prevents warning
 }
 
-void GenericCommunicator::ServiceConnect(t_ilm_message message)
+t_ilm_bool GenericCommunicator::threadMainLoop()
 {
-    LOG_DEBUG("GenericCommunicator", "ServiceConnect called");
+    process(-1);
+    return ILM_TRUE;
+}
 
+t_ilm_const_string GenericCommunicator::pluginGetName() const
+{
+    return "GenericCommunicator";
+}
+
+void GenericCommunicator::ServiceConnect(t_ilm_message message)
+{
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 
@@ -356,6 +345,10 @@ void GenericCommunicator::ServiceConnect(t_ilm_message message)
 
     m_executor->addApplicationReference(clientHandle, new IApplicationReference(processName, processId));
 
+    LOG_DEBUG("GenericCommunicator", "ServiceConnect called from "
+                << m_executor->getSenderName(clientHandle)
+                << "(" << m_executor->getSenderPid(clientHandle) << ")");
+
     response = m_ipcModule.createResponse(message);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
@@ -363,11 +356,13 @@ void GenericCommunicator::ServiceConnect(t_ilm_message message)
 
 void GenericCommunicator::ServiceDisconnect(t_ilm_message message)
 {
-    LOG_DEBUG("GenericCommunicator", "ServiceDisconnect called");
-
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 
+    LOG_DEBUG("GenericCommunicator", "ServiceDisconnect called from "
+                << m_executor->getSenderName(clientHandle)
+                << "(" << m_executor->getSenderPid(clientHandle) << ")");
+
     m_executor->removeApplicationReference(clientHandle);
 
     response = m_ipcModule.createResponse(message);
@@ -391,7 +386,7 @@ void GenericCommunicator::Debug(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -411,6 +406,8 @@ void GenericCommunicator::GetScreenResolution(t_ilm_message message)
     m_ipcModule.appendUint(response, resolution[1]);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
+
+    delete [] resolution;
 }
 
 void GenericCommunicator::GetNumberOfHardwareLayers(t_ilm_message message)
@@ -436,6 +433,7 @@ void GenericCommunicator::GetScreenIDs(t_ilm_message message)
     m_ipcModule.appendUintArray(response, IDs, length);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
+    delete [] IDs;
 }
 
 void GenericCommunicator::ScreenShot(t_ilm_message message)
@@ -457,7 +455,7 @@ void GenericCommunicator::ScreenShot(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -482,7 +480,7 @@ void GenericCommunicator::ScreenShotOfLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -506,7 +504,7 @@ void GenericCommunicator::ScreenShotOfSurface(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -548,11 +546,13 @@ void GenericCommunicator::ListAllLayerIDsOnScreen(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
+
+    delete [] array;
 }
 
 void GenericCommunicator::ListAllSurfaceIDS(t_ilm_message message)
@@ -570,111 +570,6 @@ void GenericCommunicator::ListAllSurfaceIDS(t_ilm_message message)
     m_ipcModule.destroyMessage(response);
 }
 
-void GenericCommunicator::ListAllLayerGroupIDS(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    uint* array = NULL;
-    uint length = 0;
-    m_executor->getScene()->lockScene();
-    m_executor->getScene()->getLayerGroupIDs(&length, &array);
-    m_executor->getScene()->unlockScene();
-    response = m_ipcModule.createResponse(message);
-    m_ipcModule.appendUintArray(response, array, length);
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::ListAllSurfaceGroupIDS(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    uint* array = NULL;
-    uint length = 0;
-    m_executor->getScene()->lockScene();
-    m_executor->getScene()->getSurfaceGroupIDs(&length, &array);
-    m_executor->getScene()->unlockScene();
-    response = m_ipcModule.createResponse(message);
-    m_ipcModule.appendUintArray(response, array, length);
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::ListSurfacesOfSurfacegroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    uint id = 0;
-    m_ipcModule.getUint(message, &id);
-    m_executor->getScene()->lockScene();
-    SurfaceGroup* sg = m_executor->getScene()->getSurfaceGroup(id);
-    if (NULL != sg)
-    {
-        std::list<Surface*> surfaces = sg->getList();
-        uint length = surfaces.size();
-        uint* array = new uint[length];
-        uint arrayPos = 0;
-
-        for (std::list<Surface*>::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it)
-        {
-            Surface* s = *it;
-            array[arrayPos] = s->getID();
-            ++arrayPos;
-        }
-        m_executor->getScene()->unlockScene();
-
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUintArray(response, array, length);
-    }
-    else
-    {
-        m_executor->getScene()->unlockScene();
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::ListLayersOfLayergroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    uint id = 0;
-    m_ipcModule.getUint(message, &id);
-    m_executor->getScene()->lockScene();
-    LayerGroup* sg = m_executor->getScene()->getLayerGroup(id);
-    if (NULL != sg)
-    {
-        std::list<Layer*> layers = sg->getList();
-
-        uint length = layers.size();
-        uint* array = new uint[length];
-        uint arrayPos = 0;
-
-        for (std::list<Layer*>::const_iterator it = layers.begin(); it != layers.end(); ++it)
-        {
-            Layer* l = *it;
-            array[arrayPos] = l->getID();
-            ++arrayPos;
-        }
-        m_executor->getScene()->unlockScene();
-
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUintArray(response, array, length);
-    }
-    else
-    {
-        m_executor->getScene()->unlockScene();
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
 void GenericCommunicator::ListSurfaceofLayer(t_ilm_message message)
 {
     t_ilm_message response;
@@ -701,12 +596,13 @@ void GenericCommunicator::ListSurfaceofLayer(t_ilm_message message)
 
         response = m_ipcModule.createResponse(message);
         m_ipcModule.appendUintArray(response, array, length);
+        delete [] array;
     }
     else
     {
         m_executor->getScene()->unlockScene();
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -760,7 +656,7 @@ void GenericCommunicator::GetPropertiesOfSurface(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -809,7 +705,7 @@ void GenericCommunicator::GetPropertiesOfLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -835,7 +731,6 @@ void GenericCommunicator::CreateSurface(t_ilm_message message)
 
     pf = (PixelFormat) pixelformat;
 
-
     // First of all create the surface
     t_ilm_bool status = m_executor->execute(new SurfaceCreateCommand(clientPid, &id));
 
@@ -850,7 +745,7 @@ void GenericCommunicator::CreateSurface(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -891,7 +786,7 @@ void GenericCommunicator::CreateSurfaceFromId(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -914,7 +809,7 @@ void GenericCommunicator::InitializeSurface(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -937,7 +832,7 @@ void GenericCommunicator::InitializeSurfaceFromId(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -972,7 +867,7 @@ void GenericCommunicator::SetSurfaceNativeContent(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -995,7 +890,7 @@ void GenericCommunicator::RemoveSurfaceNativeContent(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1017,7 +912,7 @@ void GenericCommunicator::RemoveSurface(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1041,7 +936,7 @@ void GenericCommunicator::CreateLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1067,11 +962,13 @@ void GenericCommunicator::CreateLayerFromId(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
+
+    delete [] resolution;
 }
 
 
@@ -1095,7 +992,7 @@ void GenericCommunicator::CreateLayerWithDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1125,7 +1022,7 @@ void GenericCommunicator::CreateLayerFromIdWithDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1147,111 +1044,7 @@ void GenericCommunicator::RemoveLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::AddSurfaceToSurfaceGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint surfaceid = 0;
-    uint surfacegroupid = 0;
-
-    m_ipcModule.getUint(message, &surfaceid);
-    m_ipcModule.getUint(message, &surfacegroupid);
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupAddSurfaceCommand(clientPid, surfacegroupid, surfaceid));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::RemoveSurfaceFromSurfaceGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint surfaceid = 0;
-    uint surfacegroupid = 0;
-
-    m_ipcModule.getUint(message, &surfaceid);
-    m_ipcModule.getUint(message, &surfacegroupid);
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupRemoveSurfaceCommand(clientPid, surfacegroupid, surfaceid));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::AddLayerToLayerGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint layerid = 0;
-    uint layergroupid = 0;
-
-    m_ipcModule.getUint(message, &layerid);
-    m_ipcModule.getUint(message, &layergroupid);
-
-    t_ilm_bool status = m_executor->execute(new LayergroupAddLayerCommand(clientPid, layergroupid, layerid));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::RemoveLayerFromLayerGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint layerid = 0;
-    uint layergroupid = 0;
-
-    m_ipcModule.getUint(message, &layerid);
-    m_ipcModule.getUint(message, &layergroupid);
-
-    t_ilm_bool status = m_executor->execute(new LayergroupRemoveLayerCommand(clientPid, layergroupid, layerid));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1277,7 +1070,7 @@ void GenericCommunicator::AddSurfaceToLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_ALREADY_INUSE);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1302,149 +1095,7 @@ void GenericCommunicator::RemoveSurfaceFromLayer(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::CreateSurfaceGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint newID = GraphicalObject::INVALID_ID;
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupCreateCommand(clientPid, &newID));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUint(response, newID);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::CreateSurfaceGroupFromId(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint newID = GraphicalObject::INVALID_ID;
-
-    m_ipcModule.getUint(message, &newID);
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupCreateCommand(clientPid, &newID));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUint(response, newID);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::RemoveSurfaceGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint param = 0;
-    m_ipcModule.getUint(message, &param);
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupRemoveCommand(clientPid, param));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::CreateLayerGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint newID = GraphicalObject::INVALID_ID;
-
-    t_ilm_bool status = m_executor->execute(new LayergroupCreateCommand(clientPid, &newID));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUint(response, newID);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::CreateLayerGroupFromId(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint newID = GraphicalObject::INVALID_ID;
-
-    m_ipcModule.getUint(message, &newID);
-
-    t_ilm_bool status = m_executor->execute(new LayergroupCreateCommand(clientPid, &newID));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUint(response, newID);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::RemoveLayerGroup(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint param = 0;
-    m_ipcModule.getUint(message, &param);
-
-    t_ilm_bool status = m_executor->execute(new LayergroupRemoveCommand(clientPid, param));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1476,7 +1127,7 @@ void GenericCommunicator::SetSurfaceSourceRegion(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1508,7 +1159,7 @@ void GenericCommunicator::SetLayerSourceRegion(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1540,7 +1191,7 @@ void GenericCommunicator::SetSurfaceDestinationRegion(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1568,7 +1219,7 @@ void GenericCommunicator::SetSurfacePosition(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1596,7 +1247,7 @@ void GenericCommunicator::GetSurfacePosition(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1624,7 +1275,7 @@ void GenericCommunicator::SetSurfaceDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1656,7 +1307,7 @@ void GenericCommunicator::SetLayerDestinationRegion(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1684,7 +1335,7 @@ void GenericCommunicator::SetLayerPosition(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1712,7 +1363,7 @@ void GenericCommunicator::GetLayerPosition(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1740,7 +1391,7 @@ void GenericCommunicator::SetLayerDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1768,7 +1419,7 @@ void GenericCommunicator::GetLayerDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1796,7 +1447,7 @@ void GenericCommunicator::GetSurfaceDimension(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1822,7 +1473,7 @@ void GenericCommunicator::SetSurfaceOpacity(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1848,59 +1499,7 @@ void GenericCommunicator::SetLayerOpacity(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::SetSurfacegroupOpacity(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint id = 0;
-    double param = 0.0;
-
-    m_ipcModule.getUint(message, &id);
-    m_ipcModule.getDouble(message, &param);
-
-    t_ilm_bool status = m_executor->execute(new SurfacegroupSetOpacityCommand(clientPid, id, param));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
-    }
-
-    m_ipcModule.sendToClients(response, &clientHandle, 1);
-    m_ipcModule.destroyMessage(response);
-}
-
-void GenericCommunicator::SetLayergroupOpacity(t_ilm_message message)
-{
-    t_ilm_message response;
-    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
-    t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint id = 0;
-    double param = 0.0;
-
-    m_ipcModule.getUint(message, &id);
-    m_ipcModule.getDouble(message, &param);
-
-    t_ilm_bool status = m_executor->execute(new LayergroupSetOpacityCommand(clientPid, id, param));
-    if (status)
-    {
-        response = m_ipcModule.createResponse(message);
-    }
-    else
-    {
-        response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1926,7 +1525,7 @@ void GenericCommunicator::GetSurfaceOpacity(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1952,7 +1551,7 @@ void GenericCommunicator::GetLayerOpacity(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -1981,7 +1580,7 @@ void GenericCommunicator::SetSurfaceOrientation(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2007,7 +1606,7 @@ void GenericCommunicator::GetSurfaceOrientation(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2036,7 +1635,7 @@ void GenericCommunicator::SetLayerOrientation(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2062,7 +1661,7 @@ void GenericCommunicator::GetLayerOrientation(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2075,7 +1674,7 @@ void GenericCommunicator::GetSurfacePixelformat(t_ilm_message message)
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
     uint id = 0;
-    PixelFormat pixelFormat;
+    PixelFormat pixelFormat = (PixelFormat)ILM_PIXEL_FORMAT_UNKNOWN;
 
     m_ipcModule.getUint(message, &id);
 
@@ -2088,7 +1687,7 @@ void GenericCommunicator::GetSurfacePixelformat(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2114,7 +1713,7 @@ void GenericCommunicator::SetSurfaceVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2140,7 +1739,7 @@ void GenericCommunicator::SetLayerVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2153,7 +1752,7 @@ void GenericCommunicator::GetSurfaceVisibility(t_ilm_message message)
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
     uint id = 0;
-    bool visibility;
+    bool visibility = false;
 
     m_ipcModule.getUint(message, &id);
 
@@ -2166,7 +1765,7 @@ void GenericCommunicator::GetSurfaceVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2179,7 +1778,7 @@ void GenericCommunicator::GetLayerVisibility(t_ilm_message message)
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
     uint id = 0;
-    bool visibility;
+    bool visibility = false;
 
     m_ipcModule.getUint(message, &id);
 
@@ -2192,25 +1791,32 @@ void GenericCommunicator::GetLayerVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
 
-void GenericCommunicator::SetSurfacegroupVisibility(t_ilm_message message)
+void GenericCommunicator::SetSynchronizedSurfaces(t_ilm_message message)
 {
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint groupid = 0;
-    t_ilm_bool myparam = ILM_FALSE;
 
-    m_ipcModule.getUint(message, &groupid);
-    m_ipcModule.getBool(message, &myparam);
+    // ipcArray was created in ipcModule using malloc (it's implemented C)
+    // so we copy it to a buffer created with new() and discard
+    // the ipcArray using free() to avoid memory corruption
+    uint* ipcArray = NULL;
+    uint* array = NULL;
+    int length = 0;
+    m_ipcModule.getUintArray(message, &ipcArray, &length);
+    array = new uint[length];
+    memset(array, 0, length * sizeof(uint));
+    memcpy(array, ipcArray, length * sizeof(uint));
+    free(ipcArray);
 
-    t_ilm_bool status = m_executor->execute(new SurfacegroupSetVisibilityCommand(clientPid, groupid, myparam));
+    t_ilm_bool status = m_executor->execute(new SetSynchronizedSurfacesCommand(clientPid, array, length));
     if (status)
     {
         response = m_ipcModule.createResponse(message);
@@ -2218,25 +1824,32 @@ void GenericCommunicator::SetSurfacegroupVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
 
-void GenericCommunicator::SetLayergroupVisibility(t_ilm_message message)
+void GenericCommunicator::RemoveSynchronizedSurfaces(t_ilm_message message)
 {
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint groupid = 0;
-    t_ilm_bool myparam = ILM_FALSE;
 
-    m_ipcModule.getUint(message, &groupid);
-    m_ipcModule.getBool(message, &myparam);
+    // ipcArray was created in ipcModule using malloc (it's implemented C)
+    // so we copy it to a buffer created with new() and discard
+    // the ipcArray using free() to avoid memory corruption
+    uint* ipcArray = NULL;
+    uint* array = NULL;
+    int length = 0;
+    m_ipcModule.getUintArray(message, &ipcArray, &length);
+    array = new uint[length];
+    memset(array, 0, length * sizeof(uint));
+    memcpy(array, ipcArray, length * sizeof(uint));
+    free(ipcArray);
 
-    t_ilm_bool status = m_executor->execute(new LayergroupSetVisibilityCommand(clientPid, groupid, myparam));
+    t_ilm_bool status = m_executor->execute(new RemoveSynchronizedSurfacesCommand(clientPid, array, length));
     if (status)
     {
         response = m_ipcModule.createResponse(message);
@@ -2244,24 +1857,33 @@ void GenericCommunicator::SetLayergroupVisibility(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
 
-
 void GenericCommunicator::SetRenderOrderOfLayers(t_ilm_message message)
 {
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
+
+    // ipcArray was created in ipcModule using malloc (it's implemented C)
+    // so we copy it to a buffer created with new() and discard
+    // the ipcArray using free() to avoid memory corruption
+    uint* ipcArray = NULL;
     uint* array = NULL;
     int length = 0;
+    m_ipcModule.getUintArray(message, &ipcArray, &length);
+    array = new uint[length];
+    memset(array, 0, length * sizeof(uint));
+    memcpy(array, ipcArray, length * sizeof(uint));
+    free(ipcArray);
+
     uint screenID = 0;
 
-    m_ipcModule.getUintArray(message, &array, &length);
     m_ipcModule.getUint(message, &screenID);
 
     t_ilm_bool status = m_executor->execute(new ScreenSetRenderOrderCommand(clientPid, screenID, array, length));
@@ -2272,7 +1894,7 @@ void GenericCommunicator::SetRenderOrderOfLayers(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2284,12 +1906,21 @@ void GenericCommunicator::SetSurfaceRenderOrderWithinLayer(t_ilm_message message
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
-    uint* array = NULL;
-    int length = 0;
-    uint layerid = 0;
 
+    uint layerid = 0;
     m_ipcModule.getUint(message, &layerid);
-    m_ipcModule.getUintArray(message, &array, &length);
+
+    // ipcArray was created in ipcModule using malloc (it's implemented C)
+    // so we copy it to a buffer created with new() and discard
+    // the ipcArray using free() to avoid memory corruption
+    uint* ipcArray = NULL;
+    uint* array = NULL;
+    int length = 0;
+    m_ipcModule.getUintArray(message, &ipcArray, &length);
+    array = new uint[length];
+    memset(array, 0, length * sizeof(uint));
+    memcpy(array, ipcArray, length * sizeof(uint));
+    free(ipcArray);
 
     t_ilm_bool status = m_executor->execute(new LayerSetRenderOrderCommand(clientPid, layerid, array, length));
     if (status)
@@ -2299,7 +1930,7 @@ void GenericCommunicator::SetSurfaceRenderOrderWithinLayer(t_ilm_message message
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2322,7 +1953,7 @@ void GenericCommunicator::GetLayerType(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2363,7 +1994,7 @@ void GenericCommunicator::GetLayerCapabilities(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2375,7 +2006,7 @@ void GenericCommunicator::FadeIn(t_ilm_message message)
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     response = m_ipcModule.createErrorResponse(message);
-    m_ipcModule.appendString(response, NOT_IMPLEMENTED);
+    m_ipcModule.appendUint(response, ILM_ERROR_NOT_IMPLEMENTED);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
@@ -2385,7 +2016,7 @@ void GenericCommunicator::SynchronizedFade(t_ilm_message message)
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     response = m_ipcModule.createErrorResponse(message);
-    m_ipcModule.appendString(response, NOT_IMPLEMENTED);
+    m_ipcModule.appendUint(response, ILM_ERROR_NOT_IMPLEMENTED);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
@@ -2395,7 +2026,7 @@ void GenericCommunicator::FadeOut(t_ilm_message message)
     t_ilm_message response;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     response = m_ipcModule.createErrorResponse(message);
-    m_ipcModule.appendString(response, NOT_IMPLEMENTED);
+    m_ipcModule.appendUint(response, ILM_ERROR_NOT_IMPLEMENTED);
     m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
@@ -2413,7 +2044,7 @@ void GenericCommunicator::Exit(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2433,7 +2064,7 @@ void GenericCommunicator::CommitChanges(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2461,7 +2092,7 @@ void GenericCommunicator::CreateShader(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2485,7 +2116,7 @@ void GenericCommunicator::DestroyShader(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2511,7 +2142,7 @@ void GenericCommunicator::SetShader(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2539,7 +2170,7 @@ void GenericCommunicator::SetUniforms(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2563,7 +2194,7 @@ void GenericCommunicator::SetKeyboardFocusOn(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2587,7 +2218,7 @@ void GenericCommunicator::GetKeyboardFocusSurfaceId(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2619,7 +2250,7 @@ void GenericCommunicator::UpdateInputEventAcceptanceOn(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2646,7 +2277,7 @@ void GenericCommunicator::SetSurfaceChromaKey(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2673,7 +2304,7 @@ void GenericCommunicator::SetLayerChromaKey(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2697,7 +2328,7 @@ void GenericCommunicator::LayerAddNotification(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2721,7 +2352,7 @@ void GenericCommunicator::SurfaceAddNotification(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2745,7 +2376,7 @@ void GenericCommunicator::LayerRemoveNotification(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2769,7 +2400,7 @@ void GenericCommunicator::SurfaceRemoveNotification(t_ilm_message message)
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response, INVALID_ARGUMENT);
+        m_ipcModule.appendUint(response, ILM_ERROR_INVALID_ARGUMENTS);
     }
 
     m_ipcModule.sendToClients(response, &clientHandle, 1);
@@ -2796,158 +2427,158 @@ void GenericCommunicator::sendNotification(GraphicalObject* object, t_ilm_notifi
     switch (object->type)
     {
     case TypeLayer:
-    {
-        Layer* layer = static_cast<Layer*>(object);
-        if (layer)
         {
-            ApplicationReferenceList& arl = layer->getNotificationClients();
-
-            if (arl.size())
+            Layer* layer = static_cast<Layer*>(object);
+            if (layer)
             {
-                t_ilm_message notification;
-                Rectangle dest = layer->getDestinationRegion();
-                Rectangle src = layer->getSourceRegion();
-                OrientationType orientation = layer->getOrientation();
-
-                unsigned char chromaKeyRed = 0;
-                unsigned char chromaKeyGreen = 0;
-                unsigned char chromaKeyBlue = 0;
-                layer->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
-
-                std::stringstream notificationName;
-                notificationName << "NotificationForLayer" << layer->getID();
-
-                notification = m_ipcModule.createNotification(notificationName.str().c_str());
-                m_ipcModule.appendUint(notification, layer->getID());
-                m_ipcModule.appendUint(notification, mask);
-
-                m_ipcModule.appendDouble(notification, layer->getOpacity());
-                m_ipcModule.appendUint(notification, src.x);
-                m_ipcModule.appendUint(notification, src.y);
-                m_ipcModule.appendUint(notification, src.width);
-                m_ipcModule.appendUint(notification, src.height);
-                m_ipcModule.appendUint(notification, layer->OriginalSourceWidth);
-                m_ipcModule.appendUint(notification, layer->OriginalSourceHeight);
-                m_ipcModule.appendUint(notification, dest.x);
-                m_ipcModule.appendUint(notification, dest.y);
-                m_ipcModule.appendUint(notification, dest.width);
-                m_ipcModule.appendUint(notification, dest.height);
-                m_ipcModule.appendUint(notification, orientation);
-                m_ipcModule.appendBool(notification, layer->getVisibility());
-                m_ipcModule.appendUint(notification, layer->getLayerType());
-                m_ipcModule.appendBool(notification, layer->getChromaKeyEnabled());
-                m_ipcModule.appendUint(notification, chromaKeyRed);
-                m_ipcModule.appendUint(notification, chromaKeyGreen);
-                m_ipcModule.appendUint(notification, chromaKeyBlue);
-                m_ipcModule.appendInt(notification, layer->getCreatorPid());
-
-                int clientCount = arl.size();
-                t_ilm_client_handle clientArray[256];
-
-                ApplicationReferenceList::iterator iter = arl.begin();
-                ApplicationReferenceList::iterator end = arl.end();
-
-                for (int clientNumber = 0;
-                     iter != end, clientNumber < 256;
-                     ++iter, ++clientNumber)
-                {
-                    t_ilm_client_handle client = *iter;
-                    clientArray[clientNumber] = client;
-                }
+                ApplicationReferenceList& arl = layer->getNotificationClients();
 
-                LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): layer " << layer->getID() << " was updated.");
-
-                if (!m_ipcModule.sendToClients(notification, clientArray, clientCount))
+                if (arl.size())
                 {
-                    LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
+                    t_ilm_message notification;
+                    Rectangle dest = layer->getDestinationRegion();
+                    Rectangle src = layer->getSourceRegion();
+                    OrientationType orientation = layer->getOrientation();
+
+                    unsigned char chromaKeyRed = 0;
+                    unsigned char chromaKeyGreen = 0;
+                    unsigned char chromaKeyBlue = 0;
+                    layer->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
+
+                    std::stringstream notificationName;
+                    notificationName << "NotificationForLayer" << layer->getID();
+
+                    notification = m_ipcModule.createNotification(notificationName.str().c_str());
+                    m_ipcModule.appendUint(notification, layer->getID());
+                    m_ipcModule.appendUint(notification, mask);
+
+                    m_ipcModule.appendDouble(notification, layer->getOpacity());
+                    m_ipcModule.appendUint(notification, src.x);
+                    m_ipcModule.appendUint(notification, src.y);
+                    m_ipcModule.appendUint(notification, src.width);
+                    m_ipcModule.appendUint(notification, src.height);
+                    m_ipcModule.appendUint(notification, layer->OriginalSourceWidth);
+                    m_ipcModule.appendUint(notification, layer->OriginalSourceHeight);
+                    m_ipcModule.appendUint(notification, dest.x);
+                    m_ipcModule.appendUint(notification, dest.y);
+                    m_ipcModule.appendUint(notification, dest.width);
+                    m_ipcModule.appendUint(notification, dest.height);
+                    m_ipcModule.appendUint(notification, orientation);
+                    m_ipcModule.appendBool(notification, layer->getVisibility());
+                    m_ipcModule.appendUint(notification, layer->getLayerType());
+                    m_ipcModule.appendBool(notification, layer->getChromaKeyEnabled());
+                    m_ipcModule.appendUint(notification, chromaKeyRed);
+                    m_ipcModule.appendUint(notification, chromaKeyGreen);
+                    m_ipcModule.appendUint(notification, chromaKeyBlue);
+                    m_ipcModule.appendInt(notification, layer->getCreatorPid());
+
+                    int clientCount = arl.size();
+                    t_ilm_client_handle clientArray[256];
+
+                    ApplicationReferenceList::iterator iter = arl.begin();
+                    ApplicationReferenceList::iterator end = arl.end();
+
+                    for (int clientNumber = 0;
+                            iter != end, clientNumber < 256;
+                            ++iter, ++clientNumber)
+                    {
+                        t_ilm_client_handle client = *iter;
+                        clientArray[clientNumber] = client;
+                    }
+
+                    LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): layer " << layer->getID() << " was updated.");
+
+                    if (!m_ipcModule.sendToClients(notification, clientArray, clientCount))
+                    {
+                        LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
+                    }
+
+                    m_ipcModule.destroyMessage(notification);
                 }
-
-                m_ipcModule.destroyMessage(notification);
             }
         }
-    }
-    break;
+        break;
     case TypeSurface:
-    {
-        Surface* surface = static_cast<Surface*>(object);
-        if (surface)
         {
-            ApplicationReferenceList& arl = surface->getNotificationClients();
-
-            if (arl.size())
+            Surface* surface = static_cast<Surface*>(object);
+            if (surface)
             {
-                t_ilm_message notification;
-                std::stringstream notificationName;
-                notificationName << "NotificationForSurface" << surface->getID();
-
-                unsigned char chromaKeyRed = 0;
-                unsigned char chromaKeyGreen = 0;
-                unsigned char chromaKeyBlue = 0;
-                surface->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
-
-                notification = m_ipcModule.createNotification(notificationName.str().c_str());
-                m_ipcModule.appendUint(notification, surface->getID());
-                m_ipcModule.appendUint(notification, mask);
-
-                m_ipcModule.appendDouble(notification, surface->getOpacity());
-                m_ipcModule.appendUint(notification, surface->getSourceRegion().x);
-                m_ipcModule.appendUint(notification, surface->getSourceRegion().y);
-                m_ipcModule.appendUint(notification, surface->getSourceRegion().width);
-                m_ipcModule.appendUint(notification, surface->getSourceRegion().height);
-                m_ipcModule.appendUint(notification, surface->OriginalSourceWidth);
-                m_ipcModule.appendUint(notification, surface->OriginalSourceHeight);
-                m_ipcModule.appendUint(notification, surface->getDestinationRegion().x);
-                m_ipcModule.appendUint(notification, surface->getDestinationRegion().y);
-                m_ipcModule.appendUint(notification, surface->getDestinationRegion().width);
-                m_ipcModule.appendUint(notification, surface->getDestinationRegion().height);
-                m_ipcModule.appendUint(notification, surface->getOrientation());
-                m_ipcModule.appendBool(notification, surface->getVisibility());
-                m_ipcModule.appendUint(notification, surface->frameCounter);
-                m_ipcModule.appendUint(notification, surface->drawCounter);
-                m_ipcModule.appendUint(notification, surface->updateCounter);
-                m_ipcModule.appendUint(notification, surface->getPixelFormat());
-                m_ipcModule.appendUint(notification, surface->getNativeContent());
-                m_ipcModule.appendUint(notification, surface->getInputEventAcceptanceOnDevices());
-                m_ipcModule.appendBool(notification, surface->getChromaKeyEnabled());
-                m_ipcModule.appendUint(notification, chromaKeyRed);
-                m_ipcModule.appendUint(notification, chromaKeyGreen);
-                m_ipcModule.appendUint(notification, chromaKeyBlue);
-                m_ipcModule.appendInt(notification, surface->getCreatorPid());
-
-                int clientCount = arl.size();
-                t_ilm_client_handle clients[256];
-
-                ApplicationReferenceList::iterator iter = arl.begin();
-                ApplicationReferenceList::iterator end = arl.end();
-
-                for (int clientNumber = 0;
-                     iter != end, clientNumber < 256;
-                     ++iter, ++clientNumber)
-                {
-                    clients[clientNumber] = *iter;
-                }
-
-                LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): surface " << surface->getID() << " was updated.");
+                ApplicationReferenceList& arl = surface->getNotificationClients();
 
-                if (!m_ipcModule.sendToClients(notification, clients, clientCount))
+                if (arl.size())
                 {
-                    LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
+                    t_ilm_message notification;
+                    std::stringstream notificationName;
+                    notificationName << "NotificationForSurface" << surface->getID();
+
+                    unsigned char chromaKeyRed = 0;
+                    unsigned char chromaKeyGreen = 0;
+                    unsigned char chromaKeyBlue = 0;
+                    surface->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
+
+                    notification = m_ipcModule.createNotification(notificationName.str().c_str());
+                    m_ipcModule.appendUint(notification, surface->getID());
+                    m_ipcModule.appendUint(notification, mask);
+
+                    m_ipcModule.appendDouble(notification, surface->getOpacity());
+                    m_ipcModule.appendUint(notification, surface->getSourceRegion().x);
+                    m_ipcModule.appendUint(notification, surface->getSourceRegion().y);
+                    m_ipcModule.appendUint(notification, surface->getSourceRegion().width);
+                    m_ipcModule.appendUint(notification, surface->getSourceRegion().height);
+                    m_ipcModule.appendUint(notification, surface->OriginalSourceWidth);
+                    m_ipcModule.appendUint(notification, surface->OriginalSourceHeight);
+                    m_ipcModule.appendUint(notification, surface->getDestinationRegion().x);
+                    m_ipcModule.appendUint(notification, surface->getDestinationRegion().y);
+                    m_ipcModule.appendUint(notification, surface->getDestinationRegion().width);
+                    m_ipcModule.appendUint(notification, surface->getDestinationRegion().height);
+                    m_ipcModule.appendUint(notification, surface->getOrientation());
+                    m_ipcModule.appendBool(notification, surface->getVisibility());
+                    m_ipcModule.appendUint(notification, surface->frameCounter);
+                    m_ipcModule.appendUint(notification, surface->drawCounter);
+                    m_ipcModule.appendUint(notification, surface->updateCounter);
+                    m_ipcModule.appendUint(notification, surface->getPixelFormat());
+                    m_ipcModule.appendUint(notification, surface->getNativeContent());
+                    m_ipcModule.appendUint(notification, surface->getInputEventAcceptanceOnDevices());
+                    m_ipcModule.appendBool(notification, surface->getChromaKeyEnabled());
+                    m_ipcModule.appendUint(notification, chromaKeyRed);
+                    m_ipcModule.appendUint(notification, chromaKeyGreen);
+                    m_ipcModule.appendUint(notification, chromaKeyBlue);
+                    m_ipcModule.appendInt(notification, surface->getCreatorPid());
+
+                    int clientCount = arl.size();
+                    t_ilm_client_handle clients[256];
+
+                    ApplicationReferenceList::iterator iter = arl.begin();
+                    ApplicationReferenceList::iterator end = arl.end();
+
+                    for (int clientNumber = 0;
+                            iter != end, clientNumber < 256;
+                            ++iter, ++clientNumber)
+                    {
+                        clients[clientNumber] = *iter;
+                    }
+
+                    LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): surface " << surface->getID() << " was updated.");
+
+                    if (!m_ipcModule.sendToClients(notification, clients, clientCount))
+                    {
+                        LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
+                    }
+
+                    m_ipcModule.destroyMessage(notification);
                 }
-
-                m_ipcModule.destroyMessage(notification);
             }
         }
-    }
-    break;
+        break;
     default:
         LOG_INFO("GenericCommunicator", "Unknown notification found in queue.");
         break;
     }
 }
 
-HealthCondition GenericCommunicator::getHealth()
+HealthCondition GenericCommunicator::pluginGetHealth()
 {
-    HealthCondition health = PluginBase::getHealth();
+    HealthCondition health = PluginBase::pluginGetHealth();
     if (0 != pthread_kill(mThreadId, 0))
     {
         health = HealthDead;
@@ -2960,26 +2591,26 @@ void GenericCommunicator::SetOptimizationMode(t_ilm_message message)
     t_ilm_message response;
     OptimizationType optimizationId;
     OptimizationModeType optimizationMode;
-    unsigned int o;    
+    unsigned int optMode;
     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 
-    m_ipcModule.getUint(message,&o);
-    optimizationId = (OptimizationType) o;
-    m_ipcModule.getUint(message,&o);
-    optimizationMode = (OptimizationModeType) o;
+    m_ipcModule.getUint(message, &optMode);
+    optimizationId = (OptimizationType)optMode;
+    m_ipcModule.getUint(message, &optMode);
+    optimizationMode = (OptimizationModeType)optMode;
 
     t_ilm_bool status = m_executor->execute(new SetOptimizationModeCommand(clientPid, optimizationId, optimizationMode));
     if (status)
     {
-        response = m_ipcModule.createResponse(message);       
+        response = m_ipcModule.createResponse(message);
     }
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response,RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
-    m_ipcModule.sendToClients(response,&clientHandle,1);
+    m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
 }
 
@@ -2992,33 +2623,62 @@ void GenericCommunicator::GetOptimizationMode(t_ilm_message message)
     OptimizationModeType optimizationMode;
     unsigned int o;
 
-    m_ipcModule.getUint(message,&o);
+    m_ipcModule.getUint(message, &o);
     optimizationId = (OptimizationType)o;
 
     t_ilm_bool status = m_executor->execute(new GetOptimizationModeCommand(clientPid, optimizationId, &optimizationMode));
     if (status)
     {
-        
         response = m_ipcModule.createResponse(message);
-        m_ipcModule.appendUint(response,(unsigned int)optimizationMode);
+        m_ipcModule.appendUint(response, (unsigned int)optimizationMode);
     }
     else
     {
         response = m_ipcModule.createErrorResponse(message);
-        m_ipcModule.appendString(response,RESOURCE_NOT_FOUND);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
     }
-    m_ipcModule.sendToClients(response,&clientHandle,1);
+    m_ipcModule.sendToClients(response, &clientHandle, 1);
     m_ipcModule.destroyMessage(response);
-
 }
 
-extern "C" ICommunicator* createGenericCommunicator(ICommandExecutor* executor)
+void GenericCommunicator::GetPropertiesOfScreen(t_ilm_message message)
 {
-    return new GenericCommunicator(executor);
-}
+    t_ilm_message response;
+    t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
+    uint id = 0;
+    m_ipcModule.getUint(message, &id);
 
-extern "C" void destroyGenericCommunicator(GenericCommunicator* p)
-{
-    delete p;
+    LmScreen* screen = m_executor->getScene()->getScreen(id);
+    if (screen != NULL)
+    {
+        LayerList renderOrder = screen->getCurrentRenderOrder();
+        std::vector<t_ilm_layer> layerIdVector;
+
+        LayerListConstIterator iter = renderOrder.begin();
+        LayerListConstIterator end = renderOrder.end();
+        for (; iter != end; ++iter)
+        {
+            layerIdVector.push_back((*iter)->getID());
+        }
+
+        uint numberOfHardwareLayers = m_executor->getNumberOfHardwareLayers(id);
+        uint* resolution = m_executor->getScreenResolution(id);
+
+        response = m_ipcModule.createResponse(message);
+        m_ipcModule.appendUintArray(response, layerIdVector.data(), layerIdVector.size());
+        m_ipcModule.appendUint(response, numberOfHardwareLayers);
+        m_ipcModule.appendUint(response, resolution[0]);
+        m_ipcModule.appendUint(response, resolution[1]);
+    }
+    else
+    {
+        response = m_ipcModule.createErrorResponse(message);
+        m_ipcModule.appendUint(response, ILM_ERROR_RESOURCE_NOT_FOUND);
+    }
+
+    m_ipcModule.sendToClients(response, &clientHandle, 1);
+    m_ipcModule.destroyMessage(response);
 }
 
+DECLARE_LAYERMANAGEMENT_PLUGIN(GenericCommunicator)
+