android -> plarforms/android

2026-07-30 15:53:03 +04:00 · 2013-05-17 17:15:20 +04:00
parent 324cafdda6
commit 20fef00a77
134 changed files with 34 additions and 27 deletions
@@ -0,0 +1,86 @@
+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_CFLAGS += -D__SUPPORT_ARMEABI_V7A_FEATURES
+LOCAL_CFLAGS += -D__SUPPORT_TEGRA3
+LOCAL_CFLAGS += -D__SUPPORT_MIPS
+#LOCAL_CFLAGS += -D__SUPPORT_ARMEABI_FEATURES
+
+LOCAL_PRELINK_MODULE := false
+
+LOCAL_MODULE := libOpenCVEngine
+
+LOCAL_LDLIBS += -lz -lbinder -llog -lutils
+
+LOCAL_LDFLAGS += -Wl,-allow-shlib-undefined
+
+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 \
+    JNIWrapper/OpenCVLibraryInfo.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_CFLAGS += -D__SUPPORT_ARMEABI_V7A_FEATURES
+LOCAL_CFLAGS += -D__SUPPORT_TEGRA3
+LOCAL_CFLAGS += -D__SUPPORT_MIPS
+#LOCAL_CFLAGS += -D__SUPPORT_ARMEABI_FEATURES
+
+LOCAL_MODULE := libOpenCVEngine_jni
+
+LOCAL_LDLIBS += -lz -lbinder -llog -lutils -landroid_runtime
+LOCAL_SHARED_LIBRARIES = libOpenCVEngine
+
+include $(BUILD_SHARED_LIBRARY)
+
+#---------------------------------------------------------------------
+#        Native test application
+#---------------------------------------------------------------------
+
+#include $(LOCAL_PATH)/Tests/Tests.mk
@@ -0,0 +1,6 @@
+APP_ABI := armeabi x86 mips
+APP_PLATFORM := android-8
+APP_STL := stlport_static
+APP_CPPFLAGS := -fno-rtti -fno-exceptions
+NDK_TOOLCHAIN_VERSION=4.4.3
+#APP_OPTIM := debug
@@ -0,0 +1,72 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "BnOpenCVEngine.h"
+#include <utils/Log.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+
+using namespace android;
+
+BnOpenCVEngine::~BnOpenCVEngine()
+{
+}
+
+// Notes about data transaction:
+// Java Binder Wrapper call readInt32 before reading return data
+// It treet this in value as exception code
+// OnTransact method support this feature
+status_t BnOpenCVEngine::onTransact(uint32_t code, const Parcel& data, android::Parcel* reply, uint32_t flags)
+{
+    LOGD("OpenCVEngine::OnTransact(%u,%u)", code, flags);
+
+    switch(code)
+    {
+        case OCVE_GET_ENGINE_VERSION:
+        {
+            LOGD("OpenCVEngine OCVE_GET_ENGINE_VERSION request");
+            CHECK_INTERFACE(IOpenCVEngine, data, reply);
+            LOGD("OpenCVEngine::GetVersion()");
+            reply->writeInt32(0);
+            return reply->writeInt32(GetVersion());
+        } break;
+        case OCVE_GET_LIB_PATH_BY_VERSION:
+        {
+            LOGD("OpenCVEngine OCVE_GET_LIB_PATH_BY_VERSION request");
+            CHECK_INTERFACE(IOpenCVEngine, data, reply);
+            const String16 version = data.readString16();
+            LOGD("OpenCVEngine::GetLibPathByVersion(%s)", String8(version).string());
+            String16 path = GetLibPathByVersion(version);
+            reply->writeInt32(0);
+            return reply->writeString16(path);
+        } break;
+        case OCVE_GET_LIB_LIST:
+        {
+            LOGD("OpenCVEngine OCVE_GET_LIB_LIST request");
+            CHECK_INTERFACE(IOpenCVEngine, data, reply);
+            const String16 version = data.readString16();
+            LOGD("OpenCVEngine::GetLibraryList(%s)", String8(version).string());
+            String16 path = GetLibraryList(version);
+            reply->writeInt32(0);
+            return reply->writeString16(path);
+        } break;
+        case OCVE_INSTALL_VERSION:
+        {
+            LOGD("OpenCVEngine OCVE_INSTALL_VERSION request");
+            CHECK_INTERFACE(IOpenCVEngine, data, reply);
+            const String16 version = data.readString16();
+            LOGD("OpenCVEngine::InstallVersion(%s)", String8(version).string());
+            bool result = InstallVersion(version);
+            reply->writeInt32(0);
+            int res = reply->writeInt32(static_cast<int32_t>(result));
+            LOGD("InstallVersion call to Binder finished with res %d", res);
+            return res;
+        } break;
+        default:
+        {
+            LOGD("OpenCVEngine unknown request");
+            return BBinder::onTransact(code, data, reply, flags);
+        }
+    }
+
+    return android::NO_ERROR;
+}
@@ -0,0 +1,21 @@
+#ifndef __BP_OPENCV_ENGINE_H__
+#define __BP_OPENCV_ENGINE_H__
+
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+
+class BnOpenCVEngine: public android::BnInterface<IOpenCVEngine>
+{
+public:
+    android::status_t onTransact(uint32_t code,
+                 const android::Parcel &data,
+                 android::Parcel *reply,
+                 uint32_t flags);
+    virtual ~BnOpenCVEngine();
+
+};
+
+#endif
@@ -0,0 +1,71 @@
+#include "IOpenCVEngine.h"
+#include "BpOpenCVEngine.h"
+
+using namespace android;
+
+BpOpenCVEngine::BpOpenCVEngine(const sp<IBinder>& impl):
+    BpInterface<IOpenCVEngine>(impl)
+{
+}
+
+BpOpenCVEngine::~BpOpenCVEngine()
+{
+}
+
+// Notes about data transaction:
+// Java Binder Wrapper call readInt32 before reading return data
+// It treet this in value as exception code
+// This implementation support this feature
+
+int BpOpenCVEngine::GetVersion()
+{
+    Parcel data, reply;
+
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    remote()->transact(OCVE_GET_ENGINE_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+
+    return reply.readInt32();
+}
+
+String16 BpOpenCVEngine::GetLibPathByVersion(String16 version)
+{
+    Parcel data, reply;
+
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_GET_LIB_PATH_BY_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+
+    return reply.readString16();
+}
+
+android::String16 BpOpenCVEngine::GetLibraryList(String16 version)
+{
+    Parcel data, reply;
+
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_GET_LIB_LIST, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+
+    return reply.readString16();
+}
+
+bool BpOpenCVEngine::InstallVersion(String16 version)
+{
+    Parcel data, reply;
+
+    data.writeInterfaceToken(IOpenCVEngine::descriptor);
+    data.writeString16(version);
+    remote()->transact(OCVE_INSTALL_VERSION, data, &reply, 0);
+    // read exception code
+    reply.readInt32();
+
+    return static_cast<bool>(reply.readInt32());
+}
+
+IMPLEMENT_META_INTERFACE(OpenCVEngine, OPECV_ENGINE_CLASSNAME)
@@ -0,0 +1,20 @@
+#ifndef __BP_OPENCV_ENGINE_H__
+#define __BP_OPENCV_ENGINE_H__
+
+#include "IOpenCVEngine.h"
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+
+class BpOpenCVEngine: public android::BpInterface<IOpenCVEngine>
+{
+public:
+    BpOpenCVEngine(const android::sp<android::IBinder>& impl);
+    virtual ~BpOpenCVEngine();
+    virtual int GetVersion();
+    virtual android::String16 GetLibPathByVersion(android::String16 version);
+    virtual android::String16 GetLibraryList(android::String16 version);
+    virtual bool InstallVersion(android::String16 version);
+};
+
+#endif
@@ -0,0 +1,175 @@
+#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;
+
+    #if defined(__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;
+        }
+    }
+#elif defined(__mips)
+#ifdef __SUPPORT_MIPS
+    result |= ARCH_MIPS;
+#else
+    result = ARCH_UNKNOWN;
+#endif
+#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();
+
+    // All Tegra platforms since Tegra3
+    if (2 < tegra_status)
+    {
+        return PLATFORM_TEGRA + tegra_status - 1;
+    }
+    else
+    {
+        return PLATFORM_UNKNOWN;
+    }
+}
@@ -0,0 +1,37 @@
+#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 ARCH_MIPS 1073741824L
+
+#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
+#define PLATFORM_TEGRA4 4L
+
+int DetectKnownPlatforms();
+int GetProcessorCount();
+std::string GetPlatformName();
+int GetCpuID();
+
+#endif
@@ -0,0 +1,202 @@
+#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();
+const int OpenCVEngine::KnownVersions[] = {2040000, 2040100, 2040200, 2040300, 2040301, 2040302, 2040400, 2040500};
+
+bool OpenCVEngine::ValidateVersion(int version)
+{
+    for (size_t i = 0; i < sizeof(KnownVersions)/sizeof(int); i++)
+        if (KnownVersions[i] == version)
+            return true;
+
+    return false;
+}
+
+int OpenCVEngine::NormalizeVersionString(std::string version)
+{
+    int result = 0;
+
+    if (version.empty())
+    {
+        return result;
+    }
+
+    std::vector<std::string> parts = SplitStringVector(version, '.');
+
+    // Use only 4 digits of the version, i.e. 1.2.3.4.
+    // Other digits will be ignored.
+    if (parts.size() > 4)
+        parts.erase(parts.begin()+4, parts.end());
+
+    int multiplyer = 1000000;
+    for (std::vector<std::string>::const_iterator it = parts.begin(); it != parts.end(); ++it)
+    {
+        int digit = atoi(it->c_str());
+        result += multiplyer*digit;
+        multiplyer /= 100;
+    }
+
+    if (!ValidateVersion(result))
+        result  = 0;
+
+    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());
+    int norm_version;
+    std::string path;
+
+    LOGD("OpenCVEngine::GetLibPathByVersion(%s) impl", String8(version).string());
+
+    norm_version = NormalizeVersionString(std_version);
+
+    if (0 != norm_version)
+    {
+        path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+        if (path.empty())
+        {
+            LOGI("Package OpenCV of version \"%s\" (%d) is not installed. Try to install it :)", String8(version).string(), norm_version);
+        }
+        else
+        {
+            FixPermissions(path);
+        }
+    }
+    else
+    {
+        LOGE("OpenCV version \"%s\" (%d) is not supported", String8(version).string(), norm_version);
+    }
+
+    return String16(path.c_str());
+}
+
+android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
+{
+    std::string std_version = String8(version).string();
+    int norm_version;
+    String16 result;
+    norm_version = NormalizeVersionString(std_version);
+
+    if (0 != norm_version)
+    {
+        std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+        if (!tmp.empty())
+        {
+            tmp += (std::string("/") + LIB_OPENCV_INFO_NAME);
+
+            LOGD("Trying to load info library \"%s\"", tmp.c_str());
+
+            void* handle;
+            InfoFunctionType info_func;
+
+            handle = dlopen(tmp.c_str(), RTLD_LAZY);
+            if (handle)
+            {
+                const char* error;
+
+                dlerror();
+                info_func = (InfoFunctionType)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\" (%d) is not installed. Try to install it :)", std_version.c_str(), norm_version);
+        }
+    }
+    else
+    {
+        LOGE("OpenCV version \"%s\" is not supported", std_version.c_str());
+    }
+
+    return result;
+}
+
+bool OpenCVEngine::InstallVersion(android::String16 version)
+{
+    std::string std_version = String8(version).string();
+    int norm_version;
+    bool result = false;
+
+    LOGD("OpenCVEngine::InstallVersion() begin");
+
+    norm_version = NormalizeVersionString(std_version);
+
+    if (0 != norm_version)
+    {
+        LOGD("PackageManager->InstallVersion call");
+        result = PackageManager->InstallVersion(norm_version, Platform, CpuID);
+    }
+    else
+    {
+        LOGE("OpenCV version \"%s\" (%d) is not supported", std_version.c_str(), norm_version);
+    }
+
+    LOGD("OpenCVEngine::InstallVersion() end");
+
+    return result;
+}
+
+bool OpenCVEngine::FixPermissions(const std::string& path)
+{
+    LOGD("Fixing permissions for folder: \"%s\"", path.c_str());
+    chmod(path.c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+
+    DIR* dir = opendir(path.c_str());
+    if (!dir)
+    {
+        LOGD("Fixing permissions error");
+        return false;
+    }
+
+    dirent* files = readdir(dir);
+    while (files)
+    {
+        LOGD("Fix permissions for \"%s\"", files->d_name);
+        chmod((path + std::string("/") + std::string(files->d_name)).c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+        files = readdir(dir);
+    }
+
+    closedir(dir);
+
+    return true;
+}
@@ -0,0 +1,37 @@
+#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 int KnownVersions[];
+
+    OpenCVEngine();
+    bool ValidateVersion(int version);
+    int NormalizeVersionString(std::string version);
+    bool FixPermissions(const std::string& path);
+
+    static const int Platform;
+    static const int CpuID;
+};
+
+#endif
@@ -0,0 +1,31 @@
+#include "ProcReader.h"
+#include "StringUtils.h"
+#include <fstream>
+
+using namespace std;
+
+map<string, string> GetCpuInfo()
+{
+    map<string, string> result;
+    ifstream f;
+
+    f.open("/proc/cpuinfo");
+    if (f.is_open())
+    {
+        while (!f.eof())
+        {
+            string tmp;
+            string key;
+            string value;
+            getline(f, tmp);
+            if (ParseString(tmp, key, value))
+            {
+                result[key] = value;
+            }
+        }
+    }
+
+    f.close();
+
+    return result;
+}
@@ -0,0 +1,29 @@
+#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 "(v7l)"
+#define CPU_INFO_ARCH_ARMV6_STR "(v6l)"
+#define CPU_INFO_ARCH_ARMV5_STR "(v5l)"
+
+#define CPU_INFO_ARCH_X86_STR "x86"
+
+#define CPU_INFO_ARCH_MIPS_STR "MIPS"
+
+
+// public part
+std::map<std::string, std::string> GetCpuInfo();
+
+#endif
@@ -0,0 +1,92 @@
+#include "StringUtils.h"
+
+using namespace std;
+
+bool StripString(string& src)
+{
+    size_t pos = 0;
+
+    if (src.empty())
+    {
+        return false;
+    }
+
+    while ((pos < src.length()) && (' ' == src[pos])) pos++;
+    src.erase(0, pos);
+
+    pos = 0;
+    while ((pos < src.length()) && ('\t' == src[pos])) pos++;
+    src.erase(0, pos);
+
+    pos = src.length() - 1;
+    while (pos && (' ' == src[pos])) pos--;
+    src.erase(pos+1);
+
+    pos = src.length() - 1;
+    while (pos && ('\t' == src[pos])) pos--;
+    src.erase(pos+1);
+
+    return true;
+}
+
+bool ParseString(const string& src, string& key, string& value)
+{
+    if (src.empty())
+        return false;
+
+    // find seporator ":"
+    size_t seporator_pos = src.find(":");
+    if (string::npos != seporator_pos)
+    {
+        key = src.substr(0, seporator_pos);
+        StripString(key);
+        value = src.substr(seporator_pos+1);
+        StripString(value);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+set<string> SplitString(const string& src, const char seporator)
+{
+    set<string> result;
+
+    if (!src.empty())
+    {
+        size_t seporator_pos;
+        size_t prev_pos = 0;
+        do
+        {
+            seporator_pos = src.find(seporator, prev_pos);
+            result.insert(src.substr(prev_pos, seporator_pos - prev_pos));
+            prev_pos = seporator_pos + 1;
+        }
+        while (string::npos != seporator_pos);
+    }
+
+    return result;
+}
+
+vector<string> SplitStringVector(const string& src, const char seporator)
+{
+    vector<string> result;
+
+    if (!src.empty())
+    {
+        size_t seporator_pos;
+        size_t prev_pos = 0;
+        do
+        {
+            seporator_pos = src.find(seporator, prev_pos);
+            string tmp = src.substr(prev_pos, seporator_pos - prev_pos);
+            result.push_back(tmp);
+            prev_pos = seporator_pos + 1;
+        }
+        while (string::npos != seporator_pos);
+    }
+
+    return result;
+}
@@ -0,0 +1,13 @@
+#ifndef __STRING_UTILS_H__
+#define __STRING_UTILS_H__
+
+#include <string>
+#include <set>
+#include <vector>
+
+bool StripString(std::string& src);
+std::set<std::string> SplitString(const std::string& src, const char seporator);
+bool ParseString(const std::string& src, std::string& key, std::string& value);
+std::vector<std::string> SplitStringVector(const std::string& src, const char seporator);
+
+#endif
@@ -0,0 +1,61 @@
+#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 KERNEL_CONFIG_TEGRA4_MAGIC "CONFIG_ARCH_TEGRA_11x_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;
+        const char *tegra4_config = KERNEL_CONFIG_TEGRA4_MAGIC;
+        int len = strlen(tegra_config);
+        int len2 = strlen(tegra2_config);
+        int len3 = strlen(tegra3_config);
+        int len4 = strlen(tegra4_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;
+            }
+
+            if (0 == strncmp(tmpbuf, tegra4_config, len4))
+            {
+                result = 4;
+                break;
+            }
+        }
+        gzclose(kernelConfig);
+    }
+    else
+    {
+        result = TEGRA_DETECTOR_ERROR;
+    }
+
+    return result;
+}
@@ -0,0 +1,9 @@
+#ifndef __TEGRA_DETECTOR_H__
+#define __TEGRA_DETECTOR_H__
+
+#define TEGRA_DETECTOR_ERROR -2
+#define TEGRA_NOT_TEGRA -1
+
+int DetectTegra();
+
+#endif
@@ -0,0 +1,25 @@
+#include "HardwareDetector_jni.h"
+#include "HardwareDetector.h"
+#include <jni.h>
+#include <string>
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* , jclass)
+{
+    return GetCpuID();
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_HardwareDetector_GetPlatformName(JNIEnv* env, jclass)
+{
+    std::string hardware_name = GetPlatformName();
+    return env->NewStringUTF(hardware_name.c_str());
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* , jclass)
+{
+    return GetProcessorCount();
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* , jclass)
+{
+    return DetectKnownPlatforms();
+}
@@ -0,0 +1,48 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class HardwareDetector */
+
+#ifndef _Included_HardwareDetector
+#define _Included_HardwareDetector
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     org_opencv_engine_HardwareDetector
+ * Method:    GetCpuID
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_HardwareDetector
+ * Method:    GetPlatformName
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_HardwareDetector_GetPlatformName
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_HardwareDetector
+ * Method:    GetProcessorCount
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount
+(JNIEnv *, jclass);
+
+/*
+ * Class:     org_opencv_engine_HardwareDetector
+ * Method:    DetectKnownPlatforms
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms
+(JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,202 @@
+#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!");
+        jenv->DeleteLocalRef(jclazz);
+        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);
+
+    jenv->DeleteLocalRef(jpkgname);
+    jenv->DeleteLocalRef(jclazz);
+
+    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);
+    }
+
+    jclass jclazz = jenv->GetObjectClass(JavaPackageManager);
+    if (!jclazz)
+    {
+        LOGE("MarketConnector class was not found!");
+        return result;
+    }
+
+    jmethodID jmethod = jenv->GetMethodID(jclazz, "GetInstalledOpenCVPackages", "()[Landroid/content/pm/PackageInfo;");
+    if (!jmethod)
+    {
+        LOGE("MarketConnector::GetInstalledOpenCVPackages method was not found!");
+        jenv->DeleteLocalRef(jclazz);
+        return result;
+    }
+
+    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);
+
+        jenv->DeleteLocalRef(jtmp);
+    }
+
+    jenv->DeleteLocalRef(jpkgs);
+    jenv->DeleteLocalRef(jclazz);
+
+    if (self_attached)
+    {
+        JavaContext->DetachCurrentThread();
+    }
+
+    LOGD("JavaBasedPackageManager::GetInstalledPackages() end");
+
+    return result;
+}
+
+static jint GetAndroidVersion(JNIEnv* jenv)
+{
+    jclass jclazz = jenv->FindClass("android/os/Build$VERSION");
+    jfieldID jfield = jenv->GetStaticFieldID(jclazz, "SDK_INT", "I");
+    jint api_level = jenv->GetStaticIntField(jclazz, jfield);
+    jenv->DeleteLocalRef(jclazz);
+
+    return api_level;
+}
+
+// IMPORTANT: This method can be called only if thread is attached to Dalvik
+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);
+    jenv->DeleteLocalRef(jnameobj);
+
+    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);
+    jenv->DeleteLocalRef(jversionobj);
+
+    jenv->DeleteLocalRef(jclazz);
+
+    static const jint api_level = GetAndroidVersion(jenv);
+    string path;
+    if (api_level > 8)
+    {
+        jclazz = jenv->GetObjectClass(package);
+        jfield = jenv->GetFieldID(jclazz, "applicationInfo", "Landroid/content/pm/ApplicationInfo;");
+        jobject japp_info = jenv->GetObjectField(package, jfield);
+        jenv->DeleteLocalRef(jclazz);
+
+        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);
+
+        jenv->DeleteLocalRef(japp_info);
+        jenv->DeleteLocalRef(jpathobj);
+        jenv->DeleteLocalRef(jclazz);
+    }
+    else
+    {
+        path = "/data/data/" + name + "/lib";
+    }
+
+    return PackageInfo(name, path, verison);
+}
+
+JavaBasedPackageManager::~JavaBasedPackageManager()
+{
+    JNIEnv* jenv;
+    bool self_attached;
+
+    LOGD("JavaBasedPackageManager::~JavaBasedPackageManager() begin");
+
+    JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6);
+    self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
+    if (self_attached)
+    {
+        JavaContext->AttachCurrentThread(&jenv, NULL);
+    }
+
+    jenv->DeleteGlobalRef(JavaPackageManager);
+
+    if (self_attached)
+    {
+        JavaContext->DetachCurrentThread();
+    }
+    LOGD("JavaBasedPackageManager::~JavaBasedPackageManager() end");
+}
@@ -0,0 +1,22 @@
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+#include <jni.h>
+#include <vector>
+
+class JavaBasedPackageManager: public CommonPackageManager
+{
+public:
+    JavaBasedPackageManager(JavaVM* JavaMashine, jobject MarketConector);
+    virtual ~JavaBasedPackageManager();
+
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();
+
+private:
+    JavaVM* JavaContext;
+    jobject JavaPackageManager;
+
+    JavaBasedPackageManager();
+    PackageInfo ConvertPackageFromJava(jobject package, JNIEnv* jenv);
+};
@@ -0,0 +1,69 @@
+#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 , jobject market)
+{
+    LOGD("Java_org_opencv_engine_BinderConnector_Init");
+
+    if (NULL == PackageManager)
+    {
+        JavaVM* jvm;
+        env->GetJavaVM(&jvm);
+        PackageManager = new JavaBasedPackageManager(jvm, env->NewGlobalRef(market));
+    }
+    if (PackageManager)
+    {
+        if (!OpenCVEngineBinder.get())
+        {
+            OpenCVEngineBinder = new OpenCVEngine(PackageManager);
+            return (NULL != OpenCVEngineBinder.get());
+        }
+        else
+        {
+            return true;
+        }
+    }
+    else
+    {
+        return false;
+    }
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_BinderConnector_Final(JNIEnv *, jobject)
+{
+    LOGD("Java_org_opencv_engine_BinderConnector_Final");
+
+    OpenCVEngineBinder = NULL;
+
+    delete PackageManager;
+    PackageManager = NULL;
+}
@@ -0,0 +1,37 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class org_opencv_engine_BinderConnector */
+
+#ifndef _Included_org_opencv_engine_BinderConnector
+#define _Included_org_opencv_engine_BinderConnector
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Connect
+ * Signature: ()Landroid/os/IBinder;
+ */
+JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Init
+ * Signature: (Lorg/opencv/engine/MarketConnector;)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     org_opencv_engine_BinderConnector
+ * Method:    Final
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_org_opencv_engine_BinderConnector_Final
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
@@ -0,0 +1,88 @@
+#include "OpenCVLibraryInfo.h"
+#include "EngineCommon.h"
+#include <utils/Log.h>
+#include <dlfcn.h>
+
+JNIEXPORT jlong JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_open
+  (JNIEnv * env, jobject, jstring str)
+{
+    const char* infoLibPath = env->GetStringUTFChars(str, NULL);
+    if (infoLibPath == NULL)
+        return 0;
+
+    LOGD("Trying to load info library \"%s\"", infoLibPath);
+
+    void* handle;
+
+    handle = dlopen(infoLibPath, RTLD_LAZY);
+    if (handle == NULL)
+        LOGI("Info library not found by path \"%s\"", infoLibPath);
+
+    return (jlong)handle;
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getPackageName
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetPackageName");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getLibraryList
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetLibraryList");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getVersionName
+  (JNIEnv* env, jobject, jlong handle)
+{
+    InfoFunctionType info_func;
+    const char* result;
+    const char* error;
+
+    dlerror();
+    info_func = (InfoFunctionType)dlsym((void*)handle, "GetRevision");
+    if ((error = dlerror()) == NULL)
+        result = (*info_func)();
+    else
+    {
+        LOGE("dlsym error: \"%s\"", error);
+        result = "unknown";
+    }
+
+    return env->NewStringUTF(result);
+}
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_close
+  (JNIEnv*, jobject, jlong handle)
+{
+    dlclose((void*)handle);
+}
@@ -0,0 +1,27 @@
+#include <jni.h>
+
+#ifndef _Included_org_opencv_engine_OpenCVLibraryInfo
+#define _Included_org_opencv_engine_OpenCVLibraryInfo
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JNIEXPORT jlong JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_open
+  (JNIEnv *, jobject, jstring);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getPackageName
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getLibraryList
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_getVersionName
+  (JNIEnv *, jobject, jlong);
+
+JNIEXPORT void JNICALL Java_org_opencv_engine_OpenCVLibraryInfo_close
+  (JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
@@ -0,0 +1,42 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <grp.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <utils/Log.h>
+
+#include <stdio.h>
+
+using namespace android;
+
+int main(int argc, char *argv[])
+{
+    LOGI("OpenCVEngine client is now starting");
+
+    sp<IServiceManager> ServiceManager = defaultServiceManager();
+    sp<IBinder> EngineService;
+    sp<IOpenCVEngine> Engine;
+
+    LOGI("Trying to contect to service");
+
+    do {
+        EngineService = ServiceManager->getService(IOpenCVEngine::descriptor);
+        if (EngineService != 0) break;
+        LOGW("OpenCVEngine not published, waiting...");
+        usleep(500000); // 0.5 s
+    } while(true);
+
+    LOGI("Connection established");
+
+    Engine = interface_cast<IOpenCVEngine>(EngineService);
+    int32_t EngineVersion = Engine->GetVersion();
+
+    printf("OpenCVEngine version %d started", EngineVersion);
+
+    return 0;
+}
@@ -0,0 +1,229 @@
+#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;
+
+vector<int> CommonPackageManager::GetInstalledVersions()
+{
+    vector<int> result;
+    vector<PackageInfo> installed_packages = GetInstalledPackages();
+
+    result.resize(installed_packages.size());
+
+    for (size_t i = 0; i < installed_packages.size(); i++)
+    {
+        int version = installed_packages[i].GetVersion();
+        assert(version);
+        result[i] = version;
+    }
+
+    return result;
+}
+
+bool CommonPackageManager::CheckVersionInstalled(int 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())
+    {
+        vector<PackageInfo>::const_iterator it = find(packages.begin(), packages.end(), target_package);
+        result = (it != packages.end());
+    }
+    LOGD("CommonPackageManager::CheckVersionInstalled() end");
+    return result;
+}
+
+bool CommonPackageManager::InstallVersion(int version, int platform, int cpu_id)
+{
+    LOGD("CommonPackageManager::InstallVersion() begin");
+    PackageInfo package(version, platform, cpu_id);
+    return InstallPackage(package);
+}
+
+string CommonPackageManager::GetPackagePathByVersion(int 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)
+    {
+        LOGD("Check version \"%d\" compatibility with \"%d\"\n", version, it->GetVersion());
+        if (IsVersionCompatible(version, it->GetVersion()))
+        {
+            LOGD("Compatible");
+            packages.push_back(*it);
+        }
+        else
+        {
+            LOGD("NOT Compatible");
+        }
+    }
+
+    if (!packages.empty())
+    {
+        int platform_group = 0;
+
+        if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
+            platform_group = 1;
+
+        if (cpu_id & ARCH_MIPS)
+            platform_group = 2;
+
+        int opt_rating = -1;
+        int opt_version = 0;
+
+        const int hardware_rating = GetHardwareRating(platform, cpu_id, ArchRatings[platform_group]);
+        LOGD("Current hardware platform rating %d for (%d,%d)", hardware_rating, platform, cpu_id);
+
+        if (-1 == hardware_rating)
+        {
+            LOGE("Cannot calculate rating for current hardware platform!");
+        }
+        else
+        {
+            vector<PackageInfo>::iterator found = packages.end();
+            for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
+            {
+                int package_group = 0;
+
+                if ((it->GetCpuID() & ARCH_X86) || (it->GetCpuID() & ARCH_X64))
+                    package_group = 1;
+
+                if (it->GetCpuID() & ARCH_MIPS)
+                    package_group = 2;
+
+                if (package_group != platform_group)
+                    continue;
+
+                const int package_rating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), ArchRatings[package_group]);
+
+                LOGD("Package \"%s\" rating %d for (%d,%d)", it->GetFullName().c_str(), package_rating, it->GetPlatform(), it->GetCpuID());
+                if ((package_rating >= 0) && (package_rating <= hardware_rating))
+                {
+                    if (((it->GetVersion() >= opt_version) && (package_rating >= opt_rating)) || (it->GetVersion() > opt_version))
+                    {
+                        opt_rating = package_rating;
+                        opt_version = it->GetVersion();
+                        found = it;
+                    }
+                }
+            }
+
+            if ((-1 != opt_rating) && (packages.end() != found))
+            {
+                result = found->GetInstalationPath();
+            }
+            else
+            {
+                LOGI("No compatible packages found!");
+            }
+        }
+    }
+
+    return result;
+}
+
+bool CommonPackageManager::IsVersionCompatible(int target_version, int package_version)
+{
+    assert(target_version);
+    assert(package_version);
+
+    // major version is the same and minor package version is above or the same as target.
+    return ( (package_version/10000 == target_version/10000) && (package_version%10000 >= target_version%10000) );
+}
+
+int CommonPackageManager::GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group)
+{
+    int result = -1;
+
+    if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64) || (cpu_id & ARCH_MIPS))
+        // Note: No raiting for x86, x64 and MIPS
+        // only one package is used
+        result = 0;
+    else
+    {
+        // Calculate rating for Arm
+        LOGD("!!! Calculating rating for ARM\n");
+        for (size_t i = 0; i < group.size(); i++)
+        {
+            LOGD("Checking (%d, %d) against (%d,%d)\n", group[i].first, group[i].second, platform, cpu_id);
+            if (group[i] == std::pair<int, int>(platform, cpu_id))
+            {
+                LOGD("Rating found: %d\n", i);
+                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_ARMv6 | FEATURES_HAS_VFPv3 | FEATURES_HAS_VFPv3d16));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA2,  ARCH_ARMv7 | FEATURES_HAS_VFPv3d16));
+    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_VFPv3d16 | FEATURES_HAS_VFPv3));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON));
+    result.push_back(std::pair<int, int>(PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3d16 | FEATURES_HAS_NEON));
+    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_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_VFPv3d16 | FEATURES_HAS_NEON));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA3,  ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    result.push_back(std::pair<int, int>(PLATFORM_TEGRA4,  ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+
+    return result;
+}
+
+// Stub for Intel platforms rating initialization. Common package for all Intel based devices is used now
+std::vector<std::pair<int, int> > CommonPackageManager::InitIntelRating()
+{
+    std::vector<std::pair<int, int> > result;
+
+    return result;
+}
+
+// Stub for MIPS platforms rating initialization. Common package for all MIPS based devices is used now
+std::vector<std::pair<int, int> > CommonPackageManager::InitMipsRating()
+{
+    std::vector<std::pair<int, int> > result;
+
+    return result;
+}
+
+const std::vector<std::pair<int, int> > CommonPackageManager::ArchRatings[] = {
+                                           CommonPackageManager::InitArmRating(),
+                                           CommonPackageManager::InitIntelRating(),
+                                           CommonPackageManager::InitMipsRating()
+                                        };
+
+CommonPackageManager::~CommonPackageManager()
+{
+}
@@ -0,0 +1,33 @@
+#ifndef __COMMON_PACKAGE_MANAGER_H__
+#define __COMMON_PACKAGE_MANAGER_H__
+
+#include "IPackageManager.h"
+#include "PackageInfo.h"
+#include <vector>
+#include <string>
+
+class CommonPackageManager: public IPackageManager
+{
+public:
+    std::vector<int> GetInstalledVersions();
+    bool CheckVersionInstalled(int version, int platform, int cpu_id);
+    bool InstallVersion(int version, int platform, int cpu_id);
+    std::string GetPackagePathByVersion(int version, int platform, int cpu_id);
+    virtual ~CommonPackageManager();
+
+protected:
+    static const std::vector<std::pair<int, int> > ArchRatings[];
+
+    static std::vector<std::pair<int, int> > InitArmRating();
+    static std::vector<std::pair<int, int> > InitIntelRating();
+    static std::vector<std::pair<int, int> > InitMipsRating();
+
+    bool IsVersionCompatible(int target_version, int package_version);
+    int GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group);
+
+    virtual bool InstallPackage(const PackageInfo& package) = 0;
+    virtual std::vector<PackageInfo> GetInstalledPackages() = 0;
+};
+
+
+#endif
@@ -0,0 +1,19 @@
+#include "NativePackageManager.h"
+
+using namespace std;
+
+bool NativePackageManager::InstallPackage(const PackageInfo& package)
+{
+    return false;
+}
+
+vector<PackageInfo> NativePackageManager::GetInstalledPackages()
+{
+    vector<PackageInfo> result;
+
+    return result;
+}
+
+NativePackageManager::~NativePackageManager()
+{
+}
@@ -0,0 +1,16 @@
+#ifndef __NATIVE_PACKAGE_MANAGER_STUB_H__
+#define __NATIVE_PACKAGE_MANAGER_STUB_H__
+
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+
+class NativePackageManager: public CommonPackageManager
+{
+public:
+    virtual ~NativePackageManager();
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();
+};
+
+#endif
@@ -0,0 +1,528 @@
+#include "EngineCommon.h"
+#include "PackageInfo.h"
+#include "HardwareDetector.h"
+#include "IOpenCVEngine.h"
+#include "StringUtils.h"
+#include <assert.h>
+#include <vector>
+#include <utils/Log.h>
+#include <dlfcn.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;
+    result[PLATFORM_TEGRA4] = PLATFORM_TEGRA4_NAME;
+
+    return result;
+}
+
+const map<int, string> PackageInfo::PlatformNameMap = InitPlatformNameMap();
+const string PackageInfo::BasePackageName = "org.opencv.lib";
+const string  DEFAULT_ENGINE_INSTALL_PATH = "/data/data/org.opencv.engine";
+
+inline string JoinARMFeatures(int cpu_id)
+{
+    string result;
+
+    if (FEATURES_HAS_NEON2 & cpu_id)
+    {
+        if (!((ARCH_ARMv5 & cpu_id) || (ARCH_ARMv6 & cpu_id) ||(ARCH_ARMv7 & cpu_id)))
+            result = string(FEATURES_HAS_NEON2_NAME);
+    }
+    else if (FEATURES_HAS_NEON & cpu_id)
+    {
+        if (!((ARCH_ARMv5 & cpu_id) || (ARCH_ARMv6 & cpu_id)))
+            result = string(FEATURES_HAS_NEON_NAME);
+    }
+    else if (FEATURES_HAS_VFPv3 & cpu_id)
+    {
+        if ((ARCH_ARMv5 & cpu_id) || (ARCH_ARMv6 & cpu_id))
+            result = string(FEATURES_HAS_VFPv3_NAME);
+    }
+    else if (FEATURES_HAS_VFPv3d16 & cpu_id)
+    {
+        if ((ARCH_ARMv5 & cpu_id) || (ARCH_ARMv6 & 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 int SplitVersion(const vector<string>& features, const string& package_version)
+{
+    int result = 0;
+
+    if ((features.size() > 1) && ('v' == features[1][0]))
+    {
+        // Taking major and minor mart of library version from package name
+        string tmp1 = features[1].substr(1);
+        result += atoi(tmp1.substr(0,1).c_str())*1000000 + atoi(tmp1.substr(1,1).c_str())*10000;
+
+        // Taking release and build number from package revision
+        vector<string> tmp2 = SplitStringVector(package_version, '.');
+        if (tmp2.size() == 2)
+        {
+            // the 2nd digit is revision
+            result += atoi(tmp2[0].c_str())*100 + 00;
+        }
+        else
+        {
+            // the 2nd digit is part of library version
+            // the 3rd digit is revision
+            result += atoi(tmp2[0].c_str())*100 + atoi(tmp2[1].c_str());
+        }
+    }
+    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 if (PLATFORM_TEGRA4_NAME == tmp)
+        {
+            result = PLATFORM_TEGRA4;
+        }
+    }
+    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>_<floating point and vectorization features>_<other features>
+ * Example: armv7_neon
+ */
+PackageInfo::PackageInfo(int version, int platform, int cpu_id, std::string install_path):
+    Version(version),
+    Platform(platform),
+    CpuID(cpu_id),
+    InstallPath("")
+{
+    #ifndef __SUPPORT_TEGRA3
+    Platform = PLATFORM_UNKNOWN;
+    #endif
+
+    int major_version = version/1000000;
+    int minor_version = version/10000 - major_version*100;
+
+    char tmp[32];
+
+    sprintf(tmp, "%d%d", major_version, minor_version);
+
+    FullName = BasePackageName + std::string("_v") + std::string(tmp);
+    if (PLATFORM_UNKNOWN != Platform)
+    {
+        FullName += string("_") + JoinPlatform(platform);
+    }
+    else
+    {
+        if (ARCH_UNKNOWN != CpuID)
+        {
+            if (ARCH_X86 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch x86");
+                FullName += string("_") + ARCH_X86_NAME;
+                #ifdef __SUPPORT_INTEL_FEATURES
+                string features = JoinIntelFeatures(CpuID);
+                if (!features.empty())
+                {
+                    FullName += string("_") + features;
+                }
+                #endif
+            }
+            else if (ARCH_X64 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch x64");
+                #ifdef __SUPPORT_INTEL_x64
+                FullName += string("_") + ARCH_X64_NAME;
+                #else
+                FullName += string("_") + ARCH_X86_NAME;
+                #endif
+                #ifdef __SUPPORT_INTEL_FEATURES
+                string features = JoinIntelFeatures(CpuID);
+                if (!features.empty())
+                {
+                    FullName += string("_") + features;
+                }
+                #endif
+            }
+            else if (ARCH_ARMv5 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch ARMv5");
+                FullName += string("_") + ARCH_ARMv5_NAME;
+                #ifdef __SUPPORT_ARMEABI_FEATURES
+                string features = JoinARMFeatures(CpuID);
+                if (!features.empty())
+                {
+                    FullName += string("_") + features;
+                }
+                #endif
+            }
+            else if (ARCH_ARMv6 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch ARMv6");
+                // NOTE: ARM v5 used instead ARM v6
+                //FullName += string("_") + ARCH_ARMv6_NAME;
+                FullName += string("_") + ARCH_ARMv5_NAME;
+                #ifdef __SUPPORT_ARMEABI_FEATURES
+                string features = JoinARMFeatures(CpuID);
+                if (!features.empty())
+                {
+                    FullName += string("_") + features;
+                }
+                #endif
+            }
+            else if (ARCH_ARMv7 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch ARMv7");
+                FullName += string("_") + ARCH_ARMv7_NAME;
+                #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+                string features = JoinARMFeatures(CpuID);
+                if (!features.empty())
+                {
+                    FullName += string("_") + features;
+                }
+                #endif
+            }
+            else if (ARCH_ARMv8 & CpuID)
+            {
+                LOGD("PackageInfo::PackageInfo: package arch ARMv8");
+                #ifdef __SUPPORT_ARMEABI_V8
+                FullName += string("_") + ARCH_ARMv8_NAME;
+                #else
+                FullName += string("_") + ARCH_ARMv7_NAME;
+                #endif
+                //string features = JoinARMFeatures(CpuID);
+                //if (!features.empty())
+                //{
+                    //    FullName += string("_") + features;
+                //}
+            }
+            #ifdef __SUPPORT_MIPS
+            else if (ARCH_MIPS & CpuID)
+            {
+                FullName += string("_") + ARCH_MIPS_NAME;
+            }
+            #endif
+            else
+            {
+                LOGD("PackageInfo::PackageInfo: package arch unknown");
+                Version = 0;
+                CpuID = ARCH_UNKNOWN;
+                Platform = PLATFORM_UNKNOWN;
+            }
+        }
+        else
+        {
+            LOGD("PackageInfo::PackageInfo: package arch unknown");
+            Version = 0;
+            CpuID = ARCH_UNKNOWN;
+            Platform = PLATFORM_UNKNOWN;
+        }
+    }
+
+    if (!FullName.empty())
+    {
+        InstallPath = install_path + FullName + "/lib";
+    }
+}
+
+PackageInfo::PackageInfo(const string& fullname, const string& install_path, string package_version):
+FullName(fullname),
+InstallPath(install_path)
+{
+    LOGD("PackageInfo::PackageInfo(\"%s\", \"%s\", \"%s\")", fullname.c_str(), install_path.c_str(), package_version.c_str());
+
+    assert(!fullname.empty());
+    assert(!install_path.empty());
+
+    if (OPENCV_ENGINE_PACKAGE == fullname)
+    {
+        // Science version 1.7 OpenCV Manager has it's own version of OpenCV inside
+        // Load libopencv_info.so to understand OpenCV version, platform and other features
+        std::string tmp;
+        if (install_path.empty())
+        {
+            tmp = std::string(DEFAULT_ENGINE_INSTALL_PATH) + "/" + LIB_OPENCV_INFO_NAME;
+        }
+        else
+        {
+            tmp = install_path + "/" + LIB_OPENCV_INFO_NAME;
+        }
+
+        LOGD("Trying to load info library \"%s\"", tmp.c_str());
+
+            void* handle;
+            InfoFunctionType name_func;
+            InfoFunctionType revision_func;
+
+            handle = dlopen(tmp.c_str(), RTLD_LAZY);
+            if (handle)
+            {
+                const char* error;
+
+                dlerror();
+                name_func = (InfoFunctionType)dlsym(handle, "GetPackageName");
+                revision_func = (InfoFunctionType)dlsym(handle, "GetRevision");
+                error = dlerror();
+
+                if (!error && revision_func && name_func)
+                {
+                    FullName = std::string((*name_func)());
+                    package_version = std::string((*revision_func)());
+                    dlclose(handle);
+                    LOGI("OpenCV package \"%s\" revision \"%s\" found", FullName.c_str(), package_version.c_str());
+                }
+                else
+                {
+                    LOGE("Library loading error (%p, %p): \"%s\"", name_func, revision_func, error);
+                }
+            }
+            else
+            {
+                LOGI("Info library not found in package");
+                LOGI("OpenCV Manager package does not contain any verison of OpenCV library");
+                Version = 0;
+                CpuID = ARCH_UNKNOWN;
+                Platform = PLATFORM_UNKNOWN;
+                return;
+            }
+    }
+
+    vector<string> features = SplitStringVector(FullName, '_');
+
+    if (!features.empty() && (BasePackageName == features[0]))
+    {
+        Version = SplitVersion(features, package_version);
+        if (0 == Version)
+        {
+            CpuID = ARCH_UNKNOWN;
+            Platform = PLATFORM_UNKNOWN;
+            return;
+        }
+
+        Platform = SplitPlatfrom(features);
+        if (PLATFORM_UNKNOWN != Platform)
+        {
+            switch (Platform)
+            {
+                case PLATFORM_TEGRA2:
+                {
+                    CpuID = ARCH_ARMv7 | FEATURES_HAS_VFPv3d16;
+                } break;
+                case PLATFORM_TEGRA3:
+                {
+                    CpuID = ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON;
+                } break;
+                case PLATFORM_TEGRA4:
+                {
+                    CpuID = ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON;
+                } break;
+            }
+        }
+        else
+        {
+            if (features.size() < 3)
+            {
+                LOGD("It is not OpenCV library package for this platform");
+                Version = 0;
+                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);
+            }
+            #ifdef __SUPPORT_MIPS
+            else if (ARCH_MIPS_NAME == features[2])
+            {
+                CpuID = ARCH_MIPS;
+            }
+            #endif
+            else
+            {
+                LOGD("It is not OpenCV library package for this platform");
+                Version = 0;
+                CpuID = ARCH_UNKNOWN;
+                Platform = PLATFORM_UNKNOWN;
+                return;
+            }
+        }
+    }
+    else
+    {
+        LOGD("It is not OpenCV library package for this platform");
+        Version = 0;
+        CpuID = ARCH_UNKNOWN;
+        Platform = PLATFORM_UNKNOWN;
+        return;
+    }
+}
+
+bool PackageInfo::IsValid() const
+{
+    return !((0 == Version) && (PLATFORM_UNKNOWN == Platform) && (ARCH_UNKNOWN == CpuID));
+}
+
+int PackageInfo::GetPlatform() const
+{
+    return Platform;
+}
+
+int PackageInfo::GetCpuID() const
+{
+    return CpuID;
+}
+
+string PackageInfo::GetFullName() const
+{
+    return FullName;
+}
+
+int PackageInfo::GetVersion() const
+{
+    return Version;
+}
+
+string PackageInfo::GetInstalationPath() const
+{
+    return InstallPath;
+}
+
+bool PackageInfo::operator==(const PackageInfo& package) const
+{
+    return (package.FullName == FullName);
+}
@@ -0,0 +1,53 @@
+#ifndef __PACKAGE_INFO_H__
+#define __PACKAGE_INFO_H__
+
+#include <map>
+#include <string>
+
+#define ARCH_X86_NAME "x86"
+#define ARCH_X64_NAME "x64"
+#define ARCH_MIPS_NAME "mips"
+#define ARCH_ARMv5_NAME "armv5"
+#define ARCH_ARMv6_NAME "armv6"
+#define ARCH_ARMv7_NAME "armv7a"
+#define ARCH_ARMv8_NAME "armv8"
+
+#define FEATURES_HAS_VFPv3d16_NAME "vfpv3d16"
+#define FEATURES_HAS_VFPv3_NAME "vfpv3"
+#define FEATURES_HAS_NEON_NAME "neon"
+#define FEATURES_HAS_NEON2_NAME "neon2"
+#define FEATURES_HAS_SSE_NAME "sse"
+#define FEATURES_HAS_SSE2_NAME "sse2"
+#define FEATURES_HAS_SSSE3_NAME "ssse3"
+#define FEATURES_HAS_GPU_NAME "gpu"
+
+#define PLATFORM_TEGRA_NAME "tegra"
+#define PLATFORM_TEGRA2_NAME "tegra2"
+#define PLATFORM_TEGRA3_NAME "tegra3"
+#define PLATFORM_TEGRA4_NAME "tegra4"
+
+class PackageInfo
+{
+public:
+    PackageInfo(int version, int platform, int cpu_id, std::string install_path = "/data/data/");
+    PackageInfo(const std::string& fullname, const std::string& install_path, std::string package_version = "0.0");
+    std::string GetFullName() const;
+    int 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();
+    int Version;
+    int Platform;
+    int CpuID;
+    std::string FullName;
+    std::string InstallPath;
+    static const std::string BasePackageName;
+};
+
+#endif
@@ -0,0 +1,32 @@
+#include "EngineCommon.h"
+#include "IOpenCVEngine.h"
+#include "OpenCVEngine.h"
+#include "IPackageManager.h"
+#include "NativePackageManager.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <grp.h>
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+#include <utils/Log.h>
+
+using namespace android;
+
+int main(int argc, char *argv[])
+{
+    LOGI("OpenCVEngine native service starting");
+    IPackageManager* PackageManager = new NativePackageManager();
+    sp<IBinder> Engine = new OpenCVEngine(PackageManager);
+
+    defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
+    LOGI("OpenCVEngine native service started successfully");
+    ProcessState::self()->startThreadPool();
+    IPCThreadState::self()->joinThreadPool();
+    LOGI("OpenCVEngine native service finished");
+
+    delete PackageManager;
+
+    return 0;
+}
@@ -0,0 +1,177 @@
+#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(CpuCount, CheckNonZero)
+{
+    EXPECT_TRUE(GetProcessorCount() != 0);
+}
+
+TEST(GetCpuInfo, GetCpuInfo)
+{
+    map<string, string> a = GetCpuInfo();
+    EXPECT_FALSE(a.empty());
+    EXPECT_TRUE(a.find("") == a.end());
+}
+
+TEST(CpuID, CheckNotEmpy)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_NE(0, cpu_id);
+}
+
+#if defined(__i386__)
+TEST(CpuID, CheckX86)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & ARCH_X86);
+}
+
+TEST(CpuID, CheckSSE2)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & FEATURES_HAS_SSE2);
+}
+#elif defined(__mips)
+#ifdef __SUPPORT_MIPS
+TEST(CpuID, CheckMips)
+{
+    int cpu_id = GetCpuID();
+    EXPECT_TRUE(cpu_id & ARCH_MIPS);
+}
+#endif
+#else
+TEST(TegraDetector, Detect)
+{
+    EXPECT_TRUE(DetectTegra() != 0);
+}
+
+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());
+}
+#endif
@@ -0,0 +1,329 @@
+#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();
+    Engine = new OpenCVEngine(PackageManager);
+
+    defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
+         LOGI("OpenCVEngine native service started successfully");
+    ProcessState::self()->startThreadPool();
+    }
+    ~ServiceStarter()
+    {
+    delete PackageManager;
+    }
+
+    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);
+}
+
+#if defined(__i386__)
+TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040000, PLATFORM_UNKNOWN, ARCH_X86);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_x86/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWOldVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_X86);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.1"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_x86/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWNewVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040100, PLATFORM_UNKNOWN, ARCH_X86);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.2"));
+    EXPECT_EQ(0, result.size());
+}
+
+#elif defined (__mips)
+TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040000, PLATFORM_UNKNOWN, ARCH_MIPS);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_mips/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWOldVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_MIPS);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.1"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_mips/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWNewVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040100, PLATFORM_UNKNOWN, ARCH_MIPS);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.2"));
+    EXPECT_EQ(0, result.size());
+}
+
+#else // armeabi
+TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040000, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+#ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
+#else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+    #endif
+#endif
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWOldVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.1"));
+#ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
+#else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+    #endif
+#endif
+}
+
+TEST(OpenCVEngineTest, GetPathForExecHWNewVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040100, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.2"));
+    EXPECT_EQ(0, result.size());
+}
+
+TEST(OpenCVEngineTest, GetPathForCompatiblePackage1)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_ARMv5);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv5/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathForCompatiblePackage2)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+#ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
+#else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+    #endif
+#endif
+}
+
+TEST(OpenCVEngineTest, GetPathForCompatiblePackage3)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040400, PLATFORM_TEGRA4, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    #ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra4/lib", String8(result).string());
+    #else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+    #endif
+    #endif
+}
+
+TEST(OpenCVEngineTest, InstallAndGetVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    EXPECT_FALSE(NULL == Engine.get());
+    EXPECT_TRUE(Engine->InstallVersion(String16("2.4")));
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    #ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
+    #else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+    #endif
+    #endif
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_2)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.2"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_3)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040300, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.3"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_3_1)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040301, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.3.1"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_3_2)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040302, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.3.2"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_4)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040400, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.4"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+
+TEST(OpenCVEngineTest, GetPathFor2_4_5)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040500, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4.5"));
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+}
+#endif
+
+#ifndef __i386__
+TEST(OpenCVEngineTest, GetPathForInCompatiblePackage1)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_X64);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    EXPECT_EQ(0, result.size());
+}
+#else
+TEST(OpenCVEngineTest, GetPathForInCompatiblePackage1)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    Starter.PackageManager->InstalledPackages.clear();
+    Starter.PackageManager->InstallVersion(2040200, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+    EXPECT_EQ(0, result.size());
+}
+#endif
+
+TEST(OpenCVEngineTest, GetPathForUnExistVersion)
+{
+    sp<IOpenCVEngine> Engine = InitConnect();
+    EXPECT_FALSE(NULL == Engine.get());
+    String16 result = Engine->GetLibPathByVersion(String16("2.5"));
+    EXPECT_EQ(0, result.size());
+}
@@ -0,0 +1,225 @@
+#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(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv7Neon)
+{
+    PackageInfo info(2040100, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v24_armv7a_neon", name.c_str());
+#else
+    EXPECT_STREQ("org.opencv.lib_v24_armv7a", name.c_str());
+#endif
+}
+
+TEST(PackageInfo, FullNameArmv7VFPv3)
+{
+    PackageInfo info(2030300, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv7VFPv3Neon)
+{
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a_neon", name.c_str());
+#else
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a", name.c_str());
+#endif
+}
+
+TEST(PackageInfo, FullNameArmv5)
+{
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv5);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv5", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv6)
+{
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv6);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v23_armv5", name.c_str());
+}
+
+TEST(PackageInfo, FullNameArmv6VFPv3)
+{
+    PackageInfo info(2030200, PLATFORM_UNKNOWN, ARCH_ARMv6 | FEATURES_HAS_VFPv3);
+    string name = info.GetFullName();
+#ifdef __SUPPORT_ARMEABI_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v23_armv5_vfpv3", name.c_str());
+#else
+    EXPECT_STREQ("org.opencv.lib_v23_armv5", name.c_str());
+#endif
+}
+
+TEST(PackageInfo, FullNameTegra3)
+{
+    PackageInfo info(2030000, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+    #ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("org.opencv.lib_v23_tegra3", name.c_str());
+    #else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a_neon", name.c_str());
+    #else
+    EXPECT_STREQ("org.opencv.lib_v23_armv7a", name.c_str());
+    #endif
+    #endif
+}
+
+TEST(PackageInfo, FullNameTegra4)
+{
+    PackageInfo info(2040400, PLATFORM_TEGRA4, ARCH_ARMv7 | FEATURES_HAS_NEON);
+    string name = info.GetFullName();
+    #ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("org.opencv.lib_v24_tegra4", name.c_str());
+    #else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v24_armv7a_neon", name.c_str());
+    #else
+    EXPECT_STREQ("org.opencv.lib_v24_armv7a", name.c_str());
+    #endif
+    #endif
+}
+
+TEST(PackageInfo, FullNameX86SSE2)
+{
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
+    string name = info.GetFullName();
+#ifdef __SUPPORT_INTEL_FEATURES
+    EXPECT_STREQ("org.opencv.lib_v23_x86_sse2", name.c_str());
+#else
+    EXPECT_STREQ("org.opencv.lib_v23_x86", name.c_str());
+#endif
+}
+
+#ifdef __SUPPORT_MIPS
+TEST(PackageInfo, FullNameMips)
+{
+    PackageInfo info(2040300, PLATFORM_UNKNOWN, ARCH_MIPS);
+    string name = info.GetFullName();
+    EXPECT_STREQ("org.opencv.lib_v24_mips", name.c_str());
+}
+#endif
+
+TEST(PackageInfo, Armv7NeonFromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_armv7a_neon", "/data/data/org.opencv.lib_v23_armv7_neon");
+    EXPECT_EQ(2030000, info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv7 | FEATURES_HAS_NEON, info.GetCpuID());
+}
+
+TEST(PackageInfo, Armv5FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_armv5", "/data/data/org.opencv.lib_v23_armv5");
+    EXPECT_EQ(2030000, info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv5, info.GetCpuID());
+}
+
+TEST(PackageInfo, Armv5VFPv3FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_armv5_vfpv3", "/data/data/org.opencv.lib_v23_armv5_vfpv3");
+    EXPECT_EQ(2030000, info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv5 | FEATURES_HAS_VFPv3, 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(2040000, info.GetVersion());
+}
+
+TEST(PackageInfo, Tegra2FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v23_tegra2", "/data/data/org.opencv.lib_v23_tegra2");
+    EXPECT_EQ(2030000, 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(2040000, info.GetVersion());
+    EXPECT_EQ(PLATFORM_TEGRA3, info.GetPlatform());
+}
+
+TEST(PackageInfo, Tegra4FromFullName)
+{
+    PackageInfo info("org.opencv.lib_v24_tegra4", "/data/data/org.opencv.lib_v24_tegra4");
+    EXPECT_EQ(2040000, info.GetVersion());
+    EXPECT_EQ(PLATFORM_TEGRA4, info.GetPlatform());
+}
+
+#ifdef __SUPPORT_MIPS
+TEST(PackageInfo, MipsFromFullName)
+{
+    PackageInfo info("org.opencv.lib_v24_mips", "/data/data/org.opencv.lib_v24_mips");
+    EXPECT_EQ(2040000, info.GetVersion());
+    EXPECT_EQ(ARCH_MIPS, info.GetCpuID());
+}
+#endif
+
+TEST(PackageInfo, Check2DigitRevision)
+{
+    PackageInfo info("org.opencv.lib_v23_armv7a_neon", "/data/data/org.opencv.lib_v23_armv7_neon", "4.1");
+    EXPECT_EQ(2030400, info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv7 | FEATURES_HAS_NEON, info.GetCpuID());
+}
+
+TEST(PackageInfo, Check3DigitRevision)
+{
+    PackageInfo info("org.opencv.lib_v23_armv7a_neon", "/data/data/org.opencv.lib_v23_armv7_neon", "4.1.5");
+    EXPECT_EQ(2030401, info.GetVersion());
+    EXPECT_EQ(ARCH_ARMv7 | FEATURES_HAS_NEON, info.GetCpuID());
+}
+
+TEST(PackageInfo, Comparator1)
+{
+    PackageInfo info1(2040000, 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(2040000, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON | FEATURES_HAS_VFPv3);
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    PackageInfo info2("org.opencv.lib_v24_armv7a_neon", "/data/data/org.opencv.lib_v24_armv7a_neon");
+#else
+    PackageInfo info2("org.opencv.lib_v24_armv7a", "/data/data/org.opencv.lib_v24_armv7a");
+#endif
+    EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
+    EXPECT_EQ(info1, info2);
+}
+
+#ifdef __SUPPORT_TEGRA3
+TEST(PackageInfo, Comparator3)
+{
+    PackageInfo info1(2030000, PLATFORM_TEGRA3, 0);
+    PackageInfo info2("org.opencv.lib_v23_tegra3", "/data/data/org.opencv.lib_v23_tegra3");
+    EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
+    EXPECT_EQ(info1, info2);
+}
+#endif
+
@@ -0,0 +1,18 @@
+#include "PackageManagerStub.h"
+
+using namespace std;
+
+bool PackageManagerStub::InstallPackage(const PackageInfo& package)
+{
+    InstalledPackages.push_back(package);
+    return true;
+}
+
+vector<PackageInfo> PackageManagerStub::GetInstalledPackages()
+{
+    return InstalledPackages;
+}
+
+PackageManagerStub::~PackageManagerStub()
+{
+}
@@ -0,0 +1,17 @@
+#ifndef __PACKAGE_MANAGER_STUB_H__
+#define __PACKAGE_MANAGER_STUB_H__
+
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+
+class PackageManagerStub: public CommonPackageManager
+{
+public:
+    std::vector<PackageInfo> InstalledPackages;
+    virtual ~PackageManagerStub();
+protected:
+    virtual bool InstallPackage(const PackageInfo& package);
+    virtual std::vector<PackageInfo> GetInstalledPackages();
+};
+
+#endif
@@ -0,0 +1,141 @@
+#include "HardwareDetector.h"
+#include "IPackageManager.h"
+#include "CommonPackageManager.h"
+#include "PackageManagerStub.h"
+#include "IOpenCVEngine.h"
+#include <utils/String16.h>
+#include <gtest/gtest.h>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+TEST(PackageManager, InstalledVersions)
+{
+    PackageManagerStub pm;
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    pm.InstalledPackages.push_back(info);
+    std::vector<int> versions = pm.GetInstalledVersions();
+    EXPECT_EQ(1, versions.size());
+    EXPECT_EQ(2030000, *versions.begin());
+}
+
+TEST(PackageManager, CheckVersionInstalled)
+{
+    PackageManagerStub pm;
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    pm.InstalledPackages.push_back(info);
+    EXPECT_TRUE(pm.CheckVersionInstalled(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7));
+}
+
+TEST(PackageManager, InstallVersion)
+{
+    PackageManagerStub pm;
+    PackageInfo info(2030000, PLATFORM_UNKNOWN, ARCH_ARMv5);
+    pm.InstalledPackages.push_back(info);
+    EXPECT_TRUE(pm.InstallVersion(2040000, PLATFORM_UNKNOWN, ARCH_ARMv5));
+    EXPECT_EQ(2, pm.InstalledPackages.size());
+    EXPECT_TRUE(pm.CheckVersionInstalled(2040000, PLATFORM_UNKNOWN, ARCH_ARMv5));
+}
+
+TEST(PackageManager, GetPackagePathForArmv5)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2040300, PLATFORM_UNKNOWN, ARCH_ARMv5));
+    string path = pm.GetPackagePathByVersion(2040300, PLATFORM_UNKNOWN, ARCH_ARMv5);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv5/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForArmv7)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7));
+    string path = pm.GetPackagePathByVersion(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForArmv7Neon)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON));
+    string path = pm.GetPackagePathByVersion(2030000, PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a_neon/lib", path.c_str());
+#else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a/lib", path.c_str());
+#endif
+}
+
+TEST(PackageManager, GetPackagePathForX86)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2030000, PLATFORM_UNKNOWN, ARCH_X86));
+    string path = pm.GetPackagePathByVersion(2030000, PLATFORM_UNKNOWN, ARCH_X86);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86/lib", path.c_str());
+}
+
+TEST(PackageManager, GetPackagePathForX86SSE2)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2030000, PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2));
+    string path = pm.GetPackagePathByVersion(2030000, PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
+#ifdef __SUPPORT_INTEL_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86_sse2/lib", path.c_str());
+#else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86/lib", path.c_str());
+#endif
+}
+
+TEST(PackageManager, GetPackagePathForTegra3)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2030000, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    string path = pm.GetPackagePathByVersion(2030000, PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+#ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_tegra3/lib", path.c_str());
+#else
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a_neon/lib", path.c_str());
+#else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a/lib", path.c_str());
+#endif
+#endif
+}
+
+TEST(PackageManager, GetPackagePathForTegra4)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2040400, PLATFORM_TEGRA4, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON));
+    string path = pm.GetPackagePathByVersion(2040400, PLATFORM_TEGRA4, ARCH_ARMv7 | FEATURES_HAS_VFPv3 | FEATURES_HAS_NEON);
+    #ifdef __SUPPORT_TEGRA3
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra4/lib", path.c_str());
+    #else
+    #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", path.c_str());
+    #else
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", path.c_str());
+    #endif
+    #endif
+}
+
+#ifdef __SUPPORT_MIPS
+TEST(PackageManager, GetPackagePathForMips)
+{
+    PackageManagerStub pm;
+    EXPECT_TRUE(pm.InstallVersion(2040000, PLATFORM_UNKNOWN, ARCH_MIPS));
+    string path = pm.GetPackagePathByVersion(2040000, PLATFORM_UNKNOWN, ARCH_MIPS);
+    EXPECT_STREQ("/data/data/org.opencv.lib_v24_mips/lib", path.c_str());
+}
+#endif
+
+// 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());
+// }
+
+
@@ -0,0 +1,7 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
@@ -0,0 +1,47 @@
+#---------------------------------------------------------------------
+#        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_CFLAGS += -D__SUPPORT_ARMEABI_V7A_FEATURES
+LOCAL_CFLAGS += -D__SUPPORT_TEGRA3
+LOCAL_CFLAGS += -D__SUPPORT_MIPS
+#LOCAL_CFLAGS += -D__SUPPORT_ARMEABI_FEATURES
+
+#LOCAL_LDFLAGS = -Wl,-allow-shlib-undefined
+
+LOCAL_MODULE := OpenCVEngineTestApp
+
+LOCAL_LDLIBS += -lz -lbinder -llog -lutils
+
+LOCAL_SHARED_LIBRARIES += libOpenCVEngine
+
+include $(BUILD_EXECUTABLE)
@@ -0,0 +1,22 @@
+#ifndef __ENGINE_COMMON_H__
+#define __ENGINE_COMMON_H__
+
+// Global tag for Logcat output
+#undef LOG_TAG
+#define LOG_TAG "OpenCVEngine"
+
+// OpenCV Engine API version
+#ifndef OPEN_CV_ENGINE_VERSION
+    #define OPEN_CV_ENGINE_VERSION 2
+#endif
+
+#define LIB_OPENCV_INFO_NAME "libopencv_info.so"
+
+// OpenCV Manager package name
+#define OPENCV_ENGINE_PACKAGE "org.opencv.engine"
+// Class name of OpenCV engine binder object. Is needned for connection to service
+#define OPECV_ENGINE_CLASSNAME "org.opencv.engine.OpenCVEngineInterface"
+
+typedef const char* (*InfoFunctionType)();
+
+#endif
@@ -0,0 +1,32 @@
+#ifndef __IOPENCV_ENGINE_H__
+#define __IOPENCV_ENGINE_H__
+
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+#include <utils/String16.h>
+#include "EngineCommon.h"
+
+enum EngineMethonID
+{
+    OCVE_GET_ENGINE_VERSION = 1,
+    OCVE_GET_LIB_PATH_BY_VERSION = 2,
+    OCVE_INSTALL_VERSION = 3,
+    OCVE_GET_LIB_LIST = 4,
+};
+
+using namespace android;
+
+class IOpenCVEngine: public android::IInterface
+{
+public:
+
+    DECLARE_META_INTERFACE(OpenCVEngine)
+
+public:
+    virtual int GetVersion() = 0;
+    virtual android::String16 GetLibPathByVersion(android::String16 version) = 0;
+    virtual android::String16 GetLibraryList(android::String16 version) = 0;
+    virtual bool InstallVersion(android::String16 version) = 0;
+};
+
+#endif
@@ -0,0 +1,17 @@
+#ifndef __IPACKAGE_MANAGER__
+#define __IPACKAGE_MANAGER__
+
+#include <vector>
+#include <string>
+
+class IPackageManager
+{
+public:
+    virtual std::vector<int> GetInstalledVersions() = 0;
+    virtual bool CheckVersionInstalled(int version, int platform, int cpu_id) = 0;
+    virtual bool InstallVersion(int version, int platform, int cpu_id) = 0;
+    virtual std::string GetPackagePathByVersion(int version, int platform, int cpu_id) = 0;
+    virtual ~IPackageManager(){};
+};
+
+#endif