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

   1 #include "EngineCommon.h"
   2 #include "OpenCVEngine.h"
   3 #include "HardwareDetector.h"
   4 #include "StringUtils.h"
   5 #include <utils/Log.h>
   6 #include <assert.h>
   7 #include <string>
   8
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <dirent.h>
  12 #include <dlfcn.h>
  13
  14 using namespace android;
  15
  16 const int OpenCVEngine::Platform = DetectKnownPlatforms();
  17 const int OpenCVEngine::CpuID = GetCpuID();
  18 const int OpenCVEngine::KnownVersions[] = {2040000, 2040100, 2040200, 2040300, 2040301, 2040302, 2040400, 2040500, 2040600};
  19
  20 bool OpenCVEngine::ValidateVersion(int version)
  21 {
  22     for (size_t i = 0; i < sizeof(KnownVersions)/sizeof(int); i++)
  23         if (KnownVersions[i] == version)
  24             return true;
  25
  26     return false;
  27 }
  28
  29 int OpenCVEngine::NormalizeVersionString(std::string version)
  30 {
  31     int result = 0;
  32
  33     if (version.empty())
  34     {
  35         return result;
  36     }
  37
  38     std::vector<std::string> parts = SplitStringVector(version, '.');
  39
  40     // Use only 4 digits of the version, i.e. 1.2.3.4.
  41     // Other digits will be ignored.
  42     if (parts.size() > 4)
  43         parts.erase(parts.begin()+4, parts.end());
  44
  45     int multiplyer = 1000000;
  46     for (std::vector<std::string>::const_iterator it = parts.begin(); it != parts.end(); ++it)
  47     {
  48         int digit = atoi(it->c_str());
  49         result += multiplyer*digit;
  50         multiplyer /= 100;
  51     }
  52
  53     if (!ValidateVersion(result))
  54         result  = 0;
  55
  56     return result;
  57 }
  58
  59 OpenCVEngine::OpenCVEngine(IPackageManager* PkgManager):
  60     PackageManager(PkgManager)
  61 {
  62     assert(PkgManager);
  63 }
  64
  65 int32_t OpenCVEngine::GetVersion()
  66 {
  67     return OPEN_CV_ENGINE_VERSION;
  68 }
  69
  70 String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
  71 {
  72     std::string std_version(String8(version).string());
  73     int norm_version;
  74     std::string path;
  75
  76     LOGD("OpenCVEngine::GetLibPathByVersion(%s) impl", String8(version).string());
  77
  78     norm_version = NormalizeVersionString(std_version);
  79
  80     if (0 != norm_version)
  81     {
  82         path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
  83         if (path.empty())
  84         {
  85             LOGI("Package OpenCV of version \"%s\" (%d) is not installed. Try to install it :)", String8(version).string(), norm_version);
  86         }
  87         else
  88         {
  89             FixPermissions(path);
  90         }
  91     }
  92     else
  93     {
  94         LOGE("OpenCV version \"%s\" (%d) is not supported", String8(version).string(), norm_version);
  95     }
  96
  97     return String16(path.c_str());
  98 }
  99
 100 android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
 101 {
 102     std::string std_version = String8(version).string();
 103     int norm_version;
 104     String16 result;
 105     norm_version = NormalizeVersionString(std_version);
 106
 107     if (0 != norm_version)
 108     {
 109         std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
 110         if (!tmp.empty())
 111         {
 112             tmp += (std::string("/") + LIB_OPENCV_INFO_NAME);
 113
 114             LOGD("Trying to load info library \"%s\"", tmp.c_str());
 115
 116             void* handle;
 117             InfoFunctionType info_func;
 118
 119             handle = dlopen(tmp.c_str(), RTLD_LAZY);
 120             if (handle)
 121             {
 122                 const char* error;
 123
 124                 dlerror();
 125                 info_func = (InfoFunctionType)dlsym(handle, "GetLibraryList");
 126                 if ((error = dlerror()) == NULL)
 127                 {
 128                     result = String16((*info_func)());
 129                     dlclose(handle);
 130                 }
 131                 else
 132                 {
 133                     LOGE("Library loading error: \"%s\"", error);
 134                 }
 135             }
 136             else
 137             {
 138                 LOGI("Info library not found in package");
 139             }
 140         }
 141         else
 142         {
 143             LOGI("Package OpenCV of version \"%s\" (%d) is not installed. Try to install it :)", std_version.c_str(), norm_version);
 144         }
 145     }
 146     else
 147     {
 148         LOGE("OpenCV version \"%s\" is not supported", std_version.c_str());
 149     }
 150
 151     return result;
 152 }
 153
 154 bool OpenCVEngine::InstallVersion(android::String16 version)
 155 {
 156     std::string std_version = String8(version).string();
 157     int norm_version;
 158     bool result = false;
 159
 160     LOGD("OpenCVEngine::InstallVersion() begin");
 161
 162     norm_version = NormalizeVersionString(std_version);
 163
 164     if (0 != norm_version)
 165     {
 166         LOGD("PackageManager->InstallVersion call");
 167         result = PackageManager->InstallVersion(norm_version, Platform, CpuID);
 168     }
 169     else
 170     {
 171         LOGE("OpenCV version \"%s\" (%d) is not supported", std_version.c_str(), norm_version);
 172     }
 173
 174     LOGD("OpenCVEngine::InstallVersion() end");
 175
 176     return result;
 177 }
 178
 179 bool OpenCVEngine::FixPermissions(const std::string& path)
 180 {
 181     LOGD("Fixing permissions for folder: \"%s\"", path.c_str());
 182     chmod(path.c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
 183
 184     DIR* dir = opendir(path.c_str());
 185     if (!dir)
 186     {
 187         LOGD("Fixing permissions error");
 188         return false;
 189     }
 190
 191     dirent* files = readdir(dir);
 192     while (files)
 193     {
 194         LOGD("Fix permissions for \"%s\"", files->d_name);
 195         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);
 196         files = readdir(dir);
 197     }
 198
 199     closedir(dir);
 200
 201     return true;
 202 }