//==///////////////////////////////////////////////////////////////////
//
///
/// Initialize Billing Manager
///
/// \param
///
/// \return
///
//==///////////////////////////////////////////////////////////////////
void XFBillingManagerAndroid :: Init(XAppBase *pApp, XFPurchaseHandler *pPurchaseHandler)
{
XFBillingManager::Init(pApp, pPurchaseHandler);
mClassPath = xClassPath;
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
mActivityClass = (jclass)aEnv->NewGlobalRef(aEnv->FindClass(mClassPath.c_str()));
}
EXPORT int osal_GetBackCameraId(){
jmethodID method_id;
JNIEnv* env=(JNIEnv*)SDL_AndroidGetJNIEnv();
jclass clazz=(*env)->FindClass(env,"com/spap/wrapper/camera");
method_id=(*env)->GetStaticMethodID(env,clazz,"get_back_camera_id","()I");
return (*env)->CallStaticIntMethodA(env,clazz,method_id,NULL);
}
void android_action_send(char *mimeType, char *filename, char *subject, char *text, char *chooser_title) {
static JNIEnv *env = NULL;
static jclass *cls = NULL;
static jmethodID mid = NULL;
if (env == NULL) {
env = (JNIEnv *) SDL_AndroidGetJNIEnv();
aassert(env);
cls = (*env)->FindClass(env, "org/renpy/android/Action");
aassert(cls);
mid = (*env)->GetStaticMethodID(env, cls, "send",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
aassert(mid);
}
jstring j_mimeType = (*env)->NewStringUTF(env, mimeType);
jstring j_filename = NULL;
jstring j_subject = NULL;
jstring j_text = NULL;
jstring j_chooser_title = NULL;
if ( filename != NULL )
j_filename = (*env)->NewStringUTF(env, filename);
if ( subject != NULL )
j_subject = (*env)->NewStringUTF(env, subject);
if ( text != NULL )
j_text = (*env)->NewStringUTF(env, text);
if ( chooser_title != NULL )
j_chooser_title = (*env)->NewStringUTF(env, text);
(*env)->CallStaticVoidMethod(
env, cls, mid,
j_mimeType, j_filename, j_subject, j_text,
j_chooser_title);
}
void Android_GetMethods()
{
env = (JNIEnv*)SDL_AndroidGetJNIEnv();
activity = (jobject)SDL_AndroidGetActivity();
actcls = (*env)->GetObjectClass(env, activity);
vibrmid = (*env)->GetMethodID(env, actcls, "vibrate", "(S)V");
}
EXPORT u32* osal_GetCameraImage(int cam_id, int* pw,int* ph){
JNIEnv* env=(JNIEnv*)SDL_AndroidGetJNIEnv();
TCamera* cam=&g_cameras[cam_id];
u32* ret=NULL;
if((unsigned int)cam_id>=(unsigned int)MAX_CAMERAS)return NULL;
//__android_log_print(ANDROID_LOG_ERROR,"STDOUT","waiting for camera image");
for(;;){
SDL_LockMutex(cam->m_cam_mutex);
if(cam->m_image_ready){
ret=cam->m_image_back;
cam->m_image_back=cam->m_image_front;
cam->m_image_front=ret;
cam->m_image_ready=0;
SDL_UnlockMutex(cam->m_cam_mutex);
break;
}else{
cam->m_is_waiting=1;
SDL_UnlockMutex(cam->m_cam_mutex);
//__android_log_print(ANDROID_LOG_ERROR,"STDOUT","SDL_SemWait(cam->m_camdat_ready_event)");
SDL_SemWait(cam->m_camdat_ready_event);
}
}
*pw=cam->m_w;
*ph=cam->m_h;
//__android_log_print(ANDROID_LOG_ERROR,"STDOUT","got camera image");
return ret;
}
void android_get_buildinfo() {
static JNIEnv *env = NULL;
if (env == NULL) {
jclass *cls = NULL;
jfieldID fid;
jstring sval;
env = (JNIEnv *) SDL_AndroidGetJNIEnv();
aassert(env);
cls = (*env)->FindClass(env, "android/os/Build");
fid = (*env)->GetStaticFieldID(env, cls, "MANUFACTURER", "Ljava/lang/String;");
sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
BUILD_MANUFACTURER = (*env)->GetStringUTFChars(env, sval, 0);
fid = (*env)->GetStaticFieldID(env, cls, "MODEL", "Ljava/lang/String;");
sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
BUILD_MODEL = (*env)->GetStringUTFChars(env, sval, 0);
fid = (*env)->GetStaticFieldID(env, cls, "PRODUCT", "Ljava/lang/String;");
sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
BUILD_PRODUCT = (*env)->GetStringUTFChars(env, sval, 0);
cls = (*env)->FindClass(env, "android/os/Build$VERSION");
fid = (*env)->GetStaticFieldID(env, cls, "RELEASE", "Ljava/lang/String;");
sval = (jstring) (*env)->GetStaticObjectField(env, cls, fid);
BUILD_VERSION_RELEASE = (*env)->GetStringUTFChars(env, sval, 0);
}
}
bool IsDirectory(const tstring& sPath)
{
// Check first to see if it's in the assets folder.
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass activity_class = env->GetObjectClass(activity);
jmethodID activity_class_assetIsDirectory = env->GetMethodID(activity_class, "assetIsDirectory", "(Ljava/lang/String;)Z");
jstring assetIsDirectory_sFile = env->NewStringUTF(sPath.c_str());
jboolean assetIsDirectory_result = env->CallBooleanMethod(activity, activity_class_assetIsDirectory, assetIsDirectory_sFile); // activity.assetIsDirectory(file);
bool bIsDirectory = assetIsDirectory_result;
env->DeleteLocalRef(assetIsDirectory_sFile);
if (bIsDirectory)
return true;
struct stat stFileInfo;
bool blnReturn;
int intStat;
// Attempt to get the file attributes
intStat = stat(sPath.c_str(), &stFileInfo);
if(intStat == 0 && S_ISDIR(stFileInfo.st_mode))
return true;
else
return false;
}
//main thread only
EXPORT int osal_TurnOnCamera(int cam_id,int w,int h,int fps){
JNIEnv* env=(JNIEnv*)SDL_AndroidGetJNIEnv();
TCamera* cam=&g_cameras[cam_id];
jmethodID method_id;
jvalue args[4];
int ret;
if((unsigned int)cam_id>=(unsigned int)MAX_CAMERAS)return 0;
if(!cam->m_inited){
cam->m_clazz=(*env)->FindClass(env,"com/spap/wrapper/camera");
method_id=(*env)->GetMethodID(env,cam->m_clazz,"<init>","()V");
cam->m_cam_object=(*env)->NewObjectA(env,cam->m_clazz,method_id,NULL);
cam->m_cam_mutex=SDL_CreateMutex();
cam->m_camdat_ready_event=SDL_CreateSemaphore(0);
cam->m_inited=1;
}
if(cam->m_is_on)return 1;
SDL_LockMutex(cam->m_cam_mutex);
cam->m_is_on=1;
method_id=(*env)->GetMethodID(env,cam->m_clazz,"turn_on","(IIII)I");
//args[].l=cam->m_cam_object;
args[0].i=cam_id;
args[1].i=w;
args[2].i=h;
args[3].i=fps;
ret=(*env)->CallIntMethodA(env,cam->m_cam_object,method_id,args);
SDL_UnlockMutex(cam->m_cam_mutex);
//__android_log_print(ANDROID_LOG_ERROR,"STDOUT","call method %p %p ret=%d",cam->m_clazz,method_id,ret);
return ret;
}
// Get the user's reply to the connection dialog (kDialogNo for No, kDialogYes
// for Yes), or kDialogWaiting if there is no result yet. Calling this consumes
// the result.
GPGMultiplayer::DialogResponse GPGMultiplayer::GetConnectionDialogResponse() {
#ifdef __ANDROID__
// If we are set to automatically connect, pretend this is true.
if (auto_connect_) {
return kDialogYes;
}
JNIEnv* env = reinterpret_cast<JNIEnv*>(SDL_AndroidGetJNIEnv());
jobject activity = reinterpret_cast<jobject>(SDL_AndroidGetActivity());
jclass fpl_class = env->GetObjectClass(activity);
jmethodID get_query_dialog_response =
env->GetMethodID(fpl_class, "getQueryDialogResponse", "()I");
int result = env->CallIntMethod(activity, get_query_dialog_response);
if (result >= 0) {
jmethodID reset_query_dialog_response =
env->GetMethodID(fpl_class, "resetQueryDialogResponse", "()V");
env->CallVoidMethod(activity, reset_query_dialog_response);
}
env->DeleteLocalRef(fpl_class);
env->DeleteLocalRef(activity);
switch (result) {
case 0:
return kDialogNo;
case 1:
return kDialogYes;
default:
return kDialogWaiting;
}
#else
return kDialogWaiting;
#endif
}
AAssetManager* getAssetManager(void) {
JNIEnv* jniEnv = (JNIEnv*)SDL_AndroidGetJNIEnv();
jclass sdlClass = (*jniEnv)->FindClass(jniEnv, "org/libsdl/app/SDLActivity");
if (sdlClass == 0) {
ANDROID_INFO("Cannot find SDLClass");
assert(0);
return NULL;
}
jmethodID mid = (*jniEnv)->GetStaticMethodID(jniEnv, sdlClass, "getContext","()Landroid/content/Context;");
jobject context = (*jniEnv)->CallStaticObjectMethod(jniEnv, sdlClass, mid);
if (context == 0) {
ANDROID_INFO("Cannot find Context");
return NULL;
}
mid = (*jniEnv)->GetMethodID(jniEnv, (*jniEnv)->GetObjectClass(jniEnv, context), "getAssets", "()Landroid/content/res/AssetManager;");
jobject assets = (*jniEnv)->CallObjectMethod(jniEnv, context, mid);
if (assets == 0) {
ANDROID_INFO("Cannot find AssetManager");
return NULL;
}
ANDROID_INFO("Found AssetManager");
return AAssetManager_fromJava(jniEnv, assets);
}
//==///////////////////////////////////////////////////////////////////
//
///
/// Destructor
///
/// \param
///
/// \return
///
//==///////////////////////////////////////////////////////////////////
XFBillingManagerAndroid :: ~XFBillingManagerAndroid()
{
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
if(mActivityClass)
aEnv->DeleteLocalRef(mActivityClass);
mActivityClass = NULL;
}
void *JNI::GetEnv () {
#ifdef ANDROID
return SDL_AndroidGetJNIEnv ();
#else
return 0;
#endif
}
size_t GetNumFiles() const override
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass zipClass = env->GetObjectClass(_zip);
jmethodID fileCountMethod = env->GetMethodID(zipClass, "getNumFiles", "()I");
return (size_t) env->CallIntMethod(_zip, fileCountMethod);
}
uint64 GetFileSize(size_t index) const override
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass zipClass = env->GetObjectClass(_zip);
jmethodID fileSizeMethod = env->GetMethodID(zipClass, "getFileSize", "(I)J");
return (size_t) env->CallLongMethod(_zip, fileSizeMethod, (jint) index);
}
~ZipArchive() override
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass zipClass = env->GetObjectClass(_zip);
jmethodID closeMethod = env->GetMethodID(zipClass, "close", "()V");
env->CallVoidMethod(_zip, closeMethod);
env->DeleteGlobalRef(_zip);
}
float platform_get_default_scale() {
JNIEnv *env = SDL_AndroidGetJNIEnv();
jobject *activity = (jobject *) SDL_AndroidGetActivity();
jclass *activityClass = (*env)->GetObjectClass(env, activity);
jmethodID getDefaultScale = (*env)->GetMethodID(env, activityClass, "getDefaultScale", "()F");
jfloat displayScale = (*env)->CallFloatMethod(env, activity, getDefaultScale);
(*env)->DeleteLocalRef(env, activity);
(*env)->DeleteLocalRef(env, activityClass);
return displayScale;
}
//==///////////////////////////////////////////////////////////////////
//
///
/// Is it possible to purchase?
///
/// \param
///
/// \return
///
//==///////////////////////////////////////////////////////////////////
bool XFBillingManagerAndroid :: CanPurchase( )
{
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
//XFOsAndroidManageLocalRef aLocalRef(aEnv);
jclass aActivityClass = aEnv->FindClass(mClassPath.c_str());
string pFuncType = "()Lcom/myapp/game/MyGame;";
jmethodID aStaticMid = aEnv->GetStaticMethodID(aActivityClass, "GetActivity", (std::string("()L")+xClassPath+";").c_str());
jobject aActivity = aEnv->CallStaticObjectMethod(aActivityClass, aStaticMid);
jmethodID aJavaMethodID = aEnv->GetMethodID(aActivityClass, "XFBillingCanPurchase", "()Z");
return aEnv->CallBooleanMethod(aActivity, aJavaMethodID);
}
ZipArchive(const std::string_view& path, ZIP_ACCESS access)
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass jniClass = env->FindClass("website/openrct2/ZipArchive");
jmethodID constructor = env->GetMethodID(jniClass, "<init>", "(Ljava/lang/String;)V");
jstring jniPath = env->NewStringUTF(path.data());
// TODO: Catch exceptions. Should probably be done on Java side, and just return null from a static method
jobject zip = env->NewObject(jniClass, constructor, jniPath);
_zip = env->NewGlobalRef(zip);
}
// Show a dialog box, allowing the user to reply to a Yes or No question.
bool GPGMultiplayer::DisplayConnectionDialog(const char* title,
const char* question_text,
const char* yes_text,
const char* no_text) {
#ifdef __ANDROID__
if (auto_connect_) {
return true;
}
bool question_shown = false;
JNIEnv* env = reinterpret_cast<JNIEnv*>(SDL_AndroidGetJNIEnv());
jobject activity = reinterpret_cast<jobject>(SDL_AndroidGetActivity());
jclass fpl_class = env->GetObjectClass(activity);
jmethodID is_text_dialog_open =
env->GetMethodID(fpl_class, "isTextDialogOpen", "()Z");
jboolean open = env->CallBooleanMethod(activity, is_text_dialog_open);
jmethodID get_query_dialog_response =
env->GetMethodID(fpl_class, "getQueryDialogResponse", "()I");
int response = env->CallIntMethod(activity, get_query_dialog_response);
if (!open && response == -1) {
jmethodID show_query_dialog =
env->GetMethodID(fpl_class, "showQueryDialog",
"(Ljava/lang/String;Ljava/lang/String;"
"Ljava/lang/String;Ljava/lang/String;)V");
jstring titlej = env->NewStringUTF(title);
jstring questionj = env->NewStringUTF(question_text);
jstring yesj = env->NewStringUTF(yes_text);
jstring noj = env->NewStringUTF(no_text);
env->CallVoidMethod(activity, show_query_dialog, titlej, questionj, yesj,
noj);
env->DeleteLocalRef(titlej);
env->DeleteLocalRef(questionj);
env->DeleteLocalRef(yesj);
env->DeleteLocalRef(noj);
question_shown = true;
}
env->DeleteLocalRef(fpl_class);
env->DeleteLocalRef(activity);
return question_shown;
#else
(void)title;
(void)question_text;
(void)yes_text;
(void)no_text;
return false;
#endif
}
bool XNotification::cancel(){
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
jclass aActivityClass = aEnv->FindClass(xClassPath.c_str());
jmethodID aStaticMid = aEnv->GetStaticMethodID(aActivityClass, "GetActivity", (std::string("()L")+xClassPath+";").c_str());
jobject aActivity = aEnv->CallStaticObjectMethod(aActivityClass, aStaticMid);
jmethodID aJavaMethodID = aEnv->GetMethodID(aActivityClass, "cancelNotify", "(I)V");
aEnv->CallVoidMethod(aActivity, aJavaMethodID, id);
dispatched = false;
return true;
}
tvector<tstring> ListAndroidAssetsDirectory(const tstring& sDirectory, bool bDirectories)
{
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass activity_class = env->GetObjectClass(activity);
jmethodID activity_class_assetOpenDir = env->GetMethodID(activity_class, "assetOpenDir", "(Ljava/lang/String;)Z");
jstring assetOpenDir_sDirectory = env->NewStringUTF(sDirectory.c_str());
jboolean assetOpenDir_success = env->CallBooleanMethod(activity, activity_class_assetOpenDir, assetOpenDir_sDirectory); // activity.assetOpenDir(sDirectory);
env->DeleteLocalRef(assetOpenDir_sDirectory);
if (!assetOpenDir_success)
return tvector<tstring>();
tvector<tstring> asResult;
const char* pszDir;
jmethodID activity_class_assetGetNext = env->GetMethodID(activity_class, "assetGetNext", "()Ljava/lang/String;");
jmethodID activity_class_assetIsDirectory = env->GetMethodID(activity_class, "assetIsDirectory", "(Ljava/lang/String;)Z");
jstring dir;
while ((dir = (jstring)env->CallObjectMethod(activity, activity_class_assetGetNext)) != NULL)
{
const char* pszDir = env->GetStringUTFChars(dir, nullptr);
tstring sDir = pszDir;
env->ReleaseStringUTFChars(dir, pszDir);
tstring sFullDir = sDirectory + "/" + sDir;
if (!bDirectories)
{
jstring assetIsDirectory_sFile = env->NewStringUTF(sFullDir.c_str());
jboolean assetIsDirectory_result = env->CallBooleanMethod(activity, activity_class_assetIsDirectory, assetIsDirectory_sFile); // activity.assetIsDirectory(file);
bool bIsDirectory = assetIsDirectory_result;
env->DeleteLocalRef(assetIsDirectory_sFile);
if (bIsDirectory)
continue;
}
asResult.push_back(sDir);
}
return asResult;
}
//==///////////////////////////////////////////////////////////////////
//
///
/// Restore previous purchases
///
/// \param
///
/// \return
///
//==///////////////////////////////////////////////////////////////////
void XFBillingManagerAndroid :: RestorePurchase(const string &pProductID)
{
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
//XFOsAndroidManageLocalRef aLocalRef(aEnv);
jclass aActivityClass = aEnv->FindClass(mClassPath.c_str());
string pFuncType = string("()L") + mClassPath + ";";
jmethodID aStaticMid = aEnv->GetStaticMethodID(aActivityClass, "GetActivity", pFuncType.c_str());
jobject aActivity = aEnv->CallStaticObjectMethod(aActivityClass, aStaticMid);
jmethodID aJavaMethodID = aEnv->GetMethodID(aActivityClass, "XFBillingRestorePurchase", "(Ljava/lang/String;I)Z");
jstring aJStr = aEnv->NewStringUTF(pProductID.c_str());
aEnv->CallBooleanMethod(aActivity, aJavaMethodID, aJStr, this);
}
void InitializeAssetManager()
{
if (!global_asset_manager)
{
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass activity_class = env->GetObjectClass(activity);
jmethodID activity_class_getAssets = env->GetMethodID(activity_class, "getAssets", "()Landroid/content/res/AssetManager;");
jobject asset_manager = env->CallObjectMethod(activity, activity_class_getAssets); // activity.getAssets();
global_asset_manager = env->NewGlobalRef(asset_manager);
g_pAssetManager = AAssetManager_fromJava(env, global_asset_manager);
}
}
void EnableMulticast()
{
//WifiManager.MulticastLock mclock;
//WifiManager wifimanager = (WifiManager)getSystemService(Context.WIFI_SERVICE);
//if (wifimanager != null)
//{
// mclock = wifimanager.createMulticastLock("lock");
// mcLock.acquire();
//}
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass activity_class = env->GetObjectClass(activity);
jmethodID activity_class_getSystemService = env->GetMethodID(activity_class, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jstring getSystemService_wifi = env->NewStringUTF("wifi");
jobject wifimanager = env->CallObjectMethod(activity, activity_class_getSystemService, getSystemService_wifi); // activity.getSystemService(Context.WIFI_SERVICE);
env->DeleteLocalRef(getSystemService_wifi);
if (wifimanager == nullptr)
{
DebugPrint("ERROR: Couldn't get WifiManager to enable multicast.\n");
return;
}
jclass wifimanager_class = env->GetObjectClass(wifimanager);
jmethodID wifimanager_class_createMulticastLock = env->GetMethodID(wifimanager_class, "createMulticastLock", "(Ljava/lang/String;)Landroid/net/wifi/WifiManager$MulticastLock;");
jstring createMulticastLock_lock = env->NewStringUTF("tinker_multicast_lock");
jobject mclock = env->CallObjectMethod(wifimanager, wifimanager_class_createMulticastLock, createMulticastLock_lock); // wifimanager.createMulticastLock("lock");
env->DeleteLocalRef(createMulticastLock_lock);
if (mclock == nullptr)
{
DebugPrint("ERROR: Couldn't get multicast lock object.\n");
return;
}
jobject global_mclock = env->NewGlobalRef(mclock);
jclass mclock_class = env->GetObjectClass(mclock);
jmethodID mclock_class_acquire = env->GetMethodID(mclock_class, "acquire", "()V");
env->CallVoidMethod(mclock, mclock_class_acquire); // mclock.acquire();
DebugPrint("Acquired multicast lock.\n");
}
bool XNotification::dispatch(){
JNIEnv *aEnv = (JNIEnv *)SDL_AndroidGetJNIEnv();
jclass aActivityClass = aEnv->FindClass(xClassPath.c_str());
jmethodID aStaticMid = aEnv->GetStaticMethodID(aActivityClass, "GetActivity", (std::string("()L")+xClassPath+";").c_str());
jobject aActivity = aEnv->CallStaticObjectMethod(aActivityClass, aStaticMid);
int pos = iconName.find(".");
iconName = iconName.substr(0, pos);
jmethodID aJavaMethodID = aEnv->GetMethodID(aActivityClass, "notify", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Z");
jboolean result = aEnv->CallBooleanMethod(aActivity, aJavaMethodID, aEnv->NewStringUTF(iconName.c_str()),
aEnv->NewStringUTF(title.c_str()), aEnv->NewStringUTF(text.c_str()), id);
return (result == JNI_TRUE);
}
std::vector<uint8> GetFileData(const std::string_view& path) const override
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass zipClass = env->GetObjectClass(_zip);
jstring javaPath = env->NewStringUTF(path.data());
jmethodID indexMethod = env->GetMethodID(zipClass, "getFileIndex", "(Ljava/lang/String;)I");
jint index = env->CallIntMethod(_zip, indexMethod, javaPath);
jmethodID fileMethod = env->GetMethodID(zipClass, "getFile", "(I)J");
jlong ptr = env->CallLongMethod(_zip, fileMethod, index);
auto dataPtr = reinterpret_cast<uint8 *>(ptr);
auto dataSize = this->GetFileSize(index);
return std::vector<uint8>(dataPtr, dataPtr + dataSize);
}
std::string AndroidGetPackageName()
{
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass clazz(env->GetObjectClass(activity));
jmethodID method_id = env->GetMethodID(clazz, "getPackageName", "()Ljava/lang/String;");
jstring packageName = (jstring)env->CallObjectMethod(activity, method_id);
const char* name = env->GetStringUTFChars(packageName, NULL);
std::string result(name);
env->ReleaseStringUTFChars(packageName, name);
env->DeleteLocalRef(activity);
env->DeleteLocalRef(clazz);
return result;
}
void GetScreenDPI(float& xdpi, float& ydpi)
{
JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv();
jobject activity = (jobject)SDL_AndroidGetActivity();
jclass activity_class = env->GetObjectClass(activity);
jmethodID activity_class_getResources = env->GetMethodID(activity_class, "getResources", "()Landroid/content/res/Resources;");
jobject resources = env->CallObjectMethod(activity, activity_class_getResources); // activity.getResources();
jclass resources_class = env->GetObjectClass(resources);
jmethodID resources_class_getDisplayMetrics = env->GetMethodID(resources_class, "getDisplayMetrics", "()Landroid/util/DisplayMetrics;");
jobject display_metrics = env->CallObjectMethod(resources, resources_class_getDisplayMetrics); // resources.getDisplayMetrics();
jclass display_metrics_class = env->GetObjectClass(display_metrics);
jfieldID xdpi_field = env->GetFieldID(display_metrics_class, "xdpi", "F");
jfieldID ydpi_field = env->GetFieldID(display_metrics_class, "ydpi", "F");
xdpi = env->GetFloatField(display_metrics, xdpi_field);
ydpi = env->GetFloatField(display_metrics, ydpi_field);
}
std::string GetFileName(size_t index) const override
{
// retrieve the JNI environment.
JNIEnv *env = (JNIEnv *) SDL_AndroidGetJNIEnv();
jclass zipClass = env->GetObjectClass(_zip);
jmethodID fileNameMethod = env->GetMethodID(zipClass, "getFileName",
"(I)Ljava/lang/String;");
jstring jniString = (jstring) env->CallObjectMethod(_zip, fileNameMethod, (jint) index);
const char *jniChars = env->GetStringUTFChars(jniString, nullptr);
utf8 *string = (char *) malloc(strlen(jniChars) + 1);
memcpy((void *) string, jniChars, strlen(jniChars));
string[strlen(jniChars)] = 0x00;
env->ReleaseStringUTFChars(jniString, jniChars);
return string;
}
EXPORT int osal_TurnOffCamera(int cam_id){
JNIEnv* env=(JNIEnv*)SDL_AndroidGetJNIEnv();
TCamera* cam=&g_cameras[cam_id];
jmethodID method_id;
jvalue args[1];
int ret;
if((unsigned int)cam_id>=(unsigned int)MAX_CAMERAS)return 0;
if(!cam->m_is_on)return 1;
SDL_LockMutex(cam->m_cam_mutex);
method_id=(*env)->GetMethodID(env,cam->m_clazz,"turn_off","()I");
args[0].l=NULL;
ret=(*env)->CallIntMethodA(env,cam->m_cam_object,method_id,args);
if(cam->m_image_back){
free(cam->m_image_back);
cam->m_image_back=NULL;
}
if(cam->m_image_front){
free(cam->m_image_front);
cam->m_image_front=NULL;
}
cam->m_is_on=0;
SDL_UnlockMutex(cam->m_cam_mutex);
return ret;
}
