<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.opencv.engine"
- android:versionCode="16"
- android:versionName="1.6" >
+ android:versionCode="17"
+ android:versionName="1.7" >
<uses-sdk android:minSdkVersion="8" />
<uses-feature android:name="android.hardware.touchscreen" android:required="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_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
-APP_ABI := armeabi x86
+APP_ABI := armeabi x86 mips
APP_PLATFORM := android-8
APP_STL := stlport_static
APP_CPPFLAGS := -fno-rtti -fno-exceptions
map<string, string> cpu_info = GetCpuInfo();
map<string, string>::const_iterator it;
-#ifdef __i386__
+#if defined(__i386__)
LOGD("Using X86 HW detector");
result |= ARCH_X86;
it = cpu_info.find("flags");
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");
{
result |= ARCH_ARMv5;
}
-
}
}
}
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;
+
+ 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;
int DetectKnownPlatforms()
{
int tegra_status = DetectTegra();
-
+
if (3 == tegra_status)
{
return PLATFORM_TEGRA3;
{
return PLATFORM_UNKNOWN;
}
-
+
// NOTE: Uncomment when all Tegras will be supported
/*if (tegra_status > 0)
{
#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
int32_t OpenCVEngine::GetVersion()
{
- return OPEN_CV_ENGINE_VERSION;
+ return OPEN_CV_ENGINE_VERSION;
}
String16 OpenCVEngine::GetLibPathByVersion(android::String16 version)
std::string tmp = PackageManager->GetPackagePathByVersion(norm_version, Platform, CpuID);
if (!tmp.empty())
{
- tmp += "/libopencvinfo.so";
+ tmp += (std::string("/") + LIB_OPENCV_INFO_NAME);
LOGD("Trying to load info library \"%s\"", tmp.c_str());
- void *handle;
+ void* handle;
char* (*info_func)();
handle = dlopen(tmp.c_str(), RTLD_LAZY);
if (handle)
{
- const char *error;
+ const char* error;
dlerror();
*(void **) (&info_func) = dlsym(handle, "GetLibraryList");
#define CPU_INFO_ARCH_X86_STR "x86"
+#define CPU_INFO_ARCH_MIPS_STR "MIPS"
+
// public part
std::map<std::string, std::string> GetCpuInfo();
result = 2;
break;
}
-
+
if (0 == strncmp(tmpbuf, tegra3_config, len3))
{
result = 3;
{
result = TEGRA_DETECTOR_ERROR;
}
-
+
return result;
}
\ No newline at end of file
#include <jni.h>
#include <string>
-JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetCpuID(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID(JNIEnv* env, jclass)
{
return GetCpuID();
}
-JNIEXPORT jstring JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetPlatformName(JNIEnv* env, jclass)
+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_manager_HardwareDetector_GetProcessorCount(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount(JNIEnv* env, jclass)
{
return GetProcessorCount();
}
-JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_DetectKnownPlatforms(JNIEnv* env, jclass)
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms(JNIEnv* env, jclass)
{
return DetectKnownPlatforms();
}
\ No newline at end of file
#endif
/*
- * Class: org_opencv_engine_manager_HardwareDetector
+ * Class: org_opencv_engine_HardwareDetector
* Method: GetCpuID
* Signature: ()I
*/
-JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetCpuID
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetCpuID
(JNIEnv *, jclass);
/*
- * Class: org_opencv_engine_manager_HardwareDetector
+ * Class: org_opencv_engine_HardwareDetector
* Method: GetPlatformName
* Signature: ()Ljava/lang/String;
*/
-JNIEXPORT jstring JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetPlatformName
+JNIEXPORT jstring JNICALL Java_org_opencv_engine_HardwareDetector_GetPlatformName
(JNIEnv *, jclass);
/*
- * Class: org_opencv_engine_manager_HardwareDetector
+ * Class: org_opencv_engine_HardwareDetector
* Method: GetProcessorCount
* Signature: ()I
*/
-JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_GetProcessorCount
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_GetProcessorCount
(JNIEnv *, jclass);
/*
- * Class: org_opencv_engine_manager_HardwareDetector
+ * Class: org_opencv_engine_HardwareDetector
* Method: DetectKnownPlatforms
* Signature: ()I
*/
-JNIEXPORT jint JNICALL Java_org_opencv_engine_manager_HardwareDetector_DetectKnownPlatforms
+JNIEXPORT jint JNICALL Java_org_opencv_engine_HardwareDetector_DetectKnownPlatforms
(JNIEnv *, jclass);
#ifdef __cplusplus
if (NULL == PackageManager)
{
JavaVM* jvm;
- env->GetJavaVM(&jvm);;
+ env->GetJavaVM(&jvm);
PackageManager = new JavaBasedPackageManager(jvm, env->NewGlobalRef(market));
}
if (PackageManager)
protected:
static std::vector<std::pair<int, int> > ArmRating;
static std::vector<std::pair<int, int> > IntelRating;
-
+
static std::vector<std::pair<int, int> > InitArmRating();
static std::vector<std::pair<int, int> > InitIntelRating();
-
+
bool IsVersionCompatible(const std::string& target_version, const std::string& package_version);
int GetHardwareRating(int platform, int cpu_id, const std::vector<std::pair<int, int> >& group);
-
+
virtual bool InstallPackage(const PackageInfo& package) = 0;
- virtual std::vector<PackageInfo> GetInstalledPackages() = 0;
+ virtual std::vector<PackageInfo> GetInstalledPackages() = 0;
};
vector<PackageInfo> NativePackageManager::GetInstalledPackages()
{
vector<PackageInfo> result;
-
+
return result;
}
virtual ~NativePackageManager();
protected:
virtual bool InstallPackage(const PackageInfo& package);
- virtual std::vector<PackageInfo> GetInstalledPackages();
+ virtual std::vector<PackageInfo> GetInstalledPackages();
};
#endif
\ No newline at end of file
#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;
-
+
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)
{
{
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)))
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_NEON2;
}
}
-
+
return result;
}
inline string JoinIntelFeatures(int cpu_id)
{
string result;
-
+
if (FEATURES_HAS_SSSE3 & cpu_id)
{
result = FEATURES_HAS_SSSE3_NAME;
{
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_SSE;
}
- }
-
+ }
+
return result;
}
inline string SplitVersion(const vector<string>& features, const string& package_version)
{
string result;
-
+
if ((features.size() > 1) && ('v' == features[1][0]))
{
result = features[1].substr(1);
{
// TODO: Report package name format error
}
-
+
return result;
}
{
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];
{
// TODO: Report package name format error
}
-
+
return result;
}
* 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, armv5_vfpv3
- */
+ */
PackageInfo::PackageInfo(const string& version, int platform, int cpu_id, std::string install_path):
Version(version),
Platform(platform),
// FullName += string("_") + features;
//}
}
+#ifdef __SUPPORT_MIPS
+ else if (ARCH_MIPS & CpuID)
+ {
+ FullName += string("_") + ARCH_MIPS_NAME;
+ }
+#endif
else
{
LOGD("PackageInfo::PackageInfo: package arch unknown");
Platform = PLATFORM_UNKNOWN;
}
}
-
+
if (!FullName.empty())
{
InstallPath = install_path + FullName + "/lib";
}
}
-PackageInfo::PackageInfo(const string& fullname, const string& install_path, const string& package_version):
+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;
+ const char* (*name_func)();
+ const char* (*revision_func)();
+
+ handle = dlopen(tmp.c_str(), RTLD_LAZY);
+ if (handle)
+ {
+ const char* error;
+
+ dlerror();
+ *(void **) (&name_func) = dlsym(handle, "GetPackageName");
+ *(void **) (&revision_func) = 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 (%x, %x): \"%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.clear();
+ CpuID = ARCH_UNKNOWN;
+ Platform = PLATFORM_UNKNOWN;
+ return;
+ }
+ }
+
vector<string> features = SplitStringVector(FullName, '_');
-
+
if (!features.empty() && (BasePackageName == features[0]))
{
Version = SplitVersion(features, package_version);
{
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");
#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"
{
public:
PackageInfo(const std::string& version, int platform, int cpu_id, std::string install_path = "/data/data/");
- PackageInfo(const std::string& fullname, const std::string& install_path, const std::string& package_version = "0.0");
+ PackageInfo(const std::string& fullname, const std::string& install_path, std::string package_version = "0.0");
std::string GetFullName() const;
std::string GetVersion() const;
int GetPlatform() const;
LOGI("OpenCVEngine native service starting");
IPackageManager* PackageManager = new NativePackageManager();
sp<IBinder> Engine = new OpenCVEngine(PackageManager);
-
+
defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
LOGI("OpenCVEngine native service started successfully");
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
LOGI("OpenCVEngine native service finished");
-
+
delete PackageManager;
-
+
return 0;
}
\ No newline at end of file
EXPECT_FALSE(b.find("eee") == b.end());
}
+TEST(CpuCount, CheckNonZero)
+{
+ EXPECT_TRUE(GetProcessorCount() != 0);
+ EXPECT_TRUE(a.find("") == a.end());
+}
+
TEST(GetCpuInfo, GetCpuInfo)
{
map<string, string> a = GetCpuInfo();
EXPECT_TRUE(a.find("") == a.end());
}
-TEST(TegraDetector, Detect)
+TEST(CpuID, CheckNotEmpy)
{
- EXPECT_TRUE(DetectTegra() != 0);
+ int cpu_id = GetCpuID();
+ EXPECT_NE(0, cpu_id);
}
-TEST(CpuCount, CheckNonZero)
+#ifdef __i386__
+TEST(CpuID, CheckX86)
{
- EXPECT_TRUE(GetProcessorCount() != 0);
+ int cpu_id = GetCpuID();
+ EXPECT_TRUE(cpu_id & ARCH_X86);
}
-TEST(CpuID, CheckNotEmpy)
+TEST(CpuID, CheckSSE2)
{
int cpu_id = GetCpuID();
- EXPECT_NE(0, cpu_id);
+ EXPECT_TRUE(cpu_id & FEATURES_HAS_SSE2);
+}
+#elseif __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)
TEST(PlatfromDetector, CheckTegra)
{
EXPECT_NE(PLATFORM_UNKNOWN, DetectKnownPlatforms());
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file
public:
ServiceStarter()
{
- PackageManager = new PackageManagerStub();
+ PackageManager = new PackageManagerStub();
Engine = new OpenCVEngine(PackageManager);
defaultServiceManager()->addService(IOpenCVEngine::descriptor, Engine);
sp<IBinder> Engine;
};
-static ServiceStarter Starter;
+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;
}
EXPECT_EQ(OPEN_CV_ENGINE_VERSION, Version);
}
+#if defined(__i386__)
+TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
+{
+ sp<IOpenCVEngine> Engine = InitConnect();
+ Starter.PackageManager->InstalledPackages.clear();
+ Starter.PackageManager->InstallVersion("240", 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("242", 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("241", 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("240", 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("242", 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("241", PLATFORM_UNKNOWN, ARCH_MIPS);
+ EXPECT_FALSE(NULL == Engine.get());
+ String16 result = Engine->GetLibPathByVersion(String16("2.4.2"));
+ EXPECT_EQ(0, result.size());
+}
+
+#else
TEST(OpenCVEngineTest, GetPathForExecHWExistVersion)
{
sp<IOpenCVEngine> Engine = InitConnect();
Starter.PackageManager->InstallVersion("240", PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_NEON);
EXPECT_FALSE(NULL == Engine.get());
String16 result = Engine->GetLibPathByVersion(String16("2.4"));
- #ifdef __SUPPORT_TEGRA3
+#ifdef __SUPPORT_TEGRA3
EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
- #else
+#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
+#endif
}
TEST(OpenCVEngineTest, GetPathForExecHWOldVersion)
Starter.PackageManager->InstallVersion("242", PLATFORM_TEGRA3, ARCH_ARMv7 | FEATURES_HAS_NEON);
EXPECT_FALSE(NULL == Engine.get());
String16 result = Engine->GetLibPathByVersion(String16("2.4.1"));
- #ifdef __SUPPORT_TEGRA3
+#ifdef __SUPPORT_TEGRA3
EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
- #else
+#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
+#endif
}
TEST(OpenCVEngineTest, GetPathForExecHWNewVersion)
EXPECT_EQ(0, result.size());
}
-TEST(OpenCVEngineTest, GetPathForUnExistVersion)
-{
- sp<IOpenCVEngine> Engine = InitConnect();
- EXPECT_FALSE(NULL == Engine.get());
- String16 result = Engine->GetLibPathByVersion(String16("2.5"));
- EXPECT_EQ(0, result.size());
-}
-
TEST(OpenCVEngineTest, GetPathForCompatiblePackage1)
{
sp<IOpenCVEngine> Engine = InitConnect();
Starter.PackageManager->InstalledPackages.clear();
Starter.PackageManager->InstallVersion("242", PLATFORM_UNKNOWN, ARCH_ARMv5);
EXPECT_FALSE(NULL == Engine.get());
- String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+ String16 result = Engine->GetLibPathByVersion(String16("2.4"));
EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv5/lib", String8(result).string());
}
#ifdef __SUPPORT_TEGRA3
EXPECT_STREQ("/data/data/org.opencv.lib_v24_tegra3/lib", String8(result).string());
#else
-#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+ #ifdef __SUPPORT_ARMEABI_V7A_FEATURES
EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a_neon/lib", String8(result).string());
-#else
+ #else
EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv7a/lib", String8(result).string());
+ #endif
#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
+}
+#endif
+
+#ifndef __i386__
TEST(OpenCVEngineTest, GetPathForInCompatiblePackage1)
{
sp<IOpenCVEngine> Engine = InitConnect();
Starter.PackageManager->InstalledPackages.clear();
Starter.PackageManager->InstallVersion("242", PLATFORM_UNKNOWN, ARCH_X64);
EXPECT_FALSE(NULL == Engine.get());
- String16 result = Engine->GetLibPathByVersion(String16("2.4"));
+ String16 result = Engine->GetLibPathByVersion(String16("2.4"));
EXPECT_EQ(0, result.size());
}
-
-TEST(OpenCVEngineTest, InstallAndGetVersion)
+#else
+TEST(OpenCVEngineTest, GetPathForInCompatiblePackage1)
{
sp<IOpenCVEngine> Engine = InitConnect();
Starter.PackageManager->InstalledPackages.clear();
+ Starter.PackageManager->InstallVersion("242", PLATFORM_UNKNOWN, ARCH_ARMv7);
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
+ 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());
}
\ No newline at end of file
#endif
}
+#ifdef __SUPPORT_MIPS
+TEST(PackageInfo, FullNameMips)
+{
+ PackageInfo info("243", 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(PLATFORM_TEGRA3, info.GetPlatform());
}
+#ifdef __SUPPORT_MIPS
+TEST(PackageInfo, MipsFromFullName)
+{
+ PackageInfo info("org.opencv.lib_v24_mips", "/data/data/org.opencv.lib_v24_mips");
+ EXPECT_EQ("240", info.GetVersion());
+ EXPECT_EQ(ARCH_MIPS, info.GetCpuID());
+}
+#endif
+
TEST(PackageInfo, Comparator1)
{
PackageInfo info1("240", PLATFORM_UNKNOWN, ARCH_X86);
EXPECT_STREQ(info1.GetFullName().c_str(), info2.GetFullName().c_str());
EXPECT_EQ(info1, info2);
}
-#endif
\ No newline at end of file
+#endif
+
EXPECT_TRUE(pm.CheckVersionInstalled("240", PLATFORM_UNKNOWN, ARCH_ARMv5));
}
+TEST(PackageManager, GetPackagePathForArmv5)
+{
+ PackageManagerStub pm;
+ EXPECT_TRUE(pm.InstallVersion("243", PLATFORM_UNKNOWN, ARCH_ARMv5));
+ string path = pm.GetPackagePathByVersion("243", PLATFORM_UNKNOWN, ARCH_ARMv5);
+ EXPECT_STREQ("/data/data/org.opencv.lib_v24_armv5/lib", path.c_str());
+}
+
TEST(PackageManager, GetPackagePathForArmv7)
{
PackageManagerStub pm;
PackageManagerStub pm;
EXPECT_TRUE(pm.InstallVersion("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON));
string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_ARMv7 | FEATURES_HAS_NEON);
-#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
+#ifdef __SUPPORT_ARMEABI_V7A_FEATURES
EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a_neon/lib", path.c_str());
-#else
+#else
EXPECT_STREQ("/data/data/org.opencv.lib_v23_armv7a/lib", path.c_str());
#endif
}
PackageManagerStub pm;
EXPECT_TRUE(pm.InstallVersion("230", PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2));
string path = pm.GetPackagePathByVersion("230", PLATFORM_UNKNOWN, ARCH_X86 | FEATURES_HAS_SSE2);
-#ifdef __SUPPORT_INTEL_FEATURES
+#ifdef __SUPPORT_INTEL_FEATURES
EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86_sse2/lib", path.c_str());
-#else
+#else
EXPECT_STREQ("/data/data/org.opencv.lib_v23_x86/lib", path.c_str());
#endif
}
#endif
}
+#ifdef __SUPPORT_MIPS
+TEST(PackageManager, GetPackagePathForMips)
+{
+ PackageManagerStub pm;
+ EXPECT_TRUE(pm.InstallVersion("243", PLATFORM_UNKNOWN, ARCH_MIPS));
+ string path = pm.GetPackagePathByVersion("243", 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)
// {
int main(int argc, char **argv)
{
-/* return 0;*/
- ::testing::InitGoogleTest(&argc, argv);
+ ::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
\ No newline at end of file
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
#define OPEN_CV_ENGINE_VERSION 1
#endif
+#define LIB_OPENCV_INFO_NAME "libopencv_info.so"
+
#endif
\ No newline at end of file
#include <binder/Parcel.h>
#include <utils/String16.h>
+// 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"
public class HardwareDetector
{
public static final int ARCH_UNKNOWN = -1;
-
+
public static final int ARCH_X86 = 0x01000000;
public static final int ARCH_X64 = 0x02000000;
-
+
public static final int ARCH_ARMv5 = 0x04000000;
public static final int ARCH_ARMv6 = 0x08000000;
public static final int ARCH_ARMv7 = 0x10000000;
public static final int ARCH_ARMv8 = 0x20000000;
-
+
+ public static final int ARCH_MIPS = 0x40000000;
// Platform specific features
// ! Check CPU arch before !
-
+
// ARM specific features
public static final int FEATURES_HAS_VFPv3d16 = 0x01;
public static final int FEATURES_HAS_VFPv3 = 0x02;
public static final int FEATURES_HAS_NEON = 0x04;
public static final int FEATURES_HAS_NEON2 = 0x08;
-
+
// X86 specific features
public static final int FEATURES_HAS_SSE = 0x01;
public static final int FEATURES_HAS_SSE2 = 0x02;
public static final int FEATURES_HAS_SSE3 = 0x04;
-
+
// GPU Acceleration options
public static final int FEATURES_HAS_GPU = 0x010000;
-
+
public static final int PLATFORM_TEGRA = 1;
public static final int PLATFORM_TEGRA2 = 2;
public static final int PLATFORM_TEGRA3 = 3;
-
- public static final int PLATFORM_UNKNOWN = -1;
-
+
+ public static final int PLATFORM_UNKNOWN = 0;
+
// Return CPU arch and list of supported features
public static native int GetCpuID();
// Return hardware platform name
public static native String GetPlatformName();
// Return processor count
public static native int GetProcessorCount();
-
+
public static native int DetectKnownPlatforms();
+
+ static
+ {
+ System.loadLibrary("OpenCVEngine");
+ System.loadLibrary("OpenCVEngine_jni");
+ }
}
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
import android.net.Uri;
+import android.util.Log;
public class MarketConnector
{
protected static final String OpenCVPackageNamePreffix = "org.opencv.lib";
+ private static final String TAG = "OpenCVEngine/MarketConnector";
protected Context mContext;
+
+ public boolean mIncludeManager = true;
public MarketConnector(Context context)
{
{
return (String) info.loadLabel(mContext.getPackageManager());
}
-
+
public boolean InstallAppFromMarket(String AppID)
{
boolean result = true;
public boolean RemoveAppFromMarket(String AppID, boolean wait)
{
boolean result = true;
- try
+ try
{
Intent intent = new Intent(
Intent.ACTION_DELETE,
return result;
}
-
public boolean CheckPackageInstalled(String AppID)
{
List<PackageInfo> Packages = mContext.getPackageManager().getInstalledPackages(PackageManager.GET_CONFIGURATIONS);
{
List<PackageInfo> AllPackages = mContext.getPackageManager().getInstalledPackages(PackageManager.GET_CONFIGURATIONS);
List<PackageInfo> OpenCVPackages = new ArrayList<PackageInfo>();
+ if (mIncludeManager)
+ {
+ try {
+ OpenCVPackages.add(mContext.getPackageManager().getPackageInfo("org.opencv.engine", PackageManager.GET_CONFIGURATIONS));
+ } catch (NameNotFoundException e) {
+ Log.e(TAG, "OpenCV Manager package info was not found!");
+ e.printStackTrace();
+ }
+ }
Iterator<PackageInfo> it = AllPackages.iterator();
while(it.hasNext())
{
+++ /dev/null
-package org.opencv.engine.manager;
-
-public class HardwareDetector
-{
- public static final int ARCH_UNKNOWN = -1;
-
- public static final int ARCH_X86 = 0x01000000;
- public static final int ARCH_X64 = 0x02000000;
-
- public static final int ARCH_ARMv5 = 0x04000000;
- public static final int ARCH_ARMv6 = 0x08000000;
- public static final int ARCH_ARMv7 = 0x10000000;
- public static final int ARCH_ARMv8 = 0x20000000;
-
- // Platform specific features
- // ! Check CPU arch before !
-
- // ARM specific features
- public static final int FEATURES_HAS_VFPv3d16 = 0x01;
- public static final int FEATURES_HAS_VFPv3 = 0x02;
- public static final int FEATURES_HAS_NEON = 0x04;
- public static final int FEATURES_HAS_NEON2 = 0x08;
-
- // X86 specific features
- public static final int FEATURES_HAS_SSE = 0x01;
- public static final int FEATURES_HAS_SSE2 = 0x02;
- public static final int FEATURES_HAS_SSE3 = 0x04;
-
- // GPU Acceleration options
- public static final int FEATURES_HAS_GPU = 0x010000;
-
- public static final int PLATFORM_TEGRA = 1;
- public static final int PLATFORM_TEGRA2 = 2;
- public static final int PLATFORM_TEGRA3 = 3;
-
- public static final int PLATFORM_UNKNOWN = 0;
-
- // Return CPU arch and list of supported features
- public static native int GetCpuID();
- // Return hardware platform name
- public static native String GetPlatformName();
- // Return processor count
- public static native int GetProcessorCount();
-
- public static native int DetectKnownPlatforms();
-
- static
- {
- System.loadLibrary("OpenCVEngine");
- System.loadLibrary("OpenCVEngine_jni");
- }
-}
import java.util.HashMap;
import java.util.StringTokenizer;
+import org.opencv.engine.HardwareDetector;
import org.opencv.engine.MarketConnector;
import org.opencv.engine.OpenCVEngineInterface;
import org.opencv.engine.R;
OsVersionView.setText(Build.VERSION.CODENAME + " (" + Build.VERSION.RELEASE + "), API " + Build.VERSION.SDK_INT);
try {
- PackageInfo packageInfo = getPackageManager().getPackageInfo(this.getPackageName(), 0);
- ManagerVersion = packageInfo.versionName;
- } catch (NameNotFoundException e) {
- // TODO Auto-generated catch block
- ManagerVersion = "N/A";
- e.printStackTrace();
- }
+ PackageInfo packageInfo = getPackageManager().getPackageInfo(this.getPackageName(), 0);
+ ManagerVersion = packageInfo.versionName;
+ } catch (NameNotFoundException e) {
+ ManagerVersion = "N/A";
+ e.printStackTrace();
+ }
mInstalledPackageView = (ListView)findViewById(R.id.InstalledPackageList);
{
HardwarePlatformView.setText("ARM v8 " + JoinArmFeatures(CpuId));
}
+ else if ((CpuId & HardwareDetector.ARCH_MIPS) == HardwareDetector.ARCH_MIPS)
+ {
+ HardwarePlatformView.setText("MIPS");
+ }
else
{
HardwarePlatformView.setText("not detected");
mUpdateEngineButton = (Button)findViewById(R.id.CheckEngineUpdate);
mUpdateEngineButton.setOnClickListener(new OnClickListener() {
-
- public void onClick(View v) {
- if (!mMarket.InstallAppFromMarket("org.opencv.engine"))
- {
- Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
- toast.show();
- }
- }
- });
+
+ public void onClick(View v) {
+ if (!mMarket.InstallAppFromMarket("org.opencv.engine"))
+ {
+ Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+ toast.show();
+ }
+ }
+ });
mActionDialog = new AlertDialog.Builder(this).create();
mActionDialog.setTitle("Choose action");
mActionDialog.setButton("Update", new DialogInterface.OnClickListener() {
-
- public void onClick(DialogInterface dialog, int which) {
- int index = (Integer)mInstalledPackageView.getTag();
- if (!mMarket.InstallAppFromMarket(mInstalledPackageInfo[index].packageName))
- {
- Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
- toast.show();
- }
- }
- });
+
+ public void onClick(DialogInterface dialog, int which) {
+ int index = (Integer)mInstalledPackageView.getTag();
+ if (!mMarket.InstallAppFromMarket(mInstalledPackageInfo[index].packageName))
+ {
+ Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+ toast.show();
+ }
+ }
+ });
mActionDialog.setButton3("Remove", new DialogInterface.OnClickListener() {
-
- public void onClick(DialogInterface dialog, int which) {
- int index = (Integer)mInstalledPackageView.getTag();
- if (!mMarket.RemoveAppFromMarket(mInstalledPackageInfo[index].packageName, true))
- {
- Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
- toast.show();
- }
- }
+
+ public void onClick(DialogInterface dialog, int which) {
+ int index = (Integer)mInstalledPackageView.getTag();
+ if (!mMarket.RemoveAppFromMarket(mInstalledPackageInfo[index].packageName, true))
+ {
+ Toast toast = Toast.makeText(getApplicationContext(), "Google Play is not avaliable", Toast.LENGTH_SHORT);
+ toast.show();
+ }
+ }
});
mActionDialog.setButton2("Return", new DialogInterface.OnClickListener() {
});
mInstalledPackageView.setOnItemClickListener(new OnItemClickListener() {
-
- public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long id) {
-
- mInstalledPackageView.setTag(Integer.valueOf((int)id));
- mActionDialog.show();
- }
+
+ public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long id) {
+ mInstalledPackageView.setTag(Integer.valueOf((int)id));
+ mActionDialog.show();
+ }
});
- if (!bindService(new Intent("org.opencv.engine.BIND"), mServiceConnection, Context.BIND_AUTO_CREATE))
- {
- TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
- EngineVersionView.setText("not avaliable");
- }
-
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_PACKAGE_ADDED);
filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
filter.addAction(Intent.ACTION_PACKAGE_INSTALL);
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
-
+
registerReceiver(mPackageChangeReciever, filter);
}
protected void FillPackageList()
{
synchronized (mListViewItems) {
+ mMarket.mIncludeManager = false;
mInstalledPackageInfo = mMarket.GetInstalledOpenCVPackages();
mListViewItems.clear();
}
temp.put("Name", PublicName);
- temp.put("Version", NormalizeVersion(OpenCVersion, mInstalledPackageInfo[i].versionName));
+ temp.put("Version", NormalizeVersion(OpenCVersion, mInstalledPackageInfo[i].versionName));
temp.put("Hardware", HardwareName);
mListViewItems.add(temp);
}
-
+
mInstalledPacksAdapter.notifyDataSetChanged();
}
}
+++ /dev/null
-package org.opencv.engine.manager;
-
-public class OpenCVPackageInfo
-{
- public OpenCVPackageInfo(String PackageName, String PackageInstallPath, String RevName)
- {
-
- }
-
- protected long mNativeObject = 0;
-
- protected static native long nativeConstructor(String PackageName, String PackageInstallPath, String RevName);
- protected static native void nativeDestructor(long nativeAddress);
- protected static native String nativeGetVersion(long thiz);
- protected static native String nativeGetPlatfrom(long thiz);
-}
projects / profile / ivi / opencv.git / commitdiff