* Common-API 3 integration and fix for the asserts order in the router tests.

Signed-off-by: Christian Linke <christian.linke@bmw.de>

6 files changed, 429 insertions, 277 deletions

diff --git a/cmake/CommonAPI.cmake b/cmake/CommonAPI.cmake
new file mode 100755
index 0000000..f98bcda
--- /dev/null
+++ b/cmake/CommonAPI.cmake
@@ -0,0 +1,291 @@
+#
+# Find common-api sources
+#
+# This module defines these variables:
+#
+#  ${PARAMS_TARGET}_GEN_HEADERS
+#      A list with generated headers
+#  ${PARAMS_TARGET}_GEN_SOURCES
+#      A list with generated sources
+#  ${PARAMS_TARGET}_GEN_INCLUDE_DIR
+#     A list with include directories
+
+include(CMakeParseArguments)
+include(TargetArch)
+
+MACRO(LOAD_COMMONAPI)
+    #parse the input parameters
+    set(options DBUS SOMEIP)
+    set(oneValueArgs "")
+    set(multiValueArgs "")
+    cmake_parse_arguments(PARAMS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    
+    # check the binding parameter ...
+    if(PARAMS_DBUS)
+        SET(COMMONAPI_USED_BINDING 0 CACHE INTERNAL "hide this!" FORCE)
+    elseif(PARAMS_SOMEIP)
+        SET(COMMONAPI_USED_BINDING 1 CACHE INTERNAL "hide this!" FORCE)
+    else()
+        SET(COMMONAPI_USED_BINDING 0 CACHE INTERNAL "hide this!" FORCE)
+    endif()
+    # load the proper libs ...
+	IF(NOT CommonAPI_FOUND)
+		FIND_PACKAGE(CommonAPI REQUIRED)
+		FIND_LIBRARY(CommonAPI_LIBRARY 
+		             REQUIRED
+		             NAMES CommonAPI
+		             PATHS
+		             "/usr/local/lib"
+		             "/usr/lib"
+		            )  
+	ENDIF(NOT CommonAPI_FOUND)
+	message(STATUS "CommonAPI Version: ${CommonAPI_VERSION}")
+	
+	string(REPLACE "." "" COMMONAPI_VERSION_NUMBER ${CommonAPI_VERSION})
+	SET(COMMONAPI_VERSION_NUMBER ${COMMONAPI_VERSION_NUMBER} CACHE INTERNAL "hide this!" FORCE)
+	SET(CommonAPI_VERSION ${CommonAPI_VERSION} PARENT_SCOPE)    
+
+    IF(${COMMONAPI_USED_BINDING} EQUAL 1)
+    	IF(NOT CommonAPI-SomeIP_FOUND)
+	        FIND_PACKAGE(CommonAPI-SomeIP REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
+	        FIND_LIBRARY(CommonAPI-SomeIP_LIBRARY 
+	                     REQUIRED
+	                     NAMES CommonAPI-SomeIP
+	                     PATHS
+	                     "/usr/local/lib"
+	                     "/usr/lib"
+	                    ) 
+        ENDIF(NOT CommonAPI-SomeIP_FOUND)
+        message(STATUS "CommonAPI-SomeIP Version: ${CommonAPI-SomeIP_VERSION}")
+        
+        string(REPLACE "." "" COMMONAPI_SOMEIP_VERSION_NUMBER ${CommonAPI-SomeIP_VERSION})
+        SET(COMMONAPI_SOMEIP_VERSION_NUMBER ${COMMONAPI_SOMEIP_VERSION_NUMBER} CACHE INTERNAL "hide this!" FORCE)
+    ELSE()
+    	SET(COMMONAPI_USED_BINDING 0 CACHE INTERNAL "hide this!" FORCE)
+    	IF(NOT CommonAPI-DBus_FOUND)
+    		FIND_PACKAGE(DBUS REQUIRED)
+	        FIND_PACKAGE(CommonAPI-DBus REQUIRED CONFIG NO_CMAKE_PACKAGE_REGISTRY)
+	        FIND_LIBRARY(CommonAPI-DBus_LIBRARY 
+	                     REQUIRED
+	                     NAMES CommonAPI-DBus
+	                     PATHS
+	                     "/usr/local/lib"
+	                     "/usr/lib"
+	                    ) 
+        ENDIF(NOT CommonAPI-DBus_FOUND)            
+        message(STATUS "CommonAPI-DBus Version: ${CommonAPI-DBus_VERSION}")
+        
+        string(REPLACE "." "" COMMONAPI_DBUS_VERSION_NUMBER ${CommonAPI-DBus_VERSION})
+        SET(COMMONAPI_DBUS_VERSION_NUMBER ${COMMONAPI_DBUS_VERSION_NUMBER} CACHE INTERNAL "hide this!" FORCE)
+    ENDIF()
+    
+ENDMACRO()
+
+# helper function giving a string with the current architecture
+function(GET_TARGET_ARCH OUT_ARCH)
+    target_architecture(TARGET_ARCH)
+    IF("${TARGET_ARCH}" STREQUAL "i386")
+        SET(${OUT_ARCH} "x86" PARENT_SCOPE)
+    ELSEIF("${TARGET_ARCH}" STREQUAL "x86_64")
+        SET(${OUT_ARCH} "x86_64" PARENT_SCOPE)
+    ELSE()       
+        SET(${OUT_ARCH} "x86_64" PARENT_SCOPE)
+    ENDIF()    
+endfunction()
+
+# helper function giving a string with the current host
+function(GET_TARGET_HOST OUT_HOST)
+    IF(CMAKE_HOST_WIN32)
+        SET(${OUT_HOST} "windows" PARENT_SCOPE) 
+    ELSE()#CMAKE_HOST_UNIX
+        SET(${OUT_HOST} "linux" PARENT_SCOPE)
+    ENDIF()
+endfunction()
+
+# get lists with headers and sources after they has been generated
+macro(GET_GENERATED_FILES GEN_DESTINATION)
+       
+        #searching for generated headers
+        execute_process(COMMAND find ${GEN_DESTINATION} -name *.hpp
+                        RESULT_VARIABLE EXIT_CODE
+                        OUTPUT_VARIABLE _CAPI_HEADERS
+                        ERROR_VARIABLE CAPI_HEADERS_ERROR
+                        OUTPUT_STRIP_TRAILING_WHITESPACE
+                        ERROR_STRIP_TRAILING_WHITESPACE)
+        
+        IF(CAPI_HEADERS_ERROR)
+            MESSAGE(FATAL_ERROR "Can't find common-api generated headers!")
+        ENDIF()
+        string(REPLACE "\n" ";" CAPI_HEADERS ${_CAPI_HEADERS})
+        
+        FOREACH(INCLUDE_ITER ${CAPI_HEADERS})
+            GET_FILENAME_COMPONENT(TEMP_PATH ${INCLUDE_ITER} PATH)
+            SET(CAPI_INCLUDES ${CAPI_INCLUDES} ${TEMP_PATH})
+        ENDFOREACH(INCLUDE_ITER ${CAPI_HEADERS})       
+        LIST(REMOVE_DUPLICATES CAPI_INCLUDES)
+        
+        #searching for generated sources
+        execute_process(COMMAND find ${GEN_DESTINATION} -name *.cpp
+                        RESULT_VARIABLE EXIT_CODE
+                        OUTPUT_VARIABLE _CAPI_SOURCES
+                        ERROR_VARIABLE CAPI_SOURCES_ERROR
+                        OUTPUT_STRIP_TRAILING_WHITESPACE
+                        ERROR_STRIP_TRAILING_WHITESPACE)
+        IF(CAPI_SOURCES_ERROR)
+            MESSAGE(FATAL_ERROR "Can't find common-api generated sources!")
+        ENDIF()
+        string(REPLACE "\n" ";" CAPI_SOURCES ${_CAPI_SOURCES})
+        LIST(REMOVE_DUPLICATES CAPI_SOURCES)
+                           
+        set(${PARAMS_TARGET}_GEN_HEADERS ${CAPI_HEADERS} PARENT_SCOPE)
+        set(${PARAMS_TARGET}_GEN_SOURCES ${CAPI_SOURCES} PARENT_SCOPE)
+                
+        #add base path src-gen
+        SET(${PARAMS_TARGET}_GEN_INCLUDE_DIR ${CAPI_INCLUDES} ${GEN_DESTINATION} PARENT_SCOPE)   
+endmacro(GET_GENERATED_FILES)
+
+macro(FIND_AND_EXEC_GENERATOR GENERATOR_EXECUTABLE SHOULD_GENERATE_STUB_DEFAULT)
+    MESSAGE(STATUS "Searching for common-api generator executable ${GENERATOR_EXECUTABLE} ...")
+    # find the generator binary ...
+    execute_process(COMMAND find "/usr/local/share/CommonAPI-${CommonAPI_VERSION}" -name ${GENERATOR_EXECUTABLE}
+                        RESULT_VARIABLE EXIT_CODE
+                        OUTPUT_VARIABLE OUT_RESULT
+                        ERROR_VARIABLE OUT_ERROR
+                        OUTPUT_STRIP_TRAILING_WHITESPACE
+                        ERROR_STRIP_TRAILING_WHITESPACE)
+	
+    IF(OUT_ERROR)
+         # in case of error just try to find the sources in the alternative folder
+        SET(TEMP_GEN_DST ${PARAMS_ALT_DESTINATION})
+        message(STATUS "Common-api generator error / ${OUT_ERROR} /. Will try the alternative folder!")
+    ELSEIF(NOT OUT_RESULT)
+        # in case of error just try to find the sources in the alternative folder
+        SET(TEMP_GEN_DST ${PARAMS_ALT_DESTINATION})
+        message(STATUS "Common-api generator can't be found. Will try the alternative folder!")
+    ELSE()
+        # the generator binary is found
+        MESSAGE(STATUS "Will execute common-api generator at path ${OUT_RESULT}")
+        function(mktmpdir OUTVAR)
+            while(NOT TEMP_DESTINATION OR EXISTS ${TEMP_DESTINATION})
+                string(RANDOM LENGTH 16 TEMP_DESTINATION)
+                set(TEMP_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${TEMP_DESTINATION}")
+            endwhile()
+
+           file(MAKE_DIRECTORY ${TEMP_DESTINATION})
+
+           set(${OUTVAR} ${TEMP_DESTINATION} PARENT_SCOPE)
+        endfunction()
+        # execute the generate command ...      
+        IF(${SHOULD_GENERATE_STUB_DEFAULT} EQUAL 1)  
+	        execute_process(COMMAND ${OUT_RESULT} -sk Default -d ${PARAMS_DESTINATION} ${FIDLS}
+	                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+	                        RESULT_VARIABLE EXIT_CODE
+	                        OUTPUT_VARIABLE GENERATOR_OUTPUT
+	                        ERROR_VARIABLE GENERATOR_ERR_OUTPUT
+	                        OUTPUT_STRIP_TRAILING_WHITESPACE
+	                        ERROR_STRIP_TRAILING_WHITESPACE)
+        ELSE()
+       		execute_process(COMMAND ${OUT_RESULT} -d ${PARAMS_DESTINATION} ${FIDLS}
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                        RESULT_VARIABLE EXIT_CODE
+                        OUTPUT_VARIABLE GENERATOR_OUTPUT
+                        ERROR_VARIABLE GENERATOR_ERR_OUTPUT
+                        OUTPUT_STRIP_TRAILING_WHITESPACE
+                        ERROR_STRIP_TRAILING_WHITESPACE)
+        ENDIF()                
+        if(EXIT_CODE)
+            message(FATAL_ERROR "Failed to generate files from FIDL:${GENERATOR_OUTPUT}")
+        elseif(GENERATOR_ERR_OUTPUT)
+        	message(FATAL_ERROR "Common-API generator error:${GENERATOR_ERR_OUTPUT}")
+        endif()
+        SET(TEMP_GEN_DST ${PARAMS_DESTINATION})   
+    ENDIF()
+endmacro(FIND_AND_EXEC_GENERATOR GENERATOR_EXECUTABLE ADDITIONAL_ARGS)
+
+# generate common-api sources and retreive a list with them 
+MACRO(EXECUTE_GENERATOR)    
+    # construct the generator binary name...
+    GET_TARGET_HOST(_TARGET_HOST)
+    GET_TARGET_ARCH(_TARGET_ARCH)
+    SET(COMMONAPI_GENERATOR_EXECUTABLE commonapi-generator-${_TARGET_HOST}-${_TARGET_ARCH})
+    IF(${COMMONAPI_USED_BINDING} EQUAL 1)
+        SET(COMMONAPI_BINDING_GENERATOR_EXECUTABLE commonapi-someip-generator-${_TARGET_HOST}-${_TARGET_ARCH})
+    ELSE()
+        SET(COMMONAPI_BINDING_GENERATOR_EXECUTABLE commonapi-dbus-generator-${_TARGET_HOST}-${_TARGET_ARCH})
+    ENDIF()
+    # prepare an additional compatibilty flag for generators prior 3.x.x ...
+    IF(${COMMONAPI_VERSION_NUMBER} GREATER 300 OR ${COMMONAPI_VERSION_NUMBER} EQUAL 300)
+        # >= 3.x.x the stubs are generated by the binding generator
+       	SET(GENERATE_STUB 1) 
+    ELSE() 
+        # < 3.0.0 the stubs are generated by the genric generator
+    	SET(GENERATE_STUB 0) 
+    ENDIF()
+    # searching for common-api-generator executable ...
+    FIND_AND_EXEC_GENERATOR(${COMMONAPI_GENERATOR_EXECUTABLE} ${GENERATE_STUB})
+    FIND_AND_EXEC_GENERATOR(${COMMONAPI_BINDING_GENERATOR_EXECUTABLE} FALSE)
+    # get the lists with the sources and headers
+    message(STATUS "Looking for generated common-api files...")
+    GET_GENERATED_FILES(${TEMP_GEN_DST})
+ENDMACRO(EXECUTE_GENERATOR)
+
+FUNCTION(COMMON_API_GENERATE_SOUCRES)
+    #parse the input parameters
+    set(options "")
+    set(oneValueArgs TARGET DESTINATION ALT_DESTINATION HEADER_TEMPLATE)
+    set(multiValueArgs FIDLS FIDL_DEPENDS)
+
+    cmake_parse_arguments(PARAMS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    
+     if(NOT IS_ABSOLUTE ${PARAMS_DESTINATION})
+         set(PARAMS_DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${PARAMS_DESTINATION})
+    endif()
+    
+    if(NOT IS_ABSOLUTE ${PARAMS_ALT_DESTINATION})
+         set(PARAMS_DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${PARAMS_ALT_DESTINATION})
+    endif()
+    # check the cmake option, whether to use the generator or not ...
+    IF(NOT WITH_COMMON_API_GEN)
+        message(STATUS "Looking for generated common-api files...")
+        # check which of the given folders exists and get it as destination
+        IF(EXISTS ${PARAMS_DESTINATION})
+            GET_GENERATED_FILES(${PARAMS_DESTINATION})
+        ELSE()
+            GET_GENERATED_FILES(${PARAMS_ALT_DESTINATION})
+        ENDIF()    
+    ELSE()
+        
+        if(NOT PARAMS_FIDLS)
+            message(FATAL_ERROR "FIDLS must be specified")
+        endif()
+    
+        if(NOT PARAMS_TARGET)
+            message(FATAL_ERROR "TARGET must be specified")
+        endif()
+    
+        if(PARAMS_HEADER_TEMPLATE)
+            list(APPEND ARGS -pref ${PARAMS_HEADER_TEMPLATE})
+        endif()
+        
+        foreach(FIDL ${PARAMS_FIDLS})
+            get_filename_component(FIDL_PATH ${FIDL} ABSOLUTE)
+        
+            # Run configure_file on the .fidl - this forces cmake to reexecute its
+            # configure phase if the input file changes.
+            string(MD5 ${FIDL_PATH} FIDL_CHECKSUM)
+            configure_file(${FIDL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${FIDL_CHECKSUM}.fidl.done)
+        
+            list(APPEND FIDLS ${FIDL_PATH})
+        endforeach()
+        
+        message(STATUS "Will generate common-api files for ${PARAMS_FIDLS} ...")
+         
+        foreach(FIDL_DEPEND ${PARAMS_FIDL_DEPENDS})
+            string(MD5 ${FIDL_PATH} FIDL_CHECKSUM)
+            configure_file(${FIDL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${FIDL_CHECKSUM}.fidl.done)
+        endforeach()
+        # run the generator ...
+        EXECUTE_GENERATOR()
+     ENDIF()
+ENDFUNCTION()
+
diff --git a/cmake/CommonAPIGenerator.cmake b/cmake/CommonAPIGenerator.cmake
deleted file mode 100755
index 332f9e6..0000000
--- a/cmake/CommonAPIGenerator.cmake
+++ /dev/null
@@ -1,205 +0,0 @@
-#
-# Find common-api sources
-#
-# This module defines these variables:
-#
-#  ${PARAMS_TARGET}_GEN_HEADERS
-#      A list with generated headers
-#  ${PARAMS_TARGET}_GEN_SOURCES
-#      A list with generated sources
-#  ${PARAMS_TARGET}_GEN_INCLUDE_DIR
-#     A list with include directories
-
-include(CMakeParseArguments)
-
-IF(COMMON_API_FOUND AND COMMON_API_DBUS_FOUND)
-    # get lists with headers and sources after they has been generated
-    macro(SEARCH_FOR_COMMON_API_GEN_FILES GEN_DESTINATION)
-           
-            #searching for generated headers
-            execute_process(COMMAND find ${GEN_DESTINATION} -name *.h
-                            RESULT_VARIABLE EXIT_CODE
-                            OUTPUT_VARIABLE _CAPI_HEADERS
-                            ERROR_VARIABLE CAPI_HEADERS_ERROR
-                            OUTPUT_STRIP_TRAILING_WHITESPACE
-                            ERROR_STRIP_TRAILING_WHITESPACE)
-            
-            IF(CAPI_HEADERS_ERROR)
-                MESSAGE(FATAL_ERROR "Can't find common-api generated headers!")
-            ENDIF()
-            string(REPLACE "\n" ";" CAPI_HEADERS ${_CAPI_HEADERS})
-            
-            FOREACH(INCLUDE_ITER ${CAPI_HEADERS})
-                GET_FILENAME_COMPONENT(TEMP_PATH ${INCLUDE_ITER} PATH)
-                SET(CAPI_INCLUDES ${CAPI_INCLUDES} ${TEMP_PATH})
-            ENDFOREACH(INCLUDE_ITER ${CAPI_HEADERS})       
-            LIST(REMOVE_DUPLICATES CAPI_INCLUDES)
-            
-            #searching for generated sources
-            execute_process(COMMAND find ${GEN_DESTINATION} -name *.cpp
-                            RESULT_VARIABLE EXIT_CODE
-                            OUTPUT_VARIABLE _CAPI_SOURCES
-                            ERROR_VARIABLE CAPI_SOURCES_ERROR
-                            OUTPUT_STRIP_TRAILING_WHITESPACE
-                            ERROR_STRIP_TRAILING_WHITESPACE)
-            IF(CAPI_SOURCES_ERROR)
-                MESSAGE(FATAL_ERROR "Can't find common-api generated sources!")
-            ENDIF()
-            string(REPLACE "\n" ";" CAPI_SOURCES ${_CAPI_SOURCES})
-            LIST(REMOVE_DUPLICATES CAPI_SOURCES)
-                               
-            set(${PARAMS_TARGET}_GEN_HEADERS ${CAPI_HEADERS} PARENT_SCOPE)
-            set(${PARAMS_TARGET}_GEN_SOURCES ${CAPI_SOURCES} PARENT_SCOPE)
-                            
-            #add base path src-gen
-            SET(${PARAMS_TARGET}_GEN_INCLUDE_DIR ${CAPI_INCLUDES} ${GEN_DESTINATION} PARENT_SCOPE)   
-    endmacro()
-    
-    # generate common-api sources and retreive a list with them 
-    macro(GENERATE_FILES)    
-
-
-        # searching for common-api-generator executable ...
-        FIND_PATH(COMMONAPI_GENERATOR_JAR
-                      NAMES 
-                          "common-api-generator.jar"
-                      PATH_SUFFIXES 
-                          CommonAPI-${COMMON_API_VERSION}	 
-                      PATHS
-                          "/usr/share" 
-                          "/usr/local/share")
-       
-		FIND_PATH(COMMONAPI_GENERATOR_EXE
-                      NAMES 
-                          "commonapi_generator"
-                      PATH_SUFFIXES 
-                          CommonAPI-${COMMON_API_VERSION}	 
-                      PATHS
-						  "~"
-                          "/usr/share" 
-                          "/usr/local/share")
-
-        if(COMMONAPI_GENERATOR_JAR)
-            # load java runtime ...
-            find_package(Java COMPONENTS Runtime REQUIRED QUIET)
-            function(mktmpdir OUTVAR)
-                while(NOT TEMP_DESTINATION OR EXISTS ${TEMP_DESTINATION})
-                    string(RANDOM LENGTH 16 TEMP_DESTINATION)
-                    set(TEMP_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${TEMP_DESTINATION}")
-                endwhile()
-    
-               file(MAKE_DIRECTORY ${TEMP_DESTINATION})
-    
-               set(${OUTVAR} ${TEMP_DESTINATION} PARENT_SCOPE)
-            endfunction()
-            # execute the generate command ...
-            execute_process(COMMAND ${Java_JAVA_EXECUTABLE} -jar "${COMMONAPI_GENERATOR_JAR}/common-api-generator.jar" -dest ${PARAMS_DESTINATION} ${ARGS} ${FIDLS}
-                            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                            RESULT_VARIABLE EXIT_CODE
-                            OUTPUT_VARIABLE GENERATOR_OUTPUT
-                            ERROR_VARIABLE GENERATOR_OUTPUT
-                            OUTPUT_STRIP_TRAILING_WHITESPACE
-                            ERROR_STRIP_TRAILING_WHITESPACE)
-            if(EXIT_CODE)
-                message(FATAL_ERROR "Failed to generate files from FIDL:\n ${GENERATOR_OUTPUT}")
-            endif()
-            SET(TEMP_GEN_DST ${PARAMS_DESTINATION})
-		elseif(COMMONAPI_GENERATOR_EXE)
-            # load executable
-            function(mktmpdir OUTVAR)
-                while(NOT TEMP_DESTINATION OR EXISTS ${TEMP_DESTINATION})
-                    string(RANDOM LENGTH 16 TEMP_DESTINATION)
-                    set(TEMP_DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${TEMP_DESTINATION}")
-                endwhile()
-    
-               file(MAKE_DIRECTORY ${TEMP_DESTINATION})
-    
-               set(${OUTVAR} ${TEMP_DESTINATION} PARENT_SCOPE)
-            endfunction()
-    
-            # execute the generate command ...
-            execute_process(COMMAND ${COMMONAPI_GENERATOR_EXE}/commonapi_generator -dest ${PARAMS_DESTINATION} ${ARGS} ${FIDLS}
-                            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-                            RESULT_VARIABLE EXIT_CODE
-                            OUTPUT_VARIABLE GENERATOR_OUTPUT
-                            ERROR_VARIABLE GENERATOR_OUTPUT
-                            OUTPUT_STRIP_TRAILING_WHITESPACE
-                            ERROR_STRIP_TRAILING_WHITESPACE)
-            if(EXIT_CODE)
-                message(FATAL_ERROR "Failed to generate files from FIDL:\n ${GENERATOR_OUTPUT}")
-            endif()
-            SET(TEMP_GEN_DST ${PARAMS_DESTINATION})	
-        else()
-            # if the generator is not found, try to find the sources in the alternative folder
-            SET(TEMP_GEN_DST ${PARAMS_ALT_DESTINATION})
-            message(STATUS "Couldn't find a common-api generator...skiping generation!")
-        endif()
-        # get the lists with the sources and headers
-        message(STATUS "Looking for available common-api generated files...")
-        SEARCH_FOR_COMMON_API_GEN_FILES(${TEMP_GEN_DST})
-    endmacro()
-    
-    function(COMMON_API_GENERATE_SOUCRES)
-        #parse the input parameters
-        set(options DBUS)
-        set(oneValueArgs TARGET DESTINATION ALT_DESTINATION HEADER_TEMPLATE)
-        set(multiValueArgs FIDLS FIDL_DEPENDS)
-
-        cmake_parse_arguments(PARAMS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-        
-         if(NOT IS_ABSOLUTE ${PARAMS_DESTINATION})
-             set(PARAMS_DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${PARAMS_DESTINATION})
-        endif()
-        
-        if(NOT IS_ABSOLUTE ${PARAMS_ALT_DESTINATION})
-             set(PARAMS_DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/${PARAMS_ALT_DESTINATION})
-        endif()
-        # check the cmake option, whether to use the generator or not ...
-        IF(NOT WITH_COMMON_API_GEN)
-            message(STATUS "Looking for available common-api generated files...")
-            # check which of the given folders exists and get it as destination
-            IF(EXISTS ${PARAMS_DESTINATION})
-                SEARCH_FOR_COMMON_API_GEN_FILES(${PARAMS_DESTINATION})
-            ELSE()
-                SEARCH_FOR_COMMON_API_GEN_FILES(${PARAMS_ALT_DESTINATION})
-            ENDIF()    
-        ELSE()
-            message(STATUS "Will generate common-api files...")
-            if(NOT PARAMS_FIDLS)
-                message(FATAL_ERROR "FIDLS must be specified")
-            endif()
-        
-            if(NOT PARAMS_TARGET)
-                message(FATAL_ERROR "TARGET must be specified")
-            endif()
-        
-            if(PARAMS_DBUS)
-                  list(APPEND ARGS -dbus)
-            endif()
-        
-            if(PARAMS_HEADER_TEMPLATE)
-                list(APPEND ARGS -pref ${PARAMS_HEADER_TEMPLATE})
-            endif()
-            
-            foreach(FIDL ${PARAMS_FIDLS})
-                get_filename_component(FIDL_PATH ${FIDL} ABSOLUTE)
-            
-                # Run configure_file on the .fidl - this forces cmake to reexecute its
-                # configure phase if the input file changes.
-                string(MD5 ${FIDL_PATH} FIDL_CHECKSUM)
-                configure_file(${FIDL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${FIDL_CHECKSUM}.fidl.done)
-            
-                list(APPEND FIDLS ${FIDL_PATH})
-            endforeach()
-            
-            message(STATUS "Determining list of generated files for ${PARAMS_FIDLS}")
-            
-            foreach(FIDL_DEPEND ${PARAMS_FIDL_DEPENDS})
-                string(MD5 ${FIDL_PATH} FIDL_CHECKSUM)
-                configure_file(${FIDL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${FIDL_CHECKSUM}.fidl.done)
-            endforeach()
-            GENERATE_FILES()
-        ENDIF()
-    endfunction()
-
-ENDIF(COMMON_API_FOUND AND COMMON_API_DBUS_FOUND)
diff --git a/cmake/FindCommonAPI.cmake b/cmake/FindCommonAPI.cmake
deleted file mode 100644
index 958b729..0000000
--- a/cmake/FindCommonAPI.cmake
+++ /dev/null
@@ -1,72 +0,0 @@
-#
-# Copyright (C) 2012, BMW AG
-# 
-# \author Christian Linke
-# 
-
-include(UsePkgConfig)
-
-pkg_check_modules(COMMON_API CommonAPI)
-IF(COMMON_API_FOUND)	
-    FIND_PATH(COMMON_API_INCLUDE_DIR
-              NAMES CommonAPI/Runtime.h CommonAPI/Proxy.h 
-              PATH_SUFFIXES CommonAPI-${COMMON_API_VERSION}	 
-              PATHS
-              ${COMMON_API_INCLUDE_DIRS}	
-              "/usr/local/include"       	
-              "/usr/include")
-
-    FIND_LIBRARY(COMMON_API_LIBRARY 
-                 NAMES CommonAPI
-                 PATHS
-                 "/usr/local/lib"
-                 "/usr/lib"
-                )      
-ENDIF(COMMON_API_FOUND)
-
-pkg_check_modules(COMMON_API_DBUS CommonAPI-DBus)
-IF(COMMON_API_DBUS_FOUND)	
-    FIND_PATH(COMMON_API_DBUS_INCLUDE_DIR
-              NAMES CommonAPI/DBus/DBusRuntime.h CommonAPI/DBus/DBusProxy.h 
-              PATH_SUFFIXES CommonAPI-${COMMON_API_VERSION}	 
-              PATHS
-              ${COMMON_API_DBUS_INCLUDE_DIRS}	
-              "/usr/local/include"       	
-              "/usr/include")
-
-    FIND_LIBRARY(COMMON_API_DBUS_LIBRARY 
-                 NAMES CommonAPI-DBus murmurhash-internal
-                 PATHS
-                 "/usr/local/lib"
-                 "/usr/lib"
-                 )      
-ENDIF(COMMON_API_DBUS_FOUND)
-
-
-SET(COMMON_API_LIBRARIES ${COMMON_API_LIBRARY})
-
-IF(COMMON_API_INCLUDE_DIR AND COMMON_API_LIBRARY)   
-   message(STATUS "Found CommonAPI ${COMMON_API_VERSION}")
-ELSE(COMMON_API_LIBRARIES AND COMMON_API_LIBRARY)   
-   message(STATUS " CommonAPI not found.")
-ENDIF(COMMON_API_INCLUDE_DIR AND COMMON_API_LIBRARY)
-
-SET(COMMON_API_DBUS_LIBRARIES ${COMMON_API_DBUS_LIBRARY})
-
-IF(COMMON_API_DBUS_INCLUDE_DIR AND COMMON_API_DBUS_LIBRARY)   
-   message(STATUS "Found CommonAPI_DBUS")
-ELSE(COMMON_API_DBUS_INCLUDE_DIR AND COMMON_API_DBUS_LIBRARY)   
-   message(STATUS " CommonAPI_DBUS not found.")
-ENDIF(COMMON_API_DBUS_INCLUDE_DIR AND COMMON_API_DBUS_LIBRARY)
-				
-MARK_AS_ADVANCED(
-    COMMON_API_DBUS_LIBRARIES 
-    COMMON_API_DBUS_INCLUDE_DIR
-)		
-		
-MARK_AS_ADVANCED(
-    COMMON_API_LIBRARIES 
-    COMMON_API_INCLUDE_DIR
-    COMMON_API_GEN_INCLUDE_DIR
-    COMMON_API_GEN_SOURCES
-)
diff --git a/cmake/TargetArch.cmake b/cmake/TargetArch.cmake
new file mode 100644
index 0000000..3761e4d
--- /dev/null
+++ b/cmake/TargetArch.cmake
@@ -0,0 +1,134 @@
+# Based on the Qt 5 processor detection code, so should be very accurate
+# https://qt.gitorious.org/qt/qtbase/blobs/master/src/corelib/global/qprocessordetection.h
+# Currently handles arm (v5, v6, v7), x86 (32/64), ia64, and ppc (32/64)
+
+# Regarding POWER/PowerPC, just as is noted in the Qt source,
+# "There are many more known variants/revisions that we do not handle/detect."
+
+set(archdetect_c_code "
+#if defined(__arm__) || defined(__TARGET_ARCH_ARM)
+    #if defined(__ARM_ARCH_7__) \\
+        || defined(__ARM_ARCH_7A__) \\
+        || defined(__ARM_ARCH_7R__) \\
+        || defined(__ARM_ARCH_7M__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 7)
+        #error cmake_ARCH armv7
+    #elif defined(__ARM_ARCH_6__) \\
+        || defined(__ARM_ARCH_6J__) \\
+        || defined(__ARM_ARCH_6T2__) \\
+        || defined(__ARM_ARCH_6Z__) \\
+        || defined(__ARM_ARCH_6K__) \\
+        || defined(__ARM_ARCH_6ZK__) \\
+        || defined(__ARM_ARCH_6M__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 6)
+        #error cmake_ARCH armv6
+    #elif defined(__ARM_ARCH_5TEJ__) \\
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM-0 >= 5)
+        #error cmake_ARCH armv5
+    #else
+        #error cmake_ARCH arm
+    #endif
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+    #error cmake_ARCH i386
+#elif defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
+    #error cmake_ARCH x86_64
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+    #error cmake_ARCH ia64
+#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__) \\
+      || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \\
+      || defined(_M_MPPC) || defined(_M_PPC)
+    #if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
+        #error cmake_ARCH ppc64
+    #else
+        #error cmake_ARCH ppc
+    #endif
+#endif
+
+#error cmake_ARCH unknown
+")
+
+# Set ppc_support to TRUE before including this file or ppc and ppc64
+# will be treated as invalid architectures since they are no longer supported by Apple
+
+function(target_architecture output_var)
+    if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+        # On OS X we use CMAKE_OSX_ARCHITECTURES *if* it was set
+        # First let's normalize the order of the values
+
+        # Note that it's not possible to compile PowerPC applications if you are using
+        # the OS X SDK version 10.6 or later - you'll need 10.4/10.5 for that, so we
+        # disable it by default
+        # See this page for more information:
+        # http://stackoverflow.com/questions/5333490/how-can-we-restore-ppc-ppc64-as-well-as-full-10-4-10-5-sdk-support-to-xcode-4
+
+        # Architecture defaults to i386 or ppc on OS X 10.5 and earlier, depending on the CPU type detected at runtime.
+        # On OS X 10.6+ the default is x86_64 if the CPU supports it, i386 otherwise.
+
+        foreach(osx_arch ${CMAKE_OSX_ARCHITECTURES})
+            if("${osx_arch}" STREQUAL "ppc" AND ppc_support)
+                set(osx_arch_ppc TRUE)
+            elseif("${osx_arch}" STREQUAL "i386")
+                set(osx_arch_i386 TRUE)
+            elseif("${osx_arch}" STREQUAL "x86_64")
+                set(osx_arch_x86_64 TRUE)
+            elseif("${osx_arch}" STREQUAL "ppc64" AND ppc_support)
+                set(osx_arch_ppc64 TRUE)
+            else()
+                message(FATAL_ERROR "Invalid OS X arch name: ${osx_arch}")
+            endif()
+        endforeach()
+
+        # Now add all the architectures in our normalized order
+        if(osx_arch_ppc)
+            list(APPEND ARCH ppc)
+        endif()
+
+        if(osx_arch_i386)
+            list(APPEND ARCH i386)
+        endif()
+
+        if(osx_arch_x86_64)
+            list(APPEND ARCH x86_64)
+        endif()
+
+        if(osx_arch_ppc64)
+            list(APPEND ARCH ppc64)
+        endif()
+    else()
+        file(WRITE "${CMAKE_BINARY_DIR}/arch.c" "${archdetect_c_code}")
+
+        enable_language(C)
+
+        # Detect the architecture in a rather creative way...
+        # This compiles a small C program which is a series of ifdefs that selects a
+        # particular #error preprocessor directive whose message string contains the
+        # target architecture. The program will always fail to compile (both because
+        # file is not a valid C program, and obviously because of the presence of the
+        # #error preprocessor directives... but by exploiting the preprocessor in this
+        # way, we can detect the correct target architecture even when cross-compiling,
+        # since the program itself never needs to be run (only the compiler/preprocessor)
+        try_run(
+            run_result_unused
+            compile_result_unused
+            "${CMAKE_BINARY_DIR}"
+            "${CMAKE_BINARY_DIR}/arch.c"
+            COMPILE_OUTPUT_VARIABLE ARCH
+            CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
+        )
+
+        # Parse the architecture name from the compiler output
+        string(REGEX MATCH "cmake_ARCH ([a-zA-Z0-9_]+)" ARCH "${ARCH}")
+
+        # Get rid of the value marker leaving just the architecture name
+        string(REPLACE "cmake_ARCH " "" ARCH "${ARCH}")
+
+        # If we are compiling with an unknown architecture this variable should
+        # already be set to "unknown" but in the case that it's empty (i.e. due
+        # to a typo in the code), then set it to unknown
+        if (NOT ARCH)
+            set(ARCH unknown)
+        endif()
+    endif()
+
+    set(${output_var} "${ARCH}" PARENT_SCOPE)
+endfunction()
diff --git a/cmake/audiomanagerConfig.cmake.in b/cmake/audiomanagerConfig.cmake.in
index c51729e..fa992ce 100644
--- a/cmake/audiomanagerConfig.cmake.in
+++ b/cmake/audiomanagerConfig.cmake.in
@@ -32,6 +32,8 @@ set(AUDIOMANAGER_UTILITIES_SRC "@AUDIOMANAGER_UTILITIES_SRC@")
 set(WITH_COMMON_API_GEN "@WITH_COMMON_API_GEN@")
 set(WRITE_COMMONAPI_DBUS_CONFIG_FILE "@WRITE_COMMONAPI_DBUS_CONFIG_FILE@")
 set(TCLAP_INCLUDE_DIR "@TCLAP_INCLUDE_DIR@")
+set(COMMONAPI_VERSION_NUMBER "@COMMONAPI_VERSION_NUMBER@")
+set(COMMONAPI_DBUS_VERSION_NUMBER "@COMMONAPI_DBUS_VERSION_NUMBER@")
 
 
 IF(WITH_TESTS)	
diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in
index fcfdc7f..3e1095f 100644
--- a/cmake/config.cmake.in
+++ b/cmake/config.cmake.in
@@ -32,6 +32,8 @@
 #cmakedefine NSM_INTERFACE "@NSM_INTERFACE@"
 #cmakedefine NSM_INTROSPECTION_FILE "@NSM_INTROSPECTION_FILE@"
 #cmakedefine AM_SHARE_FOLDER "@AM_SHARE_FOLDER@"
+#cmakedefine COMMONAPI_VERSION_NUMBER @COMMONAPI_VERSION_NUMBER@
+#cmakedefine COMMONAPI_DBUS_VERSION_NUMBER @COMMONAPI_DBUS_VERSION_NUMBER@
 
 enum { DYNAMIC_ID_BOUNDARY = @DYNAMIC_ID_BOUNDARY@ };