Code normalization problems fixed.

Rair hangs on library installation fixed.

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

@@ -21,53 +21,51 @@ status_t BnOpenCVEngine::onTransact(uint32_t code, const Parcel& data, android::
 
     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);
-    }
+        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;

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

@@ -13,97 +13,97 @@ int GetCpuID()
     map<string, string> cpu_info = GetCpuInfo();
     map<string, string>::const_iterator it;
 
-#if defined(__i386__)
+    #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;
-    }
+        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
+#ifdef __SUPPORT_MIPS
     result |= ARCH_MIPS;
-    #else
+#else
     result = ARCH_UNKNOWN;
-    #endif
+#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);
+        size_t proc_name_pos = it->second.find(CPU_INFO_ARCH_X86_STR);
         if (string::npos != proc_name_pos)
         {
-            result |= ARCH_ARMv6;
         }
         else
         {
-            proc_name_pos = it->second.find(CPU_INFO_ARCH_ARMV5_STR);
+            proc_name_pos = it->second.find(CPU_INFO_ARCH_ARMV7_STR);
             if (string::npos != proc_name_pos)
             {
-            result |= ARCH_ARMv5;
+                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;
+        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))
+        set<string> features = SplitString(it->second, ' ');
+        if (features.end() != features.find(CPU_INFO_NEON_STR))
         {
-        result |= FEATURES_HAS_VFPv3d16;
+            result |= FEATURES_HAS_NEON;
         }
-        else
+        if (features.end() != features.find(CPU_INFO_NEON2_STR))
         {
-        result |= FEATURES_HAS_VFPv3;
+            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
+    #endif
 
     return result;
 }
@@ -116,7 +116,7 @@ string GetPlatformName()
 
     if (cpu_info.end() != hw_iterator)
     {
-    hardware_name = hw_iterator->second;
+        hardware_name = hw_iterator->second;
     }
 
     return hardware_name;
@@ -126,37 +126,37 @@ int GetProcessorCount()
 {
     FILE* cpuPossible = fopen("/sys/devices/system/cpu/possible", "r");
     if(!cpuPossible)
-    return 1;
+        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;
+        return 1;
 
     //parse string of form "0-1,3,5-7,10,13-15"
-    int cpusAvailable = 0;
+        int cpusAvailable = 0;
 
-    while(*pbuf)
-    {
-        const char* pos = pbuf;
-        bool range = false;
-        while(*pbuf && *pbuf != ',')
+        while(*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;
+            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;
+        return cpusAvailable ? cpusAvailable : 1;
 }
 
 int DetectKnownPlatforms()
@@ -165,20 +165,20 @@ int DetectKnownPlatforms()
 
     if (3 == tegra_status)
     {
-    return PLATFORM_TEGRA3;
+        return PLATFORM_TEGRA3;
     }
     else
     {
-    return PLATFORM_UNKNOWN;
+        return PLATFORM_UNKNOWN;
     }
 
     // NOTE: Uncomment when all Tegras will be supported
     /*if (tegra_status > 0)
-    {
-    return PLATFORM_TEGRA + tegra_status - 1;
-    }
-    else
-    {
-    return PLATFORM_UNKNOWN;
-    }*/
+     *   {
+     *   return PLATFORM_TEGRA + tegra_status - 1;
+     }
+     else
+     {
+         return PLATFORM_UNKNOWN;
+     }*/
 }
\ No newline at end of file

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

@@ -42,31 +42,31 @@ std::string OpenCVEngine::NormalizeVersionString(std::string version)
 
     if (version.empty())
     {
-    return result;
+        return result;
     }
 
     if (('a' == version[version.size()-1]) || ('b' == version[version.size()-1]))
     {
-    suffix = version[version.size()-1];
-    version.erase(version.size()-1);
+        suffix = version[version.size()-1];
+        version.erase(version.size()-1);
     }
 
     std::vector<std::string> parts = SplitStringVector(version, '.');
 
     if (parts.size() >= 2)
     {
-    if (parts.size() >= 3)
-    {
-        result = parts[0] + parts[1] + parts[2] + suffix;
-        if (!ValidateVersionString(result))
-        result = "";
-    }
-    else
-    {
-        result = parts[0] + parts[1] + "0" + suffix;
-        if (!ValidateVersionString(result))
-        result = "";
-    }
+        if (parts.size() >= 3)
+        {
+            result = parts[0] + parts[1] + parts[2] + suffix;
+            if (!ValidateVersionString(result))
+                result = "";
+        }
+        else
+        {
+            result = parts[0] + parts[1] + "0" + suffix;
+            if (!ValidateVersionString(result))
+                result = "";
+        }
     }
 
     return result;
@@ -95,19 +95,19 @@ String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
 
     if (!norm_version.empty())
     {
-    path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
-    if (path.empty())
-    {
-        LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
-    }
-    else
-    {
-        FixPermissions(path);
-    }
+        path = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+        if (path.empty())
+        {
+            LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
+        }
+        else
+        {
+            FixPermissions(path);
+        }
     }
     else
     {
-    LOGE("OpenCV version \"%s\" (%s) is not supported", String8(version).string(), norm_version.c_str());
+        LOGE("OpenCV version \"%s\" (%s) is not supported", String8(version).string(), norm_version.c_str());
     }
 
     return String16(path.c_str());
@@ -122,46 +122,46 @@ android::String16 OpenCVEngine::GetLibraryList(android::String16 version)
 
     if (!norm_version.empty())
     {
-    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;
-        char* (*info_func)();
-
-        handle = dlopen(tmp.c_str(), RTLD_LAZY);
-        if (handle)
+        std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
+        if (!tmp.empty())
         {
-        const char* error;
-
-        dlerror();
-        *(void **) (&info_func) = dlsym(handle, "GetLibraryList");
-        if ((error = dlerror()) == NULL)
-        {
-            result = String16((*info_func)());
-            dlclose(handle);
+            tmp += (std::string("/") + LIB_OPENCV_INFO_NAME);
+
+            LOGD("Trying to load info library \"%s\"", tmp.c_str());
+
+            void* handle;
+            char* (*info_func)();
+
+            handle = dlopen(tmp.c_str(), RTLD_LAZY);
+            if (handle)
+            {
+                const char* error;
+
+                dlerror();
+                *(void **) (&info_func) = dlsym(handle, "GetLibraryList");
+                if ((error = dlerror()) == NULL)
+                {
+                    result = String16((*info_func)());
+                    dlclose(handle);
+                }
+                else
+                {
+                    LOGE("Library loading error: \"%s\"", error);
+                }
+            }
+            else
+            {
+                LOGI("Info library not found in package");
+            }
         }
         else
         {
-            LOGE("Library loading error: \"%s\"", error);
-        }
+            LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
         }
-        else
-        {
-        LOGI("Info library not found in package");
-        }
-    }
-    else
-    {
-        LOGI("Package OpenCV of version %s is not installed. Try to install it :)", norm_version.c_str());
-    }
     }
     else
     {
-    LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+        LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
     }
 
     return result;
@@ -173,26 +173,18 @@ bool OpenCVEngine::InstallVersion(android::String16 version)
     std::string norm_version;
     bool result = false;
 
+    LOGD("OpenCVEngine::InstallVersion() begin");
+
     norm_version = NormalizeVersionString(std_version);
 
     if (!norm_version.empty())
-    {
-    LOGD("OpenCVEngine::InstallVersion() begin");
-
-    if (!PackageManager->CheckVersionInstalled(norm_version, Platform, CpuID))
     {
         LOGD("PackageManager->InstallVersion call");
         result = PackageManager->InstallVersion(norm_version, Platform, CpuID);
     }
     else
     {
-        LOGI("Package OpenCV of version %s is already installed. Skiped.", norm_version.c_str());
-        result = true;
-    }
-    }
-    else
-    {
-    LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
+        LOGE("OpenCV version \"%s\" is not supported", norm_version.c_str());
     }
 
     LOGD("OpenCVEngine::InstallVersion() end");
@@ -208,16 +200,16 @@ bool OpenCVEngine::FixPermissions(const std::string& path)
     DIR* dir = opendir(path.c_str());
     if (!dir)
     {
-    LOGD("Fixing permissions error");
-    return false;
+        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);
+        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);

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

@@ -12,18 +12,18 @@ map<string, string> GetCpuInfo()
     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))
+        while (!f.eof())
         {
-        result[key] = value;
+            string tmp;
+            string key;
+            string value;
+            getline(f, tmp);
+            if (ParseString(tmp, key, value))
+            {
+                result[key] = value;
+            }
         }
     }
-    }
 
     f.close();
 

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

@@ -8,7 +8,7 @@ bool StripString(string& src)
 
     if (src.empty())
     {
-    return false;
+        return false;
     }
 
     while ((pos < src.length()) && (' ' == src[pos])) pos++;
@@ -32,7 +32,7 @@ bool StripString(string& src)
 bool ParseString(const string& src, string& key, string& value)
 {
     if (src.empty())
-    return false;
+        return false;
 
     // find seporator ":"
     size_t seporator_pos = src.find(":");
@@ -52,20 +52,19 @@ bool ParseString(const string& src, string& key, string& value)
 
 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);
+        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;
@@ -77,16 +76,16 @@ vector<string> SplitStringVector(const string& src, const char seporator)
 
     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);
+        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;

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

@@ -15,38 +15,38 @@ int DetectTegra()
     gzFile kernelConfig = gzopen(KERNEL_CONFIG, "r");
     if (kernelConfig != 0)
     {
-    char tmpbuf[KERNEL_CONFIG_MAX_LINE_WIDTH];
-    const char *tegra_config = KERNEL_CONFIG_TEGRA_MAGIC;
-    const char *tegra2_config = KERNEL_CONFIG_TEGRA2_MAGIC;
-    const char *tegra3_config = KERNEL_CONFIG_TEGRA3_MAGIC;
-    int len = strlen(tegra_config);
-    int len2 = strlen(tegra2_config);
-    int len3 = strlen(tegra3_config);
-    while (0 != gzgets(kernelConfig, tmpbuf, KERNEL_CONFIG_MAX_LINE_WIDTH))
-    {
-        if (0 == strncmp(tmpbuf, tegra_config, len))
+        char tmpbuf[KERNEL_CONFIG_MAX_LINE_WIDTH];
+        const char *tegra_config = KERNEL_CONFIG_TEGRA_MAGIC;
+        const char *tegra2_config = KERNEL_CONFIG_TEGRA2_MAGIC;
+        const char *tegra3_config = KERNEL_CONFIG_TEGRA3_MAGIC;
+        int len = strlen(tegra_config);
+        int len2 = strlen(tegra2_config);
+        int len3 = strlen(tegra3_config);
+        while (0 != gzgets(kernelConfig, tmpbuf, KERNEL_CONFIG_MAX_LINE_WIDTH))
         {
-        result = 1;
-        }
+            if (0 == strncmp(tmpbuf, tegra_config, len))
+            {
+                result = 1;
+            }
 
-        if (0 == strncmp(tmpbuf, tegra2_config, len2))
-        {
-        result = 2;
-        break;
-        }
+            if (0 == strncmp(tmpbuf, tegra2_config, len2))
+            {
+                result = 2;
+                break;
+            }
 
-        if (0 == strncmp(tmpbuf, tegra3_config, len3))
-        {
-        result = 3;
-        break;
-        }
+            if (0 == strncmp(tmpbuf, tegra3_config, len3))
+            {
+                result = 3;
+                break;
+            }
 
-    }
-    gzclose(kernelConfig);
+        }
+        gzclose(kernelConfig);
     }
     else
     {
-    result = TEGRA_DETECTOR_ERROR;
+        result = TEGRA_DETECTOR_ERROR;
     }
 
     return result;

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

@@ -8,8 +8,8 @@
 using namespace std;
 
 JavaBasedPackageManager::JavaBasedPackageManager(JavaVM* JavaMashine, jobject MarketConnector):
-    JavaContext(JavaMashine),
-    JavaPackageManager(MarketConnector)
+JavaContext(JavaMashine),
+JavaPackageManager(MarketConnector)
 {
     assert(JavaContext);
     assert(JavaPackageManager);
@@ -24,23 +24,23 @@ bool JavaBasedPackageManager::InstallPackage(const PackageInfo& package)
     self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
     if (self_attached)
     {
-    JavaContext->AttachCurrentThread(&jenv, NULL);
+        JavaContext->AttachCurrentThread(&jenv, NULL);
     }
 
     LOGD("GetObjectClass call\n");
     jclass jclazz = jenv->GetObjectClass(JavaPackageManager);
     if (!jclazz)
     {
-    LOGE("MarketConnector class was not found!");
-    return false;
+        LOGE("MarketConnector class was not found!");
+        return false;
     }
 
     LOGD("GetMethodID call\n");
     jmethodID jmethod = jenv->GetMethodID(jclazz, "InstallAppFromMarket", "(Ljava/lang/String;)Z");
     if (!jmethod)
     {
-    LOGE("MarketConnector::GetAppFormMarket method was not found!");
-    return false;
+        LOGE("MarketConnector::GetAppFormMarket method was not found!");
+        return false;
     }
 
     LOGD("Calling java package manager with package name %s\n", package.GetFullName().c_str());
@@ -50,7 +50,7 @@ bool JavaBasedPackageManager::InstallPackage(const PackageInfo& package)
 
     if (self_attached)
     {
-    JavaContext->DetachCurrentThread();
+        JavaContext->DetachCurrentThread();
     }
 
     LOGD("JavaBasedPackageManager::InstallPackage() end\n");
@@ -69,23 +69,23 @@ vector<PackageInfo> JavaBasedPackageManager::GetInstalledPackages()
     self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
     if (self_attached)
     {
-    JavaContext->AttachCurrentThread(&jenv, NULL);
+        JavaContext->AttachCurrentThread(&jenv, NULL);
     }
 
     LOGD("GetObjectClass call");
     jclass jclazz = jenv->GetObjectClass(JavaPackageManager);
     if (!jclazz)
     {
-    LOGE("MarketConnector class was not found!");
-    return result;
+        LOGE("MarketConnector class was not found!");
+        return result;
     }
 
     LOGD("GetMethodID call");
     jmethodID jmethod = jenv->GetMethodID(jclazz, "GetInstalledOpenCVPackages", "()[Landroid/content/pm/PackageInfo;");
     if (!jmethod)
     {
-    LOGE("MarketConnector::GetInstalledOpenCVPackages method was not found!");
-    return result;
+        LOGE("MarketConnector::GetInstalledOpenCVPackages method was not found!");
+        return result;
     }
 
     LOGD("Java package manager call");
@@ -98,19 +98,19 @@ vector<PackageInfo> JavaBasedPackageManager::GetInstalledPackages()
 
     for (jsize i = 0; i < size; i++)
     {
-    jobject jtmp = jenv->GetObjectArrayElement(jpkgs, i);
-    PackageInfo tmp = ConvertPackageFromJava(jtmp, jenv);
-    jenv->DeleteLocalRef(jtmp);
+        jobject jtmp = jenv->GetObjectArrayElement(jpkgs, i);
+        PackageInfo tmp = ConvertPackageFromJava(jtmp, jenv);
+        jenv->DeleteLocalRef(jtmp);
 
-    if (tmp.IsValid())
-        result.push_back(tmp);
+        if (tmp.IsValid())
+            result.push_back(tmp);
     }
 
     jenv->DeleteLocalRef(jpkgs);
 
     if (self_attached)
     {
-    JavaContext->DetachCurrentThread();
+        JavaContext->DetachCurrentThread();
     }
 
     LOGD("JavaBasedPackageManager::GetInstalledPackages() end");
@@ -140,20 +140,20 @@ PackageInfo JavaBasedPackageManager::ConvertPackageFromJava(jobject package, JNI
     jint api_level = jenv->GetStaticIntField(jclazz, jfield);
     if (api_level > 8)
     {
-    jclazz = jenv->GetObjectClass(package);
-    jfield = jenv->GetFieldID(jclazz, "applicationInfo", "Landroid/content/pm/ApplicationInfo;");
-    jobject japp_info = jenv->GetObjectField(package, jfield);
-    jclazz = jenv->GetObjectClass(japp_info);
-    jfield = jenv->GetFieldID(jclazz, "nativeLibraryDir", "Ljava/lang/String;");
-    jstring jpathobj = static_cast<jstring>(jenv->GetObjectField(japp_info, jfield));
-    const char* jpathstr = jenv->GetStringUTFChars(jpathobj, NULL);
-    path = string(jpathstr);
-    jenv->ReleaseStringUTFChars(jpathobj, jpathstr);
-    jenv->DeleteLocalRef(jpathobj);
+        jclazz = jenv->GetObjectClass(package);
+        jfield = jenv->GetFieldID(jclazz, "applicationInfo", "Landroid/content/pm/ApplicationInfo;");
+        jobject japp_info = jenv->GetObjectField(package, jfield);
+        jclazz = jenv->GetObjectClass(japp_info);
+        jfield = jenv->GetFieldID(jclazz, "nativeLibraryDir", "Ljava/lang/String;");
+        jstring jpathobj = static_cast<jstring>(jenv->GetObjectField(japp_info, jfield));
+        const char* jpathstr = jenv->GetStringUTFChars(jpathobj, NULL);
+        path = string(jpathstr);
+        jenv->ReleaseStringUTFChars(jpathobj, jpathstr);
+        jenv->DeleteLocalRef(jpathobj);
     }
     else
     {
-    path = "/data/data/" + name + "/lib";
+        path = "/data/data/" + name + "/lib";
     }
 
     return PackageInfo(name, path, verison);
@@ -170,14 +170,14 @@ JavaBasedPackageManager::~JavaBasedPackageManager()
     self_attached = (JNI_EDETACHED == JavaContext->GetEnv((void**)&jenv, JNI_VERSION_1_6));
     if (self_attached)
     {
-    JavaContext->AttachCurrentThread(&jenv, NULL);
+        JavaContext->AttachCurrentThread(&jenv, NULL);
     }
 
     jenv->DeleteGlobalRef(JavaPackageManager);
 
     if (self_attached)
     {
-    JavaContext->DetachCurrentThread();
+        JavaContext->DetachCurrentThread();
     }
     LOGD("JavaBasedPackageManager::~JavaBasedPackageManager() end");
 }

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

@@ -20,11 +20,11 @@ JNIEXPORT jobject JNICALL Java_org_opencv_engine_BinderConnector_Connect(JNIEnv*
     LOGI("Creating new component");
     if (NULL != OpenCVEngineBinder.get())
     {
-    LOGI("New component created successfully");
+        LOGI("New component created successfully");
     }
     else
     {
-    LOGE("OpenCV Engine component was not created!");
+        LOGE("OpenCV Engine component was not created!");
     }
 
     return javaObjectForIBinder(env, OpenCVEngineBinder);
@@ -36,25 +36,25 @@ JNIEXPORT jboolean JNICALL Java_org_opencv_engine_BinderConnector_Init(JNIEnv* e
 
     if (NULL == PackageManager)
     {
-    JavaVM* jvm;
-    env->GetJavaVM(&jvm);
-    PackageManager = new JavaBasedPackageManager(jvm, env->NewGlobalRef(market));
+        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;
-    }
+        if (!OpenCVEngineBinder.get())
+        {
+            OpenCVEngineBinder = new OpenCVEngine(PackageManager);
+            return (NULL != OpenCVEngineBinder.get());
+        }
+        else
+        {
+            return true;
+        }
     }
     else
     {
-    return false;
+        return false;
     }
 }
 
@@ -67,4 +67,3 @@ JNIEXPORT void JNICALL Java_org_opencv_engine_BinderConnector_Final(JNIEnv *, jo
     delete PackageManager;
     PackageManager = NULL;
 }
-

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

@@ -25,10 +25,10 @@ int main(int argc, char *argv[])
     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
+        EngineService = ServiceManager->getService(IOpenCVEngine::descriptor);
+        if (EngineService != 0) break;
+        LOGW("OpenCVEngine not published, waiting...");
+        usleep(500000); // 0.5 s
     } while(true);
 
     LOGI("Connection established");

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

@@ -18,9 +18,9 @@ set<string> CommonPackageManager::GetInstalledVersions()
 
     for (vector<PackageInfo>::const_iterator it = installed_packages.begin(); it != installed_packages.end(); ++it)
     {
-    string version = it->GetVersion();
-    assert(!version.empty());
-    result.insert(version);
+        string version = it->GetVersion();
+        assert(!version.empty());
+        result.insert(version);
     }
 
     return result;
@@ -36,12 +36,13 @@ bool CommonPackageManager::CheckVersionInstalled(const std::string& version, int
 
     for (vector<PackageInfo>::const_iterator it = packages.begin(); it != packages.end(); ++it)
     {
-    LOGD("Found package: \"%s\"", it->GetFullName().c_str());
+        LOGD("Found package: \"%s\"", it->GetFullName().c_str());
     }
 
     if (!packages.empty())
     {
-    result = (packages.end() != find(packages.begin(), packages.end(), target_package));
+        vector<PackageInfo>::const_iterator it = find(packages.begin(), packages.end(), target_package);
+        result = (it != packages.end());
     }
     LOGD("CommonPackageManager::CheckVersionInstalled() end");
     return result;
@@ -63,66 +64,66 @@ string CommonPackageManager::GetPackagePathByVersion(const std::string& version,
 
     for (vector<PackageInfo>::iterator it = all_packages.begin(); it != all_packages.end(); ++it)
     {
-    LOGD("Check version \"%s\" compatibility with \"%s\"\n", version.c_str(), it->GetVersion().c_str());
-    if (IsVersionCompatible(version, it->GetVersion()))
-    {
-        LOGD("Compatible");
-        packages.push_back(*it);
-    }
-    else
-    {
-        LOGD("NOT Compatible");
-    }
-    }
-
-    if (!packages.empty())
-    {
-    vector<PackageInfo>::iterator found = find(packages.begin(), packages.end(), target_package);
-    if (packages.end() != found)
-    {
-        result = found->GetInstalationPath();
-    }
-    else
-    {
-        int OptRating = -1;
-        std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
-
-        if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
-        group = CommonPackageManager::IntelRating;
-
-        int HardwareRating = GetHardwareRating(platform, cpu_id, group);
-        LOGD("Current hardware platform %d, %d", platform, cpu_id);
-
-        if (-1 == HardwareRating)
+        LOGD("Check version \"%s\" compatibility with \"%s\"\n", version.c_str(), it->GetVersion().c_str());
+        if (IsVersionCompatible(version, it->GetVersion()))
         {
-        LOGE("Cannot calculate rating for current hardware platform!");
+            LOGD("Compatible");
+            packages.push_back(*it);
         }
         else
         {
-        for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
-        {
-            int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
-            if (PackageRating >= 0)
-            {
-            if ((PackageRating <= HardwareRating) && (PackageRating > OptRating))
-            {
-                OptRating = PackageRating;
-                found = it;
-            }
-            }
+            LOGD("NOT Compatible");
         }
+    }
 
-        if ((-1 != OptRating) && (packages.end() != found))
+    if (!packages.empty())
+    {
+        vector<PackageInfo>::iterator found = find(packages.begin(), packages.end(), target_package);
+        if (packages.end() != found)
         {
             result = found->GetInstalationPath();
         }
         else
         {
-            LOGI("Found package is incompatible with current hardware platform");
-        }
+            int OptRating = -1;
+            std::vector<std::pair<int, int> >& group = CommonPackageManager::ArmRating;
+
+            if ((cpu_id & ARCH_X86) || (cpu_id & ARCH_X64))
+                group = CommonPackageManager::IntelRating;
+
+            int HardwareRating = GetHardwareRating(platform, cpu_id, group);
+            LOGD("Current hardware platform %d, %d", platform, cpu_id);
+
+            if (-1 == HardwareRating)
+            {
+                LOGE("Cannot calculate rating for current hardware platform!");
+            }
+            else
+            {
+                for (vector<PackageInfo>::iterator it = packages.begin(); it != packages.end(); ++it)
+                {
+                    int PackageRating = GetHardwareRating(it->GetPlatform(), it->GetCpuID(), group);
+                    if (PackageRating >= 0)
+                    {
+                        if ((PackageRating <= HardwareRating) && (PackageRating > OptRating))
+                        {
+                            OptRating = PackageRating;
+                            found = it;
+                        }
+                    }
+                }
+
+                if ((-1 != OptRating) && (packages.end() != found))
+                {
+                    result = found->GetInstalationPath();
+                }
+                else
+                {
+                    LOGI("Found package is incompatible with current hardware platform");
+                }
+            }
         }
     }
-    }
 
     return result;
 }

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

@@ -126,7 +126,7 @@ TEST(OpenCVEngineTest, GetPathForExecHWNewVersion)
     EXPECT_EQ(0, result.size());
 }
 
-#else
+#else // armeabi
 TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
 {
     sp<IOpenCVEngine> Engine = InitConnect();