merged GPU resize became same as CPU implementation

updated pdfs to 2.4.2
updated docs theme
2012-07-03 16:16:24 +00:00 · 2012-07-03 15:55:39 +00:00 · 2012-07-03 15:31:13 +00:00 · 2012-07-03 15:10:40 +00:00 · 2012-07-03 15:07:20 +00:00 · 2012-07-03 14:13:05 +00:00
@@ -7,31 +7,24 @@ project(${JASPER_LIBRARY})

 add_definitions(-DEXCLUDE_MIF_SUPPORT -DEXCLUDE_PNM_SUPPORT -DEXCLUDE_BMP_SUPPORT -DEXCLUDE_RAS_SUPPORT  -DEXCLUDE_JPG_SUPPORT -DEXCLUDE_PGX_SUPPORT)

-# List of C++ files:
 ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})

-# The .cpp files:
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 file(GLOB lib_ext_hdrs jasper/*.h)

 # ----------------------------------------------------------------------------------
-# 				Define the library target:
+#         Define the library target:
 # ----------------------------------------------------------------------------------

 add_library(${JASPER_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs} ${lib_ext_hdrs})

 if(MSVC)
-  if(NOT ENABLE_NOISY_WARNINGS)
-    string(REPLACE "/W3" "/W0" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    string(REPLACE "/W4" "/W0" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  endif()
  add_definitions(-DJAS_WIN_MSVC_BUILD)
 endif()

-if(CMAKE_COMPILER_IS_GNUCXX)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-uninitialized")
-endif()
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-implicit-function-declaration -Wno-uninitialized -Wmissing-prototypes -Wmissing-declarations -Wunused -Wshadow -Wsign-compare
+                                   /wd4013 /wd4018 /wd4715 /wd4244 /wd4101 /wd4267)

 if(UNIX)
  if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
@@ -39,22 +32,18 @@ if(UNIX)
  endif()
 endif()

-if(CMAKE_COMPILER_IS_GNUCXX AND NOT ENABLE_NOISY_WARNINGS)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-implicit-function-declaration -Wno-unused")
-endif()
-
 set_target_properties(${JASPER_LIBRARY}
-	PROPERTIES
-	OUTPUT_NAME ${JASPER_LIBRARY}
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
-	)
-	
+  PROPERTIES
+  OUTPUT_NAME ${JASPER_LIBRARY}
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
+
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(${JASPER_LIBRARY} PROPERTIES FOLDER "3rdparty")
-endif()	
-    
-if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS ${JASPER_LIBRARY} ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+endif()
+
+if(NOT BUILD_SHARED_LIBS)
+  install(TARGETS ${JASPER_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()

@@ -4,24 +4,17 @@
 # ----------------------------------------------------------------------------
 project(${JPEG_LIBRARY})

-# List of C++ files:
-
 ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})

-# The .cpp files:
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)

 # ----------------------------------------------------------------------------------
-# 				Define the library target:
+#         Define the library target:
 # ----------------------------------------------------------------------------------

 add_library(${JPEG_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})

-if(MSVC)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
-endif()
-
 if(UNIX)
  if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
@@ -32,16 +25,18 @@ if(CMAKE_COMPILER_IS_GNUCXX)
  set_source_files_properties(jcdctmgr.c PROPERTIES COMPILE_FLAGS "-O1")
 endif()

+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align -Wshadow -Wunused)
+
 set_target_properties(${JPEG_LIBRARY}
-	PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}
-	)
-	
+  PROPERTIES OUTPUT_NAME ${JPEG_LIBRARY}
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
+
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(${JPEG_LIBRARY} PROPERTIES FOLDER "3rdparty")
-endif()	
-    
-if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS ${JPEG_LIBRARY} ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+endif()
+
+if(NOT BUILD_SHARED_LIBS)
+  install(TARGETS ${JPEG_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()
@@ -4,39 +4,35 @@
 # ----------------------------------------------------------------------------
 project(${PNG_LIBRARY})

-# List of C++ files:
-
 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" ${ZLIB_INCLUDE_DIR})

 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)

 # ----------------------------------------------------------------------------------
-# 				Define the library target:
+#         Define the library target:
 # ----------------------------------------------------------------------------------

 add_library(${PNG_LIBRARY} STATIC ${lib_srcs} ${lib_hdrs})

-if(MSVC)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
-endif()
-
 if(UNIX)
  if(CMAKE_COMPILER_IS_GNUCXX OR CV_ICC)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
  endif()
 endif()

+ocv_warnings_disable(CMAKE_C_FLAGS -Wcast-align)
+
 set_target_properties(${PNG_LIBRARY}
-	PROPERTIES OUTPUT_NAME ${PNG_LIBRARY}
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
-	)
-	
+  PROPERTIES OUTPUT_NAME ${PNG_LIBRARY}
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
+
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(${PNG_LIBRARY} PROPERTIES FOLDER "3rdparty")
 endif()
-    
+
 if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS ${PNG_LIBRARY} ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+  install(TARGETS ${PNG_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()
@@ -26,7 +26,6 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmakein"

 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIR})

-# List of C++ files:
 set(lib_srcs
    tif_aux.c
    tif_close.c
@@ -82,19 +81,15 @@ set(lib_srcs

 if(UNIX)
  list(APPEND lib_srcs tif_unix.c)
-  if(CMAKE_COMPILER_IS_GNUCXX AND NOT ENABLE_NOISY_WARNINGS)
-    set_source_files_properties(tif_unix.c PROPERTIES COMPILE_FLAGS "-w")
-  endif()
 endif()

 if(WIN32)
  list(APPEND lib_srcs tif_win32.c)
 endif(WIN32)

-if(MSVC AND NOT ENABLE_NOISY_WARNINGS)
-  string(REPLACE "/W4" "/W0" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-  string(REPLACE "/W4" "/W0" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-endif()
+ocv_warnings_disable(CMAKE_C_FLAGS -Wno-unused-but-set-variable -Wmissing-prototypes -Wmissing-declarations -Wundef -Wunused -Wsign-compare
+                                   -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast)
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter /wd4100 /wd4244 /wd4706 /wd4127 /wd4701 /wd4018 /wd4267 /wd4306 /wd4305 /wd4312 /wd4311)

 if(UNIX AND (CMAKE_COMPILER_IS_GNUCXX OR CV_ICC))
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
@@ -104,16 +99,16 @@ add_library(${TIFF_LIBRARY} STATIC ${lib_srcs})
 target_link_libraries(${TIFF_LIBRARY} ${ZLIB_LIBRARIES})

 set_target_properties(${TIFF_LIBRARY}
-	PROPERTIES
-	OUTPUT_NAME "${TIFF_LIBRARY}"
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
-	)
-	
+    PROPERTIES
+    OUTPUT_NAME "${TIFF_LIBRARY}"
+    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+    ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+    )
+
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(${TIFF_LIBRARY} PROPERTIES FOLDER "3rdparty")
-endif()	
+endif()

 if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS ${TIFF_LIBRARY} ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+  install(TARGETS ${TIFF_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()
@@ -143,7 +143,7 @@

 /* Signed 64-bit type formatter */
 /* Unsigned 64-bit type formatter */
-#ifdef _MSC_VER
+#if defined _MSC_VER || defined __MINGW__ || defined __MINGW32__
 # define TIFF_UINT64_FORMAT "%I64u"
 # define TIFF_SSIZE_FORMAT "%Iu"
 #else
@@ -72,7 +72,7 @@ if(NOT EXISTS "${tbb_tarball}")
    file(REMOVE "${tbb_tarball}")
    message(FATAL_ERROR "Downloaded TBB source tarball has invalid MD5 hash: ${tbb_local_md5} (expected: ${tbb_md5})")
  endif()
-  
+
  if(EXISTS "${tbb_src_dir}")
    file(REMOVE_RECURSE "${tbb_src_dir}")
  endif()
@@ -114,25 +114,29 @@ add_definitions(-D__TBB_DYNAMIC_LOAD_ENABLED=0         #required
 if(tbb_need_GENERIC_DWORD_LOAD_STORE)
  #needed by TBB 4.0 update 1,2; fixed in TBB 4.0 update 3 but it has 2 new problems
  add_definitions(-D__TBB_USE_GENERIC_DWORD_LOAD_STORE=1)
+  set(tbb_need_GENERIC_DWORD_LOAD_STORE ON PARENT_SCOPE)
 endif()

 add_library(tbb STATIC ${lib_srcs} ${lib_hdrs} "${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h" "${CMAKE_CURRENT_SOURCE_DIR}/${tbb_version_file}")
 target_link_libraries(tbb c m dl)

-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations)
+string(REPLACE "-Werror=non-virtual-dtor" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -include \"${CMAKE_CURRENT_SOURCE_DIR}/android_additional.h\"")

 set_target_properties(tbb
-	PROPERTIES OUTPUT_NAME tbb
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
-	)
-	
+  PROPERTIES OUTPUT_NAME tbb
+  DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+  ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
+  )
+
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(tbb PROPERTIES FOLDER "3rdparty")
 endif()
-    
+
 if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS tbb ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+  install(TARGETS tbb ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()

 # get TBB version
@@ -6,4 +6,4 @@
 "TBB: BUILD_GLIBC	Unknown" ENDL \
 "TBB: BUILD_LD		Unknown" ENDL \
 "TBB: BUILD_TARGET	Unknown" ENDL \
-"TBB: BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL \
+"TBB: BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL
@@ -6,4 +6,4 @@
 #N": BUILD_GLIBC	Unknown" ENDL \
 #N": BUILD_LD		Unknown" ENDL \
 #N": BUILD_TARGET	Unknown" ENDL \
-#N": BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL \
+#N": BUILD_COMMAND	use cv::getBuildInformation() for details" ENDL
@@ -5,18 +5,10 @@

 project(${ZLIB_LIBRARY} C)

-include(CheckTypeSize)
 include(CheckFunctionExists)
 include(CheckIncludeFile)
 include(CheckCSourceCompiles)
-
-#
-# Check to see if we have large file support
-#
-check_type_size(off64_t OFF64_T)
-if(HAVE_OFF64_T)
-  add_definitions(-D_LARGEFILE64_SOURCE=1)
-endif()
+include(CheckTypeSize)

 #
 # Check for fseeko
@@ -36,6 +28,14 @@ if(MSVC)
  add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
 endif()

+#
+# Check to see if we have large file support
+#
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+  add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein"
               "${CMAKE_CURRENT_BINARY_DIR}/zconf.h" @ONLY)
 ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
@@ -82,22 +82,20 @@ if(UNIX)
  endif()
 endif()

-if(MSVC AND NOT ENABLE_NOISY_WARNINGS)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4013")
-endif()
+ocv_warnings_disable(CMAKE_C_FLAGS /wd4013 -Wattributes -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations)

 set_target_properties(${ZLIB_LIBRARY} PROPERTIES
        OUTPUT_NAME ${ZLIB_LIBRARY}
        DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
+        ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
    )

 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(${ZLIB_LIBRARY} PROPERTIES FOLDER "3rdparty")
 endif()
-	
+
 if(NOT BUILD_SHARED_LIBS)
-  install(TARGETS ${ZLIB_LIBRARY} ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+  install(TARGETS ${ZLIB_LIBRARY} ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()

 ocv_parse_header2(ZLIB "${CMAKE_CURRENT_SOURCE_DIR}/zlib.h" ZLIB_VERSION PARENT_SCOPE)
@@ -410,10 +410,18 @@ typedef uLong FAR uLongf;
 * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
 * equivalently requesting no 64-bit operations
 */
-#if -_LARGEFILE64_SOURCE - -1 == 1
+#if defined _LARGEFILE64_SOURCE && -_LARGEFILE64_SOURCE - -1 == 1
 #  undef _LARGEFILE64_SOURCE
 #endif

+#ifndef _LFS64_LARGEFILE
+#  define _LFS64_LARGEFILE 0
+#endif
+
+#ifndef _FILE_OFFSET_BITS
+#  define _FILE_OFFSET_BITS 0
+#endif
+
 #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
 #  define Z_LARGE
 #endif
@@ -37,6 +37,8 @@ if(NOT CMAKE_TOOLCHAIN_FILE)
 else(NOT CMAKE_TOOLCHAIN_FILE)
  #Android: set output folder to ${CMAKE_BINARY_DIR}
  set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "root for library output, set this to change where android libs are compiled to" )
+  # any crosscompiling
+  set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
 endif(NOT CMAKE_TOOLCHAIN_FILE)

 # --------------------------------------------------------------
@@ -116,14 +118,14 @@ OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"         ON
 OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON)
 OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_IMAGEIO        "ImageIO support for OS X"                    OFF  IF APPLE)
 OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   OFF  IF (MSVC OR X86 OR X86_64) )
 OCV_OPTION(WITH_JASPER         "Include JPEG2K support"                      ON   IF (NOT IOS) )
 OCV_OPTION(WITH_JPEG           "Include JPEG support"                        ON   IF (NOT IOS) )
 OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT IOS AND NOT APPLE) )
+OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON   IF (NOT IOS) )
 OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
@@ -131,10 +133,10 @@ OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF
 OCV_OPTION(WITH_QUICKTIME      "Use QuickTime for Video I/O insted of QTKit" OFF  IF APPLE )
 OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS) )
 OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON   IF (NOT IOS) )
-OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_VIDEOINPUT     "Build HighGUI with DirectShow support"       ON   IF WIN32 )
-OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF WIN32 )
+OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT IOS) )

 # OpenCV build components
@@ -149,6 +151,9 @@ OCV_OPTION(BUILD_TESTS              "Build accuracy & regression tests"
 OCV_OPTION(BUILD_WITH_DEBUG_INFO    "Include debug info into debug libs (not MSCV only)" ON )
 OCV_OPTION(BUILD_WITH_STATIC_CRT    "Enables use of staticaly linked CRT for staticaly linked OpenCV" ON IF MSVC )
 OCV_OPTION(BUILD_FAT_JAVA_LIB       "Create fat java wrapper containing the whole OpenCV library" ON IF ANDROID AND NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX )
+OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF IF ANDROID AND ANDROID_USE_STLPORT AND ANDROID_SOURCE_TREE )
+OCV_OPTION(BUILD_ANDROID_PACKAGE    "Build platform-specific package for Google Play" OFF IF ANDROID )
+

 # 3rd party libs
 OCV_OPTION(BUILD_ZLIB               "Build zlib from source"         WIN32 OR IOS OR APPLE )
@@ -188,6 +193,8 @@ OCV_OPTION(ENABLE_SSE42               "Enable SSE4.2 instructions"
 OCV_OPTION(ENABLE_NOISY_WARNINGS      "Show all warnings even if they are too noisy"             OFF )
 OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors"                                 OFF )

+OCV_OPTION(OPENCV_CAN_BREAK_BINARY_COMPATIBILITY "Allow changes breaking binary compatibility with OpenCV 2.4.0" OFF )
+
 # uncategorized options
 # ===================================================
 OCV_OPTION(CMAKE_VERBOSE "Verbose mode" OFF )
@@ -208,7 +215,6 @@ include(cmake/OpenCVVersion.cmake REQUIRED)
 # ----------------------------------------------------------------------------

 # Save libs and executables in the same place
-set(LIBRARY_OUTPUT_PATH "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Output directory for libraries" )
 set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications" )

 if(ANDROID OR WIN32)
@@ -220,17 +226,32 @@ else()
 endif()

 if(ANDROID)
-    set(OPENCV_LIB_INSTALL_PATH libs/${ANDROID_NDK_ABI_NAME})
+    set(LIBRARY_OUTPUT_PATH         "${OpenCV_BINARY_DIR}/lib/${ANDROID_NDK_ABI_NAME}")
+    set(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}")
+    set(OPENCV_LIB_INSTALL_PATH     sdk/native/libs/${ANDROID_NDK_ABI_NAME})
+    set(OPENCV_3P_LIB_INSTALL_PATH  sdk/native/3rdparty/libs/${ANDROID_NDK_ABI_NAME})
+    set(OPENCV_CONFIG_INSTALL_PATH  sdk/native/jni)
+    set(OPENCV_INCLUDE_INSTALL_PATH sdk/native/jni/include)
 else()
-    set(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX})
+    set(LIBRARY_OUTPUT_PATH         "${OpenCV_BINARY_DIR}/lib")
+    set(3P_LIBRARY_OUTPUT_PATH      "${OpenCV_BINARY_DIR}/3rdparty/lib${LIB_SUFFIX}")
+    set(OPENCV_LIB_INSTALL_PATH     lib${LIB_SUFFIX})
+    set(OPENCV_3P_LIB_INSTALL_PATH  share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH})
+    set(OPENCV_INCLUDE_INSTALL_PATH include)
+
+    math(EXPR SIZEOF_VOID_P_BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
+    if(LIB_SUFFIX AND NOT SIZEOF_VOID_P_BITS EQUAL LIB_SUFFIX)
+      set(OPENCV_CONFIG_INSTALL_PATH lib${LIB_SUFFIX}/cmake/opencv)
+    else()
+      set(OPENCV_CONFIG_INSTALL_PATH share/OpenCV)
+    endif()
 endif()

 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

-set(OPENCV_INCLUDE_PREFIX include)
 if(INSTALL_TO_MANGLED_PATHS)
-  set(OPENCV_INCLUDE_PREFIX include/opencv-${OPENCV_VERSION})
+  set(OPENCV_INCLUDE_INSTALL_PATH ${OPENCV_INCLUDE_INSTALL_PATH}/opencv-${OPENCV_VERSION})
 endif()

 if(WIN32)
@@ -286,13 +307,13 @@ endif()
 # ----------------------------------------------------------------------------
 # OpenCV compiler and linker options
 # ----------------------------------------------------------------------------
-include(cmake/OpenCVCompilerOptions.cmake REQUIRED)
-
 # In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
 if(CMAKE_GENERATOR MATCHES "Makefiles|Ninja" AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
  set(CMAKE_BUILD_TYPE Release)
 endif()

+include(cmake/OpenCVCompilerOptions.cmake REQUIRED)
+

 # ----------------------------------------------------------------------------
 # Use statically or dynamically linked CRT?
@@ -318,7 +339,7 @@ if(UNIX)
    CHECK_INCLUDE_FILE(pthread.h HAVE_LIBPTHREAD)
    if(ANDROID)
      set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} dl m log)
-    elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+    elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD|NetBSD|DragonFly")
      set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} m pthread)
    else()
      set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} dl m pthread rt)
@@ -406,6 +427,13 @@ if(BUILD_EXAMPLES OR BUILD_ANDROID_EXAMPLES OR INSTALL_PYTHON_EXAMPLES)
  add_subdirectory(samples)
 endif()

+if(BUILD_ANDROID_SERVICE)
+  add_subdirectory(android/service)
+endif()
+
+if(BUILD_ANDROID_PACKAGE)
+  add_subdirectory(android/package)
+endif()

 # ----------------------------------------------------------------------------
 # Finalization: generate configuration-based files
@@ -471,6 +499,7 @@ else()
  status("    Linker flags (Release):" ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE})
  status("    Linker flags (Debug):"   ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG})
 endif()
+status("    Precompiled headers:"     PCHSupport_FOUND AND ENABLE_PRECOMPILED_HEADERS THEN YES ELSE NO)

 # ========================== OpenCV modules ==========================
 status("")
@@ -509,6 +538,7 @@ if(ANDROID)
  endif()
  status("    android tool:"  ANDROID_EXECUTABLE  THEN "${ANDROID_EXECUTABLE} (${ANDROID_TOOLS_Pkg_Desc})" ELSE NO)
  status("    ant:"           ANT_EXECUTABLE      THEN "${ANT_EXECUTABLE} (ver ${ANT_VERSION})"            ELSE NO)
+  status("    Google Play package:" BUILD_ANDROID_PACKAGE THEN YES ELSE NO)
 endif()

 # ========================== GUI ==========================
@@ -560,7 +590,7 @@ if(WITH_TIFF)
  if(TIFF_VERSION_STRING AND TIFF_FOUND)
    status("    TIFF:"     "${TIFF_LIBRARY} (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
  else()
-    status("    TIFF:"     TIFF_FOUND    THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION})"            ELSE "build (ver ${TIFF_VERSION})")
+    status("    TIFF:"     TIFF_FOUND    THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION})"            ELSE "build (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
  endif()
 else()
  status("    TIFF:"       "NO")
@@ -1 +1 @@
-See http://opencv.willowgarage.com/wiki/Android
+See http://code.opencv.org/projects/opencv/wiki/OpenCV4Android
@@ -36,13 +36,13 @@
 #    ANDROID_NDK=/opt/android-ndk - path to the NDK root.
 #      Can be set as environment variable. Can be set only at first cmake run.
 #
-#    ANDROID_STANDALONE_TOOLCHAIN=/opt/android-toolchain - path to the 
+#    ANDROID_STANDALONE_TOOLCHAIN=/opt/android-toolchain - path to the
 #      standalone toolchain. This option is not used if full NDK is found
 #      (ignored if ANDROID_NDK is set).
 #      Can be set as environment variable. Can be set only at first cmake run.
 #
 #    ANDROID_ABI=armeabi-v7a -  specifies the target Application Binary
-#      Interface (ABI). This option nearly matches to the APP_ABI variable 
+#      Interface (ABI). This option nearly matches to the APP_ABI variable
 #      used by ndk-build tool from Android NDK.
 #      Possible values are:
 #        "armeabi" - matches to the NDK ABI with the same name.
@@ -94,10 +94,10 @@
 #      The flags will be prepopulated with critical flags, so don't loose them.
 #      Also be aware that toolchain also sets configuration-specific compiler
 #      flags and linker flags.
-#    
-#    ANDROID and BUILD_ANDROID will be set to true, you may test any of these 
+#
+#    ANDROID and BUILD_ANDROID will be set to true, you may test any of these
 #    variables to make necessary Android-specific configuration changes.
-#    
+#
 #    Also ARMEABI or ARMEABI_V7A or X86 will be set true, mutually exclusive.
 #    NEON option will be set true if VFP is set to NEON.
 #
@@ -131,7 +131,7 @@
 #         cmake pass
 #     [~] toolchain exits with error if ARM_TARGET is not recognized
 #   - modified June 2011
-#     [~] default NDK path is updated for version r5c 
+#     [~] default NDK path is updated for version r5c
 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
 #     [~] toolchain install directory is added to linker paths
 #     [-] removed SWIG-related stuff from toolchain
@@ -705,12 +705,14 @@ set( ANDROID_SYSTEM_LIB_DIRS "" )
 set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
 set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )

-if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
- set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
-else()
- set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
+if(NOT _CMAKE_IN_TRY_COMPILE)
+ if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
+ else()
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
+ endif()
+ set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
 endif()
-set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )

 #includes
 list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_SYSROOT}/usr/include" )
@@ -960,7 +962,7 @@ endif()
 set( ANDROID True )
 set( BUILD_ANDROID True )

-# where is the target environment 
+# where is the target environment
 set( CMAKE_FIND_ROOT_PATH "${ANDROID_TOOLCHAIN_ROOT}/bin" "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" "${ANDROID_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" )

 # only search for libraries and includes in the ndk toolchain
@@ -1053,7 +1055,7 @@ endif()
 #   ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86", "mips"
 #   ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14 (depends on NDK version)
 #   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
-#   ANDROID_USE_STLPORT : OFF/ON - EXPERIMENTAL!!! 
+#   ANDROID_USE_STLPORT : OFF/ON - EXPERIMENTAL!!!
 #   ANDROID_FORBID_SYGWIN : ON/OFF
 #   ANDROID_NO_UNDEFINED : ON/OFF
 #   ANDROID_SO_UNDEFINED : OFF/ON  (default depends on NDK version)
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.lib_v@OPENCV_VERSION_MAJOR@@OPENCV_VERSION_MINOR@_@ANDROID_PACKAGE_PLATFORM@"
+    android:versionCode="@OPENCV_VERSION_PATCH@@ANDROID_PACKAGE_RELEASE@"
+    android:versionName="@OPENCV_VERSION_PATCH@.@ANDROID_PACKAGE_RELEASE@" >
+
+    <uses-sdk android:minSdkVersion="@ANDROID_SDK_VERSION@" />
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" >
+    </application>
+
+</manifest>
@@ -0,0 +1,94 @@
+if(NOT ANDROID_PACKAGE_RELEASE)
+  set(ANDROID_PACKAGE_RELEASE 1)
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM armv7a_neon)
+    else()
+      set(ANDROID_PACKAGE_PLATFORM armv7a)
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM armv6)
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM armv5)
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM x86)
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM mips)
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM")
+  endif()
+endif()
+
+if(NOT ANDROID_PACKAGE_PLATFORM_NAME)
+  if(ARMEABI_V7A)
+    if(NEON)
+      set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v7a with NEON")
+    else()
+      set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v7a")
+    endif()
+  elseif(ARMEABI_V6)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi-v6")
+  elseif(ARMEABI)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "armeabi")
+  elseif(X86)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "x86")
+  elseif(MIPS)
+    set(ANDROID_PACKAGE_PLATFORM_NAME "mips")
+  else()
+    message(ERROR "Can not automatically determine the value for ANDROID_PACKAGE_PLATFORM_NAME")
+  endif()
+endif()
+
+if("${ANDROID_NATIVE_API_LEVEL}" MATCHES "[1-9][0-9]*$")
+  set(ANDROID_SDK_VERSION ${CMAKE_MATCH_0})
+endif()
+
+if(NOT ANDROID_SDK_VERSION GREATER 7)
+  set(ANDROID_SDK_VERSION 8)
+endif()
+
+set(PACKAGE_DIR "${OpenCV_BINARY_DIR}/package")
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_MANIFEST_FILE}" "${PACKAGE_DIR}/${ANDROID_MANIFEST_FILE}"  @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/values/strings.xml"   "${PACKAGE_DIR}/res/values/strings.xml"    @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/res/drawable/icon.png"   "${PACKAGE_DIR}/res/drawable/icon.png"   COPYONLY)
+
+set(target_name "OpenCV_${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}_binary_pack_${ANDROID_PACKAGE_PLATFORM}")
+get_target_property(opencv_java_location opencv_java LOCATION)
+
+set(android_proj_target_files ${ANDROID_PROJECT_FILES})
+ocv_list_add_prefix(android_proj_target_files "${PACKAGE_DIR}/")
+android_get_compatible_target(android_proj_sdk_target ${ANDROID_SDK_VERSION})
+set(APK_NAME "${PACKAGE_DIR}/bin/${target_name}-release-unsigned.apk")
+
+file(GLOB camera_wrappers "${OpenCV_SOURCE_DIR}/3rdparty/lib/${ANDROID_NDK_ABI_NAME}/libnative_camera_r*.so")
+set(CAMERA_LIB_COMMANDS "")
+
+foreach(wrapper ${camera_wrappers})
+  list(APPEND CAMERA_LIB_COMMANDS COMMAND ${CMAKE_COMMAND} -E copy "${wrapper}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/")
+endforeach()
+
+add_custom_command(
+         OUTPUT "${APK_NAME}"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/libs"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/bin"
+         COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGE_DIR}/gen"
+         COMMAND ${CMAKE_COMMAND} -E remove ${android_proj_target_files}
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${PACKAGE_DIR}/src"
+         COMMAND ${CMAKE_COMMAND} -E make_directory "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         ${CAMERA_LIB_COMMANDS}
+         COMMAND ${CMAKE_COMMAND} -E copy "${opencv_java_location}" "${PACKAGE_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+         COMMAND ${ANDROID_EXECUTABLE} --silent update project --path "${PACKAGE_DIR}" --target "${android_proj_sdk_target}" --name "${target_name}"
+         COMMAND ${ANT_EXECUTABLE} -q -noinput -k release
+         COMMAND ${CMAKE_COMMAND} -E touch "${APK_NAME}"
+         WORKING_DIRECTORY "${PACKAGE_DIR}"
+         MAIN_DEPENDENCY "${PACKAGE_DIR}/${ANDROID_MANIFEST_FILE}"
+         DEPENDS "${OpenCV_BINARY_DIR}/bin/.classes.jar.dephelper" "${PACKAGE_DIR}/res/values/strings.xml" "${PACKAGE_DIR}/res/drawable/icon.png" ${camera_wrappers} opencv_java
+       )
+
+install(FILES "${APK_NAME}" DESTINATION "apk/" COMPONENT main)
+add_custom_target(android_package ALL SOURCES "${APK_NAME}" )
+add_dependencies(android_package opencv_java)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">OCV @OPENCV_VERSION_MAJOR@.@OPENCV_VERSION_MINOR@ pack @ANDROID_PACKAGE_PLATFORM_NAME@</string>
+
+</resources>
@@ -0,0 +1,8 @@
+############################
+OpenCV4Android Reference
+############################
+
+.. toctree::
+   :maxdepth: 2
+
+   service/doc/index.rst
@@ -1,5 +1,5 @@
@ECHO OFF

 PUSHD %~dp0..
-CALL .\scripts\build.cmd %*
+CALL .\scripts\build.cmd %* -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON
 POPD
@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build
 cd build

-cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake $@ ../..
+cmake -DCMAKE_BUILD_WITH_INSTALL_RPATH=ON -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake $@ ../..

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd `dirname $0`/..
+
+mkdir -p build_service
+cd build_service
+
+cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake -DANDROID_USE_STLPORT=ON -DBUILD_ANDROID_SERVICE=ON -DANDROID_SOURCE_TREE=~/Projects/AndroidSource/2.2.2/ $@ ../..
+
@@ -0,0 +1,2 @@
+add_subdirectory(engine)
+#add_subdirectory(engine_test)
@@ -0,0 +1,22 @@
+***************
+Package Content
+***************
+
+The package provides new OpenCV SDK that uses OpenCV Manager for library initialization. OpenCV Manager provides the following benefits:
+
+* Less memory usage. All apps use the same binaries from service and do not keep native libs inside them self;
+* Hardware specific optimizations for all supported platforms;
+* Trusted OpenCV library source. All packages with OpenCV are published on Google Play service;
+* Regular updates and bug fixes;
+ 
+Package consists from Library Project for Java development with Eclipse, C++ headers and libraries for native application development, javadoc samples and prebuilt binaries for ARM and X86 platforms.
+To try new SDK on serial device with Google Play just install sample package and follow application messages (Google Play service access will be needed).
+TO start example on device without Google Play you need to install OpenCV manager package and OpenCV binary pack for your platform from apk folder before.
+See docs/doc/tutorials/introduction/android_binary_package/android_binary_package.html and docs/android/refmain.html for details about service.
+On-line documentation will be available at address: http://docs.opencv.org/trunk
+
+********
+Contacts
+********
+
+Please send all feedback to Alexander Smorkalov mailto: alexander.smorkalov@itseez.com
@@ -0,0 +1,14 @@
+*********************************************
+Base Loader Callback Interface implementation
+*********************************************
+
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Implements OpenCV initialization callback interface.
+.. class:: BaseLoaderCallback
+
+    Basic implementation of LoaderCallbackInterface. Implementation logic is described by diagram.
+
+.. image:: img/AndroidAppUsageModel.dia.png
+
@@ -0,0 +1,35 @@
+**************************
+Install Callback Interface
+**************************
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Defines callback interface for package management.
+
+.. class:: InstallCallbackInterface
+
+    Callback interface for package installation or update.
+
+String getPackageName()
+-----------------------
+
+.. method:: String getPackageName()
+
+    Get name of a package to be installed
+
+    :rtype: String
+    :return: Return package name, i.e. "OpenCV Manager Service" or "OpenCV library"
+
+void install()
+--------------
+
+.. method:: void install()
+
+    Installation of package is approved
+
+void cancel()
+-------------
+
+.. method:: void cancel()
+
+    Installation if package was canceled
@@ -0,0 +1,40 @@
+
+.. _Android_OpenCV_Manager_Intro:
+
+************
+Introduction
+************
+
+.. highlight:: java
+
+OpenCV Manager is an Android service targeted to manage OpenCV library binaries on end users devices. It allows sharing the OpenCV dynamic libraries of different versions between applications on the same device. The Manager provides the following benefits\:
+
+#. Less memory usage. All apps use the same binaries from service and do not keep native libs inside them self;
+#. Hardware specific optimizations for all supported platforms;
+#. Trusted OpenCV library source. All packages with OpenCV are published on Google Play service;
+#. Regular updates and bug fixes;
+
+Usage model for target user
+---------------------------
+
+.. image:: img/AndroidAppUsageModel.dia.png
+
+First OpenCV app\:
+
+#. User downloads app dependent from OpenCV from Google Play or installs it manually;
+#. User starts application. Application asks user to install OpenCV Manager;
+#. User installs OpenCV Manager from Google Play Service;
+#. User starts application. Application proposes to user to install OpenCV library for target device and runs Google Play;
+#. User runs app in the third time  and gets what he or she wants.
+
+Next OpenCV app\:
+
+#. User downloads app dependent from OpenCV from Google Play or installs it manually;
+#. User starts application.
+#. If selected version is not installed Manager asks user to install OpenCV library package and runs Google Play;
+#. User runs app in the second time and gets what he or she wants.
+
+OpenCV Manager structure
+------------------------
+
+.. image:: img/Structure.dia.png
@@ -0,0 +1,50 @@
+******************
+Java OpenCV Loader
+******************
+
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Implements Android dependent Java classes.
+.. Class:: OpenCVLoader
+
+Helper class provides common initialization methods for OpenCV library
+
+boolean initDebug()
+-------------------
+
+.. method:: static boolean initDebug()
+
+    Load and initialize OpenCV library from current application package. Roughly it is analog of system.loadLibrary("opencv_java")
+
+    :rtype: boolean
+    :return: Return true if initialization of OpenCV was successful
+
+.. note:: This way is deprecated for production code. It is designed for experimantal and local development purposes only. If you want to publish your app use approach with async initialization
+
+boolean initAsync()
+-------------------
+
+.. method:: static boolean initAsync(String Version, Context AppContext, LoaderCallbackInterface Callback)
+
+    Load and initialize OpenCV library using OpenCV Manager service.
+
+    :param Version: OpenCV Library version
+    :param AppContext: Application context for connecting to service
+    :param Callback: Object, that implements LoaderCallbackInterface for handling Connection status. See BaseLoaderCallback.
+    :rtype: boolean
+    :return: Return true if initialization of OpenCV starts successfully
+
+OpenCV version constants
+-------------------------
+
+.. data:: OPENCV_VERSION_2_4_2
+
+    OpenCV Library version 2.4.2
+
+Other constatnts
+----------------
+
+.. data:: OPEN_CV_SERVICE_URL
+
+    Url for OpenCV Manager on Google Play (Android Market)
@@ -0,0 +1,56 @@
+*************************
+Loader Callback Interface
+*************************
+
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Defines OpenCV initialization callback interface.
+.. class:: LoaderCallbackInterface
+
+    Interface for callback object in case of asynchronous initialization of OpenCV
+
+void onManagerConnected()
+-------------------------
+
+.. method:: void onManagerConnected(int status)
+
+    Callback method that is called after OpenCV library initialization
+
+    :param status: Status of initialization. See Initialization status constants
+
+void onPackageInstall()
+-----------------------
+
+.. method:: void onPackageInstall(InstallCallbackInterface Callback)
+
+    Callback method that is called in case when package installation is needed
+
+    @param callback Answer object with approve and cancel methods and package description
+
+Initialization status constants
+-------------------------------
+
+.. data:: SUCCESS
+
+    OpenCV initialization finished successfully
+
+.. data:: RESTART_REQUIRED
+
+    OpenCV library installation via Google Play service was initialized. Application restart is required
+
+.. data:: MARKET_ERROR
+
+    Google Play (Android Market) cannot be invoked
+
+.. data:: INSTALL_CANCELED
+
+    OpenCV library installation was canceled by user
+
+.. data:: INCOMPATIBLE_MANAGER_VERSION
+
+    Version of OpenCV Manager Service is incompatible with this app. Service update is needed
+
+.. data:: INIT_FAILED
+
+    OpenCV library initialization failed
@@ -0,0 +1,89 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html      to make standalone HTML files"
+	@echo "  dirhtml   to make HTML files named index.html in directories"
+	@echo "  pickle    to make pickle files"
+	@echo "  json      to make JSON files"
+	@echo "  htmlhelp  to make HTML files and a HTML help project"
+	@echo "  qthelp    to make HTML files and a qthelp project"
+	@echo "  latex     to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  changes   to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck to check all external links for integrity"
+	@echo "  doctest   to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/OpenCVEngine.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/OpenCVEngine.qhc"
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \
+	      "run these through (pdf)latex."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
@@ -0,0 +1,29 @@
+*******************************************
+Engine use Cases
+*******************************************
+
+First application start
+-----------------------
+
+There is no OpenCV Manager and OpenCV libraries.
+
+.. image:: img/NoService.dia.png
+
+Second application start
+------------------------
+
+There is OpenCV Manager service, but there is no OpenCV library.
+If OpenCV library installation approved\:
+
+.. image:: img/LibInstallAproved.dia.png
+
+If OpenCV library installation canceled\:
+
+.. image:: img/LibInstallCanceled.dia.png
+
+Regular application start
+-------------------------
+
+OpenCV Manager and OpenCV library has bee already installed.
+
+.. image:: img/LibInstalled.dia.png
@@ -0,0 +1,23 @@
+#!/usr/bin/python
+
+import os
+
+TARGET_PATH = "img"
+
+pipe = os.popen("which dia")
+DiaPath = pipe.readline()
+DiaPath = DiaPath.strip("\n");
+pipe.close()
+
+if ("" == DiaPath):
+    print("Error: Dia tool was not found")
+    exit(-1)
+
+print("Dia tool: \"%s\"" % DiaPath)
+
+if (not os.path.exists(TARGET_PATH)):
+    os.mkdir("img")
+
+for filename in os.listdir("."):
+    if ("dia" == filename[-3:]):
+	os.system("%s --export %s %s" % (DiaPath, os.path.join(TARGET_PATH, filename + ".png"), filename))
@@ -0,0 +1,18 @@
+
+.. _Android_OpenCV_Manager:
+
+***********************
+Android OpenCV Manager
+***********************
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   Intro
+   UseCases
+   JavaHelper
+   BaseLoaderCallback
+   LoaderCallbackInterface
+   InstallCallbackInterface
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>OpenCV-2.4.0</name>
+	<name>OpenCVEngineService</name>
 	<comment></comment>
 	<projects>
 	</projects>
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.engine"
+    android:versionCode="11"
+    android:versionName="1.1" >
+
+    <uses-sdk android:minSdkVersion="8" />
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
+
+    <application
+        android:icon="@drawable/icon"
+        android:label="@string/app_name" >
+
+    <service android:exported="true" android:name="OpenCVEngineService" android:process=":OpenCVEngineProcess">
+    	<intent-filter>
+    		<action android:name="org.opencv.engine.BIND"></action>
+    	</intent-filter>
+    </service>
+    
+    <activity android:name="org.opencv.engine.manager.ManagerActivity" android:label="@string/app_name" >
+        <intent-filter>
+        	<action android:name="android.intent.action.MAIN" />
+            <category android:name="android.intent.category.LAUNCHER" />
+        </intent-filter>
+    </activity>
+    
+</application>
+</manifest>
@@ -0,0 +1,36 @@
+set(engine OpenCVEngine)
+set(JNI_LIB_NAME ${engine} ${engine}_jni)
+add_android_project(opencv_engine "${CMAKE_CURRENT_SOURCE_DIR}" SDK_TARGET 8 ${ANDROID_SDK_TARGET} IGNORE_JAVA ON)
+
+link_directories("${ANDROID_SOURCE_TREE}/out/target/product/generic/system/lib" "${ANDROID_SOURCE_TREE}/out/target/product/${ANDROID_PRODUCT}/system/lib" "${ANDROID_SOURCE_TREE}/bin_${ANDROID_ARCH_NAME}/system/lib")
+
+SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-allow-shlib-undefined")
+file(GLOB engine_files "jni/BinderComponent/*.cpp" "jni/BinderComponent/*.h" "jni/include/*.h")
+
+include_directories(jni/BinderComponent jni/include)
+include_directories(SYSTEM "${ANDROID_SOURCE_TREE}/frameworks/base/include" "${ANDROID_SOURCE_TREE}/system/core/include")
+add_library(${engine} SHARED ${engine_files})
+target_link_libraries(${engine} z binder log utils)
+
+set_target_properties(${engine} PROPERTIES
+    OUTPUT_NAME ${engine}
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.build/libs/${ANDROID_NDK_ABI_NAME}"
+    )
+
+get_target_property(engine_lib_location ${engine} LOCATION)
+add_custom_command(TARGET ${engine} POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "${engine_lib_location}")
+
+file(GLOB engine_jni_files "jni/JNIWrapper/*.cpp" "jni/JNIWrapper/*.h" "jni/include/*.h")
+list(APPEND engine_jni_files jni/NativeService/CommonPackageManager.cpp jni/NativeService/PackageInfo.cpp)
+
+include_directories(jni/include jni/JNIWrapper jni/NativeService jni/BinderComponent "${ANDROID_SOURCE_TREE}/frameworks/base/include" "${ANDROID_SOURCE_TREE}/system/core/include" "${ANDROID_SOURCE_TREE}/frameworks/base/core/jni")
+add_library(${engine}_jni SHARED ${engine_jni_files})
+target_link_libraries(${engine}_jni z binder log utils android_runtime ${engine})
+
+set_target_properties(${engine}_jni PROPERTIES
+    OUTPUT_NAME ${engine}_jni
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.build/libs/${ANDROID_NDK_ABI_NAME}"
+    )
+
+get_target_property(engine_lib_location ${engine}_jni LOCATION)
+add_custom_command(TARGET ${engine}_jni POST_BUILD COMMAND ${CMAKE_STRIP} --strip-unneeded "${engine_lib_location}")
@@ -0,0 +1,78 @@
+LOCAL_PATH := $(call my-dir)
+
+#---------------------------------------------------------------------
+#        Binder component library
+#---------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    BinderComponent/OpenCVEngine.cpp \
+    BinderComponent/BnOpenCVEngine.cpp \
+    BinderComponent/BpOpenCVEngine.cpp \
+    BinderComponent/ProcReader.cpp \
+    BinderComponent/TegraDetector.cpp \
+    BinderComponent/StringUtils.cpp \
+    BinderComponent/HardwareDetector.cpp
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/include \
+    $(LOCAL_PATH)/BinderComponent \
+    $(TOP)/frameworks/base/include \
+    $(TOP)/system/core/include
+
+LOCAL_CFLAGS += -DPLATFORM_ANDROID
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_MODULE := libOpenCVEngine
+
+LOCAL_LDLIBS += -lz -lbinder -llog -lutils
+
+LOCAL_LDFLAGS += -Wl,-allow-shlib-undefine
+
+include $(BUILD_SHARED_LIBRARY)
+
+#---------------------------------------------------------------------
+#        JNI library for Java service
+#---------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    JNIWrapper/OpenCVEngine_jni.cpp \
+    NativeService/CommonPackageManager.cpp \
+    JNIWrapper/JavaBasedPackageManager.cpp \
+    NativeService/PackageInfo.cpp \
+    JNIWrapper/HardwareDetector_jni.cpp
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/include \
+    $(LOCAL_PATH)/JNIWrapper \
+    $(LOCAL_PATH)/NativeService \
+    $(LOCAL_PATH)/BinderComponent \
+    $(TOP)/frameworks/base/include \
+    $(TOP)/system/core/include \
+    $(TOP)/frameworks/base/core/jni
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_CFLAGS += -DPLATFORM_ANDROID
+
+LOCAL_MODULE := libOpenCVEngine_jni
+
+LOCAL_LDLIBS += -lz -lbinder -llog -lutils -landroid_runtime
+
+LOCAL_SHARED_LIBRARIES = libOpenCVEngine
+
+include $(BUILD_SHARED_LIBRARY)
+
+#---------------------------------------------------------------------
+#        Native test application
+#---------------------------------------------------------------------
+
+include $(LOCAL_PATH)/Tests/Tests.mk
@@ -0,0 +1,5 @@
+APP_ABI := armeabi x86
+APP_PLATFORM := android-8
+APP_STL := stlport_static
+APP_CPPFLAGS := -fno-rtti -fno-exceptions
+#APP_OPTIM := debug
@@ -0,0 +1,74 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "BnOpenCVEngine.h"
+#include <utils/Log.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+
+using namespace android;
+
+BnOpenCVEngine::~BnOpenCVEngine()
+{
+}
+
+// Notes about data transaction:
+// Java Binder Wrapper call readInt32 before reading return data
+// It treet this in value as exception code
+// OnTransact method support this feature
+status_t BnOpenCVEngine::onTransact(uint32_t code, const Parcel& data, android::Parcel* reply, uint32_t flags)
+{
+    LOGD("OpenCVEngine::OnTransact(%u,%u)", code, flags);
+    
+    switch(code)
+    {
+	case OCVE_GET_ENGINE_VERSION:
+	{
+	    LOGD("OpenCVEngine OCVE_GET_ENGINE_VERSION request");
+	    CHECK_INTERFACE(IOpenCVEngine, data, reply);
+	    LOGD("OpenCVEngine::GetVersion()");
+	    reply->writeInt32(0);
+	    return reply->writeInt32(GetVersion());
+	} break;
+	case OCVE_GET_LIB_PATH_BY_VERSION:
+	{
+	    LOGD("OpenCVEngine OCVE_GET_LIB_PATH_BY_VERSION request");
+	    CHECK_INTERFACE(IOpenCVEngine, data, reply);
+	    const String16 version = data.readString16();
+	    LOGD("OpenCVEngine::GetLibPathByVersion(%s)", String8(version).string());
+	    String16 path = GetLibPathByVersion(version);
+	    reply->writeInt32(0);
+	    return reply->writeString16(path);
+	} break;
+	case OCVE_GET_LIB_LIST:
+	{
+	    LOGD("OpenCVEngine OCVE_GET_LIB_LIST request");
+	    CHECK_INTERFACE(IOpenCVEngine, data, reply);
+	    const String16 version = data.readString16();
+	    LOGD("OpenCVEngine::GetLibraryList(%s)", String8(version).string());
+	    String16 path = GetLibraryList(version);
+	    reply->writeInt32(0);
+	    return reply->writeString16(path);
+	} break;
+	case OCVE_INSTALL_VERSION:
+	{
+	    LOGD("OpenCVEngine OCVE_INSTALL_VERSION request");
+	    CHECK_INTERFACE(IOpenCVEngine, data, reply);
+	    const String16 version = data.readString16();
+	    LOGD("OpenCVEngine::InstallVersion(%s)", String8(version).string());
+	    bool result = InstallVersion(version);
+	    reply->writeInt32(0);
+	    int res = reply->writeInt32(static_cast<int32_t>(result));
+	    LOGD("InstallVersion call to Binder finished with res %d", res);
+	    return res;
+	    
+	} break;
+	
+	default:
+	{
+	    LOGD("OpenCVEngine unknown request");
+	    return BBinder::onTransact(code, data, reply, flags);
+	}
+    }
+    
+    return android::NO_ERROR;
+}
@@ -0,0 +1,21 @@
+#ifndef __BP_OPENCV_ENGINE_H__
+#define __BP_OPENCV_ENGINE_H__
+
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+
+class BnOpenCVEngine: public android::BnInterface<IOpenCVEngine>
+{
+public:
+    android::status_t onTransact(uint32_t code,
+				 const android::Parcel &data,
+				 android::Parcel *reply,
+				 uint32_t flags);
+    virtual ~BnOpenCVEngine();
+    
+};
+
+#endif
@@ -0,0 +1,71 @@
+#include "IOpenCVEngine.h"
+#include "BpOpenCVEngine.h"
+
+using namespace android;
+
+BpOpenCVEngine::BpOpenCVEngine(const sp<IBinder>& impl):
+    BpInterface<IOpenCVEngine>(impl)
+{
+}
+
+BpOpenCVEngine::~BpOpenCVEngine()
+{   
+}
+
+// Notes about data transaction:
+// Java Binder Wrapper call readInt32 before reading return data
+// It treet this in value as exception code
+// This implementation support this feature
+
+int BpOpenCVEngine::GetVersion()
+{
+    Parcel data, reply;
+    
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    remote()->transact(OCVE_GET_ENGINE_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+    
+    return reply.readInt32();
+}
+
+String16 BpOpenCVEngine::GetLibPathByVersion(String16 version)
+{
+    Parcel data, reply;
+    
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_GET_LIB_PATH_BY_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+    
+    return reply.readString16();
+}
+
+android::String16 BpOpenCVEngine::GetLibraryList(String16 version)
+{
+    Parcel data, reply;
+    
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_GET_LIB_LIST, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+    
+    return reply.readString16();    
+}
+
+bool BpOpenCVEngine::InstallVersion(String16 version)
+{
+    Parcel data, reply;
+    
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_INSTALL_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+    
+    return static_cast<bool>(reply.readInt32());
+}
+
+IMPLEMENT_META_INTERFACE(OpenCVEngine, OPECV_ENGINE_CLASSNAME)
@@ -0,0 +1,20 @@
+#ifndef __BP_OPENCV_ENGINE_H__
+#define __BP_OPENCV_ENGINE_H__
+
+#include "IOpenCVEngine.h"
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+
+class BpOpenCVEngine: public android::BpInterface<IOpenCVEngine>
+{
+public:
+    BpOpenCVEngine(const android::sp<android::IBinder>& impl);
+    virtual ~BpOpenCVEngine();
+    virtual int GetVersion();
+    virtual android::String16 GetLibPathByVersion(android::String16 version);
+    virtual android::String16 GetLibraryList(android::String16 version);
+    virtual bool InstallVersion(android::String16 version);
+};
+
+#endif
@@ -0,0 +1,179 @@
+#include "HardwareDetector.h"
+#include "TegraDetector.h"
+#include "ProcReader.h"
+#include "EngineCommon.h"
+#include "StringUtils.h"
+#include <utils/Log.h>
+
+using namespace std;
+
+int GetCpuID()
+{
+    int result = 0;
+    map<string, string> cpu_info = GetCpuInfo();
+    map<string, string>::const_iterator it;
+    
+#ifdef __i386__
+    LOGD("Using X86 HW detector");
+    result |= ARCH_X86;
+    it = cpu_info.find("flags");
+    if (cpu_info.end() != it)
+    {
+	set<string> features = SplitString(it->second, ' ');
+	if (features.end() != features.find(CPU_INFO_SSE_STR))
+	{
+	    result |= FEATURES_HAS_SSE;
+	}
+	if (features.end() != features.find(CPU_INFO_SSE2_STR))
+	{
+	    result |= FEATURES_HAS_SSE2;
+	}
+	if (features.end() != features.find(CPU_INFO_SSSE3_STR))
+	{
+	    result |= FEATURES_HAS_SSSE3;
+	}
+    }
+#else
+    LOGD("Using ARM HW detector");
+    it = cpu_info.find("Processor");
+
+    if (cpu_info.end() != it)
+    {
+	size_t proc_name_pos = it->second.find(CPU_INFO_ARCH_X86_STR);
+	if (string::npos != proc_name_pos)
+	{
+	}
+	else
+	{
+	    proc_name_pos = it->second.find(CPU_INFO_ARCH_ARMV7_STR);
+	    if (string::npos != proc_name_pos)
+	    {
+		result |= ARCH_ARMv7;
+	    }
+	    else
+	    {
+		proc_name_pos = it->second.find(CPU_INFO_ARCH_ARMV6_STR);
+		if (string::npos != proc_name_pos)
+		{
+		    result |= ARCH_ARMv6;
+		}
+		else
+		{
+		    proc_name_pos = it->second.find(CPU_INFO_ARCH_ARMV5_STR);
+		    if (string::npos != proc_name_pos)
+		    {
+			result |= ARCH_ARMv5;
+		    }
+		    
+		}
+	    }
+	}
+    }
+    else
+    {
+	return ARCH_UNKNOWN;
+    }
+
+    it = cpu_info.find("Features");
+    if (cpu_info.end() != it)
+    {
+	set<string> features = SplitString(it->second, ' ');
+	if (features.end() != features.find(CPU_INFO_NEON_STR))
+	{
+	    result |= FEATURES_HAS_NEON;
+	}
+	if (features.end() != features.find(CPU_INFO_NEON2_STR))
+	{
+	    result |= FEATURES_HAS_NEON2;
+	}
+	if (features.end() != features.find(CPU_INFO_VFPV3_STR))
+	{
+	    if (features.end () != features.find(CPU_INFO_VFPV3D16_STR))
+	    {
+		result |= FEATURES_HAS_VFPv3d16;
+	    }
+	    else
+	    {
+		result |= FEATURES_HAS_VFPv3;
+	    }
+	}
+    }
+#endif
+
+    return result;
+}
+
+string GetPlatformName()
+{
+    map<string, string> cpu_info = GetCpuInfo();
+    string hardware_name = "";
+    map<string, string>::const_iterator hw_iterator = cpu_info.find("Hardware");
+    
+    if (cpu_info.end() != hw_iterator)
+    {
+	hardware_name = hw_iterator->second;
+    }
+    
+    return hardware_name;   
+}
+
+int GetProcessorCount()
+{ 
+    FILE* cpuPossible = fopen("/sys/devices/system/cpu/possible", "r");
+    if(!cpuPossible)
+	return 1;
+    
+    char buf[2000]; //big enough for 1000 CPUs in worst possible configuration
+    char* pbuf = fgets(buf, sizeof(buf), cpuPossible);
+    fclose(cpuPossible);
+    if(!pbuf)
+	return 1;
+    
+    //parse string of form "0-1,3,5-7,10,13-15"
+	int cpusAvailable = 0;
+	
+	while(*pbuf)
+	{
+	    const char* pos = pbuf;
+	    bool range = false;
+	    while(*pbuf && *pbuf != ',')
+	    {
+		if(*pbuf == '-') range = true;
+		++pbuf;
+	    }
+	    if(*pbuf) *pbuf++ = 0;
+	    if(!range)
+		++cpusAvailable;
+	    else
+	    {
+		int rstart = 0, rend = 0;
+		sscanf(pos, "%d-%d", &rstart, &rend);
+		cpusAvailable += rend - rstart + 1;
+	    }
+	}
+	return cpusAvailable ? cpusAvailable : 1;
+}
+
+int DetectKnownPlatforms()
+{
+    int tegra_status = DetectTegra();
+    
+    if (3 == tegra_status)
+    {
+	return PLATFORM_TEGRA3;
+    }
+    else
+    {
+	return PLATFORM_UNKNOWN;
+    }
+    
+    // NOTE: Uncomment when all Tegras will be supported
+    /*if (tegra_status > 0)
+    {
+	return PLATFORM_TEGRA + tegra_status - 1;
+    }
+    else
+    {
+	return PLATFORM_UNKNOWN;
+    }*/
+}
@@ -0,0 +1,35 @@
+#ifndef __HARDWARE_DETECTOR_H__
+#define __HARDWARE_DETECTOR_H__
+
+#include <string>
+
+#define ARCH_UNKNOWN 0L
+#define ARCH_X86 16777216L
+#define ARCH_X64 33554432L
+#define ARCH_ARMv5 67108864L
+#define ARCH_ARMv6 134217728L
+#define ARCH_ARMv7 268435456L
+#define ARCH_ARMv8 536870912L
+
+#define FEATURES_HAS_VFPv3d16 1L
+#define FEATURES_HAS_VFPv3 2L
+#define FEATURES_HAS_NEON 4L
+#define FEATURES_HAS_NEON2 8L
+#define FEATURES_HAS_SSE 1L
+#define FEATURES_HAS_SSE2 2L
+#define FEATURES_HAS_SSSE3 4L
+#define FEATURES_HAS_GPU 65536L
+
+// TODO: Do not forget to add Platrfom name to PackageInfo::PlatformNameMap 
+// in method PackageInfo::InitPlatformNameMap()
+#define PLATFORM_UNKNOWN 0L
+#define PLATFORM_TEGRA 1L
+#define PLATFORM_TEGRA2 2L
+#define PLATFORM_TEGRA3 3L
+
+int DetectKnownPlatforms();
+int GetProcessorCount();
+std::string GetPlatformName();
+int GetCpuID();
+
+#endif
@@ -0,0 +1,225 @@
+#include "EngineCommon.h"
+#include "OpenCVEngine.h"
+#include "HardwareDetector.h"
+#include "StringUtils.h"
+#include <utils/Log.h>
+#include <assert.h>
+#include <string>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <dlfcn.h>
+
+using namespace android;
+
+const int OpenCVEngine::Platform = DetectKnownPlatforms();
+const int OpenCVEngine::CpuID = GetCpuID();
+
+std::set<std::string> OpenCVEngine::InitKnownOpenCVersions()
+{
+    std::set<std::string> result;
+
+    result.insert("240");
+    result.insert("241");
+    result.insert("242");
+
+    return result;
+}
+
+const std::set<std::string> OpenCVEngine::KnownVersions = InitKnownOpenCVersions();
+
+bool OpenCVEngine::ValidateVersionString(const std::string& version)
+{
+    return (KnownVersions.find(version) != KnownVersions.end());
+}
+
+std::string OpenCVEngine::NormalizeVersionString(std::string version)
+{
+    std::string result = "";
+    std::string suffix = "";
+
+    if (version.empty())
+    {
+	return result;
+    }
+
+    if (('a' == version[version.size()-1]) || ('b' == version[version.size()-1]))
+    {
+	suffix = version[version.size()-1];
+	version.erase(version.size()-1);
+    }
+
+    std::vector<std::string> parts = SplitStringVector(version, '.');
+
+    if (parts.size() >= 2)
+    {
+	if (parts.size() >= 3)
+	{
+	    result = parts[0] + parts[1] + parts[2] + suffix;
+	    if (!ValidateVersionString(result))
+		result = "";
+	}
+	else
+	{
+	    result = parts[0] + parts[1] + "0" + suffix;
+	    if (!ValidateVersionString(result))
+		result = "";
+	}
+    }
+
+    return result;
+}
+
+OpenCVEngine::OpenCVEngine(IPackageManager* PkgManager):
+    PackageManager(PkgManager)
+{
+    assert(PkgManager);
+}
+
+int32_t OpenCVEngine::GetVersion()
+{
+    return OPEN_CV_ENGINE_VERSION; 
+}
+
+String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
+{
+    std::string std_version(String8(version).string());
+    std::string norm_version;
+    std::string path;
+
+    LOGD("OpenCVEngine::GetLibPathByVersion(%s) impl", String8(version).string());
+
+    norm_version = NormalizeVersionString(std_version);
+
+    if (!norm_version.empty())
+    {
+	path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+	if (path.empty())
+	{
+	    LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
+	}
+	else
+	{
+	    FixPermissions(path);
+	}
+    }
+    else
+    {
+	LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+    }
+
+    return String16(path.c_str());
+}
+
+android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
+{
+    std::string std_version = String8(version).string();
+    std::string norm_version;
+    String16 result;
+    norm_version = NormalizeVersionString(std_version);
+
+    if (!norm_version.empty())
+    {
+	std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+	if (!tmp.empty())
+	{
+	    tmp += "/libopencvinfo.so";
+	    
+	    LOGD("Trying to load info library \"%s\"", tmp.c_str());
+	    
+	    void *handle;
+	    char* (*info_func)();
+	    
+	    handle = dlopen(tmp.c_str(), RTLD_LAZY);
+	    if (handle)
+	    {
+		const char *error;
+		
+		dlerror(); 
+		*(void **) (&info_func) = dlsym(handle, "GetLibraryList");
+		if ((error = dlerror()) == NULL)
+		{
+		    result = String16((*info_func)());
+		    dlclose(handle);   
+		}
+		else
+		{
+		    LOGE("Library loading error: \"%s\"", error);
+		}
+	    }
+	    else
+	    {
+		LOGI("Info library not found in package");
+	    }
+	}
+	else
+	{
+	    LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
+	}
+    }
+    else
+    {
+	LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+    }
+
+    return result;
+}
+
+bool OpenCVEngine::InstallVersion(android::String16 version)
+{
+    std::string std_version = String8(version).string();
+    std::string norm_version;
+    bool result = false;
+
+    norm_version = NormalizeVersionString(std_version);
+
+    if (!norm_version.empty())
+    {
+	LOGD("OpenCVEngine::InstallVersion() begin");
+	
+	if (!PackageManager->CheckVersionInstalled(norm_version, Platform, CpuID))
+	{
+	    LOGD("PackageManager->InstallVersion call");
+	    result = PackageManager->InstallVersion(norm_version, Platform, CpuID);
+	}
+	else
+	{
+	    LOGI("Package OpenCV of version %s is already installed. Skiped.", norm_version.c_str());
+	    result = true;
+	}
+    }
+    else
+    {
+	LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+    }
+
+    LOGD("OpenCVEngine::InstallVersion() end");
+
+    return result;
+}
+
+bool OpenCVEngine::FixPermissions(const std::string& path)
+{
+    LOGD("Fixing permissions for folder: \"%s\"", path.c_str());
+    chmod(path.c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+
+    DIR* dir = opendir(path.c_str());
+    if (!dir)
+    {
+	LOGD("Fixing permissions error");
+	return false;
+    }
+
+    dirent* files = readdir(dir);
+    while (files)
+    {
+	LOGD("Fix permissions for \"%s\"", files->d_name);
+	chmod((path + std::string("/") + std::string(files->d_name)).c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+	files = readdir(dir);
+    }
+
+    closedir(dir);
+
+    return true;
+}
@@ -0,0 +1,38 @@
+#ifndef __OPEN_CV_ENGINE_H__
+#define __OPEN_CV_ENGINE_H__
+
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "BnOpenCVEngine.h"
+#include "IPackageManager.h"
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+#include <string>
+#include <set>
+
+class OpenCVEngine: public BnOpenCVEngine
+{
+public:
+    OpenCVEngine(IPackageManager* PkgManager);
+    int32_t GetVersion();
+    android::String16 GetLibPathByVersion(android::String16 version);
+    virtual android::String16 GetLibraryList(android::String16 version);
+    bool InstallVersion(android::String16 version);
+    
+protected:
+    IPackageManager* PackageManager;
+    static const std::set<std::string> KnownVersions;
+    
+    OpenCVEngine();
+    static std::set<std::string> InitKnownOpenCVersions();
+    bool ValidateVersionString(const std::string& version);
+    std::string NormalizeVersionString(std::string version);
+    bool FixPermissions(const std::string& path);
+    
+    static const int Platform;
+    static const int CpuID;
+};
+
+#endif
@@ -0,0 +1,31 @@
+#include "ProcReader.h"
+#include "StringUtils.h"
+#include <fstream>
+
+using namespace std;
+
+map<string, string> GetCpuInfo()
+{
+    map<string, string> result;
+    ifstream f;
+    
+    f.open("/proc/cpuinfo");
+    if (f.is_open())
+    {
+	while (!f.eof())
+	{
+	    string tmp;
+	    string key;
+	    string value;
+	    getline(f, tmp);
+	    if (ParseString(tmp, key, value))
+	    {
+		result[key] = value;
+	    }
+	}
+    }
+        
+    f.close();
+    
+    return result;
+}
@@ -0,0 +1,27 @@
+#ifndef __PROC_READER_H__
+#define __PROC_READER_H__
+
+#include <map>
+#include <set>
+#include <string>
+
+#define CPU_INFO_NEON_STR "neon"
+#define CPU_INFO_NEON2_STR "neon2"
+#define CPU_INFO_VFPV3_STR "vfpv3"
+#define CPU_INFO_VFPV3D16_STR "vfpv3d16"
+
+#define CPU_INFO_SSE_STR "sse"
+#define CPU_INFO_SSE2_STR "sse2"
+#define CPU_INFO_SSSE3_STR "ssse3"
+
+#define CPU_INFO_ARCH_ARMV7_STR "ARMv7"
+#define CPU_INFO_ARCH_ARMV6_STR "ARMv6"
+#define CPU_INFO_ARCH_ARMV5_STR "ARMv5"
+
+#define CPU_INFO_ARCH_X86_STR "x86"
+
+
+// public part
+std::map<std::string, std::string> GetCpuInfo();
+
+#endif
@@ -0,0 +1,93 @@
+#include "StringUtils.h"
+
+using namespace std;
+
+bool StripString(string& src)
+{ 
+    size_t pos = 0;
+    
+    if (src.empty())
+    {
+	return false;
+    }
+    
+    while ((pos < src.length()) && (' ' == src[pos])) pos++;
+    src.erase(0, pos);
+    
+    pos = 0;
+    while ((pos < src.length()) && ('\t' == src[pos])) pos++;
+    src.erase(0, pos);
+    
+    pos = src.length() - 1;
+    while (pos && (' ' == src[pos])) pos--;
+    src.erase(pos+1);
+    
+    pos = src.length() - 1;
+    while (pos && ('\t' == src[pos])) pos--;
+    src.erase(pos+1);
+    
+    return true;
+}
+
+bool ParseString(const string& src, string& key, string& value)
+{
+    if (src.empty())
+	return false;
+    
+    // find seporator ":"
+	size_t seporator_pos = src.find(":");
+	if (string::npos != seporator_pos)
+	{
+	    key = src.substr(0, seporator_pos);
+	    StripString(key);
+	    value = src.substr(seporator_pos+1);
+	    StripString(value);
+	    return true;
+	}
+	else
+	{
+	    return false;
+	}
+}
+
+set<string> SplitString(const string& src, const char seporator)
+{
+    
+    set<string> result;
+    
+    if (!src.empty())
+    {
+	size_t seporator_pos;
+	size_t prev_pos = 0;
+	do
+	{
+	    seporator_pos = src.find(seporator, prev_pos);
+	    result.insert(src.substr(prev_pos, seporator_pos - prev_pos));
+	    prev_pos = seporator_pos + 1;
+	}
+	while (string::npos != seporator_pos);
+    }
+    
+    return result;
+}
+
+vector<string> SplitStringVector(const string& src, const char seporator)
+{
+    vector<string> result;
+    
+    if (!src.empty())
+    {
+	size_t seporator_pos;
+	size_t prev_pos = 0;
+	do
+	{
+	    seporator_pos = src.find(seporator, prev_pos);
+	    string tmp = src.substr(prev_pos, seporator_pos - prev_pos);
+	    result.push_back(tmp);
+	    prev_pos = seporator_pos + 1;
+	}
+	while (string::npos != seporator_pos);
+    }
+    
+    return result;
+}
@@ -0,0 +1,13 @@
+#ifndef __STRING_UTILS_H__
+#define __STRING_UTILS_H__
+
+#include <string>
+#include <set>
+#include <vector>
+
+bool StripString(std::string& src);
+std::set<std::string> SplitString(const std::string& src, const char seporator);
+bool ParseString(const std::string& src, std::string& key, std::string& value);
+std::vector<std::string> SplitStringVector(const std::string& src, const char seporator);
+
+#endif
@@ -0,0 +1,53 @@
+#include "TegraDetector.h"
+#include <zlib.h>
+#include <string.h>
+
+#define KERNEL_CONFIG "/proc/config.gz"
+#define KERNEL_CONFIG_MAX_LINE_WIDTH 512
+#define KERNEL_CONFIG_TEGRA_MAGIC "CONFIG_ARCH_TEGRA=y"
+#define KERNEL_CONFIG_TEGRA2_MAGIC "CONFIG_ARCH_TEGRA_2x_SOC=y"
+#define KERNEL_CONFIG_TEGRA3_MAGIC "CONFIG_ARCH_TEGRA_3x_SOC=y"
+#define MAX_DATA_LEN    4096
+
+int DetectTegra()
+{
+    int result = TEGRA_NOT_TEGRA;
+    gzFile kernelConfig = gzopen(KERNEL_CONFIG, "r");
+    if (kernelConfig != 0)
+    {
+	char tmpbuf[KERNEL_CONFIG_MAX_LINE_WIDTH];
+	const char *tegra_config = KERNEL_CONFIG_TEGRA_MAGIC;
+	const char *tegra2_config = KERNEL_CONFIG_TEGRA2_MAGIC;
+	const char *tegra3_config = KERNEL_CONFIG_TEGRA3_MAGIC;
+	int len = strlen(tegra_config);
+	int len2 = strlen(tegra2_config);
+	int len3 = strlen(tegra3_config);
+	while (0 != gzgets(kernelConfig, tmpbuf, KERNEL_CONFIG_MAX_LINE_WIDTH))
+	{
+	    if (0 == strncmp(tmpbuf, tegra_config, len))
+	    {
+		result = 1;
+	    }
+
+	    if (0 == strncmp(tmpbuf, tegra2_config, len2))
+	    {
+		result = 2;
+		break;
+	    }
+	    
+	    if (0 == strncmp(tmpbuf, tegra3_config, len3))
+	    {
+		result = 3;
+		break;
+	    }
+
+	}
+	gzclose(kernelConfig);
+    }
+    else
+    {
+	result = TEGRA_DETECTOR_ERROR;
+    }
+    
+    return result;
+}
@@ -0,0 +1,9 @@
+#ifndef __TEGRA_DETECTOR_H__
+#define __TEGRA_DETECTOR_H__
+
+#define TEGRA_DETECTOR_ERROR -2
+#define TEGRA_NOT_TEGRA -1
+
+int DetectTegra();
+
+#endif
@@ -0,0 +1,25 @@
+#include "HardwareDetector_jni.h"
+#include "HardwareDetector.h"
+#include <jni.h>
+#include <string>
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetCpuID(JNIEnv* env, jclass)
+{
+    return GetCpuID();
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetPlatformName(JNIEnv* env, jclass)
+{
+    std::string hardware_name = GetPlatformName();
+    return env->NewStringUTF(hardware_name.c_str());
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetProcessorCount(JNIEnv* env, jclass)
+{
+    return GetProcessorCount();
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_DetectKnownPlatforms(JNIEnv* env, jclass)
+{
+    return DetectKnownPlatforms();
+}
@@ -0,0 +1,48 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class HardwareDetector */
+
+#ifndef _Included_HardwareDetector
+#define _Included_HardwareDetector
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     org_opencv_engine_manager_HardwareDetector
+ * Method:    GetCpuID
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetCpuID
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_manager_HardwareDetector
+ * Method:    GetPlatformName
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetPlatformName
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_manager_HardwareDetector
+ * Method:    GetProcessorCount
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetProcessorCount
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_manager_HardwareDetector
+ * Method:    DetectKnownPlatforms
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_DetectKnownPlatforms
+(JNIEnv *, jclass);
+  
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,176 @@
+#include "JavaBasedPackageManager.h"
+#include <utils/Log.h>
+#include <assert.h>
+
+#undef LOG_TAG
+#define LOG_TAG "JavaBasedPackageManager"
+
+using namespace std;
+
+JavaBasedPackageManager::JavaBasedPackageManager(JavaVM* JavaMashine, jobject MarketConnector):
+    JavaContext(JavaMashine),
+    JavaPackageManager(MarketConnector)
+{
+    assert(JavaContext);    
+    assert(JavaPackageManager);
+}
+
+bool JavaBasedPackageManager::InstallPackage(const PackageInfo& package)
+{
+    JNIEnv* jenv;
+    bool self_attached;
+    LOGD("JavaBasedPackageManager::InstallPackage() begin\n");
+    
+    self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
+    if (self_attached)
+    {
+	JavaContext->AttachCurrentThread(&jenv, NULL);
+    }
+    
+    LOGD("GetObjectClass call\n");
+    jclass jclazz = jenv->GetObjectClass(JavaPackageManager);
+    if (!jclazz)
+    {
+	LOGE("MarketConnector class was not found!");
+	return false;
+    }
+
+    LOGD("GetMethodID call\n");
+    jmethodID jmethod = jenv->GetMethodID(jclazz, "InstallAppFromMarket", "(Ljava/lang/String;)Z");
+    if (!jmethod)
+    {
+	LOGE("MarketConnector::GetAppFormMarket method was not found!");
+	return false;
+    }
+    
+    LOGD("Calling java package manager with package name %s\n", package.GetFullName().c_str());
+    jobject jpkgname = jenv->NewStringUTF(package.GetFullName().c_str());
+    bool result = jenv->CallNonvirtualBooleanMethod(JavaPackageManager, jclazz, jmethod, jpkgname);
+    
+    if (self_attached)
+    {
+	JavaContext->DetachCurrentThread();
+    }
+    
+    LOGD("JavaBasedPackageManager::InstallPackage() end\n");
+    
+    return result;
+}
+
+vector<PackageInfo> JavaBasedPackageManager::GetInstalledPackages()
+{
+    vector<PackageInfo> result;
+    JNIEnv* jenv;
+    bool self_attached;
+
+    LOGD("JavaBasedPackageManager::GetInstalledPackages() begin");
+        
+    self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
+    if (self_attached)
+    {
+	JavaContext->AttachCurrentThread(&jenv, NULL);
+    }
+    
+    LOGD("GetObjectClass call");
+    jclass jclazz = jenv->GetObjectClass(JavaPackageManager);
+    if (!jclazz)
+    {
+	LOGE("MarketConnector class was not found!");
+	return result;
+    }
+    
+    LOGD("GetMethodID call");
+    jmethodID jmethod = jenv->GetMethodID(jclazz, "GetInstalledOpenCVPackages", "()[Landroid/content/pm/PackageInfo;");
+    if (!jmethod)
+    {
+	LOGE("MarketConnector::GetInstalledOpenCVPackages method was not found!");
+	return result;
+    }
+    
+    LOGD("Java package manager call");
+    jobjectArray jpkgs = static_cast<jobjectArray>(jenv->CallNonvirtualObjectMethod(JavaPackageManager, jclazz, jmethod));
+    jsize size = jenv->GetArrayLength(jpkgs);
+   
+    LOGD("Package info conversion");
+    
+    result.reserve(size);
+   
+    for (jsize i = 0; i < size; i++)
+    {
+	jobject jtmp = jenv->GetObjectArrayElement(jpkgs, i);
+	PackageInfo tmp = ConvertPackageFromJava(jtmp, jenv);
+	if (tmp.IsValid())
+	    result.push_back(tmp);
+    }
+    
+    if (self_attached)
+    {
+	JavaContext->DetachCurrentThread();
+    }
+    
+    LOGD("JavaBasedPackageManager::GetInstalledPackages() end");
+    
+    return result;
+}
+
+PackageInfo JavaBasedPackageManager::ConvertPackageFromJava(jobject package, JNIEnv* jenv)
+{
+    jclass jclazz = jenv->GetObjectClass(package);
+    jfieldID jfield = jenv->GetFieldID(jclazz, "packageName", "Ljava/lang/String;");
+    jstring jnameobj = static_cast<jstring>(jenv->GetObjectField(package, jfield));
+    const char* jnamestr = jenv->GetStringUTFChars(jnameobj, NULL);
+    string name(jnamestr);
+    
+    jfield = jenv->GetFieldID(jclazz, "versionName", "Ljava/lang/String;");
+    jstring jversionobj = static_cast<jstring>(jenv->GetObjectField(package, jfield));
+    const char* jversionstr = jenv->GetStringUTFChars(jversionobj, NULL);
+    string verison(jversionstr);
+    
+    string path;
+    jclazz = jenv->FindClass("android/os/Build$VERSION");
+    jfield = jenv->GetStaticFieldID(jclazz, "SDK_INT", "I");
+    jint api_level = jenv->GetStaticIntField(jclazz, jfield);
+    if (api_level > 8)
+    {
+	jclazz = jenv->GetObjectClass(package);
+	jfield = jenv->GetFieldID(jclazz, "applicationInfo", "Landroid/content/pm/ApplicationInfo;");
+	
+	jobject japp_info = jenv->GetObjectField(package, jfield);
+	jclazz = jenv->GetObjectClass(japp_info);
+	jfield = jenv->GetFieldID(jclazz, "nativeLibraryDir", "Ljava/lang/String;");
+	jstring jpathobj = static_cast<jstring>(jenv->GetObjectField(japp_info, jfield));
+	
+	const char* jpathstr = jenv->GetStringUTFChars(jpathobj, NULL);
+	path = string(jpathstr);
+	jenv->ReleaseStringUTFChars(jpathobj, jpathstr);
+    }
+    else
+    {
+	path = "/data/data/" + name + "/lib";
+    }
+    
+    return PackageInfo(name, path, verison);
+}
+
+JavaBasedPackageManager::~JavaBasedPackageManager()
+{
+    JNIEnv* jenv;
+    bool self_attached;
+
+    LOGD("JavaBasedPackageManager::~JavaBasedPackageManager() begin");
+    
+    JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6);
+    self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
+    if (self_attached)
+    {
+	JavaContext->AttachCurrentThread(&jenv, NULL);
+    }
+
+    jenv->DeleteGlobalRef(JavaPackageManager);
+
+    if (self_attached)
+    {
+	JavaContext->DetachCurrentThread();
+    }
+    LOGD("JavaBasedPackageManager::~JavaBasedPackageManager() end");
+}
@@ -0,0 +1,22 @@
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+#include <jni.h>
+#include <vector>
+
+class JavaBasedPackageManager: public CommonPackageManager
+{
+public:
+    JavaBasedPackageManager(JavaVM* JavaMashine, jobject MarketConector);
+    virtual ~JavaBasedPackageManager();
+
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();
+    
+private:
+    JavaVM* JavaContext;
+    jobject JavaPackageManager;
+    
+    JavaBasedPackageManager();
+    PackageInfo ConvertPackageFromJava(jobject package, JNIEnv* jenv);
+};
@@ -0,0 +1,70 @@
+#include "OpenCVEngine_jni.h"
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "OpenCVEngine.h"
+#include "IPackageManager.h"
+#include "JavaBasedPackageManager.h"
+#include <utils/Log.h>
+#include <android_util_Binder.h>
+
+#undef LOG_TAG
+#define LOG_TAG "OpenCVEngine/JNI"
+
+using namespace android;
+
+sp<IBinder> OpenCVEngineBinder = NULL;
+IPackageManager* PackageManager = NULL;
+
+JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect(JNIEnv* env, jobject)
+{
+    LOGI("Creating new component");
+    if (NULL != OpenCVEngineBinder.get())
+    {
+	LOGI("New component created successfully");
+    }
+    else
+    {
+	LOGE("OpenCV Engine component was not created!");
+    }
+    
+    return javaObjectForIBinder(env, OpenCVEngineBinder);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* env, jobject thiz, jobject market)
+{
+    LOGD("Java_org_opencv_engine_BinderConnector_Init");
+    
+    if (NULL == PackageManager)
+    {
+	JavaVM* jvm;
+	env->GetJavaVM(&jvm);;
+	PackageManager = new JavaBasedPackageManager(jvm, env->NewGlobalRef(market));
+    }
+    if (PackageManager)
+    {
+	if (!OpenCVEngineBinder.get())
+	{
+	    OpenCVEngineBinder = new OpenCVEngine(PackageManager);
+	    return (NULL != OpenCVEngineBinder.get());
+	}
+	else
+	{
+	    return true;
+	}
+    }
+    else
+    {
+	return false;
+    }
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_BinderConnector_Final(JNIEnv *, jobject)
+{
+    LOGD("Java_org_opencv_engine_BinderConnector_Final");
+    
+    OpenCVEngineBinder = NULL;
+
+    delete PackageManager;
+    PackageManager = NULL;
+}
+
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_opencv_engine_BinderConnector */
+
+#ifndef _Included_org_opencv_engine_BinderConnector
+#define _Included_org_opencv_engine_BinderConnector
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Connect
+ * Signature: ()Landroid/os/IBinder;
+ */
+JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Init
+ * Signature: (Lorg/opencv/engine/MarketConnector;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Final
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_engine_BinderConnector_Final
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
@@ -0,0 +1,42 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <grp.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <utils/Log.h>
+
+#include <stdio.h>
+
+using namespace android;
+
+int main(int argc, char *argv[])
+{
+    LOGI("OpenCVEngine client is now starting");
+    
+    sp<IServiceManager> ServiceManager = defaultServiceManager();
+    sp<IBinder> EngineService;
+    sp<IOpenCVEngine> Engine;
+    
+    LOGI("Trying to contect to service");
+    
+    do {
+	EngineService = ServiceManager->getService(IOpenCVEngine::descriptor);
+	if (EngineService != 0) break;
+	LOGW("OpenCVEngine not published, waiting...");
+	usleep(500000); // 0.5 s
+    } while(true);
+        
+    LOGI("Connection established");
+
+    Engine = interface_cast<IOpenCVEngine>(EngineService);
+    int32_t EngineVersion = Engine->GetVersion();
+    
+    printf("OpenCVEngine version %d started", EngineVersion);
+	
+    return 0;
+}
@@ -0,0 +1,186 @@
+#include "IOpenCVEngine.h"
+#include "CommonPackageManager.h"
+#include "HardwareDetector.h"
+#include <utils/Log.h>
+#include <algorithm>
+#include <stdio.h>
+#include <assert.h>
+
+#undef LOG_TAG
+#define LOG_TAG "CommonPackageManager"
+
+using namespace std;
+
+set<string> CommonPackageManager::GetInstalledVersions()
+{
+    set<string> result;
+    vector<PackageInfo> installed_packages = GetInstalledPackages();
+    
+    for (vector<PackageInfo>::const_iterator it = installed_packages.begin(); it != installed_packages.end(); ++it)
+    {
+	string version = it->GetVersion();
+	assert(!version.empty());
+	result.insert(version);
+    }
+    
+    return result;
+}
+
+bool CommonPackageManager::CheckVersionInstalled(const std::string& version, int platform, int cpu_id)
+{
+    bool result = false;
+    LOGD("CommonPackageManager::CheckVersionInstalled() begin");
+    PackageInfo target_package(version, platform, cpu_id);
+    LOGD("GetInstalledPackages() call");
+    vector<PackageInfo> packages = GetInstalledPackages();
+    
+    for (vector<PackageInfo>::const_iterator it = packages.begin(); it != packages.end(); ++it)
+    {
+	LOGD("Found package: \"%s\"", it->GetFullName().c_str());
+    }
+    
+    if (!packages.empty())
+    {
+	result = (packages.end() != find(packages.begin(), packages.end(), target_package));
+    }
+    LOGD("CommonPackageManager::CheckVersionInstalled() end");
+    return result;
+}
+
+bool CommonPackageManager::InstallVersion(const std::string& version, int platform, int cpu_id)
+{
+    LOGD("CommonPackageManager::InstallVersion() begin");
+    PackageInfo package(version, platform, cpu_id);    
+    return InstallPackage(package);
+}
+
+string CommonPackageManager::GetPackagePathByVersion(const std::string& version, int platform, int cpu_id)
+{
+    string result;
+    PackageInfo target_package(version, platform, cpu_id);
+    vector<PackageInfo> all_packages = GetInstalledPackages();
+    vector<PackageInfo> packages;
+    
+    for (vector<PackageInfo>::iterator it = all_packages.begin(); it != all_packages.end(); ++it)
+    {
+	if (IsVersionCompatible(version, it->GetVersion()))
+	{
+	    packages.push_back(*it);
+	}
+    }
+    
+    if (!packages.empty())
+    {
+	vector<PackageInfo>::iterator found = find(packages.begin(), packages.end(), target_package);
+	if (packages.end() != found)
+	{
+	    result = found->GetInstalationPath();
+	}
+	else
+	{
+	    int OptRating = -1;
+	    std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
+	    
+	    if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
+		group = CommonPackageManager::IntelRating;
+	    
+	    int HardwareRating = GetHardwareRating(platform, cpu_id, group);
+	    
+	    if (-1 == HardwareRating)
+	    {
+		LOGE("Cannot calculate rating for current hardware platfrom!");
+	    }
+	    else
+	    {
+		for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
+		{
+		    int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
+		    if (PackageRating >= 0)
+		    {
+			if ((PackageRating <= HardwareRating) && (PackageRating > OptRating))
+			{
+			    OptRating = PackageRating;
+			    found = it;
+			}
+		    }
+		}
+		
+		if ((-1 != OptRating) && (packages.end() != found))
+		{
+		    result = found->GetInstalationPath();
+		}
+	    }
+	}
+    }
+    
+    return result;
+}
+
+bool CommonPackageManager::IsVersionCompatible(const std::string& target_version, const std::string& package_version)
+{
+    assert (target_version.size() == 3);
+    assert (package_version.size() == 3);
+    
+    bool result = false;
+    
+    // major version is the same and minor package version is above or the same as target.
+    if ((package_version[0] == target_version[0]) && (package_version[1] == target_version[1]) && (package_version[2] >= target_version[2]))
+    {
+	result = true;    
+    }
+	
+    return result;
+}
+
+int CommonPackageManager::GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group)
+{
+    int result = -1;
+    
+    for (size_t i = 0; i < group.size(); i++)
+    {
+	if (group[i] == std::pair<int, int>(platform, cpu_id))
+	{
+	    result = i;
+	    break;
+	}
+    }
+
+    return result;
+}
+
+std::vector<std::pair<int, int> > CommonPackageManager::InitArmRating()
+{
+    std::vector<std::pair<int, int> > result;
+    
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv5));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3d16));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA2, ARCH_ARMv7 | FEATURES_HAS_VFPv3));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    
+    return result;
+}
+
+std::vector<std::pair<int, int> > CommonPackageManager::InitIntelRating()
+{
+    std::vector<std::pair<int, int> > result;
+    
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X64));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSSE3));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_X86));
+    
+    return result;
+}
+
+std::vector<std::pair<int, int> > CommonPackageManager::IntelRating = CommonPackageManager::InitIntelRating();
+std::vector<std::pair<int, int> > CommonPackageManager::ArmRating = InitArmRating();
+
+CommonPackageManager::~CommonPackageManager()
+{
+}
@@ -0,0 +1,34 @@
+#ifndef __COMMON_PACKAGE_MANAGER_H__
+#define __COMMON_PACKAGE_MANAGER_H__
+
+#include "IPackageManager.h"
+#include "PackageInfo.h"
+#include <set>
+#include <vector>
+#include <string>
+
+class CommonPackageManager: public IPackageManager
+{
+public:
+    std::set<std::string> GetInstalledVersions();
+    bool CheckVersionInstalled(const std::string& version, int platform, int cpu_id);
+    bool InstallVersion(const std::string& version, int platform, int cpu_id);
+    std::string GetPackagePathByVersion(const std::string& version, int platform, int cpu_id);
+    virtual ~CommonPackageManager();
+
+protected:
+    static std::vector<std::pair<int, int> > ArmRating;
+    static std::vector<std::pair<int, int> > IntelRating;
+    
+    static std::vector<std::pair<int, int> > InitArmRating();
+    static std::vector<std::pair<int, int> > InitIntelRating();
+    
+    bool IsVersionCompatible(const std::string& target_version, const std::string& package_version);
+    int GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group);
+    
+    virtual bool InstallPackage(const PackageInfo& package) = 0;
+    virtual std::vector<PackageInfo> GetInstalledPackages() = 0;   
+};
+
+
+#endif
@@ -0,0 +1,19 @@
+#include "NativePackageManager.h"
+
+using namespace std;
+
+bool NativePackageManager::InstallPackage(const PackageInfo& package)
+{
+    return false;
+}
+
+vector<PackageInfo> NativePackageManager::GetInstalledPackages()
+{
+    vector<PackageInfo> result;
+    
+    return result;
+}
+
+NativePackageManager::~NativePackageManager()
+{
+}
@@ -0,0 +1,16 @@
+#ifndef __NATIVE_PACKAGE_MANAGER_STUB_H__
+#define __NATIVE_PACKAGE_MANAGER_STUB_H__
+
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+
+class NativePackageManager: public CommonPackageManager
+{
+public:
+    virtual ~NativePackageManager();
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();    
+};
+
+#endif
@@ -0,0 +1,391 @@
+#include "EngineCommon.h"
+#include "PackageInfo.h"
+#include "HardwareDetector.h"
+#include "IOpenCVEngine.h"
+#include "StringUtils.h"
+#include <assert.h>
+#include <vector>
+#include <utils/Log.h>
+
+using namespace std;
+
+map<int, string> PackageInfo::InitPlatformNameMap()
+{
+    map<int, string> result;
+    
+    // TODO: Do not forget to add Platrfom constant to HardwareDetector.h
+    result[PLATFORM_TEGRA] = PLATFORM_TEGRA_NAME;
+    result[PLATFORM_TEGRA2] = PLATFORM_TEGRA2_NAME;
+    result[PLATFORM_TEGRA3] = PLATFORM_TEGRA3_NAME;
+    
+    return result;
+}
+
+const map<int, string> PackageInfo::PlatformNameMap = InitPlatformNameMap();
+const string PackageInfo::BasePackageName = "org.opencv.lib";
+
+inline string JoinARMFeatures(int cpu_id)
+{
+    string result;
+
+    if (FEATURES_HAS_NEON2 & cpu_id)
+    {
+	result = string(FEATURES_HAS_NEON2_NAME);
+    }    
+    else if (FEATURES_HAS_NEON & cpu_id)
+    {
+	result = string(FEATURES_HAS_NEON_NAME);
+    }
+    else if (FEATURES_HAS_VFPv3 & cpu_id)
+    {
+	result = string(FEATURES_HAS_VFPv3_NAME);
+    }
+    else if (FEATURES_HAS_VFPv3d16 & cpu_id)
+    {
+	result = string(FEATURES_HAS_VFPv3d16_NAME);
+    }
+    
+    return result;
+}
+
+inline int SplitARMFeatures(const vector<string>& features)
+{
+    int result = 0;
+    
+    for (size_t i = 3; i < features.size(); i++)
+    {
+	if (FEATURES_HAS_VFPv3_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_VFPv3;
+	}
+	else if (FEATURES_HAS_VFPv3d16_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_VFPv3d16;
+	}
+	else if (FEATURES_HAS_NEON_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_NEON;
+	}
+	else if (FEATURES_HAS_NEON2_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_NEON2;
+	}
+    }
+    
+    return result;
+}
+
+inline string JoinIntelFeatures(int cpu_id)
+{
+    string result;
+    
+    if (FEATURES_HAS_SSSE3 & cpu_id)
+    {
+	result = FEATURES_HAS_SSSE3_NAME;
+    }
+    else if (FEATURES_HAS_SSE2 & cpu_id)
+    {
+	result = FEATURES_HAS_SSE2_NAME;
+    }
+    else if (FEATURES_HAS_SSE & cpu_id)
+    {
+	result = FEATURES_HAS_SSE_NAME;
+    }
+    
+    return result;
+}
+
+inline int SplitIntelFeatures(const vector<string>& features)
+{
+    int result = 0;
+    
+    for (size_t i = 3; i < features.size(); i++)
+    {
+	if (FEATURES_HAS_SSSE3_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_SSSE3;
+	}
+	else if (FEATURES_HAS_SSE2_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_SSE2;
+	}
+	else if (FEATURES_HAS_SSE_NAME == features[i])
+	{
+	    result |= FEATURES_HAS_SSE;
+	}
+    }    
+    
+    return result;
+}
+
+inline string SplitVersion(const vector<string>& features, const string& package_version)
+{
+    string result;
+    
+    if ((features.size() > 1) && ('v' == features[1][0]))
+    {
+	result = features[1].substr(1);
+	result += SplitStringVector(package_version, '.')[0];
+    }
+    else
+    {
+	// TODO: Report package name format error
+    }
+    
+    return result;
+}
+
+inline string JoinPlatform(int platform)
+{
+    string result;
+    map<int, string>::const_iterator it = PackageInfo::PlatformNameMap.find(platform);
+    
+    assert(PackageInfo::PlatformNameMap.end() != it);
+    result = it->second;
+    
+    return result;
+}
+
+inline int SplitPlatfrom(const vector<string>& features)
+{
+    int result = 0;
+    
+    if (features.size() > 2)
+    {
+	string tmp = features[2];
+	if (PLATFORM_TEGRA_NAME == tmp)
+	{
+	    result = PLATFORM_TEGRA;
+	}
+	else if (PLATFORM_TEGRA2_NAME == tmp)
+	{
+	    result = PLATFORM_TEGRA2;
+	}
+	else if (PLATFORM_TEGRA3_NAME == tmp)
+	{
+	    result = PLATFORM_TEGRA3;
+	}
+    }
+    else
+    {
+	// TODO: Report package name format error
+    }
+	
+    return result;
+}
+
+/* Package naming convention
+ * All parts of package name seporated by "_" symbol
+ * First part is base namespace.
+ * Second part is version. Version starts from "v" symbol. After "v" symbol version nomber without dot symbol added.
+ * If platform is known third part is platform name
+ * If platform is unknown it is defined by hardware capabilities using pattern: <arch>_<fpu features>_<vectorisation features>_<other features>
+ * Example: armv7_vfpv3_neon, armv7_vfpv3d16_neon
+ */ 
+PackageInfo::PackageInfo(const string& version, int platform, int cpu_id):
+    Version(version),
+    Platform(platform),
+    CpuID(cpu_id),
+    InstallPath("")
+{
+    FullName = BasePackageName + "_v" + Version.substr(0, Version.size()-1);
+    if (PLATFORM_UNKNOWN != Platform)
+    {
+	FullName += string("_") + JoinPlatform(platform);
+    }
+    else
+    {
+	if (ARCH_UNKNOWN != CpuID)
+	{
+	    if (ARCH_X86 & CpuID)
+	    {
+		LOGD("Found processor with x86 arch");
+		FullName += string("_") + ARCH_X86_NAME;
+		// NOTE: Intel features temporary are not supported
+		//string features = JoinIntelFeatures(CpuID);
+		string features;
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	    if (ARCH_X64 & CpuID)
+	    {
+		LOGD("Found processor with x64 arch");
+		// NOTE: Intel features temporary are not supported
+		//FullName += string("_") + ARCH_X64_NAME;
+		//string features = JoinIntelFeatures(CpuID);
+		FullName += string("_") + ARCH_X86_NAME;
+		string features;
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	    if (ARCH_ARMv5 & CpuID)
+	    {
+		LOGD("Found processor with ARMv5 arch");
+		FullName += string("_") + ARCH_ARMv5_NAME;
+		string features = JoinARMFeatures(CpuID);
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	    if (ARCH_ARMv6 & CpuID)
+	    {
+		LOGD("Found processor with ARMv6 arch");
+		// NOTE: ARM v6 used instead ARM v6
+		//FullName += string("_") + ARCH_ARMv6_NAME;
+		FullName += string("_") + ARCH_ARMv5_NAME;
+		// NOTE: ARM features temporary are not supported
+		//string features = JoinARMFeatures(CpuID);
+		string features;
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	    if (ARCH_ARMv7 & CpuID)
+	    {
+		LOGD("Found processor with ARMv7 arch");
+		FullName += string("_") + ARCH_ARMv7_NAME;
+		// NOTE: ARM features temporary are not supported
+		//string features = JoinARMFeatures(CpuID);
+		string features;
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	    if (ARCH_ARMv8 & CpuID)
+	    {
+		LOGD("Found processor with ARMv8 arch");
+		FullName += string("_") + ARCH_ARMv8_NAME;
+		string features = JoinARMFeatures(CpuID);
+		if (!features.empty())
+		{
+		    FullName += string("_") + features;
+		}
+	    }
+	}
+	else
+	{
+	    LOGD("Found processor with unknown arch");
+	    Version.clear();
+	    CpuID = ARCH_UNKNOWN;
+	    Platform = PLATFORM_UNKNOWN;
+	}
+    }
+}
+
+PackageInfo::PackageInfo(const string& fullname, const string& install_path, const string& package_version):
+    FullName(fullname),
+    InstallPath(install_path)
+{
+    LOGD("PackageInfo::PackageInfo(\"%s\", \"%s\")", fullname.c_str(), install_path.c_str());
+    
+    assert(!fullname.empty());
+    assert(!install_path.empty());
+    
+    vector<string> features = SplitStringVector(FullName, '_');
+    
+    if (!features.empty() && (BasePackageName == features[0])) 
+    {
+	Version = SplitVersion(features, package_version);
+	if (Version.empty())
+	{
+	    CpuID = ARCH_UNKNOWN;
+	    Platform = PLATFORM_UNKNOWN;
+	    return;
+	}
+	
+	Platform = SplitPlatfrom(features);
+	if (PLATFORM_UNKNOWN != Platform)
+	{
+	   CpuID = 0;
+	}
+	else
+	{
+	    if (features.size() < 3)
+	    {
+		LOGD("It is not OpenCV library package for this platform");
+		Version.clear();
+		CpuID = ARCH_UNKNOWN;
+		Platform = PLATFORM_UNKNOWN;
+		return;
+	    }
+	    else if (ARCH_ARMv5_NAME == features[2])
+	    {
+		CpuID = ARCH_ARMv5 | SplitARMFeatures(features);
+	    }
+	    else if (ARCH_ARMv6_NAME == features[2])
+	    {
+		CpuID = ARCH_ARMv6 | SplitARMFeatures(features);
+	    }
+	    else if (ARCH_ARMv7_NAME == features[2])
+	    {
+		CpuID = ARCH_ARMv7 | SplitARMFeatures(features);
+	    }
+	    else if (ARCH_X86_NAME == features[2])
+	    {
+		CpuID = ARCH_X86 | SplitIntelFeatures(features);
+	    }
+	    else if (ARCH_X64_NAME == features[2])
+	    {
+		CpuID = ARCH_X64 | SplitIntelFeatures(features);
+	    }
+	    else
+	    {
+		LOGD("It is not OpenCV library package for this platform");
+		Version.clear();
+		CpuID = ARCH_UNKNOWN;
+		Platform = PLATFORM_UNKNOWN;
+		return;
+	    }
+	}
+    }
+    else
+    {
+	LOGD("It is not OpenCV library package for this platform");
+	Version.clear();
+	CpuID = ARCH_UNKNOWN;
+	Platform = PLATFORM_UNKNOWN;
+	return;
+    }
+}
+
+bool PackageInfo::IsValid() const
+{
+    return !(Version.empty() && (PLATFORM_UNKNOWN == Platform) && (ARCH_UNKNOWN == CpuID));
+}
+
+int PackageInfo::GetPlatform() const
+{
+    return Platform;
+}
+
+int PackageInfo::GetCpuID() const
+{
+    return CpuID;
+}
+
+string PackageInfo::GetFullName() const
+{
+    return FullName;
+}
+
+string PackageInfo::GetVersion() const
+{
+    return Version;
+}
+
+string PackageInfo::GetInstalationPath() const
+{
+    return InstallPath;
+}
+
+bool PackageInfo::operator==(const PackageInfo& package) const
+{
+    return (package.FullName == FullName);
+}
@@ -0,0 +1,52 @@
+#ifndef __PACKAGE_INFO_H__
+#define __PACKAGE_INFO_H__
+
+#include <map>
+#include <string>
+
+#define ARCH_X86_NAME "x86"
+#define ARCH_X64_NAME "x64"
+#define ARCH_ARMv5_NAME "armv5"
+#define ARCH_ARMv6_NAME "armv6"
+#define ARCH_ARMv7_NAME "armv7a"
+#define ARCH_ARMv8_NAME "armv8"
+
+#define FEATURES_HAS_VFPv3d16_NAME "vfpv3d16"
+#define FEATURES_HAS_VFPv3_NAME "vfpv3"
+#define FEATURES_HAS_NEON_NAME "neon"
+#define FEATURES_HAS_NEON2_NAME "neon2"
+#define FEATURES_HAS_SSE_NAME "sse"
+#define FEATURES_HAS_SSE2_NAME "sse2"
+#define FEATURES_HAS_SSSE3_NAME "ssse3"
+#define FEATURES_HAS_GPU_NAME "gpu"
+
+#define PLATFORM_TEGRA_NAME "tegra"
+#define PLATFORM_TEGRA2_NAME "tegra2"
+#define PLATFORM_TEGRA3_NAME "tegra3"
+
+
+class PackageInfo
+{
+public:
+    PackageInfo(const std::string& version, int platform, int cpu_id);
+    PackageInfo(const std::string& fullname, const std::string& install_path, const std::string& package_version = "0.0");
+    std::string GetFullName() const;
+    std::string GetVersion() const;
+    int GetPlatform() const;
+    int GetCpuID() const;
+    std::string GetInstalationPath() const;
+    bool operator==(const PackageInfo& package) const;
+    static const std::map<int, std::string> PlatformNameMap;
+    bool IsValid() const;
+
+protected:
+    static std::map<int, std::string> InitPlatformNameMap();
+    std::string Version;
+    int Platform;
+    int CpuID;
+    std::string FullName;
+    std::string InstallPath;
+    static const std::string BasePackageName;
+};
+
+#endif
@@ -0,0 +1,32 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "OpenCVEngine.h"
+#include "IPackageManager.h"
+#include "NativePackageManager.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <grp.h>
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <utils/Log.h>
+
+using namespace android;
+
+int main(int argc, char *argv[])
+{
+    LOGI("OpenCVEngine native service starting");
+    IPackageManager* PackageManager = new NativePackageManager();
+    sp<IBinder> Engine = new OpenCVEngine(PackageManager);
+    
+    defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
+    LOGI("OpenCVEngine native service started successfully");
+    ProcessState::self()->startThreadPool();
+    IPCThreadState::self()->joinThreadPool();
+    LOGI("OpenCVEngine native service finished");
+    
+    delete PackageManager;
+    
+    return 0;
+}
@@ -0,0 +1,155 @@
+#include <gtest/gtest.h>
+#include "ProcReader.h"
+#include "TegraDetector.h"
+#include "HardwareDetector.h"
+#include "StringUtils.h"
+
+using namespace std;
+
+TEST(Strip, StripEmptyString)
+{
+   string a = "";
+   EXPECT_FALSE(StripString(a));
+}
+
+TEST(Strip, StripClearString)
+{
+    string a = "qqqwww";
+    EXPECT_TRUE(StripString(a));
+    EXPECT_STREQ("qqqwww", a.c_str());
+}
+
+TEST(Strip, StripStringLeft)
+{
+    string a = "  qqqwww";
+    EXPECT_TRUE(StripString(a));
+    EXPECT_STREQ("qqqwww", a.c_str());
+}
+
+TEST(Strip, StripStringRight)
+{
+    string a = "qqqwww  ";
+    EXPECT_TRUE(StripString(a));
+    EXPECT_STREQ("qqqwww", a.c_str());
+}
+
+TEST(Strip, StripStringLeftRight)
+{
+    string a = "qqqwww  ";
+    EXPECT_TRUE(StripString(a));
+    EXPECT_STREQ("qqqwww", a.c_str());
+}
+
+TEST(Strip, StripStringWithSpaces)
+{
+    string a = "   qqq www  ";
+    EXPECT_TRUE(StripString(a));
+    EXPECT_STREQ("qqq www", a.c_str());
+}
+
+TEST(Parse, ParseEmptyString)
+{
+    string a = "";
+    string key;
+    string value;
+    EXPECT_FALSE(ParseString(a, key, value));
+}
+
+TEST(Parse, ParseStringWithoutSeporator)
+{
+    string a = "qqqwww";
+    string key;
+    string value;    
+    EXPECT_FALSE(ParseString(a, key, value));
+}
+
+TEST(Parse, ParseClearString)
+{
+    string a = "qqq:www";
+    string key;
+    string value;
+    EXPECT_TRUE(ParseString(a, key, value));
+    EXPECT_STREQ("qqq", key.c_str());
+    EXPECT_STREQ("www", value.c_str());
+}
+
+TEST(Parse, ParseDirtyString)
+{
+    string a = "qqq :  www";
+    string key;
+    string value;
+    EXPECT_TRUE(ParseString(a, key, value));
+    EXPECT_STREQ("qqq", key.c_str());
+    EXPECT_STREQ("www", value.c_str());
+}
+
+TEST(Split, SplitEmptyString)
+{
+    string a = "";
+    set<string> b = SplitString(a, ' ');
+    EXPECT_EQ(0, b.size());
+}
+
+TEST(Split, SplitOneElementString)
+{
+    string a = "qqq";
+    set<string> b = SplitString(a, ' ');
+    EXPECT_EQ(1, b.size());
+    EXPECT_FALSE(b.find("qqq") == b.end());
+}
+
+TEST(Split, SplitMultiElementString)
+{
+    string a = "qqq www eee";
+    set<string> b = SplitString(a, ' ');
+    EXPECT_EQ(3, b.size());
+    EXPECT_FALSE(b.find("qqq") == b.end());
+    EXPECT_FALSE(b.find("www") == b.end());
+    EXPECT_FALSE(b.find("eee") == b.end());
+}
+
+TEST(GetCpuInfo, GetCpuInfo)
+{
+    map<string, string> a = GetCpuInfo();
+    EXPECT_FALSE(a.empty());
+    EXPECT_TRUE(a.find("") == a.end());
+}
+
+TEST(TegraDetector, Detect)
+{
+    EXPECT_TRUE(DetectTegra() != 0);
+}
+
+TEST(CpuCount, CheckNonZero)
+{
+    EXPECT_TRUE(GetProcessorCount() != 0);
+}
+
+TEST(CpuID, CheckNotEmpy)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_NE(0, cpu_id);
+}
+
+TEST(CpuID, CheckArmV7)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & ARCH_ARMv7);
+}
+
+TEST(CpuID, CheckNeon)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & FEATURES_HAS_NEON);
+}
+
+TEST(CpuID, CheckVFPv3)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & FEATURES_HAS_VFPv3);
+}
+
+TEST(PlatfromDetector, CheckTegra)
+{
+    EXPECT_NE(PLATFORM_UNKNOWN, DetectKnownPlatforms());
+}
@@ -0,0 +1,101 @@
+#include "IOpenCVEngine.h"
+#include "EngineCommon.h"
+#include "OpenCVEngine.h"
+#include "IPackageManager.h"
+#include "PackageManagerStub.h"
+#include "PackageInfo.h"
+#include "HardwareDetector.h"
+
+#include <gtest/gtest.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <utils/Log.h>
+
+using namespace android;
+
+class ServiceStarter
+{
+public:
+    ServiceStarter()
+    {
+	PackageManager = new PackageManagerStub();
+	PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7);
+	PackageManager->InstalledPackages.push_back(info);
+	
+	Engine = new OpenCVEngine(PackageManager);
+	
+	defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
+	     LOGI("OpenCVEngine native service started successfully");
+	ProcessState::self()->startThreadPool();
+    }
+    ~ServiceStarter()
+    {
+	delete PackageManager;
+    }
+private:
+    PackageManagerStub* PackageManager;
+    sp<IBinder> Engine;
+};
+
+static ServiceStarter Starter; 
+
+sp<IOpenCVEngine> InitConnect()
+{
+    sp<IServiceManager> ServiceManager = defaultServiceManager();
+    sp<IBinder> EngineService;
+    sp<IOpenCVEngine> Engine;
+    
+    do
+    {
+	EngineService = ServiceManager->getService(IOpenCVEngine::descriptor);
+	if (EngineService != 0) break;
+	usleep(500000); // 0.5 s
+    } while(true);
+    
+    Engine = interface_cast<IOpenCVEngine>(EngineService);
+    
+    return Engine;
+}
+
+TEST(OpenCVEngineTest, GetVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    int32_t Version = Engine->GetVersion();
+    EXPECT_EQ(OPEN_CV_ENGINE_VERSION, Version);
+}
+
+TEST(OpenCVEngineTest, InstallVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    bool result = Engine->InstallVersion(String16("2.4"));
+    EXPECT_EQ(true, result);
+}
+
+TEST(OpenCVEngineTest, GetPathForExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.3"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7/lib",String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForUnExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.5"));
+    EXPECT_EQ(0, result.size());
+}
+
+TEST(OpenCVEngineTest, InstallAndGetVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    EXPECT_TRUE(Engine->InstallVersion(String16("2.5")));
+    String16 result = Engine->GetLibPathByVersion(String16("2.5"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v25_tegra3/lib", String8(result).string());
+}
@@ -0,0 +1,127 @@
+#include "HardwareDetector.h"
+#include "IPackageManager.h"
+#include "IOpenCVEngine.h"
+#include "PackageInfo.h"
+#include <gtest/gtest.h>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+TEST(PackageInfo, FullNameArmv7)
+{
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv7Neon)
+{
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7", name.c_str());
+    // TODO: Replace if seporate package will be exists    
+    //EXPECT_STREQ("org.opencv.lib_v23_armv7_neon", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv7VFPv3)
+{
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7", name.c_str());
+    // TODO: Replace if seporate package will be exists
+    //EXPECT_STREQ("org.opencv.lib_v23_armv7_vfpv3", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv7VFPv3Neon)
+{
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7", name.c_str());
+    // TODO: Replace if seporate package will be exists
+    //EXPECT_STREQ("org.opencv.lib_v23_armv7_neon", name.c_str());
+}
+
+TEST(PackageInfo, FullNameX86SSE2)
+{
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_x86", name.c_str());
+    // TODO: Replace if seporate package will be exists
+    //EXPECT_STREQ("org.opencv.lib_v23_x86_sse2", name.c_str());
+}
+
+TEST(PackageInfo, Armv7VFPv3NeonFromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_armv7_vfpv3_neon", "/data/data/org.opencv.lib_v23_armv7_vfpv3_neon");
+    EXPECT_EQ("230", info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON, info.GetCpuID());    
+}
+
+TEST(PackageInfo, X86SSE2FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v24_x86_sse2", "/data/data/org.opencv.lib_v24_x86_sse2");
+    EXPECT_EQ(PLATFORM_UNKNOWN, info.GetPlatform());
+    EXPECT_EQ(ARCH_X86 | FEATURES_HAS_SSE2, info.GetCpuID());
+    EXPECT_EQ("240", info.GetVersion());
+}
+
+TEST(PackageInfo, Tegra2FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_tegra2", "/data/data/org.opencv.lib_v23_tegra2");
+    EXPECT_EQ("230", info.GetVersion());
+    EXPECT_EQ(PLATFORM_TEGRA2, info.GetPlatform());
+}
+
+TEST(PackageInfo, Tegra3FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v24_tegra3", "/data/data/org.opencv.lib_v24_tegra3");
+    EXPECT_EQ("240", info.GetVersion());
+    EXPECT_EQ(PLATFORM_TEGRA3, info.GetPlatform());
+}
+
+TEST(PackageInfo, FullNameTegra3)
+{
+    PackageInfo info("230", PLATFORM_TEGRA3, 0);
+    EXPECT_TRUE(!info.IsValid());
+    // TODO: Replace if seporate package will be exists
+    //string name = info.GetFullName();
+    //EXPECT_STREQ("org.opencv.lib_v23_tegra3", name.c_str());
+}
+
+TEST(PackageInfo, FullNameTegra2)
+{
+    PackageInfo info("230", PLATFORM_TEGRA2, 0);
+    EXPECT_TRUE(!info.IsValid());
+    // TODO: Replace if seporate package will be exists
+    //string name = info.GetFullName();
+    //EXPECT_STREQ("org.opencv.lib_v23_tegra2", name.c_str());
+}
+
+TEST(PackageInfo, Comparator1)
+{
+    PackageInfo info1("240", PLATFORM_UNKNOWN, ARCH_X86);
+    PackageInfo info2("org.opencv.lib_v24_x86", "/data/data/org.opencv.lib_v24_x86");
+    EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
+    EXPECT_EQ(info1, info2);
+}
+
+TEST(PackageInfo, Comparator2)
+{
+    PackageInfo info1("240", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON | FEATURES_HAS_VFPv3);
+    PackageInfo info2("org.opencv.lib_v24_armv7", "/data/data/org.opencv.lib_v24_armv7");
+    // TODO: Replace if seporate package will be exists
+    //PackageInfo info2("org.opencv.lib_v24_armv7_vfpv3_neon", "/data/data/org.opencv.lib_v24_armv7_vfpv3_neon");
+    EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
+    EXPECT_EQ(info1, info2);
+}
+
+// TODO: Enable test if seporate package will be exists 
+// TEST(PackageInfo, Comparator3)
+// {
+//     PackageInfo info1("230", PLATFORM_TEGRA2, 0);
+//     PackageInfo info2("org.opencv.lib_v23_tegra2", "/data/data/org.opencv.lib_v23_tegra2");
+//     EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
+//     EXPECT_EQ(info1, info2);
+// }
@@ -0,0 +1,18 @@
+#include "PackageManagerStub.h"
+
+using namespace std;
+
+bool PackageManagerStub::InstallPackage(const PackageInfo& package)
+{
+    InstalledPackages.push_back(PackageInfo(package.GetFullName(), "/data/data/" + package.GetFullName()));
+    return true;
+}
+
+vector<PackageInfo> PackageManagerStub::GetInstalledPackages()
+{
+    return InstalledPackages;
+}
+
+PackageManagerStub::~PackageManagerStub()
+{
+}
@@ -0,0 +1,17 @@
+#ifndef __PACKAGE_MANAGER_STUB_H__
+#define __PACKAGE_MANAGER_STUB_H__
+
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+
+class PackageManagerStub: public CommonPackageManager
+{
+public:
+    std::vector<PackageInfo> InstalledPackages;
+    virtual ~PackageManagerStub();
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();    
+};
+
+#endif
@@ -0,0 +1,100 @@
+#include "HardwareDetector.h"
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+#include "PackageManagerStub.h"
+#include "IOpenCVEngine.h"
+#include <utils/String16.h>
+#include <gtest/gtest.h>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+TEST(PackageManager, InstalledVersions)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7);
+    pm.InstalledPackages.push_back(info);
+    std::set<string> versions = pm.GetInstalledVersions();
+    EXPECT_EQ(1, versions.size());
+    EXPECT_EQ("230", *versions.begin());
+}
+
+TEST(PackageManager, CheckVersionInstalled)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_TEGRA3, 0);
+    pm.InstalledPackages.push_back(info);
+    EXPECT_TRUE(pm.CheckVersionInstalled("230", PLATFORM_TEGRA3, 0));
+}
+
+TEST(PackageManager, InstallVersion)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_TEGRA3, 0);
+    pm.InstalledPackages.push_back(info);
+    EXPECT_TRUE(pm.InstallVersion("240", PLATFORM_TEGRA3, 0));
+    EXPECT_EQ(2, pm.InstalledPackages.size());
+    EXPECT_TRUE(pm.CheckVersionInstalled("240", PLATFORM_TEGRA3, 0));
+}
+
+TEST(PackageManager, GetPackagePathForArmv7)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7);
+    pm.InstalledPackages.push_back(info);
+    string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForArmv7Neon)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    pm.InstalledPackages.push_back(info);
+    
+    string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7/lib", path.c_str());
+    // TODO: Replace if seporate package will be exists
+    //EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7_neon/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForX86)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_X86);
+    pm.InstalledPackages.push_back(info);
+    string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_X86);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForX86SSE2)
+{
+    PackageManagerStub pm;
+    PackageInfo info("230", PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
+    pm.InstalledPackages.push_back(info);
+    string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86/lib", path.c_str());
+    // TODO: Replace if seporate package will be exists
+    //EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86_sse2/lib", path.c_str());
+}
+
+// TODO: Enable tests if seporate package will be exists
+// TEST(PackageManager, GetPackagePathForTegra2)
+// {
+//     PackageManagerStub pm;
+//     PackageInfo info("240", PLATFORM_TEGRA2, 0);
+//     pm.InstalledPackages.push_back(info);
+//     string path = pm.GetPackagePathByVersion("240", PLATFORM_TEGRA2, 0);
+//     EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra2/lib", path.c_str());
+// }
+// 
+// TEST(PackageManager, GetPackagePathForTegra3)
+// {
+//     PackageManagerStub pm;
+//     PackageInfo info("230", PLATFORM_TEGRA3, 0);
+//     pm.InstalledPackages.push_back(info);
+//     string path = pm.GetPackagePathByVersion("230", PLATFORM_TEGRA3, 0);
+//     EXPECT_STREQ("/data/data/org.opencv.lib_v23_tegra3/lib", path.c_str());
+// }
@@ -0,0 +1,8 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+/*    return 0;*/
+        ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
@@ -0,0 +1,43 @@
+#---------------------------------------------------------------------
+#        Native test application
+#---------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    Tests/gtest/gtest-all.cpp \
+    BinderComponent/ProcReader.cpp \
+    BinderComponent/TegraDetector.cpp \
+    BinderComponent/HardwareDetector.cpp \
+    Tests/PackageManagerStub.cpp \
+    NativeService/CommonPackageManager.cpp \
+    NativeService/PackageInfo.cpp \
+    Tests/PackageManagmentTest.cpp \
+    Tests/PackageInfoTest.cpp \
+    Tests/OpenCVEngineTest.cpp \
+     Tests/TestMain.cpp
+#     Tests/HardwareDetectionTest.cpp \
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/Tests \
+    $(LOCAL_PATH)/Tests/gtest \
+    $(LOCAL_PATH)/include \
+    $(LOCAL_PATH)/BinderComponent \
+    $(LOCAL_PATH)/NativeService \
+    $(LOCAL_PATH)/Tests/gtest/include \
+    $(TOP)/frameworks/base/include \
+    $(TOP)/system/core/include
+
+LOCAL_CFLAGS += -O0 -DGTEST_HAS_CLONE=0 -DGTEST_OS_LINUX_ANDROID=1 -DGTEST_HAS_TR1_TUPLE=0
+
+LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
+
+LOCAL_MODULE := OpenCVEngineTestApp
+
+LOCAL_LDLIBS += -lz -lbinder -llog
+
+LOCAL_SHARED_LIBRARIES += libOpenCVEngine
+
+include $(BUILD_EXECUTABLE)
@@ -0,0 +1,12 @@
+#ifndef __ENGINE_COMMON_H__
+#define __ENGINE_COMMON_H__
+
+// Global tag for Logcat output
+#undef LOG_TAG
+#define LOG_TAG "OpenCVEngine" 
+
+#ifndef OPEN_CV_ENGINE_VERSION
+    #define OPEN_CV_ENGINE_VERSION 1
+#endif
+
+#endif
@@ -0,0 +1,34 @@
+#ifndef __IOPENCV_ENGINE_H__
+#define __IOPENCV_ENGINE_H__
+
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+
+// Class name of OpenCV engine binder object. Is needned for connection to service
+#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+
+enum EngineMethonID
+{
+    OCVE_GET_ENGINE_VERSION = 1,
+    OCVE_GET_LIB_PATH_BY_VERSION = 2,
+    OCVE_INSTALL_VERSION = 3,
+    OCVE_GET_LIB_LIST = 4,
+};
+
+using namespace android;
+
+class IOpenCVEngine: public android::IInterface
+{
+public:
+       
+    DECLARE_META_INTERFACE(OpenCVEngine)
+
+public:
+    virtual int GetVersion() = 0;
+    virtual android::String16 GetLibPathByVersion(android::String16 version) = 0;
+    virtual android::String16 GetLibraryList(android::String16 version) = 0;
+    virtual bool InstallVersion(android::String16 version) = 0; 
+};
+
+#endif
@@ -0,0 +1,17 @@
+#ifndef __IPACKAGE_MANAGER__
+#define __IPACKAGE_MANAGER__
+
+#include <set>
+#include <string>
+
+class IPackageManager
+{
+public:
+    virtual std::set<std::string> GetInstalledVersions() = 0;
+    virtual bool CheckVersionInstalled(const std::string& version, int platform, int cpu_id) = 0;
+    virtual bool InstallVersion(const std::string&, int platform, int cpu_id) = 0;
+    virtual std::string GetPackagePathByVersion(const std::string&, int platform, int cpu_id) = 0;
+    virtual ~IPackageManager(){};
+};
+
+#endif
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:focusable="false"
+    android:orientation="vertical" >
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+        <TextView
+            android:id="@+id/InfoName"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Large Text"
+            android:textAppearance="?android:attr/textAppearanceMedium" />
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+        <TextView
+            android:id="@+id/textView1"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Version: "
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+        <TextView
+            android:id="@+id/InfoVersion"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Small Text"
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+        <TextView
+            android:id="@+id/textView2"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Target hardware: "
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+        <TextView
+            android:id="@+id/InfoHardware"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Small Text"
+            android:textAppearance="?android:attr/textAppearanceSmall" />
+
+    </LinearLayout>
+
+</LinearLayout>
@@ -0,0 +1,119 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical" >
+
+    <TextView
+        android:id="@+id/textView4"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="About"
+        android:textAppearance="?android:attr/textAppearanceLarge" />
+
+    <TextView
+        android:id="@+id/textView2"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="OpenCV library (www.opencv.org) is used by other applications for image enhancement, panorama stitching, object detection, recognition and tracking and so on. OpenCV Manager provides the best version of the OpenCV for your hardware."
+        android:textAppearance="?android:attr/textAppearanceMedium" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+        <TextView
+            android:id="@+id/EngineVersionCaption"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Version: "
+            android:textAppearance="?android:attr/textAppearanceMedium" />
+
+        <TextView
+            android:id="@+id/EngineVersionValue"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="version"
+            android:textAppearance="?android:attr/textAppearanceMedium" />
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+    </LinearLayout>
+
+    <TextView
+        android:id="@+id/textView3"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Device information"
+        android:textAppearance="?android:attr/textAppearanceLarge" android:layout_marginTop="20dp"/>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical" >
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content" >
+
+            <TextView
+                android:id="@+id/HardwareCaption"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Hardware: "
+                android:textAppearance="?android:attr/textAppearanceMedium" />
+
+            <TextView
+                android:id="@+id/HardwareValue"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Hardware"
+                android:textAppearance="?android:attr/textAppearanceMedium" />
+
+        </LinearLayout>
+
+    </LinearLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" >
+
+        <TextView
+            android:id="@+id/OsVersionCaption"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="OS version: "
+            android:textAppearance="?android:attr/textAppearanceMedium" />
+
+        <TextView
+            android:id="@+id/OsVersionValue"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Os Specification"
+            android:textAppearance="?android:attr/textAppearanceMedium" />
+
+    </LinearLayout>
+
+    <TextView
+        android:id="@+id/textView1"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Installed packages"
+        android:textAppearance="?android:attr/textAppearanceLarge" android:layout_marginTop="15dp"/>
+
+    <ListView
+        android:id="@+id/InstalledPackageList"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" android:layout_weight="1">
+    </ListView>
+
+    <Button
+        android:id="@+id/CheckEngineUpdate"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="Check for update" />
+
+</LinearLayout>
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Manager</string>
+</resources>
--- a/Mostrar Mais
+++ b/Mostrar Mais
Autor	SHA1	Mensagem	Data
Marina Kolpakova	cdbda45125	merged GPU resize became same as CPU implementation	2012-07-03 16:16:24 +00:00
Alexander Shishkov	13735decf3	updated pdfs to 2.4.2	2012-07-03 15:55:39 +00:00
Alexander Shishkov	7c2270bb3b	updated docs theme	2012-07-03 15:31:13 +00:00
Kirill Kornyakov	f0bff1b64f	minor fixes for the second Android tutorial	2012-07-03 15:10:40 +00:00
Andrey Pavlenko	4ac3eb04c4	updating pictures; removing redundant 'fix prj prop-s' step	2012-07-03 15:07:20 +00:00
Kirill Kornyakov	892a0e28ad	minor fixes for the first Android tutorial	2012-07-03 14:13:05 +00:00
Alexander Smorkalov	01d08208f6	Library name updated.	2012-07-03 13:40:30 +00:00
Alexander Smorkalov	d943c35ef7	Touchscreen requirement turned off.	2012-07-03 13:31:15 +00:00
Alexander Smorkalov	a5c3c1a7de	Package name pattern changed.	2012-07-03 13:18:22 +00:00
Kirill Kornyakov	960a03ca65	renamed google group to the OpenCV4Android instead of android-opencv	2012-07-03 13:16:22 +00:00
Andrey Pavlenko	4b8863c933	install bin.apk	2012-07-03 13:15:41 +00:00
Alexander Smorkalov	73a798e718	About message updated. Version updated.	2012-07-03 13:04:40 +00:00
Alexander Smorkalov	1ba250b69c	Message box text updated.	2012-07-03 13:03:38 +00:00
Alexander Smorkalov	50c49f73f8	Icon for binary package updated.	2012-07-03 12:56:53 +00:00
Andrey Pavlenko	94f05241c5	removing windows-specific path from includes	2012-07-03 12:50:36 +00:00
Andrey Kamaev	efdc055fb1	Fixed Java API tests	2012-07-03 12:44:32 +00:00
Andrey Kamaev	5615ec7c97	Fixed code block in android tutorial	2012-07-03 12:02:58 +00:00
Andrey Kamaev	d386667478	Merged the trunk r8927, r8929	2012-07-03 11:52:54 +00:00
Alexander Smorkalov	a0ce328f98	Internal docs about service were moved to opencv_extra.	2012-07-03 09:19:04 +00:00
Alexander Smorkalov	7294ccba3c	Icon for OpenCV Manager updated.	2012-07-03 09:14:54 +00:00
Andrey Pavlenko	9c60412480	starting 2.4.2 O4A packages will be packed with ZIP instead of TAR.BZ2	2012-07-03 08:38:34 +00:00
Alexander Smorkalov	e5067bff41	Typo fix.	2012-07-03 08:12:27 +00:00
Alexander Smorkalov	65b53f96d0	OpenCV 2.4.0 constant version removed. All docs and samples updated for 2.4.2.	2012-07-03 07:58:48 +00:00
Andrey Kamaev	a78bd92b8e	Documentation: fixed duplicated appendix reference	2012-07-02 21:39:17 +00:00
Andrey Kamaev	c68eb408c0	Merged the trunk r8917:8919	2012-07-02 21:12:45 +00:00
Andrey Kamaev	de153f0154	Fixed several opencv version references	2012-07-02 15:40:18 +00:00
Andrey Kamaev	81a5415417	Merged the trunk r8913	2012-07-02 15:15:40 +00:00
Andrey Kamaev	d2b36d74cd	Merged the trunk r8911	2012-07-02 14:21:51 +00:00
Alexander Smorkalov	139cc61001	Application start without service fixed.	2012-07-02 14:19:14 +00:00
Andrey Kamaev	aa911275c3	Merged the trunk r8907, r8908	2012-07-02 14:12:34 +00:00
Andrey Kamaev	af912f4843	Merged the trunk r8901:8904	2012-07-02 13:46:47 +00:00
Alexander Smorkalov	721c24bc1f	Typo fix. Name of native library was inconsists with java loadLibrary	2012-07-02 13:39:55 +00:00
Andrey Kamaev	a66cd5698a	Merged the trunk 8892,8894,8898	2012-07-02 13:06:28 +00:00
Alexander Shishkov	cf97209f95	update FFMPEG wrapper binaries	2012-07-02 12:57:52 +00:00
Andrey Kamaev	d4df1e0b5c	Merged the trunk r8887, r8891, r8314	2012-07-02 12:33:37 +00:00
Andrey Kamaev	5a7804d958	Version number is adjusted to 2.4.2	2012-07-02 12:10:13 +00:00
Andrey Kamaev	088a6597bc	Merged the trunk 8855,8885,8886	2012-07-02 12:05:06 +00:00
Andrey Kamaev	3a40f27655	Merged facerec from the trunk	2012-07-02 11:48:16 +00:00
Andrey Kamaev	b368f99d03	Merged the trunk r8852:8880	2012-07-02 11:04:43 +00:00
Marina Kolpakova	304dac7f00	fixed #2113	2012-06-30 09:37:40 +00:00
Andrey Kamaev	17fd1c7c61	Merged recent changes from trunk - 8833,8848,8850	2012-06-29 07:52:34 +00:00
Andrey Kamaev	57fb5f0981	Merged Android build fix	2012-06-28 19:32:32 +00:00
Andrey Kamaev	35a31e1c35	Fixed few warnings	2012-06-28 18:11:54 +00:00
Marina Kolpakova	37a63523e7	fixed merge problem	2012-06-28 17:54:08 +00:00
Andrey Kamaev	a71797c0c4	Reverted some changes in videostab module	2012-06-28 17:48:53 +00:00
Andrey Kamaev	5715d9ef42	Removed incorrectly merged test	2012-06-28 17:41:03 +00:00
Marina Kolpakova	ab69f5e091	merged python samles	2012-06-28 17:33:11 +00:00
Marina Kolpakova	54ee92e3b0	merged trunk r8815:8827	2012-06-28 17:28:27 +00:00
Marina Kolpakova	b28b2428f6	changing package layout after 'make install' for Android build	2012-06-28 17:23:50 +00:00
Marina Kolpakova	2dcb091d94	merged Android samples	2012-06-28 17:14:29 +00:00
Marina Kolpakova	162f9fd7ea	merged the trunk r8735:8766, r8769, r8777:8780, r8790 and r8800:8811	2012-06-28 17:07:17 +00:00
Marina Kolpakova	b156e2f7ed	added FREAK (by Kirell Benzi, Raphael Ortiz, Alexandre Alahi and Pierre Vandergheynst)	2012-06-28 16:46:29 +00:00
Marina Kolpakova	3def843652	merged the trunk r8719:8731 and 8807	2012-06-28 16:39:53 +00:00
Marina Kolpakova	01570fa800	merged Android Manager and new java layout	2012-06-28 16:23:19 +00:00
Marina Kolpakova	680a44189c	merged the trunk r8704:8716	2012-06-28 16:13:29 +00:00
Marina Kolpakova	2777ebb8a0	merged GPU scan	2012-06-28 16:00:38 +00:00
Marina Kolpakova	6cca6a4548	merged the trunk r8669:8702	2012-06-28 15:41:27 +00:00
Marina Kolpakova	150aeee58f	merged iOS framework from the trunk	2012-06-28 15:13:57 +00:00
Vladislav Vinogradov	59ce0a9f81	Merged revision(s) 8679 from trunk: new implementation of gpu::PyrLKOpticalFlow::sparse (1.5 - 2x faster) ........	2012-06-27 10:53:35 +00:00
Vladislav Vinogradov	5c19c6cb67	Merged revision(s) 8664 from trunk: new implementation of gpu::PyrLKOpticalFlow::dense (1.5 - 2x faster) ........	2012-06-27 09:58:33 +00:00
Andrey Kamaev	f666bd221f	Merged the trunk r8595:8668 (except iOS and new gpu functionality)	2012-06-15 13:21:26 +00:00
Andrey Kamaev	bd0e0b5800	Merged the trunk r8589:8653 - all changes related to build warnings	2012-06-15 13:04:17 +00:00
Andrey Kamaev	73c152abc4	Merged the trunk r8575:8583 (INTER_AREA interpolation for GPU resize)	2012-06-15 08:52:08 +00:00
Andrey Kamaev	ab20da0f53	Merged the trunk r8547:8574, r8587	2012-06-15 08:36:35 +00:00