android -> plarforms/android

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

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

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

@@ -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

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

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

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

@@ -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

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

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

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

@@ -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

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

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