adding OpenCV Manager

CMakeLists.txt

@@ -150,6 +150,8 @@ 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    "TBD" OFF IF ANDROID )
+OCV_OPTION(BUILD_ANDROID_PACKAGE    "TBD" OFF IF ANDROID )
 
 # 3rd party libs
 OCV_OPTION(BUILD_ZLIB               "Build zlib from source"         WIN32 OR IOS OR APPLE )
@@ -416,6 +418,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
@@ -520,6 +529,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("    Build service:" BUILD_ANDROID_SERVICE THEN YES ELSE NO)
 endif()
 
 # ========================== GUI ==========================

android/package/CMakeLists.txt

+#tbd
+add_subdirectory(info_lib)

android/package/info_lib/CMakeLists.txt

+#tbd

android/package/info_lib/jni/Android.mk

+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+    src/info.c
+
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/include \
+    $(TOP)/frameworks/base/core/jni
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_MODULE := libopencvinfo
+
+include $(BUILD_SHARED_LIBRARY)

android/package/info_lib/jni/Application.mk

+APP_ABI := armeabi-v7a x86
+APP_PLATFORM := android-8
\ No newline at end of file

android/package/info_lib/jni/include/info.h

+// Function return list of shared libs seporated with ";" symbol
+// in load order
+const char* GetLibraryList();
\ No newline at end of file

android/package/info_lib/jni/include/info_jni.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_opencv_android_OpenCVLoader */
+
+#ifndef _Included_org_opencv_android_OpenCVLoader
+#define _Included_org_opencv_android_OpenCVLoader
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef org_opencv_android_OpenCVLoader_Success
+#define org_opencv_android_OpenCVLoader_Success 0L
+#undef org_opencv_android_OpenCVLoader_NoService
+#define org_opencv_android_OpenCVLoader_NoService 1L
+#undef org_opencv_android_OpenCVLoader_RestartRequired
+#define org_opencv_android_OpenCVLoader_RestartRequired 2L
+#undef org_opencv_android_OpenCVLoader_MarketError
+#define org_opencv_android_OpenCVLoader_MarketError 3L
+#undef org_opencv_android_OpenCVLoader_InitFailed
+#define org_opencv_android_OpenCVLoader_InitFailed 255L
+/*
+ * Class:     org_opencv_android_OpenCVLoader
+ * Method:    GetLibraryList
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

android/package/info_lib/jni/src/info.c

+#include "info.h"
+#include <jni.h>
+
+#ifndef LIB_STRING
+    #define LIB_STRING "libtbb.so;libopencv_java.so"
+#endif
+
+const char* GetLibraryList()
+{
+    return LIB_STRING;
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_android_StaticHelper_getLibraryList(JNIEnv* jenv, jclass clazz)
+{
+    jstring result = (*jenv)->NewStringUTF(jenv, LIB_STRING);
+
+    return result;
+}
\ No newline at end of file

android/refman.rst

+############################
+OpenCV4Android Reference
+############################
+
+.. toctree::
+   :maxdepth: 2
+
+   service/doc/index.rst
\ No newline at end of file

android/scripts/cmake_android_service.sh

+#!/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/ $@ ../..
+

android/service/CMakeLists.txt

+add_subdirectory(engine)
+#add_subdirectory(engine_test)

android/service/ReadMe.txt

+***************
+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
\ No newline at end of file

android/service/doc/AsyncServiceHelper.rst

+*******************************************
+Java Asynchronious OpenCV Helper (internal)
+*******************************************
+
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Implements Android dependent Java classes
+.. Class:: AsyncServiceHelper
+
+Helper class provides implementation of asynchronious OpenCV initialization with Android OpenCV Engine Service.
+
+.. note:: This is imternal class. Does not use it directly. Use OpenCVLoader.initAsync() instead!
+
+int initOpenCV()
+----------------
+
+.. method:: int initOpenCV(String Version, Context AppContext, LoaderCallbackInterface Callback)
+
+    Tries to init OpenCV library using OpenCV Engine Service. Callback method will be called, when initialisation finishes
+
+    :param Version: Version of OpenCV
+    :param AppContext: Application context for service connection
+    :param CallBack: Object that implements LoaderCallbackInterface. See Helper callback interface
+    :rtype: boolean
+    :return: Return true if initialization starts successfully
\ No newline at end of file

android/service/doc/BaseLoaderCallback.rst

+*********************************************
+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
+

android/service/doc/IOpenCVEngine.rst

+***************************************
+Native OpenCV Manager service interface
+***************************************
+
+.. highlight:: cpp
+.. module:: IOpenCVEngine.h
+    :platform: Android
+    :synopsis: Defines OpenCV Manager interface for Android Binder component
+.. Class:: OpenCVEngine
+
+OpenCVEngine class provides Binder interface to OpenCV Manager Service
+
+int getEngineVersion()
+----------------------
+
+.. method:: int GetEngineVersion()
+
+    Gets OpenCV Manager version
+
+    :rtype: int
+    :return: Returns OpenCV Manager version
+
+android::String16 getLibPathByVersion()
+---------------------------------------
+
+.. method:: android::String16 GetLibPathByVersion(android::String16 version)
+
+    Gets path to native OpenCV libraries 
+
+    :param version: OpenCV Library version
+    :rtype: String;
+    :return: Returns path to OpenCV native libs or empty string if OpenCV was not found
+
+android::String16 getLibraryList()
+----------------------------------
+
+.. method:: android::String16 GetLibraryList(android::String16 version)
+
+    Gets list of OpenCV native libraries in loading order
+
+    :param version: OpenCV Library version
+    :rtype: String;
+    :return: Returns OpenCV libraries names separated by semicolon symbol in loading order
+
+boolean installVersion()
+------------------------
+
+.. method:: boolean InstallVersion(android::String16 version)
+
+    Trys to install defined version of OpenCV
+
+    :param version: OpenCV Library version
+    :rtype: String
+    :return: Returns true if installation successful or package has been already installed

android/service/doc/InstallCallbackInterface.rst

+**************************
+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

android/service/doc/Intro.rst

+************
+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
\ No newline at end of file

android/service/doc/JavaHelper.rst

+******************
+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_0
+
+    OpenCV Library version 2.4.0
+
+.. 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)
\ No newline at end of file

android/service/doc/LoaderCallbackInterface.rst

+*************************
+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
\ No newline at end of file

android/service/doc/Makefile

+# 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."

android/service/doc/NativeHelper.rst

+********************
+Native OpenCV Helper
+********************
+
+.. highlight:: cpp
\ No newline at end of file

android/service/doc/OpenCVEngineInterface.rst

+*********************************
+Java OpenCV OpenCVEngineInterface
+*********************************
+
+.. highlight:: java
+.. module:: org.opencv.engine
+    :platform: Android
+    :synopsis: Defines OpenCV Manager interface for Android.
+.. Class:: OpenCVEngineInterface
+
+OpenCVEngineInterface class provides Java interface to OpenCV Manager Service. Is synchronous with native OpenCVEngine class
+
+.. note:: Do not use this class directly. Use OpenCVLoader instead!
+
+int getEngineVersion()
+----------------------
+
+.. method:: int GetEngineVersion()
+
+    Get OpenCV Manager version
+
+    :rtype: int
+    :return: Return OpenCV Manager version
+
+String getLibPathByVersion()
+----------------------------
+
+.. method:: String GetLibPathByVersion(String version)
+
+    Find already installed OpenCV library 
+
+    :param version: OpenCV library version
+    :rtype: String
+    :return: Return path to OpenCV native libs or empty string if OpenCV was not found
+
+String getLibraryList()
+-----------------------
+
+.. method:: String GetLibraryList(String version)
+
+    Get list of OpenCV native libraries in loading order separated by ";" symbol
+
+    :param version: OpenCV library version
+    :rtype: String
+    :return: Return OpenCV libraries names separated by symbol ";" in loading order
+
+boolean installVersion()
+------------------------
+
+.. method:: boolean InstallVersion(String version)
+
+    Try to install defined version of OpenCV from Google Play (Android Market).
+
+    :param version: OpenCV library version
+    :rtype: String
+    :return: Return true if installation was successful or OpenCV package has been already installed
+ 
\ No newline at end of file

android/service/doc/StaticHelper.rst

+************************************
+Java Static OpenCV Helper (internal)
+************************************
+
+.. highlight:: java
+.. module:: org.opencv.android
+    :platform: Android
+    :synopsis: Implements Android dependent Java classes
+.. Class:: StaticHelper
+
+Helper class provides implementation of static OpenCV initialization. All OpenCV libraries must be included to application package.
+
+.. note:: This is internal class. Does not use it directly. Use OpenCVLoader.initDebug() instead!
+
+int initOpenCV()
+----------------
+
+.. method:: int initOpenCV()
+
+    Tries to init OpenCV library using libraries from application package. Method uses libopencv_info.so library for getting 
+    list of libraries in loading order. Method loads libopencv_java.so, if info library is not present.
+
+    :rtype: boolean
+    :return: Return true if initialization was successful
\ No newline at end of file

android/service/doc/UseCases.rst

+*******************************************
+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
\ No newline at end of file

android/service/doc/build_uml.py

+#!/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))
\ No newline at end of file

android/service/doc/index.rst

+***********************
+Android OpenCV Manager
+***********************
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   Intro
+   UseCases
+   JavaHelper
+   BaseLoaderCallback
+   LoaderCallbackInterface
+   InstallCallbackInterface

android/service/engine/.classpath

+<?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>

android/service/engine/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>OpenCVEngineService</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

android/service/engine/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.engine"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk android:minSdkVersion="8" />
+
+    <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>
\ No newline at end of file

android/service/engine/CMakeLists.txt

+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}/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 "${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}")

android/service/engine/jni/Android.mk

+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
\ No newline at end of file

android/service/engine/jni/Application.mk

+APP_ABI := armeabi x86
+APP_PLATFORM := android-8
+APP_STL := stlport_static
+APP_CPPFLAGS := -fno-rtti -fno-exceptions
+#APP_OPTIM := debug
\ No newline at end of file

android/service/engine/jni/BinderComponent/BnOpenCVEngine.cpp

+#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;
+}
\ No newline at end of file

android/service/engine/jni/BinderComponent/BnOpenCVEngine.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/BpOpenCVEngine.cpp

+#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)
\ No newline at end of file

android/service/engine/jni/BinderComponent/BpOpenCVEngine.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/HardwareDetector.cpp

+#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;
+    }*/
+}
\ No newline at end of file

android/service/engine/jni/BinderComponent/HardwareDetector.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/OpenCVEngine.cpp

+#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;
+}

android/service/engine/jni/BinderComponent/OpenCVEngine.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/ProcReader.cpp

+#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;
+}

android/service/engine/jni/BinderComponent/ProcReader.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/StringUtils.cpp

+#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;
+}
\ No newline at end of file

android/service/engine/jni/BinderComponent/StringUtils.h

+#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
\ No newline at end of file

android/service/engine/jni/BinderComponent/TegraDetector.cpp

+#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;
+}
\ No newline at end of file

android/service/engine/jni/BinderComponent/TegraDetector.h

+#ifndef __TEGRA_DETECTOR_H__
+#define __TEGRA_DETECTOR_H__
+
+#define TEGRA_DETECTOR_ERROR -2
+#define TEGRA_NOT_TEGRA -1
+
+int DetectTegra();
+
+#endif
\ No newline at end of file

android/service/engine/jni/JNIWrapper/HardwareDetector_jni.cpp

+#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();
+}
\ No newline at end of file

android/service/engine/jni/JNIWrapper/HardwareDetector_jni.h

+/* 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

android/service/engine/jni/JNIWrapper/JavaBasedPackageManager.cpp

+#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");
+}

android/service/engine/jni/JNIWrapper/JavaBasedPackageManager.h

+#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);
+};
\ No newline at end of file

android/service/engine/jni/JNIWrapper/OpenCVEngine_jni.cpp

+#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;
+}
+

android/service/engine/jni/JNIWrapper/OpenCVEngine_jni.h

+/* 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

android/service/engine/jni/NativeClient/ClientMain.cpp

+#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;
+}
\ No newline at end of file

android/service/engine/jni/NativeService/CommonPackageManager.cpp

+#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()
+{
+}

android/service/engine/jni/NativeService/CommonPackageManager.h

+#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
\ No newline at end of file

android/service/engine/jni/NativeService/NativePackageManager.cpp

+#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()
+{
+}
\ No newline at end of file

android/service/engine/jni/NativeService/NativePackageManager.h

+#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
\ No newline at end of file

android/service/engine/jni/NativeService/PackageInfo.cpp

+#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);
+}
\ No newline at end of file

android/service/engine/jni/NativeService/PackageInfo.h

+#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 "armv7"
+#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
\ No newline at end of file

android/service/engine/jni/NativeService/ServiceMain.cpp

+#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;
+}
\ No newline at end of file

android/service/engine/jni/Tests/HardwareDetectionTest.cpp

+#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());
+}
\ No newline at end of file

android/service/engine/jni/Tests/OpenCVEngineTest.cpp

+#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());
+}
\ No newline at end of file

android/service/engine/jni/Tests/PackageInfoTest.cpp

+#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);
+// }
\ No newline at end of file

android/service/engine/jni/Tests/PackageManagerStub.cpp

+#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()
+{
+}
\ No newline at end of file

android/service/engine/jni/Tests/PackageManagerStub.h

+#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
\ No newline at end of file

android/service/engine/jni/Tests/PackageManagmentTest.cpp

+#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());
+// }

android/service/engine/jni/Tests/TestMain.cpp

+#include <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+/*    return 0;*/
+        ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
\ No newline at end of file

android/service/engine/jni/Tests/Tests.mk

+#---------------------------------------------------------------------
+#        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)
\ No newline at end of file

android/service/engine/jni/include/EngineCommon.h

+#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
\ No newline at end of file

android/service/engine/jni/include/IOpenCVEngine.h

+#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
\ No newline at end of file

android/service/engine/jni/include/IPackageManager.h

+#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
\ No newline at end of file

android/service/engine/res/layout/info.xml

+<?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>
\ No newline at end of file

android/service/engine/res/layout/main.xml

+<?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="This application allows you to manage OpenCV library on your device."
+        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 Manager update" />
+
+</LinearLayout>
\ No newline at end of file

android/service/engine/res/values/strings.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Manager</string>
+</resources>
\ No newline at end of file

android/service/engine/src/org/opencv/engine/BinderConnector.java

+package org.opencv.engine;
+
+import android.os.IBinder;
+
+public class BinderConnector
+{
+	public BinderConnector(MarketConnector Market)
+	{
+		Init(Market);
+	}
+	public native IBinder Connect();
+	public boolean Disconnect()
+	{
+		Final();
+		return true;
+	}
+	
+	static
+	{	 
+		System.loadLibrary("OpenCVEngine");
+		System.loadLibrary("OpenCVEngine_jni");
+	}	
+	
+	private native boolean Init(MarketConnector Market);
+	public native void Final();	
+}

android/service/engine/src/org/opencv/engine/HardwareDetector.java

+package org.opencv.engine;
+
+public class HardwareDetector
+{
+	public static final int ARCH_UNKNOWN = -1;
+	
+	public static final int ARCH_X86      = 0x01000000;
+	public static final int ARCH_X64      = 0x02000000;
+		
+	public static final int ARCH_ARMv5    = 0x04000000;
+	public static final int ARCH_ARMv6    = 0x08000000;
+	public static final int ARCH_ARMv7    = 0x10000000;
+	public static final int ARCH_ARMv8    = 0x20000000;
+		
+	// Platform specific features
+	// ! Check CPU arch before !
+	
+	// ARM specific features
+	public static final int FEATURES_HAS_VFPv3d16 = 0x01;
+	public static final int FEATURES_HAS_VFPv3    = 0x02;
+	public static final int FEATURES_HAS_NEON     = 0x04;
+	public static final int FEATURES_HAS_NEON2    = 0x08;
+	
+	// X86 specific features
+	public static final int FEATURES_HAS_SSE  = 0x01;
+	public static final int FEATURES_HAS_SSE2 = 0x02;
+	public static final int FEATURES_HAS_SSE3 = 0x04;
+	
+	// GPU Acceleration options
+	public static final int FEATURES_HAS_GPU = 0x010000;
+	
+	public static final int PLATFORM_TEGRA  = 1;
+	public static final int PLATFORM_TEGRA2 = 2;
+	public static final int PLATFORM_TEGRA3 = 3;
+	
+	public static final int PLATFORM_UNKNOWN = -1;
+	
+	// Return CPU arch and list of supported features
+	public static native int GetCpuID();
+	// Return hardware platform name
+	public static native String GetPlatformName();
+	// Return processor count
+	public static native int GetProcessorCount();
+	
+	public static native int DetectKnownPlatforms();
+}

android/service/engine/src/org/opencv/engine/MarketConnector.java

+package org.opencv.engine;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+
+public class MarketConnector
+{
+	protected static final String OpenCVPackageNamePreffix = "org.opencv.lib";
+	protected Context mContext;
+	
+	public MarketConnector(Context context)
+	{
+		mContext = context;
+	}
+
+	public String GetApplicationName(ApplicationInfo info)
+	{
+		return (String) info.loadLabel(mContext.getPackageManager());
+	}
+	
+	public boolean InstallAppFromMarket(String AppID)
+	{
+        boolean result = true;
+		try
+        {
+        	Intent intent = new Intent(
+        		Intent.ACTION_VIEW,
+        		Uri.parse("market://details?id=" + AppID)
+        		);
+        	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        	mContext.startActivity(intent);
+        }
+        catch(Exception e)
+        {
+        	result = false;
+        }
+
+		return result;
+	}
+
+	public boolean RemoveAppFromMarket(String AppID, boolean wait)
+	{
+        boolean result = true;
+		try
+        {
+        	Intent intent = new Intent(
+        		Intent.ACTION_DELETE,
+        		Uri.parse("package:" + AppID)
+        		);
+        	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        	if (wait)
+        	{
+        		((Activity)mContext).startActivityForResult(intent, 0);
+        	}
+        	else
+        	{
+        		mContext.startActivity(intent);
+        	}
+        }
+        catch(Exception e)
+        {
+        	e.printStackTrace();
+        	result = false;
+        }
+
+		return result;
+	}
+
+
+	public boolean CheckPackageInstalled(String AppID)
+	{
+		List<PackageInfo> Packages = mContext.getPackageManager().getInstalledPackages(PackageManager.GET_CONFIGURATIONS);
+		Iterator<PackageInfo> it = Packages.iterator();
+		while(it.hasNext())
+		{
+			PackageInfo CurrentPack = it.next();
+			if (CurrentPack.packageName == AppID)
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public PackageInfo[] GetInstalledOpenCVPackages()
+	{
+		List<PackageInfo> AllPackages = mContext.getPackageManager().getInstalledPackages(PackageManager.GET_CONFIGURATIONS);
+		List<PackageInfo> OpenCVPackages = new ArrayList<PackageInfo>();
+		Iterator<PackageInfo> it = AllPackages.iterator();
+		while(it.hasNext())
+		{
+			PackageInfo CurrentPack = it.next();
+			if (CurrentPack.packageName.contains(OpenCVPackageNamePreffix))
+			{
+				OpenCVPackages.add(CurrentPack);
+			}
+		}
+
+		PackageInfo[] OpenCVPackagesArray = new PackageInfo[OpenCVPackages.size()];
+
+		it = OpenCVPackages.iterator();
+		int idx = 0;
+		while(it.hasNext())
+		{
+			OpenCVPackagesArray[idx] = it.next();
+			idx++;
+		}
+
+		return OpenCVPackagesArray;
+	}
+}

android/service/engine/src/org/opencv/engine/OpenCVEngineInterface.aidl

+package org.opencv.engine;
+
+/**
+* Class provides Java interface to OpenCV Engine Service. Is synchronious with native OpenCVEngine class.
+*/
+interface OpenCVEngineInterface
+{
+	/**
+	* @return Return service version
+	*/
+	int getEngineVersion();
+
+	/**
+	* Find installed OpenCV library
+	* @param OpenCV version
+	* @return Returns path to OpenCV native libs or empty string if OpenCV was not found
+	*/
+	String getLibPathByVersion(String version);
+
+	/**
+	* Try to install defined version of OpenCV from Google Play (Android Market).
+	* @param OpenCV version
+	* @return Returns true if installation was successful or OpenCV package has been already installed
+	*/
+	boolean installVersion(String version);
+ 
+	/**
+	* Return list of libraries in loading order seporated by ";" symbol
+	* @param OpenCV version
+	* @return Returns OpenCV libraries names seporated by symbol ";" in loading order
+	*/
+	String getLibraryList(String version);
+}
\ No newline at end of file

android/service/engine/src/org/opencv/engine/OpenCVEngineService.java

+package org.opencv.engine;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+
+
+public class OpenCVEngineService extends Service
+{
+	private static final String TAG = "OpenCVEngine/Service";
+	private IBinder mEngineInterface;
+	private MarketConnector mMarket;
+	private BinderConnector mNativeBinder;
+	public void onCreate()
+	{
+		Log.i(TAG, "Service starting");
+		super.onCreate();
+		Log.i(TAG, "Engine binder component creating");
+		mMarket = new MarketConnector(getBaseContext());
+		mNativeBinder = new BinderConnector(mMarket);
+		mEngineInterface = mNativeBinder.Connect();
+		Log.i(TAG, "Service started successfully");
+	}
+	
+	public IBinder onBind(Intent intent)
+	{
+		Log.i(TAG, "Service onBind called for intent " + intent.toString());		
+		return mEngineInterface;
+	}
+	public boolean onUnbind(Intent intent)
+	{
+		Log.i(TAG, "Service onUnbind called for intent " + intent.toString());		
+		return true;
+	}
+	public void OnDestroy()
+	{
+		Log.i(TAG, "OpenCV Engine service destruction");
+		mNativeBinder.Disconnect();
+	}
+
+}

android/service/engine/src/org/opencv/engine/manager/HardwareDetector.java

+package org.opencv.engine.manager;
+
+public class HardwareDetector
+{
+	public static final int ARCH_UNKNOWN = -1;
+	
+	public static final int ARCH_X86      = 0x01000000;
+	public static final int ARCH_X64      = 0x02000000;
+		
+	public static final int ARCH_ARMv5    = 0x04000000;
+	public static final int ARCH_ARMv6    = 0x08000000;
+	public static final int ARCH_ARMv7    = 0x10000000;
+	public static final int ARCH_ARMv8    = 0x20000000;
+		
+	// Platform specific features
+	// ! Check CPU arch before !
+	
+	// ARM specific features
+	public static final int FEATURES_HAS_VFPv3d16 = 0x01;
+	public static final int FEATURES_HAS_VFPv3    = 0x02;
+	public static final int FEATURES_HAS_NEON     = 0x04;
+	public static final int FEATURES_HAS_NEON2    = 0x08;
+	
+	// X86 specific features
+	public static final int FEATURES_HAS_SSE  = 0x01;
+	public static final int FEATURES_HAS_SSE2 = 0x02;
+	public static final int FEATURES_HAS_SSE3 = 0x04;
+	
+	// GPU Acceleration options
+	public static final int FEATURES_HAS_GPU = 0x010000;
+	
+	public static final int PLATFORM_TEGRA  = 1;
+	public static final int PLATFORM_TEGRA2 = 2;
+	public static final int PLATFORM_TEGRA3 = 3;
+	
+	public static final int PLATFORM_UNKNOWN = 0;
+	
+	// Return CPU arch and list of supported features
+	public static native int GetCpuID();
+	// Return hardware platform name
+	public static native String GetPlatformName();
+	// Return processor count
+	public static native int GetProcessorCount();
+	
+	public static native int DetectKnownPlatforms();
+	
+	static
+	{
+		System.loadLibrary("OpenCVEngine");
+		System.loadLibrary("OpenCVEngine_jni");
+	}
+}

android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java

+package org.opencv.engine.manager;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+
+import org.opencv.engine.MarketConnector;
+import org.opencv.engine.OpenCVEngineInterface;
+import org.opencv.engine.R;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.content.pm.PackageInfo;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.Button;
+import android.widget.ListView;
+import android.widget.SimpleAdapter;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class ManagerActivity extends Activity
+{
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.main);
+        
+        TextView OsVersionView = (TextView)findViewById(R.id.OsVersionValue);
+        OsVersionView.setText(Build.VERSION.CODENAME + " (" + Build.VERSION.RELEASE + "), API " + Build.VERSION.SDK_INT);
+        
+        mInstalledPackageView = (ListView)findViewById(R.id.InstalledPackageList);
+        
+        mMarket = new MarketConnector(this);
+        
+        mInstalledPacksAdapter = new SimpleAdapter(
+        	    this,
+        	    mListViewItems,
+        	    R.layout.info,
+        	    new String[] {"Name", "Version", "Hardware"},
+        	    new int[] {R.id.InfoName,R.id.InfoVersion, R.id.InfoHardware}
+        	    );
+        
+        mInstalledPackageView.setAdapter(mInstalledPacksAdapter);
+        
+        TextView HardwarePlatformView = (TextView)findViewById(R.id.HardwareValue);
+        int Platfrom = HardwareDetector.DetectKnownPlatforms();
+        int CpuId = HardwareDetector.GetCpuID();
+        
+        if (HardwareDetector.PLATFORM_UNKNOWN != Platfrom)
+        {
+        	if (HardwareDetector.PLATFORM_TEGRA == Platfrom)
+        	{
+        		HardwarePlatformView.setText("Tegra");
+        	}
+        	else if (HardwareDetector.PLATFORM_TEGRA == Platfrom)
+        	{
+        		HardwarePlatformView.setText("Tegra 2");
+        	}
+        	else
+        	{
+        		HardwarePlatformView.setText("Tegra 3");
+        	}
+        }
+        else
+        {
+        	if ((CpuId & HardwareDetector.ARCH_X86) == HardwareDetector.ARCH_X86) 
+        	{
+        		HardwarePlatformView.setText("x86 " + JoinIntelFeatures(CpuId));
+        	}
+        	else if ((CpuId & HardwareDetector.ARCH_X64) == HardwareDetector.ARCH_X64)
+        	{
+        		HardwarePlatformView.setText("x64 " + JoinIntelFeatures(CpuId));
+        	}
+        	else if ((CpuId & HardwareDetector.ARCH_ARMv5) == HardwareDetector.ARCH_ARMv5)
+        	{
+        		HardwarePlatformView.setText("ARM v5 " + JoinArmFeatures(CpuId));
+        	}
+        	else if ((CpuId & HardwareDetector.ARCH_ARMv6) == HardwareDetector.ARCH_ARMv6)
+        	{
+        		HardwarePlatformView.setText("ARM v6 " + JoinArmFeatures(CpuId));
+        	}
+        	else if ((CpuId & HardwareDetector.ARCH_ARMv7) == HardwareDetector.ARCH_ARMv7)
+        	{
+        		HardwarePlatformView.setText("ARM v7 " + JoinArmFeatures(CpuId));
+        	}
+        	else if ((CpuId & HardwareDetector.ARCH_ARMv8) == HardwareDetector.ARCH_ARMv8)
+        	{
+        		HardwarePlatformView.setText("ARM v8 " + JoinArmFeatures(CpuId));
+        	}
+        	else
+        	{
+        		HardwarePlatformView.setText("not detected");
+        	}
+        }
+        
+        mUpdateEngineButton = (Button)findViewById(R.id.CheckEngineUpdate);
+        mUpdateEngineButton.setOnClickListener(new OnClickListener() {
+			
+			public void onClick(View v) {
+				if (!mMarket.InstallAppFromMarket("org.opencv.engine"))
+				{
+					Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+					toast.show();
+				}
+			}
+		});
+        
+        mActionDialog = new AlertDialog.Builder(this).create();
+        
+        mActionDialog.setTitle("Choose action");
+        mActionDialog.setButton("Update", new DialogInterface.OnClickListener() {
+			
+			public void onClick(DialogInterface dialog, int which) {
+				int index = (Integer)mInstalledPackageView.getTag();
+				if (!mMarket.InstallAppFromMarket(mInstalledPackageInfo[index].packageName))
+				{
+					Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+					toast.show();
+				}
+			}
+		});
+        
+        mActionDialog.setButton3("Remove", new DialogInterface.OnClickListener() {
+			
+			public void onClick(DialogInterface dialog, int which) {
+				int index = (Integer)mInstalledPackageView.getTag();
+				if (!mMarket.RemoveAppFromMarket(mInstalledPackageInfo[index].packageName, true))
+				{
+					Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+					toast.show();
+				}				
+			}
+		});
+        
+        mActionDialog.setButton2("Return", new DialogInterface.OnClickListener() {
+			
+			public void onClick(DialogInterface dialog, int which) {
+				// nothing
+			}
+		});
+        
+        mInstalledPackageView.setOnItemClickListener(new OnItemClickListener() {
+
+			public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long id) {
+				
+		        mInstalledPackageView.setTag(new Integer((int)id));
+		        mActionDialog.show();
+			}		
+        });
+        
+        if (!bindService(new Intent("org.opencv.engine.BIND"), mServiceConnection, Context.BIND_AUTO_CREATE))
+        {
+        	TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
+        	EngineVersionView.setText("not avaliable");
+        }
+        
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(Intent.ACTION_PACKAGE_ADDED);
+        filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
+        filter.addAction(Intent.ACTION_PACKAGE_INSTALL);
+        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+        filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
+        
+        registerReceiver(mPackageChangeReciever, filter);
+    }
+    
+    @Override
+    protected void onDestroy() {
+    	super.onDestroy();
+    	unregisterReceiver(mPackageChangeReciever);
+    }
+    
+    @Override
+    protected void onResume() {
+    	super.onResume();
+    	FillPackageList();
+    }
+    
+    protected SimpleAdapter mInstalledPacksAdapter;
+    protected ListView mInstalledPackageView;
+    protected Button mUpdateEngineButton;
+    protected PackageInfo[] mInstalledPackageInfo;
+    protected static final ArrayList<HashMap<String,String>> mListViewItems = new ArrayList<HashMap<String,String>>();
+    protected MarketConnector mMarket;
+    AlertDialog mActionDialog;
+    
+    protected BroadcastReceiver mPackageChangeReciever = new BroadcastReceiver() {
+		
+		@Override
+		public void onReceive(Context context, Intent intent) {
+			Log.d("OpenCV Manager/Reciever", "Bradcast message " + intent.getAction() + " reciever");
+			FillPackageList();
+		}
+	};
+    
+    protected ServiceConnection mServiceConnection = new ServiceConnection() {
+		
+		public void onServiceDisconnected(ComponentName name) {
+			// TODO Auto-generated method stub
+			
+		}
+		
+		public void onServiceConnected(ComponentName name, IBinder service) {
+			TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
+			OpenCVEngineInterface EngineService = OpenCVEngineInterface.Stub.asInterface(service);
+			try {
+				EngineVersionView.setText("" + EngineService.getEngineVersion());
+			} catch (RemoteException e) {
+				EngineVersionView.setText("not avaliable");
+				e.printStackTrace();
+			}
+			unbindService(mServiceConnection);
+		}
+	};
+	
+	protected void FillPackageList()
+	{
+        mInstalledPackageInfo = mMarket.GetInstalledOpenCVPackages();
+        mListViewItems.clear();
+        
+        for (int i = 0; i < mInstalledPackageInfo.length; i++)
+        {
+        	// Convert to Items for package list view
+        	HashMap<String,String> temp = new HashMap<String,String>();
+        	temp.put("Name", mMarket.GetApplicationName(mInstalledPackageInfo[i].applicationInfo));
+
+            int idx = 0;
+            String OpenCVersion = "unknown";
+            String HardwareName = "";
+            StringTokenizer tokenizer = new StringTokenizer(mInstalledPackageInfo[i].packageName, "_");
+            while (tokenizer.hasMoreTokens())
+            {
+            	if (idx == 1)
+            	{
+            		// version of OpenCV
+            		OpenCVersion = tokenizer.nextToken().substring(1);
+            	}
+            	else if (idx >= 2)
+            	{
+            		// hardware options
+            		HardwareName += tokenizer.nextToken() + " ";
+            	}
+            	else
+            	{
+            		tokenizer.nextToken();
+            	}
+            	idx++;
+            }
+            
+        	temp.put("Version", NormalizeVersion(OpenCVersion, mInstalledPackageInfo[i].versionName));
+        	temp.put("Hardware", HardwareName);
+        	mListViewItems.add(temp);
+        }
+        
+        mInstalledPacksAdapter.notifyDataSetChanged();
+	}
+    
+	protected String NormalizeVersion(String OpenCVersion, String PackageVersion)
+	{
+		int dot = PackageVersion.indexOf(".");
+		return OpenCVersion.substring(0,  OpenCVersion.length()-1) + "." + 
+			OpenCVersion.toCharArray()[OpenCVersion.length()-1] + "." + 
+			PackageVersion.substring(0, dot) + " rev " + PackageVersion.substring(dot+1);		
+	}
+	
+    protected String ConvertPackageName(String Name, String Version)
+    {
+    	return Name + " rev " + Version;
+    }
+    
+    protected String JoinIntelFeatures(int features)
+    {
+    	// TODO: update if package will be published
+    	return "";
+    }
+    
+    protected String JoinArmFeatures(int features)
+    {
+    	// TODO: update if package will be published
+    	if ((features & HardwareDetector.FEATURES_HAS_NEON) == HardwareDetector.FEATURES_HAS_NEON)
+    	{
+    		return "with Neon";
+    	}
+    	else if ((features & HardwareDetector.FEATURES_HAS_VFPv3) == HardwareDetector.FEATURES_HAS_VFPv3)
+    	{
+    		return "with VFP v3";
+    	}
+    	else if ((features & HardwareDetector.FEATURES_HAS_VFPv3d16) == HardwareDetector.FEATURES_HAS_VFPv3d16)
+    	{
+    		return "with VFP v3d16";
+    	}
+    	else
+    	{
+    		return "";
+    	}
+    }
+}

android/service/engine/src/org/opencv/engine/manager/OpenCVPackageInfo.java

+package org.opencv.engine.manager;
+
+public class OpenCVPackageInfo
+{
+	public OpenCVPackageInfo(String PackageName, String PackageInstallPath, String RevName)
+	{
+		
+	}
+	
+	protected long mNativeObject = 0;
+	
+	protected static native long nativeConstructor(String PackageName, String PackageInstallPath, String RevName);
+	protected static native void nativeDestructor(long nativeAddress);
+	protected static native String nativeGetVersion(long thiz);
+	protected static native String nativeGetPlatfrom(long thiz);
+}

android/service/engine_test/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/JavaService"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

android/service/engine_test/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>tests</name>
+	<comment></comment>
+	<projects>
+		<project>JavaService</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

android/service/engine_test/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.opencv.engine.test"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk android:minSdkVersion="8" />
+
+    <instrumentation
+        android:name="android.test.InstrumentationTestRunner"
+        android:targetPackage="org.opencv.engine" />
+
+    <application
+        android:icon="@drawable/ic_launcher"
+        android:label="@string/app_name" >
+        <uses-library android:name="android.test.runner" />
+        
+    </application>
+
+</manifest>
\ No newline at end of file

android/service/engine_test/res/layout/main.xml

+<?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:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/hello" />
+
+</LinearLayout>
\ No newline at end of file

android/service/engine_test/res/values/strings.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="hello">Hello World!</string>
+    <string name="app_name">JavaServiceTest</string>
+
+</resources>
\ No newline at end of file

android/service/engine_test/src/org/opencv/engine/test/EngineInterfaceTest.java

+package org.opencv.engine.test;
+
+import org.opencv.engine.OpenCVEngineInterface;
+import org.opencv.engine.OpenCVEngineService;
+
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.test.ServiceTestCase;
+
+public class EngineInterfaceTest extends ServiceTestCase<OpenCVEngineService>
+{
+    public EngineInterfaceTest()
+    {
+		super(OpenCVEngineService.class);
+		// TODO Auto-generated constructor stub
+	}
+
+    public void testVersion() throws RemoteException 
+    {
+		IBinder ServiceBinder = bindService(new Intent("org.opencv.engine.BIND"));
+		assertNotNull(ServiceBinder);			
+		OpenCVEngineInterface ServiceObj = OpenCVEngineInterface.Stub.asInterface(ServiceBinder);
+		assertNotNull(ServiceObj);
+		int ServiceVersion = ServiceObj.getEngineVersion();
+		assertEquals(1, ServiceVersion);
+    }
+	
+	public void testInstallVersion() throws RemoteException
+	{
+		IBinder ServiceBinder = bindService(new Intent("org.opencv.engine"));
+		assertNotNull(ServiceBinder);			
+		OpenCVEngineInterface ServiceObj = OpenCVEngineInterface.Stub.asInterface(ServiceBinder);
+		assertNotNull(ServiceObj);		
+		assertTrue(ServiceObj.installVersion("2.4"));		
+	}
+
+	public void testGetPathForExistVersion() throws RemoteException
+	{
+		IBinder ServiceBinder = bindService(new Intent("org.opencv.engine"));
+		assertNotNull(ServiceBinder);			
+		OpenCVEngineInterface ServiceObj = OpenCVEngineInterface.Stub.asInterface(ServiceBinder);
+		assertNotNull(ServiceObj);		
+		assertEquals("/data/data/org.opencv.lib_v240_tegra3/lib", ServiceObj.getLibPathByVersion("2.4"));		
+	}
+
+	public void testGetPathForUnExistVersion() throws RemoteException
+	{
+		IBinder ServiceBinder = bindService(new Intent("org.opencv.engine"));
+		assertNotNull(ServiceBinder);			
+		OpenCVEngineInterface ServiceObj = OpenCVEngineInterface.Stub.asInterface(ServiceBinder);
+		assertNotNull(ServiceObj);
+		assertEquals("", ServiceObj.getLibPathByVersion("2.5"));		
+	}
+
+	public void testInstallAndGetVersion() throws RemoteException
+	{
+		IBinder ServiceBinder = bindService(new Intent("org.opencv.engine"));
+		assertNotNull(ServiceBinder);			
+		OpenCVEngineInterface ServiceObj = OpenCVEngineInterface.Stub.asInterface(ServiceBinder);
+		assertNotNull(ServiceObj);
+		assertTrue(ServiceObj.installVersion("2.4"));		
+		assertEquals("/data/data/org.opencv.lib_v240_tegra3/lib", ServiceObj.getLibPathByVersion("2.4"));		
+	}	
+}

android/service/push_native.py

+#!/usr/bin/python
+
+import os
+
+TARGET_DEVICE_PATH = "/data/data/EngineTest"
+DEVICE_NAME = ""
+DEVICE_STR = ""
+DEVICE_ARCH = "armeabi"
+if (DEVICE_NAME != ""):
+    DEVICE_STR = "-s " + DEVICE_NAME
+
+if (__name__ ==  "__main__"):
+    print("Waiting for device ...")
+    os.system("adb %s wait-for-device" % DEVICE_STR)
+    os.system("adb %s shell mkdir -p %s" % (DEVICE_STR, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/libOpenCVEngine.so %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/OpenCVEngineNativeClient %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/OpenCVEngineNativeService %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/OpenCVEngineTest %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/OpenCVEngineTestApp %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
+    os.system("adb %s push ./engine/libs/%s/libOpenCVEngine_jni.so %s" % (DEVICE_STR, DEVICE_ARCH, TARGET_DEVICE_PATH))
\ No newline at end of file

android/service/test_native.py

+#!/usr/bin/python
+
+import os
+import sys
+
+DEVICE_NAME = ""
+DEVICE_STR = ""
+if (DEVICE_NAME != ""):
+    DEVICE_STR = "-s " + DEVICE_NAME
+
+LOCAL_LOG_PATH = os.path.join(os.getcwd(), "logs")
+DEVICE_LOG_PATH = "/sdcard/OpenCVEngineLogs"
+DEVICE_BIN_PATH = "/data/data/EngineTest"
+
+def RunTestApp(AppName):
+    TestLog = os.path.join(DEVICE_LOG_PATH, AppName + ".xml")
+    os.system("adb %s shell \"LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH;%s --gtest_output=\"xml:%s\"\"" % (DEVICE_STR, DEVICE_BIN_PATH, os.path.join(DEVICE_BIN_PATH, AppName), TestLog))
+    os.system("adb %s pull \"%s\" \"%s\"" % (DEVICE_STR, TestLog, LOCAL_LOG_PATH))
+
+if (__name__ ==  "__main__"):
+    
+    if (not os.path.exists(LOCAL_LOG_PATH)):
+	os.makedirs(LOCAL_LOG_PATH)
+    
+    print("Waiting for device ...")
+    os.system("adb %s wait-for-device" % DEVICE_STR)
+    
+    os.system("adb %s shell rm -r \"%s\"" % (DEVICE_STR, DEVICE_LOG_PATH))
+    os.system("adb %s shell mkdir -p \"%s\"" % (DEVICE_STR, DEVICE_LOG_PATH))
+
+    RunTestApp("OpenCVEngineTestApp")
+

cmake/OpenCVDetectAndroidSDK.cmake

@@ -178,7 +178,7 @@ endmacro()
 #add_android_project(target_name ${path} NATIVE_DEPS opencv_core LIBRARY_DEPS ${OpenCV_BINARY_DIR} SDK_TARGET 11)
 macro(add_android_project target path)
   # parse arguments
-  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET)
+  set(android_proj_arglist NATIVE_DEPS LIBRARY_DEPS SDK_TARGET IGNORE_JAVA)
   set(__varname "android_proj_")
   foreach(v ${android_proj_arglist})
     set(${__varname}${v} "")
@@ -205,7 +205,11 @@ macro(add_android_project target path)
   endif()
 
   # check native dependencies
-  ocv_check_dependencies(${android_proj_NATIVE_DEPS} opencv_java)
+  if(android_proj_IGNORE_JAVA)
+    ocv_check_dependencies(${android_proj_NATIVE_DEPS})
+  else()
+    ocv_check_dependencies(${android_proj_NATIVE_DEPS} opencv_java)
+  endif()
 
   if(OCV_DEPENDENCIES_FOUND AND android_proj_sdk_target AND ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND ANDROID_TOOLS_Pkg_Revision GREATER 13 AND EXISTS "${path}/${ANDROID_MANIFEST_FILE}")
 
@@ -255,7 +259,7 @@ macro(add_android_project target path)
     file(GLOB_RECURSE android_proj_jni_files "${path}/jni/*.c" "${path}/jni/*.h" "${path}/jni/*.cpp" "${path}/jni/*.hpp")
     ocv_list_filterout(android_proj_jni_files ".svn")
 
-    if(android_proj_jni_files AND EXISTS ${path}/jni/Android.mk)
+    if(android_proj_jni_files AND EXISTS ${path}/jni/Android.mk AND NOT DEFINED JNI_LIB_NAME)
       file(STRINGS "${path}/jni/Android.mk" JNI_LIB_NAME REGEX "LOCAL_MODULE[ ]*:=[ ]*.*" )
       string(REGEX REPLACE "LOCAL_MODULE[ ]*:=[ ]*([a-zA-Z_][a-zA-Z_0-9]*)[ ]*" "\\1" JNI_LIB_NAME "${JNI_LIB_NAME}")
 
@@ -279,6 +283,15 @@ macro(add_android_project target path)
     endif()
 
     # build java part
+    if(android_proj_IGNORE_JAVA)
+      add_custom_command(
+         OUTPUT "${android_proj_bin_dir}/bin/${target}-debug.apk"
+         COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug
+         COMMAND ${CMAKE_COMMAND} -E touch "${android_proj_bin_dir}/bin/${target}-debug.apk" # needed because ant does not update the timestamp of updated apk
+         WORKING_DIRECTORY "${android_proj_bin_dir}"
+         MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
+         DEPENDS ${android_proj_file_deps} ${JNI_LIB_NAME})
+    else()
     add_custom_command(
        OUTPUT "${android_proj_bin_dir}/bin/${target}-debug.apk"
        COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug
@@ -287,9 +300,15 @@ macro(add_android_project target path)
        MAIN_DEPENDENCY "${android_proj_bin_dir}/${ANDROID_MANIFEST_FILE}"
        DEPENDS "${OpenCV_BINARY_DIR}/bin/classes.jar" opencv_java # as we are part of OpenCV we can just force this dependency
        DEPENDS ${android_proj_file_deps} ${JNI_LIB_NAME})
+    endif()
 
     add_custom_target(${target} ALL SOURCES "${android_proj_bin_dir}/bin/${target}-debug.apk" )
-    add_dependencies(${target} opencv_java ${android_proj_native_deps})
+    if(NOT android_proj_IGNORE_JAVA)
+      add_dependencies(${target} opencv_java)
+    endif()
+    if(android_proj_native_deps)
+      add_dependencies(${target} ${android_proj_native_deps})
+    endif()
 
     # put the final .apk to the OpenCV's bin folder
     add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy "${android_proj_bin_dir}/bin/${target}-debug.apk" "${OpenCV_BINARY_DIR}/bin/${target}.apk")

doc/tutorials/introduction/android_binary_package/android_binary_package.rst

@@ -317,23 +317,127 @@ Well, running samples from Eclipse is very simple:
      :alt: Tutorial 1 Basic - 1. Add OpenCV - running Canny
      :align: center
 
-
-
 How to use OpenCV library project in your application
 =====================================================
 
-If you already have an Android application, you can add a reference to OpenCV and import all its functionality. 
+Application development with async initialization
+-------------------------------------------------
+
+Using async initialization is a preferred way for application Development. It uses OpenCV Manager service to get OpenCV libraries.
+
+#. Add OpenCV library project to your workspace. Go to :guilabel:`File –> Import –> Existing project in your workspace`, push Browse button and select OpenCV SDK path. 
+
+.. image:: images/eclipse_opencv_dependency0.png
+     :alt: Add dependency from OpenCV library
+     :align: center
 
-#. First of all you need to have both projects (your app and OpenCV) in a single workspace. 
-   So, open workspace with your application and import the OpenCV project into your workspace as stated above. 
+#. In application project add reference to OpenCV Java SDK in :guilabel:`Project –> Properties –> Android –> Library –> Add` select OpenCV-2.4.2;
 
-#. Add a reference to OpenCV project.
+.. image:: images/eclipse_opencv_dependency1.png
+     :alt: Add dependency from OpenCV library
+     :align: center
 
-   Do the right mouse click on your app in Package Explorer, go to :menuselection:`Properties --> Android --> Library --> Add`
-   and choose the OpenCV library project. 
+If you want to use OpenCV Manager-based approach you need to install packages with the Service and OpenCV package for you platform. You can do it using Google Play service or manually with adb tool:
+
+.. code-block:: sh
+    :linenos:
+
+    adb install ./org.opencv.engine.apk
+    adb install ./org.opencv.lib_v24_<hardware version>.apk
+
+There is a very base code snippet for Async init. It shows only basis principles of library Initiation. See 15-puzzle example for details.
+
+.. code-block:: java
+    :linenos:
+    
+    public class MyActivity extends Activity implements HelperCallbackInterface
+    {
+	private BaseLoaderCallback mOpenCVCallBack = new BaseLoaderCallback(this) {
+	@Override
+	public void onManagerConnected(int status) {
+		switch (status) {
+		    case LoaderCallbackInterface.SUCCESS:
+		    {
+			Log.i(TAG, "OpenCV loaded successfully");
+			// Create and set View
+			mView = new puzzle15View(mAppContext);
+			setContentView(mView);
+		    } break;
+		    default:
+		    {
+			super.onManagerConnected(status);
+		    } break;
+		}
+	    }
+	};
+
+	/** Called when the activity is first created. */
+	@Override
+	public void onCreate(Bundle savedInstanceState)
+	{
+	    Log.i(TAG, "onCreate");
+	    super.onCreate(savedInstanceState);
+        
+	    Log.i(TAG, "Trying to load OpenCV library");
+	    if (!OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_0, this, mOpenCVCallBack))
+	    {
+        	Log.e(TAG, "Cannot connect to OpenCV Manager");
+	    }
+	}
+
+	// ...
+    }
+
+It this case application works with OpenCV Manager in asynchronous fashion. OnManagerConnected callback will be called in UI thread, when initialization finishes. 
+Attention, It is not allowed to use CV calls or load OpenCV-dependent native libs before invoking this callback. Load your own native libraries after OpenCV initialization.
+
+Application development with static initialization
+--------------------------------------------------
+
+In this way of using OpenCV all OpenCV binaries a linked and put to your application package. It is designed for experimental and local development purposes only. 
+This way is depricated for production code. If you want to publish your app use approach with async initialization.
+
+#. Add OpenCV library project to your workspace. Go to :guilabel:`File –> Import –> Existing project in your workspace`, push Browse button and select OpenCV SDK path. 
+
+.. image:: images/eclipse_opencv_dependency0.png
+     :alt: Add dependency from OpenCV library
+     :align: center
+
+#. In application project add reference to OpenCV Java SDK in :guilabel:`Project –> Properties –> Android –> Library –> Add` select OpenCV-2.4.2;
+
+.. image:: images/eclipse_opencv_dependency1.png
+     :alt: Add dependency from OpenCV library
+     :align: center
+
+#. Copy native libs to your project directory to folder libs/trget_arch/
+
+After adding depedency from OpenCV library project Android toolchain add all needed libraries to Application package.
+To use OpenCV functionality you need to add OpenCV library initialization before using any OpenCV specific code, for example, in static section of Activity class.
+
+.. code-block:: java
+   :linenos:
+
+    static {
+        if (!OpenCVLoader.initDebug()) {
+            // Report initialization error
+        }
+    }
+
+If you application includes other OpenCV-dependent native libraries you need to init OpenCV before them.
+
+.. code-block:: java
+    :linenos:
+
+    static {
+        if (OpenCVLoader.initDebug()) {
+            System.loadLibrary("my_super_lib1");
+            System.loadLibrary("my_super_lib2");
+        } else {
+            // Report initialization error
+        }
+    }
 
 Whats next?
 ===========
 
 Read the :ref:`Android_Binary_Package_with_NDK` tutorial to learn how add native OpenCV code to your Android project.
-

index.rst

@@ -10,6 +10,7 @@ Welcome to opencv documentation!
    :maxdepth: 2
 
    modules/refman.rst
+   android/refman.rst
    doc/user_guide/user_guide.rst
    doc/tutorials/tutorials.rst
 

modules/java/CMakeLists.txt

@@ -121,7 +121,7 @@ set(JAVA_OUTPUT_DIR "src/org/opencv")
 
 # copy each documented header to the final destination
 set(java_files "")
-foreach(java_file ${documented_java_files})
+foreach(java_file ${documented_java_files} ${handwrittren_aidl_sources})
   get_filename_component(java_file_name "${java_file}" NAME)
   string(REPLACE "-jdoc.java" ".java" java_file_name "${java_file_name}")
   string(REPLACE "+" "/" java_file_name "${java_file_name}")
@@ -249,8 +249,8 @@ if(ANDROID)
         DEPENDS ${lib_proj_files} ${lib_target_files} ${java_files}
         COMMENT "Building OpenCV Android library project"
         )
-      install(FILES "${OpenCV_BINARY_DIR}/bin/classes.jar" "${OpenCV_BINARY_DIR}/bin/jarlist.cache" "${OpenCV_BINARY_DIR}/bin/build.prop" DESTINATION bin COMPONENT main)
-      install(DIRECTORY "${OpenCV_BINARY_DIR}/bin/res" "${OpenCV_BINARY_DIR}/bin/classes" DESTINATION bin COMPONENT main)
+      #install(FILES "${OpenCV_BINARY_DIR}/bin/classes.jar" "${OpenCV_BINARY_DIR}/bin/jarlist.cache" "${OpenCV_BINARY_DIR}/bin/build.prop" DESTINATION bin COMPONENT main)
+      #install(DIRECTORY "${OpenCV_BINARY_DIR}/bin/res" "${OpenCV_BINARY_DIR}/bin/classes" DESTINATION bin COMPONENT main)
       list(APPEND lib_target_files "${OpenCV_BINARY_DIR}/bin/classes.jar")
     endif()
 

modules/java/android_lib/.settings/org.eclipse.jdt.core.prefs

-#Wed Jun 29 04:36:40 MSD 2011
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
-org.eclipse.jdt.core.compiler.compliance=1.5
-org.eclipse.jdt.core.compiler.source=1.5

modules/java/generator/gen_java.py

@@ -717,12 +717,12 @@ $imports
 public class %(jc)s {
 """ % { 'm' : self.module, 'jc' : jname } )
 
-        self.java_code[class_name]["jn_code"].write("""
-    //
-    // native stuff
-    //
-    static { System.loadLibrary("opencv_java"); }
-""" )
+#        self.java_code[class_name]["jn_code"].write("""
+#    //
+#    // native stuff
+#    //
+#    static { System.loadLibrary("opencv_java"); }
+#""" )
 
 
 

modules/java/generator/gen_javadoc.py

@@ -248,7 +248,7 @@ if __name__ == "__main__":
     print "Parsing documentation..."
     parser = rst_parser.RstParser(hdr_parser.CppHeaderParser())
     for m in allmodules:
-        parser.parse(m, os.path.join(selfpath, "../" + m))
+        parser.parse(m, os.path.join(selfpath, "../../" + m))
         
     parser.printSummary()
 

modules/java/generator/rst_parser.py

@@ -719,14 +719,14 @@ if __name__ == "__main__":
             verbose = True
 
     rst_parser_dir  = os.path.dirname(os.path.abspath(sys.argv[0]))
-    hdr_parser_path = os.path.join(rst_parser_dir, "../python/src2")
+    hdr_parser_path = os.path.join(rst_parser_dir, "../../python/src2")
 
     sys.path.append(hdr_parser_path)
     import hdr_parser
 
     module = sys.argv[1]
 
-    if module != "all" and not os.path.isdir(os.path.join(rst_parser_dir, "../" + module)):
+    if module != "all" and not os.path.isdir(os.path.join(rst_parser_dir, "../../" + module)):
         print "RST parser error E%03d: module \"%s\" could not be found." % (ERROR_010_NOMODULE, module)
         exit(1)
 
@@ -734,9 +734,9 @@ if __name__ == "__main__":
 
     if module == "all":
         for m in allmodules:
-            parser.parse(m, os.path.join(rst_parser_dir, "../" + m))
+            parser.parse(m, os.path.join(rst_parser_dir, "../../" + m))
     else:
-        parser.parse(module, os.path.join(rst_parser_dir, "../" + module))
+        parser.parse(module, os.path.join(rst_parser_dir, "../../" + module))
 
     # summary
     parser.printSummary()

modules/java/generator/src/java/android+AsyncServiceHelper.java

+package org.opencv.android;
+
+import java.io.File;
+import java.util.StringTokenizer;
+
+import org.opencv.engine.OpenCVEngineInterface;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.net.Uri;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+
+class AsyncServiceHelper
+{
+    public static boolean initOpenCV(String Version, final Context AppContext,
+            final LoaderCallbackInterface Callback)
+    {
+        AsyncServiceHelper helper = new AsyncServiceHelper(Version, AppContext, Callback);
+        if (AppContext.bindService(new Intent("org.opencv.engine.BIND"),
+                helper.mServiceConnection, Context.BIND_AUTO_CREATE))
+        {
+            return true;
+        }
+        else
+        {
+            AppContext.unbindService(helper.mServiceConnection);
+            InstallService(AppContext, Callback);
+            return false;
+        }
+    }
+
+    protected AsyncServiceHelper(String Version, Context AppContext,
+            LoaderCallbackInterface Callback)
+    {
+        mOpenCVersion = Version;
+        mUserAppCallback = Callback;
+        mAppContext = AppContext;
+    }
+
+    protected static final String TAG = "OpenCVManager/Helper";
+    protected static final int MINIMUM_ENGINE_VERSION = 1;
+    protected OpenCVEngineInterface mEngineService;
+    protected LoaderCallbackInterface mUserAppCallback;
+    protected String mOpenCVersion;
+    protected Context mAppContext;
+    protected int mStatus = LoaderCallbackInterface.SUCCESS;
+
+    private static void InstallService(final Context AppContext, final LoaderCallbackInterface Callback)
+    {
+        InstallCallbackInterface InstallQuery = new InstallCallbackInterface() {
+            private Context mAppContext = AppContext;
+            private LoaderCallbackInterface mUserAppCallback = Callback;
+        	public String getPackageName()
+            {
+                return "OpenCV Manager Service";
+            }
+            public void install() {
+                Log.d(TAG, "Trying to install OpenCV Manager via Google Play");
+
+                boolean result = true;
+                try
+                {
+                    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(OPEN_CV_SERVICE_URL));
+                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                    mAppContext.startActivity(intent);
+                }
+                catch(Exception e)
+                {
+                    result = false;
+                }
+
+                if (result)
+                {
+                    int Status = LoaderCallbackInterface.RESTART_REQUIRED;
+                    Log.d(TAG, "Init finished with status " + Status);
+                    Log.d(TAG, "Calling using callback");
+                    mUserAppCallback.onManagerConnected(Status);
+                }
+                else
+                {
+                    Log.d(TAG, "OpenCV package was not installed!");
+                    int Status = LoaderCallbackInterface.MARKET_ERROR;
+                    Log.d(TAG, "Init finished with status " + Status);
+                    Log.d(TAG, "Unbind from service");
+                    Log.d(TAG, "Calling using callback");
+                    mUserAppCallback.onManagerConnected(Status);
+                }
+            }
+
+            public void cancel()
+            {
+                Log.d(TAG, "OpenCV library installation was canceled");
+                int Status = LoaderCallbackInterface.INSTALL_CANCELED;
+                Log.d(TAG, "Init finished with status " + Status);
+                Log.d(TAG, "Calling using callback");
+                mUserAppCallback.onManagerConnected(Status);
+            }
+        };
+
+        Callback.onPackageInstall(InstallQuery);
+    }
+    
+    /**
+     * URI for OpenCV Manager on Google Play (Android Market)
+     */
+    protected static final String OPEN_CV_SERVICE_URL = "market://details?id=org.opencv.engine";
+
+    protected ServiceConnection mServiceConnection = new ServiceConnection()
+    {
+        public void onServiceConnected(ComponentName className, IBinder service)
+        {
+            Log.d(TAG, "Service connection created");
+            mEngineService = OpenCVEngineInterface.Stub.asInterface(service);
+            if (null == mEngineService)
+            {
+                Log.d(TAG, "OpenCV Manager Service connection fails. May be service was not installed?");
+                InstallService(mAppContext, mUserAppCallback);
+            }
+            else
+            {
+                try
+                {
+                    if (mEngineService.getEngineVersion() < MINIMUM_ENGINE_VERSION)
+                    {
+                        mStatus = LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION;
+                        Log.d(TAG, "Init finished with status " + mStatus);
+                        Log.d(TAG, "Unbind from service");
+                        mAppContext.unbindService(mServiceConnection);
+                        Log.d(TAG, "Calling using callback");
+                        mUserAppCallback.onManagerConnected(mStatus);
+                        return;
+                    }
+
+                    Log.d(TAG, "Trying to get library path");
+                    String path = mEngineService.getLibPathByVersion(mOpenCVersion);
+                    if ((null == path) || (path.length() == 0))
+                    {
+                        InstallCallbackInterface InstallQuery = new InstallCallbackInterface() {
+                            public String getPackageName()
+                            {
+                                return "OpenCV library";
+                            }
+                            public void install() {
+                                Log.d(TAG, "Trying to install OpenCV lib via Google Play");
+                                try
+                                {
+                                    if (mEngineService.installVersion(mOpenCVersion))
+                                    {
+                                        mStatus = LoaderCallbackInterface.RESTART_REQUIRED;
+                                    }
+                                    else
+                                    {
+                                        Log.d(TAG, "OpenCV package was not installed!");
+                                        mStatus = LoaderCallbackInterface.MARKET_ERROR;
+                                    }
+                                } catch (RemoteException e) {
+                                    e.printStackTrace();
+                                    mStatus = LoaderCallbackInterface.INIT_FAILED;
+                                }
+
+                                Log.d(TAG, "Init finished with status " + mStatus);
+                                Log.d(TAG, "Unbind from service");
+                                mAppContext.unbindService(mServiceConnection);
+                                Log.d(TAG, "Calling using callback");
+                                mUserAppCallback.onManagerConnected(mStatus);
+                            }
+                            public void cancel() {
+                                Log.d(TAG, "OpenCV library installation was canceled");
+                                mStatus = LoaderCallbackInterface.INSTALL_CANCELED;
+                                Log.d(TAG, "Init finished with status " + mStatus);
+                                Log.d(TAG, "Unbind from service");
+                                mAppContext.unbindService(mServiceConnection);
+                                Log.d(TAG, "Calling using callback");
+                                mUserAppCallback.onManagerConnected(mStatus);
+                            }
+                        };
+
+                        mUserAppCallback.onPackageInstall(InstallQuery);
+                        return;
+                    }
+                    else
+                    {
+                        Log.d(TAG, "Trying to get library list");
+                        String libs = mEngineService.getLibraryList(mOpenCVersion);
+                        Log.d(TAG, "Library list: \"" + libs + "\"");
+                        Log.d(TAG, "First attempt to load libs");
+                        if (initOpenCVLibs(path, libs))
+                        {
+                            Log.d(TAG, "First attempt to load libs is OK");
+                            mStatus = LoaderCallbackInterface.SUCCESS;
+                        }
+                        else
+                        {
+                            Log.d(TAG, "First attempt to load libs fails");
+                            mStatus = LoaderCallbackInterface.INIT_FAILED;
+                        }
+
+                        Log.d(TAG, "Init finished with status " + mStatus);
+                        Log.d(TAG, "Unbind from service");
+                        mAppContext.unbindService(mServiceConnection);
+                        Log.d(TAG, "Calling using callback");
+                        mUserAppCallback.onManagerConnected(mStatus);
+                    }
+                }
+                catch (RemoteException e)
+                {
+                    e.printStackTrace();
+                    mStatus = LoaderCallbackInterface.INIT_FAILED;
+                    Log.d(TAG, "Init finished with status " + mStatus);
+                    Log.d(TAG, "Unbind from service");
+                    mAppContext.unbindService(mServiceConnection);
+                    Log.d(TAG, "Calling using callback");
+                    mUserAppCallback.onManagerConnected(mStatus);
+                }
+            }
+        }
+        
+        public void onServiceDisconnected(ComponentName className)
+        {
+            mEngineService = null;
+        }
+    };
+    
+    private boolean loadLibrary(String AbsPath)
+    {
+        boolean result = true;
+
+        Log.d(TAG, "Trying to load library " + AbsPath);
+        try
+        {
+            System.load(AbsPath);
+            Log.d(TAG, "OpenCV libs init was ok!");
+        }
+        catch(UnsatisfiedLinkError e)
+        {
+            Log.d(TAG, "Cannot load library \"" + AbsPath + "\"");
+            e.printStackTrace();
+            result &= false;
+        }
+
+        return result;
+    }
+
+    private boolean initOpenCVLibs(String Path, String Libs)
+    {
+        Log.d(TAG, "Trying to init OpenCV libs");
+        if ((null != Path) && (Path.length() != 0))
+        {
+            boolean result = true;
+            if ((null != Libs) && (Libs.length() != 0))
+            {
+                Log.d(TAG, "Trying to load libs by dependency list");
+                StringTokenizer splitter = new StringTokenizer(Libs, ";");
+                while(splitter.hasMoreTokens())
+                {
+                    String AbsLibraryPath = Path + File.separator + splitter.nextToken();
+                    result &= loadLibrary(AbsLibraryPath);
+                }
+            }
+            else
+            {
+                // If dependencies list is not defined or empty
+                String AbsLibraryPath = Path + File.separator + "libopencv_java.so";
+                result &= loadLibrary(AbsLibraryPath);
+            }
+
+            return result;
+        }
+        else
+        {
+            Log.d(TAG, "Library path \"" + Path + "\" is empty");
+            return false;
+        }
+    }
+}

modules/java/generator/src/java/android+BaseLoaderCallback.java

+package org.opencv.android;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.util.Log;
+
+/**
+ * Basic implementation of LoaderCallbackInterface
+ */
+public abstract class BaseLoaderCallback implements LoaderCallbackInterface {
+
+    public BaseLoaderCallback(Activity AppContext) {
+        mAppContext = AppContext;
+    }
+
+    public void onManagerConnected(int status)
+    {
+        switch (status)
+        {
+            /** OpenCV initialization was successful. **/
+            case LoaderCallbackInterface.SUCCESS:
+            {
+                /** Application must override this method to handle successful library initialization **/
+            } break;
+            /** OpenCV Manager or library package installation is in progress. Restart of application is required **/
+            case LoaderCallbackInterface.RESTART_REQUIRED:
+            {
+                Log.d(TAG, "OpenCV downloading. App restart is needed!");
+                AlertDialog RestartMessage = new AlertDialog.Builder(mAppContext).create();
+                RestartMessage.setTitle("App restart is required");
+                RestartMessage.setMessage("Application will be closed now. Start it when installation will be finished!");
+                RestartMessage.setCancelable(false); // This blocks the 'BACK' button
+                RestartMessage.setButton("OK", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        mAppContext.finish();
+                    }
+                });
+
+                RestartMessage.show();
+            } break;
+            /** OpenCV loader cannot start Google Play **/
+            case LoaderCallbackInterface.MARKET_ERROR:
+            {
+                Log.d(TAG, "Google Play service is not installed! You can get it here");
+                AlertDialog MarketErrorMessage = new AlertDialog.Builder(mAppContext).create();
+                MarketErrorMessage.setTitle("OpenCV Manager");
+                MarketErrorMessage.setMessage("Package installation failed!");
+                MarketErrorMessage.setCancelable(false); // This blocks the 'BACK' button
+                MarketErrorMessage.setButton("OK", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        mAppContext.finish();
+                    }
+                });
+                MarketErrorMessage.show();
+            } break;
+            /** Package installation was canceled **/
+            case LoaderCallbackInterface.INSTALL_CANCELED:
+            {
+                Log.d(TAG, "OpenCV library instalation was canceled by user");
+                mAppContext.finish();
+            } break;
+            /** Application is incompatible with this version of OpenCV Manager. Possible Service update is needed **/
+            case LoaderCallbackInterface.INCOMPATIBLE_MANAGER_VERSION:
+            {
+                Log.d(TAG, "OpenCV Manager Service is uncompatible with this app!");
+                AlertDialog IncomatibilityMessage = new AlertDialog.Builder(mAppContext).create();
+                IncomatibilityMessage.setTitle("OpenCV Manager");
+                IncomatibilityMessage.setMessage("OpenCV Manager service is incompatible with this app. Update it!");
+                IncomatibilityMessage.setCancelable(false); // This blocks the 'BACK' button
+                IncomatibilityMessage.setButton("OK", new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        mAppContext.finish();
+                    }
+                });
+                IncomatibilityMessage.show();
+            }
+            /** Other status, i.e. INIT_FAILED **/
+            default:
+            {
+                Log.e(TAG, "OpenCV loading failed!");
+                AlertDialog InitFailedDialog = new AlertDialog.Builder(mAppContext).create();
+                InitFailedDialog.setTitle("OpenCV error");
+                InitFailedDialog.setMessage("OpenCV was not initialised correctly. Application will be shut down");
+                InitFailedDialog.setCancelable(false); // This blocks the 'BACK' button
+                InitFailedDialog.setButton("OK", new OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int which) {
+                        mAppContext.finish();
+                    }
+                });
+
+                InitFailedDialog.show();
+            } break;
+        }
+    }
+
+    public void onPackageInstall(final InstallCallbackInterface callback)
+    {
+        AlertDialog InstallMessage = new AlertDialog.Builder(mAppContext).create();
+        InstallMessage.setTitle("Package not found");
+        InstallMessage.setMessage(callback.getPackageName() + " package was not found! Try to install it?");
+        InstallMessage.setCancelable(false); // This blocks the 'BACK' button
+        InstallMessage.setButton("Yes", new OnClickListener()
+        {
+            public void onClick(DialogInterface dialog, int which)
+            {
+                callback.install();
+            }
+        });
+
+        InstallMessage.setButton2("No", new OnClickListener() {
+
+            public void onClick(DialogInterface dialog, int which)
+            {
+                callback.cancel();
+            }
+        });
+
+        InstallMessage.show();
+    }
+
+    protected Activity mAppContext;
+    private final static String TAG = "OpenCVLoader/BaseLoaderCallback";
+}

modules/java/generator/src/java/android+InstallCallbackInterface.java

+package org.opencv.android;
+
+/**
+ * Installation callback interface
+ */
+public interface InstallCallbackInterface
+{
+    /**
+     * Target package name
+     * @return Return target package name
+     */
+    public String getPackageName();
+    /**
+     * Installation of package is approved
+     */
+    public void install();
+    /**
+     * Installation canceled
+     */
+    public void cancel();
+};

modules/java/generator/src/java/android+LoaderCallbackInterface.java

+package org.opencv.android;
+
+/**
+ * Interface for callback object in case of asynchronous initialization of OpenCV
+ */
+public interface LoaderCallbackInterface
+{
+    /**
+     * OpenCV initialization finished successfully
+     */
+    static final int SUCCESS = 0;
+    /**
+     * OpenCV library installation via Google Play service was initialized. Application restart is required
+     */
+    static final int RESTART_REQUIRED = 1;
+    /**
+     * Google Play (Android Market) cannot be invoked
+     */
+    static final int MARKET_ERROR = 2;
+    /**
+     * OpenCV library installation was canceled by user
+     */
+    static final int INSTALL_CANCELED = 3;
+    /**
+     * Version of OpenCV Manager Service is incompatible with this app. Service update is needed
+     */
+    static final int INCOMPATIBLE_MANAGER_VERSION = 4;
+    /**
+     * OpenCV library initialization failed
+     */
+    static final int INIT_FAILED = 0xff;
+
+    /**
+     * Callback method that is called after OpenCV library initialization
+     * @param status Status of initialization. See Initialization status constants
+     */
+    public void onManagerConnected(int status);
+
+    /**
+     * Callback method that is called in case when package installation is needed
+     * @param callback Answer object with approve and cancel methods and package description
+     */
+    public void onPackageInstall(InstallCallbackInterface callback);
+};

modules/java/generator/src/java/android+OpenCVLoader.java

+package org.opencv.android;
+
+import android.content.Context;
+
+/**
+ * Helper class provides common initialization methods for OpenCV library
+ */
+public class OpenCVLoader
+{
+    /**
+     * OpenCV Library version 2.4.0
+     */
+    public static final String OPEN_CV_VERSION_2_4_0 = "2.4.0";
+
+    /**
+     * OpenCV Library version 2.4.0
+     */
+    public static final String OPEN_CV_VERSION_2_4_2 = "2.4.2";
+
+    /**
+     * Load and initialize OpenCV library from current application package. Roughly it is analog of system.loadLibrary("opencv_java")
+     * @return Return true is initialization of OpenCV was successful
+     */
+    public static boolean initDebug()
+    {
+        return StaticHelper.initOpenCV();
+    }
+
+    /**
+     *  Load and initialize OpenCV library using OpenCV Engine service.
+     * @param Version OpenCV Library version
+     * @param AppContext Application context for connecting to service
+     * @param Callback Object, that implements LoaderCallbackInterface for handling Connection status
+     * @return Return true if initialization of OpenCV starts successfully
+     */
+    public static boolean initAsync(String Version, Context AppContext,
+            LoaderCallbackInterface Callback)
+    {
+        return AsyncServiceHelper.initOpenCV(Version, AppContext, Callback);
+    }
+}

modules/java/generator/src/java/android+StaticHelper.java

+package org.opencv.android;
+
+import java.util.StringTokenizer;
+
+import android.util.Log;
+
+class StaticHelper {
+
+    public static boolean initOpenCV()
+    {
+        boolean result;
+        String libs = "";
+
+        Log.d(TAG, "Trying to get library list");
+
+        try
+        {
+            System.loadLibrary("opencvinfo");
+            libs = getLibraryList();
+        }
+        catch(UnsatisfiedLinkError e)
+        {
+            Log.e(TAG, "OpenCV error: Cannot load info library for OpenCV");
+        }
+
+        Log.d(TAG, "Library list: \"" + libs + "\"");
+        Log.d(TAG, "First attempt to load libs");
+        if (initOpenCVLibs(libs))
+        {
+            Log.d(TAG, "First attempt to load libs is OK");
+            result = true;
+        }
+        else
+        {
+            Log.d(TAG, "First attempt to load libs fails");
+            result = false;
+        }
+
+        return result;
+    }
+
+    private static boolean loadLibrary(String Name)
+    {
+        boolean result = true;
+
+        Log.d(TAG, "Trying to load library " + Name);
+        try
+        {
+            System.loadLibrary(Name);
+            Log.d(TAG, "OpenCV libs init was ok!");
+        }
+        catch(UnsatisfiedLinkError e)
+        {
+            Log.d(TAG, "Cannot load library \"" + Name + "\"");
+            e.printStackTrace();
+            result &= false;
+        }
+
+        return result;
+    }
+
+    private static boolean initOpenCVLibs(String Libs)
+    {
+        Log.d(TAG, "Trying to init OpenCV libs");
+
+        boolean result = true;
+
+        if ((null != Libs) && (Libs.length() != 0))
+        {
+            Log.d(TAG, "Trying to load libs by dependency list");
+            StringTokenizer splitter = new StringTokenizer(Libs, ";");
+            while(splitter.hasMoreTokens())
+            {
+                result &= loadLibrary(splitter.nextToken());
+            }
+        }
+        else
+        {
+            // If dependencies list is not defined or empty
+            result &= loadLibrary("opencv_java");
+        }
+
+        return result;
+    }
+
+    private static final String TAG = "OpenCV/StaticHelper";
+
+    private static native String getLibraryList();
+}

modules/java/generator/src/java/android+Utils.java

@@ -113,11 +113,6 @@ public class Utils {
         nMatToBitmap(m.nativeObj, b);
     }
 
-    // native stuff
-    static {
-        System.loadLibrary("opencv_java");
-    }
-
     private static native void nBitmapToMat(Bitmap b, long m_addr);
 
     private static native void nMatToBitmap(long m_addr, Bitmap b);

modules/java/generator/src/java/android+sync.py

+#!/usr/bin/python
+
+import os
+import shutil
+
+for f in os.listdir("."):
+    shutil.copyfile(f, os.path.join("../../../../../../modules/java/generator/src/java/", "android+" + f));
\ No newline at end of file

modules/java/generator/src/java/core+Mat.java

@@ -1082,13 +1082,6 @@ public class Mat {
         return nativeObj;
     }
 
-    //
-    // native stuff
-    //
-    static {
-        System.loadLibrary("opencv_java");
-    }
-
     // C++: Mat::Mat()
     private static native long n_Mat();
 

modules/java/generator/src/java/engine+OpenCVEngineInterface.aidl

+package org.opencv.engine;
+
+/**
+* Class provides Java interface to OpenCV Engine Service. Is synchronous with native OpenCVEngine class.
+*/
+interface OpenCVEngineInterface
+{
+	/**
+	* @return Return service version
+	*/
+	int getEngineVersion();
+
+	/**
+	* Find installed OpenCV library
+	* @param OpenCV version
+	* @return Return path to OpenCV native libs or empty string if OpenCV was not found
+	*/
+	String getLibPathByVersion(String version);
+
+	/**
+	* Try to install defined version of OpenCV from Google Play (Android Market).
+	* @param OpenCV version
+	* @return Return true if installation was successful or OpenCV package has been already installed
+	*/
+	boolean installVersion(String version);
+ 
+	/**
+	* Return list of libraries in loading order separated by ";" symbol
+	* @param OpenCV version
+	* @return Return OpenCV libraries names separated by symbol ";" in loading order
+	*/
+	String getLibraryList(String version);
+}
\ No newline at end of file

modules/java/generator/src/java/highgui+VideoCapture.java

@@ -194,12 +194,6 @@ public class VideoCapture {
         super.finalize();
     }
 
-    // native stuff
-
-    static {
-        System.loadLibrary("opencv_java");
-    }
-
     // C++: VideoCapture::VideoCapture()
     private static native long n_VideoCapture();
 

modules/java/generator/src/java/utils+Converters.java

@@ -721,10 +721,4 @@ public class Converters {
             llb.add(lb);
         }
     }
-
-
-    static {
-        System.loadLibrary("opencv_java");
-    }
-
 }

samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15Activity.java

 package org.opencv.samples.puzzle15;
 
+import org.opencv.android.BaseLoaderCallback;
+import org.opencv.android.LoaderCallbackInterface;
+import org.opencv.android.OpenCVLoader;
+
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.DialogInterface;
@@ -9,14 +13,48 @@ import android.view.Menu;
 import android.view.MenuItem;
 import android.view.Window;
 
-public class puzzle15Activity extends Activity {
-    private static final String TAG = "Sample::Activity";
+/** Activity class implements LoaderCallbackInterface to handle OpenCV initialization status **/
+public class puzzle15Activity extends Activity
+{
+	private static final String TAG = "Sample::Activity";
 
     private MenuItem            mItemNewGame;
     private MenuItem            mItemToggleNumbers;
-    private puzzle15View        mView;
-
-    public puzzle15Activity() {
+    private puzzle15View        mView = null;
+    private BaseLoaderCallback  mOpenCVCallBack = new BaseLoaderCallback(this) {
+    	@Override
+    	public void onManagerConnected(int status) {
+    		switch (status) {
+				case LoaderCallbackInterface.SUCCESS:
+				{
+					Log.i(TAG, "OpenCV loaded successfully");
+					// Create and set View
+					mView = new puzzle15View(mAppContext);
+					setContentView(mView);
+					// Check native OpenCV camera
+					if( !mView.openCamera() ) {
+						AlertDialog ad = new AlertDialog.Builder(mAppContext).create();
+						ad.setCancelable(false); // This blocks the 'BACK' button
+						ad.setMessage("Fatal error: can't open camera!");
+						ad.setButton("OK", new DialogInterface.OnClickListener() {
+						    public void onClick(DialogInterface dialog, int which) {
+							dialog.dismiss();
+							finish();
+						    }
+						});
+						ad.show();
+					}
+				} break;
+				default:
+				{
+					super.onManagerConnected(status);
+				} break;
+			}
+    	}
+	};
+    
+    public puzzle15Activity()
+    {
         Log.i(TAG, "Instantiated new " + this.getClass());
     }
 
@@ -24,35 +62,43 @@ public class puzzle15Activity extends Activity {
 	protected void onPause() {
         Log.i(TAG, "onPause");
 		super.onPause();
-		mView.releaseCamera();
+		if (null != mView)
+			mView.releaseCamera();
 	}
 
 	@Override
 	protected void onResume() {
         Log.i(TAG, "onResume");
 		super.onResume();
-		if( !mView.openCamera() ) {
-			AlertDialog ad = new AlertDialog.Builder(this).create();  
-			ad.setCancelable(false); // This blocks the 'BACK' button  
-			ad.setMessage("Fatal error: can't open camera!");  
-			ad.setButton("OK", new DialogInterface.OnClickListener() {  
-			    public void onClick(DialogInterface dialog, int which) {  
-			        dialog.dismiss();                      
-					finish();
-			    }  
-			});  
+		if( mView!=null && !mView.openCamera() ) {
+			AlertDialog ad = new AlertDialog.Builder(this).create();
+			ad.setCancelable(false); // This blocks the 'BACK' button
+			ad.setMessage("Fatal error: can't open camera!");
+			ad.setButton("OK", new DialogInterface.OnClickListener() {
+			    public void onClick(DialogInterface dialog, int which) {
+				dialog.dismiss();
+				finish();
+			    }
+			});
 			ad.show();
 		}
 	}
 
     /** Called when the activity is first created. */
     @Override
-    public void onCreate(Bundle savedInstanceState) {
+    public void onCreate(Bundle savedInstanceState)
+    {
         Log.i(TAG, "onCreate");
         super.onCreate(savedInstanceState);
+
         requestWindowFeature(Window.FEATURE_NO_TITLE);
-        mView = new puzzle15View(this);
-        setContentView(mView);
+
+        Log.i(TAG, "Trying to load OpenCV library");
+        if (!OpenCVLoader.initAsync(OpenCVLoader.OPEN_CV_VERSION_2_4_0, this, mOpenCVCallBack))
+        {
+        	Log.e(TAG, "Cannot connect to OpenCV Manager");
+        	finish();
+        }
     }
 
     @Override

samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java

 package org.opencv.samples.imagemanipulations;
 
+import org.opencv.android.OpenCVLoader;
+
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.DialogInterface;
@@ -13,14 +15,14 @@ public class ImageManipulationsActivity extends Activity {
 
 	private static final String TAG = "Sample-ImageManipulations::Activity";
 
-    public static final int     VIEW_MODE_RGBA  = 0;
-    public static final int     VIEW_MODE_HIST  = 1;
-    public static final int     VIEW_MODE_CANNY = 2;
-    public static final int     VIEW_MODE_SEPIA = 3;
-    public static final int     VIEW_MODE_SOBEL = 4;
-    public static final int     VIEW_MODE_ZOOM  = 5;
+    public static final int     VIEW_MODE_RGBA      = 0;
+    public static final int     VIEW_MODE_HIST      = 1;
+    public static final int     VIEW_MODE_CANNY     = 2;
+    public static final int     VIEW_MODE_SEPIA     = 3;
+    public static final int     VIEW_MODE_SOBEL     = 4;
+    public static final int     VIEW_MODE_ZOOM      = 5;
     public static final int     VIEW_MODE_PIXELIZE  = 6;
-    public static final int     VIEW_MODE_POSTERIZE  = 7;
+    public static final int     VIEW_MODE_POSTERIZE = 7;
 
     private MenuItem            mItemPreviewRGBA;
     private MenuItem            mItemPreviewHist;
@@ -70,8 +72,17 @@ public class ImageManipulationsActivity extends Activity {
         Log.i(TAG, "onCreate");
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
-        mView = new ImageManipulationsView(this);
-        setContentView(mView);
+        /** Try to load OpenCV library **/
+        if (OpenCVLoader.initDebug())
+        {
+        	 mView = new ImageManipulationsView(this);
+        	 setContentView(mView);
+        }
+        else
+        {
+			Log.e(TAG, "OpenCV loading failed!");
+			finish();
+        }
     }
 
     @Override