1148 lines
40 KiB
C++
1148 lines
40 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "GameActivity.h"
|
|
|
|
#include <android/api-level.h>
|
|
#include <android/asset_manager.h>
|
|
#include <android/asset_manager_jni.h>
|
|
#include <android/log.h>
|
|
#include <android/looper.h>
|
|
#include <android/native_window.h>
|
|
#include <android/native_window_jni.h>
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <jni.h>
|
|
#include <poll.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/system_properties.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <string>
|
|
|
|
#include "GameActivityLog.h"
|
|
|
|
namespace {
|
|
|
|
struct OwnedGameTextInputState {
|
|
OwnedGameTextInputState &operator=(const GameTextInputState &rhs) {
|
|
inner = rhs;
|
|
owned_string = std::string(rhs.text_UTF8, rhs.text_length);
|
|
inner.text_UTF8 = owned_string.data();
|
|
return *this;
|
|
}
|
|
GameTextInputState inner;
|
|
std::string owned_string;
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
#ifndef NELEM
|
|
#define NELEM(x) ((int)(sizeof(x) / sizeof((x)[0])))
|
|
#endif
|
|
|
|
/*
|
|
* JNI methods of the GameActivity Java class.
|
|
*/
|
|
static struct {
|
|
jmethodID finish;
|
|
jmethodID setWindowFlags;
|
|
jmethodID getWindowInsets;
|
|
jmethodID getWaterfallInsets;
|
|
jmethodID setImeEditorInfoFields;
|
|
} gGameActivityClassInfo;
|
|
|
|
/*
|
|
* JNI fields of the androidx.core.graphics.Insets Java class.
|
|
*/
|
|
static struct {
|
|
jfieldID left;
|
|
jfieldID right;
|
|
jfieldID top;
|
|
jfieldID bottom;
|
|
} gInsetsClassInfo;
|
|
|
|
/*
|
|
* JNI fields of the Configuration Java class.
|
|
*/
|
|
static struct ConfigurationClassInfo {
|
|
jfieldID colorMode;
|
|
jfieldID densityDpi;
|
|
jfieldID fontScale;
|
|
jfieldID fontWeightAdjustment;
|
|
jfieldID hardKeyboardHidden;
|
|
jfieldID keyboard;
|
|
jfieldID keyboardHidden;
|
|
jfieldID mcc;
|
|
jfieldID mnc;
|
|
jfieldID navigation;
|
|
jfieldID navigationHidden;
|
|
jfieldID orientation;
|
|
jfieldID screenHeightDp;
|
|
jfieldID screenLayout;
|
|
jfieldID screenWidthDp;
|
|
jfieldID smallestScreenWidthDp;
|
|
jfieldID touchscreen;
|
|
jfieldID uiMode;
|
|
} gConfigurationClassInfo;
|
|
|
|
/*
|
|
* JNI methods of the WindowInsetsCompat.Type Java class.
|
|
*/
|
|
static struct {
|
|
jmethodID methods[GAMECOMMON_INSETS_TYPE_COUNT];
|
|
jclass clazz;
|
|
} gWindowInsetsCompatTypeClassInfo;
|
|
|
|
/*
|
|
* Contains a command to be executed by the GameActivity
|
|
* on the application main thread.
|
|
*/
|
|
struct ActivityWork {
|
|
int32_t cmd;
|
|
int64_t arg1;
|
|
int64_t arg2;
|
|
int64_t arg3;
|
|
};
|
|
|
|
/*
|
|
* The type of commands that can be passed to the GameActivity and that
|
|
* are executed on the application main thread.
|
|
*/
|
|
enum {
|
|
CMD_FINISH = 1,
|
|
CMD_SET_WINDOW_FORMAT,
|
|
CMD_SET_WINDOW_FLAGS,
|
|
CMD_SHOW_SOFT_INPUT,
|
|
CMD_HIDE_SOFT_INPUT,
|
|
CMD_SET_SOFT_INPUT_STATE,
|
|
CMD_SET_IME_EDITOR_INFO
|
|
};
|
|
|
|
/*
|
|
* Last known Configuration values. They may be accessed from the different
|
|
* thread, this is why they are made atomic.
|
|
*/
|
|
static struct Configuration {
|
|
std::atomic_int colorMode;
|
|
std::atomic_int densityDpi;
|
|
std::atomic<float> fontScale;
|
|
std::atomic_int fontWeightAdjustment;
|
|
std::atomic_int hardKeyboardHidden;
|
|
std::atomic_int keyboard;
|
|
std::atomic_int keyboardHidden;
|
|
std::atomic_int mcc;
|
|
std::atomic_int mnc;
|
|
std::atomic_int navigation;
|
|
std::atomic_int navigationHidden;
|
|
std::atomic_int orientation;
|
|
std::atomic_int screenHeightDp;
|
|
std::atomic_int screenLayout;
|
|
std::atomic_int screenWidthDp;
|
|
std::atomic_int smallestScreenWidthDp;
|
|
std::atomic_int touchscreen;
|
|
std::atomic_int uiMode;
|
|
} gConfiguration;
|
|
|
|
/*
|
|
* Write a command to be executed by the GameActivity on the application main
|
|
* thread.
|
|
*/
|
|
static void write_work(int fd, int32_t cmd, int64_t arg1 = 0, int64_t arg2 = 0,
|
|
int64_t arg3 = 0) {
|
|
ActivityWork work;
|
|
work.cmd = cmd;
|
|
work.arg1 = arg1;
|
|
work.arg2 = arg2;
|
|
work.arg3 = arg3;
|
|
|
|
LOG_TRACE("write_work: cmd=%d", cmd);
|
|
restart:
|
|
int res = write(fd, &work, sizeof(work));
|
|
if (res < 0 && errno == EINTR) {
|
|
goto restart;
|
|
}
|
|
|
|
if (res == sizeof(work)) return;
|
|
|
|
if (res < 0) {
|
|
ALOGW("Failed writing to work fd: %s", strerror(errno));
|
|
} else {
|
|
ALOGW("Truncated writing to work fd: %d", res);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Read commands to be executed by the GameActivity on the application main
|
|
* thread.
|
|
*/
|
|
static bool read_work(int fd, ActivityWork *outWork) {
|
|
int res = read(fd, outWork, sizeof(ActivityWork));
|
|
// no need to worry about EINTR, poll loop will just come back again.
|
|
if (res == sizeof(ActivityWork)) return true;
|
|
|
|
if (res < 0) {
|
|
ALOGW("Failed reading work fd: %s", strerror(errno));
|
|
} else {
|
|
ALOGW("Truncated reading work fd: %d", res);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Native state for interacting with the GameActivity class.
|
|
*/
|
|
struct NativeCode : public GameActivity {
|
|
NativeCode() {
|
|
memset((GameActivity *)this, 0, sizeof(GameActivity));
|
|
memset(&callbacks, 0, sizeof(callbacks));
|
|
memset(&insetsState, 0, sizeof(insetsState));
|
|
nativeWindow = NULL;
|
|
mainWorkRead = mainWorkWrite = -1;
|
|
gameTextInput = NULL;
|
|
}
|
|
|
|
~NativeCode() {
|
|
if (callbacks.onDestroy != NULL) {
|
|
callbacks.onDestroy(this);
|
|
}
|
|
if (env != NULL) {
|
|
if (javaGameActivity != NULL) {
|
|
env->DeleteGlobalRef(javaGameActivity);
|
|
}
|
|
if (javaAssetManager != NULL) {
|
|
env->DeleteGlobalRef(javaAssetManager);
|
|
}
|
|
}
|
|
GameTextInput_destroy(gameTextInput);
|
|
if (looper != NULL && mainWorkRead >= 0) {
|
|
ALooper_removeFd(looper, mainWorkRead);
|
|
}
|
|
ALooper_release(looper);
|
|
looper = NULL;
|
|
|
|
setSurface(NULL);
|
|
if (mainWorkRead >= 0) close(mainWorkRead);
|
|
if (mainWorkWrite >= 0) close(mainWorkWrite);
|
|
}
|
|
|
|
void setSurface(jobject _surface) {
|
|
if (nativeWindow != NULL) {
|
|
ANativeWindow_release(nativeWindow);
|
|
}
|
|
if (_surface != NULL) {
|
|
nativeWindow = ANativeWindow_fromSurface(env, _surface);
|
|
} else {
|
|
nativeWindow = NULL;
|
|
}
|
|
}
|
|
|
|
GameActivityCallbacks callbacks;
|
|
|
|
std::string internalDataPathObj;
|
|
std::string externalDataPathObj;
|
|
std::string obbPathObj;
|
|
|
|
ANativeWindow *nativeWindow;
|
|
int32_t lastWindowWidth;
|
|
int32_t lastWindowHeight;
|
|
|
|
// These are used to wake up the main thread to process work.
|
|
int mainWorkRead;
|
|
int mainWorkWrite;
|
|
ALooper *looper;
|
|
|
|
// Need to hold on to a reference here in case the upper layers destroy our
|
|
// AssetManager.
|
|
jobject javaAssetManager;
|
|
|
|
GameTextInput *gameTextInput;
|
|
// Set by users in GameActivity_setTextInputState, then passed to
|
|
// GameTextInput.
|
|
OwnedGameTextInputState gameTextInputState;
|
|
std::mutex gameTextInputStateMutex;
|
|
|
|
ARect insetsState[GAMECOMMON_INSETS_TYPE_COUNT];
|
|
};
|
|
|
|
static void readConfigurationValues(NativeCode *code, jobject javaConfig);
|
|
|
|
extern "C" void GameActivity_finish(GameActivity *activity) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
write_work(code->mainWorkWrite, CMD_FINISH, 0);
|
|
}
|
|
|
|
extern "C" void GameActivity_setWindowFlags(GameActivity *activity,
|
|
uint32_t values, uint32_t mask) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
write_work(code->mainWorkWrite, CMD_SET_WINDOW_FLAGS, values, mask);
|
|
}
|
|
|
|
extern "C" void GameActivity_showSoftInput(GameActivity *activity,
|
|
uint32_t flags) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
write_work(code->mainWorkWrite, CMD_SHOW_SOFT_INPUT, flags);
|
|
}
|
|
|
|
extern "C" void GameActivity_setTextInputState(
|
|
GameActivity *activity, const GameTextInputState *state) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
std::lock_guard<std::mutex> lock(code->gameTextInputStateMutex);
|
|
code->gameTextInputState = *state;
|
|
write_work(code->mainWorkWrite, CMD_SET_SOFT_INPUT_STATE);
|
|
}
|
|
|
|
extern "C" void GameActivity_getTextInputState(
|
|
GameActivity *activity, GameTextInputGetStateCallback callback,
|
|
void *context) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
return GameTextInput_getState(code->gameTextInput, callback, context);
|
|
}
|
|
|
|
extern "C" void GameActivity_hideSoftInput(GameActivity *activity,
|
|
uint32_t flags) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
write_work(code->mainWorkWrite, CMD_HIDE_SOFT_INPUT, flags);
|
|
}
|
|
|
|
extern "C" void GameActivity_getWindowInsets(GameActivity *activity,
|
|
GameCommonInsetsType type,
|
|
ARect *insets) {
|
|
if (type < 0 || type >= GAMECOMMON_INSETS_TYPE_COUNT) return;
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
*insets = code->insetsState[type];
|
|
}
|
|
|
|
extern "C" GameTextInput *GameActivity_getTextInput(
|
|
const GameActivity *activity) {
|
|
const NativeCode *code = static_cast<const NativeCode *>(activity);
|
|
return code->gameTextInput;
|
|
}
|
|
|
|
/*
|
|
* Log the JNI exception, if any.
|
|
*/
|
|
static void checkAndClearException(JNIEnv *env, const char *methodName) {
|
|
if (env->ExceptionCheck()) {
|
|
ALOGE("Exception while running %s", methodName);
|
|
env->ExceptionDescribe();
|
|
env->ExceptionClear();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Callback for handling native events on the application's main thread.
|
|
*/
|
|
static int mainWorkCallback(int fd, int events, void *data) {
|
|
ALOGD("************** mainWorkCallback *********");
|
|
NativeCode *code = (NativeCode *)data;
|
|
if ((events & POLLIN) == 0) {
|
|
return 1;
|
|
}
|
|
|
|
ActivityWork work;
|
|
if (!read_work(code->mainWorkRead, &work)) {
|
|
return 1;
|
|
}
|
|
LOG_TRACE("mainWorkCallback: cmd=%d", work.cmd);
|
|
switch (work.cmd) {
|
|
case CMD_FINISH: {
|
|
code->env->CallVoidMethod(code->javaGameActivity,
|
|
gGameActivityClassInfo.finish);
|
|
checkAndClearException(code->env, "finish");
|
|
} break;
|
|
case CMD_SET_WINDOW_FLAGS: {
|
|
code->env->CallVoidMethod(code->javaGameActivity,
|
|
gGameActivityClassInfo.setWindowFlags,
|
|
work.arg1, work.arg2);
|
|
checkAndClearException(code->env, "setWindowFlags");
|
|
} break;
|
|
case CMD_SHOW_SOFT_INPUT: {
|
|
GameTextInput_showIme(code->gameTextInput, work.arg1);
|
|
} break;
|
|
case CMD_SET_SOFT_INPUT_STATE: {
|
|
std::lock_guard<std::mutex> lock(code->gameTextInputStateMutex);
|
|
GameTextInput_setState(code->gameTextInput,
|
|
&code->gameTextInputState.inner);
|
|
checkAndClearException(code->env, "setTextInputState");
|
|
} break;
|
|
case CMD_HIDE_SOFT_INPUT: {
|
|
GameTextInput_hideIme(code->gameTextInput, work.arg1);
|
|
} break;
|
|
case CMD_SET_IME_EDITOR_INFO: {
|
|
code->env->CallVoidMethod(
|
|
code->javaGameActivity,
|
|
gGameActivityClassInfo.setImeEditorInfoFields, work.arg1,
|
|
work.arg2, work.arg3);
|
|
checkAndClearException(code->env, "setImeEditorInfo");
|
|
} break;
|
|
default:
|
|
ALOGW("Unknown work command: %d", work.cmd);
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
static thread_local std::string g_error_msg;
|
|
|
|
static jlong initializeNativeCode_native(
|
|
JNIEnv *env, jobject javaGameActivity, jstring internalDataDir,
|
|
jstring obbDir, jstring externalDataDir, jobject jAssetMgr,
|
|
jbyteArray savedState, jobject javaConfig) {
|
|
LOG_TRACE("initializeNativeCode_native");
|
|
NativeCode *code = NULL;
|
|
|
|
code = new NativeCode();
|
|
|
|
code->looper = ALooper_forThread();
|
|
if (code->looper == nullptr) {
|
|
g_error_msg = "Unable to retrieve native ALooper";
|
|
ALOGW("%s", g_error_msg.c_str());
|
|
delete code;
|
|
return 0;
|
|
}
|
|
ALooper_acquire(code->looper);
|
|
|
|
int msgpipe[2];
|
|
if (pipe(msgpipe)) {
|
|
g_error_msg = "could not create pipe: ";
|
|
g_error_msg += strerror(errno);
|
|
|
|
ALOGW("%s", g_error_msg.c_str());
|
|
delete code;
|
|
return 0;
|
|
}
|
|
code->mainWorkRead = msgpipe[0];
|
|
code->mainWorkWrite = msgpipe[1];
|
|
int result = fcntl(code->mainWorkRead, F_SETFL, O_NONBLOCK);
|
|
SLOGW_IF(result != 0,
|
|
"Could not make main work read pipe "
|
|
"non-blocking: %s",
|
|
strerror(errno));
|
|
result = fcntl(code->mainWorkWrite, F_SETFL, O_NONBLOCK);
|
|
SLOGW_IF(result != 0,
|
|
"Could not make main work write pipe "
|
|
"non-blocking: %s",
|
|
strerror(errno));
|
|
ALooper_addFd(code->looper, code->mainWorkRead, 0, ALOOPER_EVENT_INPUT,
|
|
mainWorkCallback, code);
|
|
|
|
code->GameActivity::callbacks = &code->callbacks;
|
|
if (env->GetJavaVM(&code->vm) < 0) {
|
|
ALOGW("GameActivity GetJavaVM failed");
|
|
delete code;
|
|
return 0;
|
|
}
|
|
code->env = env;
|
|
code->javaGameActivity = env->NewGlobalRef(javaGameActivity);
|
|
|
|
const char *dirStr =
|
|
internalDataDir ? env->GetStringUTFChars(internalDataDir, NULL) : "";
|
|
code->internalDataPathObj = dirStr;
|
|
code->internalDataPath = code->internalDataPathObj.c_str();
|
|
if (internalDataDir) env->ReleaseStringUTFChars(internalDataDir, dirStr);
|
|
|
|
dirStr =
|
|
externalDataDir ? env->GetStringUTFChars(externalDataDir, NULL) : "";
|
|
code->externalDataPathObj = dirStr;
|
|
code->externalDataPath = code->externalDataPathObj.c_str();
|
|
if (externalDataDir) env->ReleaseStringUTFChars(externalDataDir, dirStr);
|
|
|
|
code->javaAssetManager = env->NewGlobalRef(jAssetMgr);
|
|
code->assetManager = AAssetManager_fromJava(env, jAssetMgr);
|
|
|
|
dirStr = obbDir ? env->GetStringUTFChars(obbDir, NULL) : "";
|
|
code->obbPathObj = dirStr;
|
|
code->obbPath = code->obbPathObj.c_str();
|
|
if (obbDir) env->ReleaseStringUTFChars(obbDir, dirStr);
|
|
|
|
jbyte *rawSavedState = NULL;
|
|
jsize rawSavedSize = 0;
|
|
if (savedState != NULL) {
|
|
rawSavedState = env->GetByteArrayElements(savedState, NULL);
|
|
rawSavedSize = env->GetArrayLength(savedState);
|
|
}
|
|
|
|
readConfigurationValues(code, javaConfig);
|
|
|
|
GameActivity_onCreate_C(code, rawSavedState, rawSavedSize);
|
|
|
|
code->gameTextInput = GameTextInput_init(env, 0);
|
|
GameTextInput_setEventCallback(code->gameTextInput,
|
|
reinterpret_cast<GameTextInputEventCallback>(
|
|
code->callbacks.onTextInputEvent),
|
|
code);
|
|
|
|
if (rawSavedState != NULL) {
|
|
env->ReleaseByteArrayElements(savedState, rawSavedState, 0);
|
|
}
|
|
|
|
return reinterpret_cast<jlong>(code);
|
|
}
|
|
|
|
static jstring getDlError_native(JNIEnv *env, jobject javaGameActivity) {
|
|
jstring result = env->NewStringUTF(g_error_msg.c_str());
|
|
g_error_msg.clear();
|
|
return result;
|
|
}
|
|
|
|
static void terminateNativeCode_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("terminateNativeCode_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
delete code;
|
|
}
|
|
}
|
|
|
|
static void onStart_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
ALOGV("onStart_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onStart != NULL) {
|
|
code->callbacks.onStart(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onResume_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("onResume_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onResume != NULL) {
|
|
code->callbacks.onResume(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct SaveInstanceLocals {
|
|
JNIEnv *env;
|
|
jbyteArray array;
|
|
};
|
|
|
|
static jbyteArray onSaveInstanceState_native(JNIEnv *env,
|
|
jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("onSaveInstanceState_native");
|
|
|
|
SaveInstanceLocals locals{
|
|
env, NULL}; // Passed through the user's state prep function.
|
|
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onSaveInstanceState != NULL) {
|
|
code->callbacks.onSaveInstanceState(
|
|
code,
|
|
[](const char *bytes, int len, void *context) {
|
|
auto locals = static_cast<SaveInstanceLocals *>(context);
|
|
if (len > 0) {
|
|
locals->array = locals->env->NewByteArray(len);
|
|
if (locals->array != NULL) {
|
|
locals->env->SetByteArrayRegion(
|
|
locals->array, 0, len, (const jbyte *)bytes);
|
|
}
|
|
}
|
|
},
|
|
&locals);
|
|
}
|
|
}
|
|
return locals.array;
|
|
}
|
|
|
|
static void onPause_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("onPause_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onPause != NULL) {
|
|
code->callbacks.onPause(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onStop_native(JNIEnv *env, jobject javaGameActivity, jlong handle) {
|
|
LOG_TRACE("onStop_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onStop != NULL) {
|
|
code->callbacks.onStop(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void readConfigurationValues(NativeCode *code, jobject javaConfig) {
|
|
if (gConfigurationClassInfo.colorMode != NULL) {
|
|
gConfiguration.colorMode = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.colorMode);
|
|
}
|
|
|
|
gConfiguration.densityDpi =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.densityDpi);
|
|
gConfiguration.fontScale =
|
|
code->env->GetFloatField(javaConfig, gConfigurationClassInfo.fontScale);
|
|
|
|
if (gConfigurationClassInfo.fontWeightAdjustment != NULL) {
|
|
gConfiguration.fontWeightAdjustment = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.fontWeightAdjustment);
|
|
}
|
|
|
|
gConfiguration.hardKeyboardHidden = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.hardKeyboardHidden);
|
|
gConfiguration.mcc =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.mcc);
|
|
gConfiguration.mnc =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.mnc);
|
|
gConfiguration.navigation =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.navigation);
|
|
gConfiguration.navigationHidden = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.navigationHidden);
|
|
gConfiguration.orientation =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.orientation);
|
|
gConfiguration.screenHeightDp = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.screenHeightDp);
|
|
gConfiguration.screenLayout = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.screenLayout);
|
|
gConfiguration.screenWidthDp = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.screenWidthDp);
|
|
gConfiguration.smallestScreenWidthDp = code->env->GetIntField(
|
|
javaConfig, gConfigurationClassInfo.smallestScreenWidthDp);
|
|
gConfiguration.touchscreen =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.touchscreen);
|
|
gConfiguration.uiMode =
|
|
code->env->GetIntField(javaConfig, gConfigurationClassInfo.uiMode);
|
|
|
|
checkAndClearException(code->env, "Configuration.get");
|
|
}
|
|
|
|
static void onConfigurationChanged_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jobject javaNewConfig) {
|
|
LOG_TRACE("onConfigurationChanged_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
readConfigurationValues(code, javaNewConfig);
|
|
|
|
if (code->callbacks.onConfigurationChanged != NULL) {
|
|
code->callbacks.onConfigurationChanged(code);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onTrimMemory_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jint level) {
|
|
LOG_TRACE("onTrimMemory_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onTrimMemory != NULL) {
|
|
code->callbacks.onTrimMemory(code, level);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onWindowFocusChanged_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jboolean focused) {
|
|
LOG_TRACE("onWindowFocusChanged_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onWindowFocusChanged != NULL) {
|
|
code->callbacks.onWindowFocusChanged(code, focused ? 1 : 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onSurfaceCreated_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jobject surface) {
|
|
ALOGV("onSurfaceCreated_native");
|
|
LOG_TRACE("onSurfaceCreated_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
code->setSurface(surface);
|
|
|
|
if (code->nativeWindow != NULL &&
|
|
code->callbacks.onNativeWindowCreated != NULL) {
|
|
code->callbacks.onNativeWindowCreated(code, code->nativeWindow);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onSurfaceChanged_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jobject surface, jint format,
|
|
jint width, jint height) {
|
|
LOG_TRACE("onSurfaceChanged_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
ANativeWindow *oldNativeWindow = code->nativeWindow;
|
|
// Fix for window being destroyed behind the scenes on older Android
|
|
// versions.
|
|
if (oldNativeWindow != NULL) {
|
|
ANativeWindow_acquire(oldNativeWindow);
|
|
}
|
|
code->setSurface(surface);
|
|
if (oldNativeWindow != code->nativeWindow) {
|
|
if (oldNativeWindow != NULL &&
|
|
code->callbacks.onNativeWindowDestroyed != NULL) {
|
|
code->callbacks.onNativeWindowDestroyed(code, oldNativeWindow);
|
|
}
|
|
if (code->nativeWindow != NULL) {
|
|
if (code->callbacks.onNativeWindowCreated != NULL) {
|
|
code->callbacks.onNativeWindowCreated(code,
|
|
code->nativeWindow);
|
|
}
|
|
|
|
code->lastWindowWidth =
|
|
ANativeWindow_getWidth(code->nativeWindow);
|
|
code->lastWindowHeight =
|
|
ANativeWindow_getHeight(code->nativeWindow);
|
|
}
|
|
} else {
|
|
// Maybe it was resized?
|
|
int32_t newWidth = ANativeWindow_getWidth(code->nativeWindow);
|
|
int32_t newHeight = ANativeWindow_getHeight(code->nativeWindow);
|
|
|
|
if (newWidth != code->lastWindowWidth ||
|
|
newHeight != code->lastWindowHeight) {
|
|
code->lastWindowWidth = newWidth;
|
|
code->lastWindowHeight = newHeight;
|
|
|
|
if (code->callbacks.onNativeWindowResized != NULL) {
|
|
code->callbacks.onNativeWindowResized(
|
|
code, code->nativeWindow, newWidth, newHeight);
|
|
}
|
|
}
|
|
}
|
|
// Release the window we acquired earlier.
|
|
if (oldNativeWindow != NULL) {
|
|
ANativeWindow_release(oldNativeWindow);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onSurfaceRedrawNeeded_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("onSurfaceRedrawNeeded_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->nativeWindow != NULL &&
|
|
code->callbacks.onNativeWindowRedrawNeeded != NULL) {
|
|
code->callbacks.onNativeWindowRedrawNeeded(code,
|
|
code->nativeWindow);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void onSurfaceDestroyed_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle) {
|
|
LOG_TRACE("onSurfaceDestroyed_native");
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->nativeWindow != NULL &&
|
|
code->callbacks.onNativeWindowDestroyed != NULL) {
|
|
code->callbacks.onNativeWindowDestroyed(code, code->nativeWindow);
|
|
}
|
|
code->setSurface(NULL);
|
|
}
|
|
}
|
|
|
|
extern "C" void GameActivity_setImeEditorInfo(GameActivity *activity,
|
|
int inputType, int actionId,
|
|
int imeOptions) {
|
|
NativeCode *code = static_cast<NativeCode *>(activity);
|
|
write_work(code->mainWorkWrite, CMD_SET_IME_EDITOR_INFO, inputType,
|
|
actionId, imeOptions);
|
|
}
|
|
|
|
extern "C" int GameActivity_getColorMode(GameActivity *) {
|
|
return gConfiguration.colorMode;
|
|
}
|
|
|
|
extern "C" int GameActivity_getDensityDpi(GameActivity *) {
|
|
return gConfiguration.densityDpi;
|
|
}
|
|
|
|
extern "C" float GameActivity_getFontScale(GameActivity *) {
|
|
return gConfiguration.fontScale;
|
|
}
|
|
|
|
extern "C" int GameActivity_getFontWeightAdjustment(GameActivity *) {
|
|
return gConfiguration.fontWeightAdjustment;
|
|
}
|
|
|
|
extern "C" int GameActivity_getHardKeyboardHidden(GameActivity *) {
|
|
return gConfiguration.hardKeyboardHidden;
|
|
}
|
|
|
|
extern "C" int GameActivity_getKeyboard(GameActivity *) {
|
|
return gConfiguration.keyboard;
|
|
}
|
|
|
|
extern "C" int GameActivity_getKeyboardHidden(GameActivity *) {
|
|
return gConfiguration.keyboardHidden;
|
|
}
|
|
|
|
extern "C" int GameActivity_getMcc(GameActivity *) {
|
|
return gConfiguration.mcc;
|
|
}
|
|
|
|
extern "C" int GameActivity_getMnc(GameActivity *) {
|
|
return gConfiguration.mnc;
|
|
}
|
|
|
|
extern "C" int GameActivity_getNavigation(GameActivity *) {
|
|
return gConfiguration.navigation;
|
|
}
|
|
|
|
extern "C" int GameActivity_getNavigationHidden(GameActivity *) {
|
|
return gConfiguration.navigationHidden;
|
|
}
|
|
|
|
extern "C" int GameActivity_getOrientation(GameActivity *) {
|
|
return gConfiguration.orientation;
|
|
}
|
|
|
|
extern "C" int GameActivity_getScreenHeightDp(GameActivity *) {
|
|
return gConfiguration.screenHeightDp;
|
|
}
|
|
|
|
extern "C" int GameActivity_getScreenLayout(GameActivity *) {
|
|
return gConfiguration.screenLayout;
|
|
}
|
|
|
|
extern "C" int GameActivity_getScreenWidthDp(GameActivity *) {
|
|
return gConfiguration.screenWidthDp;
|
|
}
|
|
|
|
extern "C" int GameActivity_getSmallestScreenWidthDp(GameActivity *) {
|
|
return gConfiguration.smallestScreenWidthDp;
|
|
}
|
|
|
|
extern "C" int GameActivity_getTouchscreen(GameActivity *) {
|
|
return gConfiguration.touchscreen;
|
|
}
|
|
|
|
extern "C" int GameActivity_getUIMode(GameActivity *) {
|
|
return gConfiguration.uiMode;
|
|
}
|
|
|
|
static bool onTouchEvent_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jobject motionEvent) {
|
|
if (handle == 0) return false;
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onTouchEvent == nullptr) return false;
|
|
|
|
static GameActivityMotionEvent c_event;
|
|
GameActivityMotionEvent_fromJava(env, motionEvent, &c_event);
|
|
return code->callbacks.onTouchEvent(code, &c_event);
|
|
|
|
}
|
|
|
|
static bool onKeyUp_native(JNIEnv *env, jobject javaGameActivity, jlong handle,
|
|
jobject keyEvent) {
|
|
if (handle == 0) return false;
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onKeyUp == nullptr) return false;
|
|
|
|
static GameActivityKeyEvent c_event;
|
|
GameActivityKeyEvent_fromJava(env, keyEvent, &c_event);
|
|
return code->callbacks.onKeyUp(code, &c_event);
|
|
}
|
|
|
|
static bool onKeyDown_native(JNIEnv *env, jobject javaGameActivity,
|
|
jlong handle, jobject keyEvent) {
|
|
if (handle == 0) return false;
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onKeyDown == nullptr) return false;
|
|
|
|
static GameActivityKeyEvent c_event;
|
|
GameActivityKeyEvent_fromJava(env, keyEvent, &c_event);
|
|
return code->callbacks.onKeyDown(code, &c_event);
|
|
}
|
|
|
|
static void onTextInput_native(JNIEnv *env, jobject activity, jlong handle,
|
|
jobject textInputEvent) {
|
|
if (handle == 0) return;
|
|
NativeCode *code = (NativeCode *)handle;
|
|
GameTextInput_processEvent(code->gameTextInput, textInputEvent);
|
|
}
|
|
|
|
static void onWindowInsetsChanged_native(JNIEnv *env, jobject activity,
|
|
jlong handle) {
|
|
if (handle == 0) return;
|
|
NativeCode *code = (NativeCode *)handle;
|
|
if (code->callbacks.onWindowInsetsChanged == nullptr) return;
|
|
for (int type = 0; type < GAMECOMMON_INSETS_TYPE_COUNT; ++type) {
|
|
jobject jinsets;
|
|
// Note that waterfall insets are handled differently on the Java side.
|
|
if (type == GAMECOMMON_INSETS_TYPE_WATERFALL) {
|
|
jinsets = env->CallObjectMethod(
|
|
code->javaGameActivity,
|
|
gGameActivityClassInfo.getWaterfallInsets);
|
|
} else {
|
|
jint jtype = env->CallStaticIntMethod(
|
|
gWindowInsetsCompatTypeClassInfo.clazz,
|
|
gWindowInsetsCompatTypeClassInfo.methods[type]);
|
|
jinsets = env->CallObjectMethod(
|
|
code->javaGameActivity, gGameActivityClassInfo.getWindowInsets,
|
|
jtype);
|
|
}
|
|
ARect &insets = code->insetsState[type];
|
|
if (jinsets == nullptr) {
|
|
insets.left = 0;
|
|
insets.right = 0;
|
|
insets.top = 0;
|
|
insets.bottom = 0;
|
|
} else {
|
|
insets.left = env->GetIntField(jinsets, gInsetsClassInfo.left);
|
|
insets.right = env->GetIntField(jinsets, gInsetsClassInfo.right);
|
|
insets.top = env->GetIntField(jinsets, gInsetsClassInfo.top);
|
|
insets.bottom = env->GetIntField(jinsets, gInsetsClassInfo.bottom);
|
|
}
|
|
}
|
|
GameTextInput_processImeInsets(
|
|
code->gameTextInput, &code->insetsState[GAMECOMMON_INSETS_TYPE_IME]);
|
|
code->callbacks.onWindowInsetsChanged(code);
|
|
}
|
|
|
|
static void setInputConnection_native(JNIEnv *env, jobject activity,
|
|
jlong handle, jobject inputConnection) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
GameTextInput_setInputConnection(code->gameTextInput, inputConnection);
|
|
}
|
|
|
|
static void onContentRectChangedNative_native(JNIEnv *env, jobject activity,
|
|
jlong handle, jint x, jint y,
|
|
jint w, jint h) {
|
|
if (handle != 0) {
|
|
NativeCode *code = (NativeCode *)handle;
|
|
|
|
if (code->callbacks.onContentRectChanged != nullptr) {
|
|
ARect rect;
|
|
rect.left = x;
|
|
rect.top = y;
|
|
rect.right = x+w;
|
|
rect.bottom = y+h;
|
|
code->callbacks.onContentRectChanged(code, &rect);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const JNINativeMethod g_methods[] = {
|
|
{"initializeNativeCode",
|
|
"(Ljava/lang/String;Ljava/lang/String;"
|
|
"Ljava/lang/String;Landroid/content/res/AssetManager;"
|
|
"[BLandroid/content/res/Configuration;)J",
|
|
(void *)initializeNativeCode_native},
|
|
{"getDlError", "()Ljava/lang/String;", (void *)getDlError_native},
|
|
{"terminateNativeCode", "(J)V", (void *)terminateNativeCode_native},
|
|
{"onStartNative", "(J)V", (void *)onStart_native},
|
|
{"onResumeNative", "(J)V", (void *)onResume_native},
|
|
{"onSaveInstanceStateNative", "(J)[B", (void *)onSaveInstanceState_native},
|
|
{"onPauseNative", "(J)V", (void *)onPause_native},
|
|
{"onStopNative", "(J)V", (void *)onStop_native},
|
|
{"onConfigurationChangedNative", "(JLandroid/content/res/Configuration;)V",
|
|
(void *)onConfigurationChanged_native},
|
|
{"onTrimMemoryNative", "(JI)V", (void *)onTrimMemory_native},
|
|
{"onWindowFocusChangedNative", "(JZ)V",
|
|
(void *)onWindowFocusChanged_native},
|
|
{"onSurfaceCreatedNative", "(JLandroid/view/Surface;)V",
|
|
(void *)onSurfaceCreated_native},
|
|
{"onSurfaceChangedNative", "(JLandroid/view/Surface;III)V",
|
|
(void *)onSurfaceChanged_native},
|
|
{"onSurfaceRedrawNeededNative", "(JLandroid/view/Surface;)V",
|
|
(void *)onSurfaceRedrawNeeded_native},
|
|
{"onSurfaceDestroyedNative", "(J)V", (void *)onSurfaceDestroyed_native},
|
|
{"onTouchEventNative", "(JLandroid/view/MotionEvent;)Z",
|
|
(void *)onTouchEvent_native},
|
|
{"onKeyDownNative", "(JLandroid/view/KeyEvent;)Z",
|
|
(void *)onKeyDown_native},
|
|
{"onKeyUpNative", "(JLandroid/view/KeyEvent;)Z", (void *)onKeyUp_native},
|
|
{"onTextInputEventNative",
|
|
"(JLcom/google/androidgamesdk/gametextinput/State;)V",
|
|
(void *)onTextInput_native},
|
|
{"onWindowInsetsChangedNative", "(J)V",
|
|
(void *)onWindowInsetsChanged_native},
|
|
{"setInputConnectionNative",
|
|
"(JLcom/google/androidgamesdk/gametextinput/InputConnection;)V",
|
|
(void *)setInputConnection_native},
|
|
{"onContentRectChangedNative", "(JIIII)V",
|
|
(void *)onContentRectChangedNative_native},
|
|
};
|
|
|
|
static const char *const kGameActivityPathName =
|
|
"com/google/androidgamesdk/GameActivity";
|
|
|
|
static const char *const kInsetsPathName = "androidx/core/graphics/Insets";
|
|
static const char *const kConfigurationPathName =
|
|
"android/content/res/Configuration";
|
|
static const char *const kWindowInsetsCompatTypePathName =
|
|
"androidx/core/view/WindowInsetsCompat$Type";
|
|
|
|
#define FIND_CLASS(var, className) \
|
|
var = env->FindClass(className); \
|
|
LOG_FATAL_IF(!var, "Unable to find class %s", className);
|
|
|
|
#define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
|
|
var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
|
|
LOG_FATAL_IF(!var, "Unable to find method %s", methodName);
|
|
|
|
#define GET_STATIC_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
|
|
var = env->GetStaticMethodID(clazz, methodName, fieldDescriptor); \
|
|
LOG_FATAL_IF(!var, "Unable to find static method %s", methodName);
|
|
|
|
#define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
|
|
var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
|
|
LOG_FATAL_IF(!var, "Unable to find field %s", fieldName);
|
|
|
|
static int jniRegisterNativeMethods(JNIEnv *env, const char *className,
|
|
const JNINativeMethod *methods,
|
|
int numMethods) {
|
|
ALOGV("Registering %s's %d native methods...", className, numMethods);
|
|
jclass clazz = env->FindClass(className);
|
|
LOG_FATAL_IF(clazz == nullptr,
|
|
"Native registration unable to find class '%s'; aborting...",
|
|
className);
|
|
int result = env->RegisterNatives(clazz, methods, numMethods);
|
|
env->DeleteLocalRef(clazz);
|
|
if (result == 0) {
|
|
return 0;
|
|
}
|
|
|
|
// Failure to register natives is fatal. Try to report the corresponding
|
|
// exception, otherwise abort with generic failure message.
|
|
jthrowable thrown = env->ExceptionOccurred();
|
|
if (thrown != NULL) {
|
|
env->ExceptionDescribe();
|
|
env->DeleteLocalRef(thrown);
|
|
}
|
|
LOG_FATAL("RegisterNatives failed for '%s'; aborting...", className);
|
|
}
|
|
|
|
extern "C" int GameActivity_register(JNIEnv *env) {
|
|
ALOGD("GameActivity_register");
|
|
jclass activity_class;
|
|
FIND_CLASS(activity_class, kGameActivityPathName);
|
|
GET_METHOD_ID(gGameActivityClassInfo.finish, activity_class, "finish",
|
|
"()V");
|
|
GET_METHOD_ID(gGameActivityClassInfo.setWindowFlags, activity_class,
|
|
"setWindowFlags", "(II)V");
|
|
GET_METHOD_ID(gGameActivityClassInfo.getWindowInsets, activity_class,
|
|
"getWindowInsets", "(I)Landroidx/core/graphics/Insets;");
|
|
GET_METHOD_ID(gGameActivityClassInfo.getWaterfallInsets, activity_class,
|
|
"getWaterfallInsets", "()Landroidx/core/graphics/Insets;");
|
|
GET_METHOD_ID(gGameActivityClassInfo.setImeEditorInfoFields, activity_class,
|
|
"setImeEditorInfoFields", "(III)V");
|
|
|
|
jclass insets_class;
|
|
FIND_CLASS(insets_class, kInsetsPathName);
|
|
GET_FIELD_ID(gInsetsClassInfo.left, insets_class, "left", "I");
|
|
GET_FIELD_ID(gInsetsClassInfo.right, insets_class, "right", "I");
|
|
GET_FIELD_ID(gInsetsClassInfo.top, insets_class, "top", "I");
|
|
GET_FIELD_ID(gInsetsClassInfo.bottom, insets_class, "bottom", "I");
|
|
|
|
jclass configuration_class;
|
|
FIND_CLASS(configuration_class, kConfigurationPathName);
|
|
|
|
if (android_get_device_api_level() >= 26) {
|
|
GET_FIELD_ID(gConfigurationClassInfo.colorMode, configuration_class,
|
|
"colorMode", "I");
|
|
}
|
|
|
|
GET_FIELD_ID(gConfigurationClassInfo.densityDpi, configuration_class,
|
|
"densityDpi", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.fontScale, configuration_class,
|
|
"fontScale", "F");
|
|
|
|
if (android_get_device_api_level() >= 31) {
|
|
GET_FIELD_ID(gConfigurationClassInfo.fontWeightAdjustment,
|
|
configuration_class, "fontWeightAdjustment", "I");
|
|
}
|
|
|
|
GET_FIELD_ID(gConfigurationClassInfo.hardKeyboardHidden,
|
|
configuration_class, "hardKeyboardHidden", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.keyboard, configuration_class,
|
|
"keyboard", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.keyboardHidden, configuration_class,
|
|
"keyboardHidden", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.mcc, configuration_class, "mcc", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.mnc, configuration_class, "mnc", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.navigation, configuration_class,
|
|
"navigation", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.navigationHidden, configuration_class,
|
|
"navigationHidden", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.orientation, configuration_class,
|
|
"orientation", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.screenHeightDp, configuration_class,
|
|
"screenHeightDp", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.screenLayout, configuration_class,
|
|
"screenLayout", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.screenWidthDp, configuration_class,
|
|
"screenWidthDp", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.smallestScreenWidthDp,
|
|
configuration_class, "smallestScreenWidthDp", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.touchscreen, configuration_class,
|
|
"touchscreen", "I");
|
|
GET_FIELD_ID(gConfigurationClassInfo.uiMode, configuration_class, "uiMode",
|
|
"I");
|
|
|
|
jclass windowInsetsCompatType_class;
|
|
FIND_CLASS(windowInsetsCompatType_class, kWindowInsetsCompatTypePathName);
|
|
gWindowInsetsCompatTypeClassInfo.clazz =
|
|
(jclass)env->NewGlobalRef(windowInsetsCompatType_class);
|
|
// These names must match, in order, the GameCommonInsetsType enum fields
|
|
// Note that waterfall is handled differently by the insets API, so we
|
|
// exclude it here.
|
|
const char *methodNames[GAMECOMMON_INSETS_TYPE_WATERFALL] = {
|
|
"captionBar",
|
|
"displayCutout",
|
|
"ime",
|
|
"mandatorySystemGestures",
|
|
"navigationBars",
|
|
"statusBars",
|
|
"systemBars",
|
|
"systemGestures",
|
|
"tappableElement"};
|
|
for (int i = 0; i < GAMECOMMON_INSETS_TYPE_WATERFALL; ++i) {
|
|
GET_STATIC_METHOD_ID(gWindowInsetsCompatTypeClassInfo.methods[i],
|
|
windowInsetsCompatType_class, methodNames[i],
|
|
"()I");
|
|
}
|
|
return jniRegisterNativeMethods(env, kGameActivityPathName, g_methods,
|
|
NELEM(g_methods));
|
|
}
|
|
|
|
// XXX: This symbol is renamed with a _C suffix and then re-exported from
|
|
// Rust because Rust/Cargo don't give us a way to directly export symbols
|
|
// from C/C++ code: https://github.com/rust-lang/rfcs/issues/2771
|
|
//
|
|
extern "C" JNIEXPORT jlong JNICALL
|
|
Java_com_google_androidgamesdk_GameActivity_initializeNativeCode_C(
|
|
JNIEnv *env, jobject javaGameActivity, jstring internalDataDir,
|
|
jstring obbDir, jstring externalDataDir, jobject jAssetMgr,
|
|
jbyteArray savedState, jobject javaConfig) {
|
|
GameActivity_register(env);
|
|
jlong nativeCode = initializeNativeCode_native(
|
|
env, javaGameActivity, internalDataDir, obbDir, externalDataDir,
|
|
jAssetMgr, savedState, javaConfig);
|
|
return nativeCode;
|
|
}
|