int register_android_app_NativeActivity(JNIEnv* env)
{
//ALOGD("register_android_app_NativeActivity");
jclass clazz;
FIND_CLASS(clazz, kNativeActivityPathName);
GET_METHOD_ID(gNativeActivityClassInfo.finish,
clazz,
"finish", "()V");
GET_METHOD_ID(gNativeActivityClassInfo.setWindowFlags,
clazz,
"setWindowFlags", "(II)V");
GET_METHOD_ID(gNativeActivityClassInfo.setWindowFormat,
clazz,
"setWindowFormat", "(I)V");
GET_METHOD_ID(gNativeActivityClassInfo.showIme,
clazz,
"showIme", "(I)V");
GET_METHOD_ID(gNativeActivityClassInfo.hideIme,
clazz,
"hideIme", "(I)V");
return AndroidRuntime::registerNativeMethods(
env, kNativeActivityPathName,
g_methods, NELEM(g_methods));
}
static void jni_get (void *data_in, void *data_out)
{
struct jni_params *in_params = (struct jni_params*)data_in;
struct jni_out_params_char *out_args = (struct jni_out_params_char*)data_out;
char obj_method_name[128];
char obj_method_signature[128];
jclass class_ptr = NULL;
jobject obj = NULL;
jmethodID giid = NULL;
jstring ret_char;
snprintf(obj_method_name, sizeof(obj_method_name), "getStringExtra");
snprintf(obj_method_signature, sizeof(obj_method_signature), "(Ljava/lang/String;)Ljava/lang/String;");
GET_OBJECT_CLASS(in_params->env, class_ptr, in_params->class_obj);
GET_METHOD_ID(in_params->env, giid, class_ptr, in_params->method_name, in_params->method_signature);
CALL_OBJ_METHOD(in_params->env, obj, in_params->class_obj, giid);
GET_OBJECT_CLASS(in_params->env, class_ptr, obj);
GET_METHOD_ID(in_params->env, giid, class_ptr, obj_method_name, obj_method_signature);
CALL_OBJ_METHOD_PARAM(in_params->env, ret_char, obj, giid, (*in_params->env)->NewStringUTF(in_params->env, out_args->in));
if (giid != NULL && ret_char)
{
const char *test_argv = (*in_params->env)->GetStringUTFChars(in_params->env, ret_char, 0);
strncpy(out_args->out, test_argv, out_args->out_sizeof);
(*in_params->env)->ReleaseStringUTFChars(in_params->env, ret_char, test_argv);
}
}
int register_android_server_PowerManagerService(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/power/PowerManagerService",
gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
// Callbacks
jclass clazz;
FIND_CLASS(clazz, "com/android/server/power/PowerManagerService");
GET_METHOD_ID(gPowerManagerServiceClassInfo.wakeUpFromNative, clazz,
"wakeUpFromNative", "(J)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.goToSleepFromNative, clazz,
"goToSleepFromNative", "(JI)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivityFromNative, clazz,
"userActivityFromNative", "(JII)V");
// Initialize
for (int i = 0; i <= USER_ACTIVITY_EVENT_LAST; i++) {
gLastEventTime[i] = LLONG_MIN;
}
gScreenOn = true;
gScreenBright = true;
gPowerManagerServiceObj = NULL;
gPowerModule = NULL;
return 0;
}
static jlong nativeInit(JNIEnv* env, jclass clazz, jobject callbacksObj,
jobject messageQueueObj) {
int err;
hw_module_t* module;
err = hw_get_module(HDMI_CEC_HARDWARE_MODULE_ID,
const_cast<const hw_module_t **>(&module));
if (err != 0) {
ALOGE("Error acquiring hardware module: %d", err);
return 0;
}
hw_device_t* device;
err = module->methods->open(module, HDMI_CEC_HARDWARE_INTERFACE, &device);
if (err != 0) {
ALOGE("Error opening hardware module: %d", err);
return 0;
}
sp<MessageQueue> messageQueue =
android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
HdmiCecController* controller = new HdmiCecController(
reinterpret_cast<hdmi_cec_device*>(device),
env->NewGlobalRef(callbacksObj),
messageQueue->getLooper());
controller->init();
GET_METHOD_ID(gHdmiCecControllerClassInfo.handleIncomingCecCommand, clazz,
"handleIncomingCecCommand", "(II[B)V");
GET_METHOD_ID(gHdmiCecControllerClassInfo.handleHotplug, clazz,
"handleHotplug", "(IZ)V");
return reinterpret_cast<jlong>(controller);
}
JNIEXPORT void JNICALL
Java_sun_awt_gtk_GFramePeer_initIDs (JNIEnv *env, jclass cls)
{
GET_FIELD_ID (GFramePeer_menuBarHeightFID, "menuBarHeight", "I");
GET_METHOD_ID (GFramePeer_postWindowIconifiedMID, "postWindowIconified", "()V");
GET_METHOD_ID (GFramePeer_postWindowDeiconifiedMID, "postWindowDeiconified", "()V");
awt_gtk_threadsEnter();
WM_STATE = gdk_atom_intern ("WM_STATE", FALSE);
awt_gtk_threadsLeave();
}
/**
* JNI Functions
*/
JNIEXPORT void JNICALL
Java_sun_awt_pocketpc_PPCTextComponentPeer_initIDs (JNIEnv *env, jclass cls)
{
GET_METHOD_ID(PPCTextComponentPeer_valueChangedMID, "valueChanged", "()V");
cls = env->FindClass( "java/awt/TextArea" );
if ( cls == NULL )
return;
WCachedIDs.java_awt_TextAreaClass = (jclass) env->NewGlobalRef (cls);
GET_METHOD_ID( java_awt_TextArea_getScrollbarVisibilityMID,
"getScrollbarVisibility", "()I");
}
int register_android_view_InputDevice(JNIEnv* env)
{
FIND_CLASS(gInputDeviceClassInfo.clazz, "android/view/InputDevice");
gInputDeviceClassInfo.clazz = jclass(env->NewGlobalRef(gInputDeviceClassInfo.clazz));
GET_METHOD_ID(gInputDeviceClassInfo.ctor, gInputDeviceClassInfo.clazz,
"<init>", "(IILjava/lang/String;Ljava/lang/String;ZIILandroid/view/KeyCharacterMap;Z)V");
GET_METHOD_ID(gInputDeviceClassInfo.addMotionRange, gInputDeviceClassInfo.clazz,
"addMotionRange", "(IIFFFFF)V");
return 0;
}
JNIEXPORT void JNICALL
Java_sun_awt_pocketpc_PPCCheckboxPeer_initIDs (JNIEnv *env, jclass cls) {
GET_METHOD_ID (PPCCheckboxPeer_handleActionMID,
"handleAction", "(Z)V");
cls = env->FindClass ("java/awt/Checkbox");
if (cls == NULL)
return;
GET_METHOD_ID (java_awt_Checkbox_getLabelMID,
"getLabel", "()Ljava/lang/String;");
GET_METHOD_ID (java_awt_Checkbox_getStateMID,
"getState", "()Z");
GET_METHOD_ID (java_awt_Checkbox_getCheckboxGroupMID,
"getCheckboxGroup", "()Ljava/awt/CheckboxGroup;");
}
int register_android_view_DisplayEventReceiver(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/DisplayEventReceiver",
gMethods, NELEM(gMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
FIND_CLASS(gDisplayEventReceiverClassInfo.clazz, "android/view/DisplayEventReceiver");
GET_METHOD_ID(gDisplayEventReceiverClassInfo.dispatchVsync,
gDisplayEventReceiverClassInfo.clazz,
"dispatchVsync", "(JII)V");
GET_METHOD_ID(gDisplayEventReceiverClassInfo.dispatchHotplug,
gDisplayEventReceiverClassInfo.clazz,
"dispatchHotplug", "(J*Z)V");
return 0;
}
JNIEXPORT void JNICALL
Java_sun_awt_pocketpc_PPCChoicePeer_initIDs( JNIEnv *env, jclass cls )
{
GET_METHOD_ID( PPCChoicePeer_handleActionMID,
"handleAction", "(I)V" );
return;
}
static void nativeInit(JNIEnv *env, jobject clazz, jobject callbackObj) {
ALOG(LOG_VERBOSE, LOG_TAG, "nativeInit()\n");
FIND_CLASS(gFingerprintServiceClassInfo.clazz, FINGERPRINT_SERVICE);
GET_METHOD_ID(gFingerprintServiceClassInfo.notify, gFingerprintServiceClassInfo.clazz,
"notify", "(III)V");
gFingerprintServiceClassInfo.callbackObject = env->NewGlobalRef(callbackObj);
}
int register_android_view_KeyEvent(JNIEnv* env) {
FIND_CLASS(gKeyEventClassInfo.clazz, "android/view/KeyEvent");
GET_STATIC_METHOD_ID(gKeyEventClassInfo.obtain, gKeyEventClassInfo.clazz,
"obtain", "(JJIIIIIIIILjava/lang/String;)Landroid/view/KeyEvent;");
GET_METHOD_ID(gKeyEventClassInfo.recycle, gKeyEventClassInfo.clazz,
"recycle", "()V");
GET_FIELD_ID(gKeyEventClassInfo.mDeviceId, gKeyEventClassInfo.clazz,
"mDeviceId", "I");
GET_FIELD_ID(gKeyEventClassInfo.mSource, gKeyEventClassInfo.clazz,
"mSource", "I");
GET_FIELD_ID(gKeyEventClassInfo.mMetaState, gKeyEventClassInfo.clazz,
"mMetaState", "I");
GET_FIELD_ID(gKeyEventClassInfo.mAction, gKeyEventClassInfo.clazz,
"mAction", "I");
GET_FIELD_ID(gKeyEventClassInfo.mKeyCode, gKeyEventClassInfo.clazz,
"mKeyCode", "I");
GET_FIELD_ID(gKeyEventClassInfo.mScanCode, gKeyEventClassInfo.clazz,
"mScanCode", "I");
GET_FIELD_ID(gKeyEventClassInfo.mRepeatCount, gKeyEventClassInfo.clazz,
"mRepeatCount", "I");
GET_FIELD_ID(gKeyEventClassInfo.mFlags, gKeyEventClassInfo.clazz,
"mFlags", "I");
GET_FIELD_ID(gKeyEventClassInfo.mDownTime, gKeyEventClassInfo.clazz,
"mDownTime", "J");
GET_FIELD_ID(gKeyEventClassInfo.mEventTime, gKeyEventClassInfo.clazz,
"mEventTime", "J");
GET_FIELD_ID(gKeyEventClassInfo.mCharacters, gKeyEventClassInfo.clazz,
"mCharacters", "Ljava/lang/String;");
return AndroidRuntime::registerNativeMethods(
env, "android/view/KeyEvent", g_methods, NELEM(g_methods));
}
int register_android_server_AssetAtlasService(JNIEnv* env) {
jclass clazz;
FIND_CLASS(clazz, "android/graphics/Canvas");
GET_METHOD_ID(gCanvasClassInfo.setNativeBitmap, clazz, "setNativeBitmap", "(J)V");
return jniRegisterNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
int register_android_server_fingerprint_FingerprintService(JNIEnv* env) {
FIND_CLASS(gFingerprintServiceClassInfo.clazz, FINGERPRINT_SERVICE);
GET_METHOD_ID(gFingerprintServiceClassInfo.notify, gFingerprintServiceClassInfo.clazz, "notify",
"(III)V");
int result = AndroidRuntime::registerNativeMethods(
env, FINGERPRINT_SERVICE, g_methods, NELEM(g_methods));
ALOG(LOG_VERBOSE, LOG_TAG, "FingerprintManager JNI ready.\n");
return result;
}
int register_android_view_InputQueue(JNIEnv* env)
{
jclass clazz;
FIND_CLASS(clazz, kInputQueuePathName);
GET_METHOD_ID(gInputQueueClassInfo.finishInputEvent, clazz, "finishInputEvent", "(JZ)V");
return AndroidRuntime::registerNativeMethods(
env, kInputQueuePathName,
g_methods, NELEM(g_methods));
}
JNIEXPORT void JNICALL
Java_sun_awt_gtk_GScrollbarPeer_initIDs (JNIEnv *env, jclass cls)
{
GET_METHOD_ID (GScrollbarPeer_postAdjustmentEvent, "postAdjustmentEvent", "(II)V");
cls = (*env)->FindClass (env, "java/awt/Scrollbar");
if (cls == NULL)
return;
GET_FIELD_ID (java_awt_Scrollbar_valueFID, "value", "I");
}
JNIEXPORT void JNICALL
Java_sun_awt_gtk_GChoicePeer_initIDs (JNIEnv *env, jclass cls)
{
GET_METHOD_ID (GChoicePeer_postItemEventMID, "postItemEvent", "(I)V");
cls = (*env)->FindClass (env, "java/awt/Choice");
if (cls == NULL)
return;
GET_FIELD_ID (java_awt_Choice_selectedIndexFID, "selectedIndex", "I");
}
int register_android_view_MotionEvent(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/MotionEvent",
gMotionEventMethods, NELEM(gMotionEventMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
(void)res;
FIND_CLASS(gMotionEventClassInfo.clazz, "android/view/MotionEvent");
gMotionEventClassInfo.clazz = jclass(env->NewGlobalRef(gMotionEventClassInfo.clazz));
GET_STATIC_METHOD_ID(gMotionEventClassInfo.obtain, gMotionEventClassInfo.clazz,
"obtain", "()Landroid/view/MotionEvent;");
GET_METHOD_ID(gMotionEventClassInfo.recycle, gMotionEventClassInfo.clazz,
"recycle", "()V");
GET_FIELD_ID(gMotionEventClassInfo.mNativePtr, gMotionEventClassInfo.clazz,
"mNativePtr", "J");
jclass clazz;
FIND_CLASS(clazz, "android/view/MotionEvent$PointerCoords");
GET_FIELD_ID(gPointerCoordsClassInfo.mPackedAxisBits, clazz,
"mPackedAxisBits", "J");
GET_FIELD_ID(gPointerCoordsClassInfo.mPackedAxisValues, clazz,
"mPackedAxisValues", "[F");
GET_FIELD_ID(gPointerCoordsClassInfo.x, clazz,
"x", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.y, clazz,
"y", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.pressure, clazz,
"pressure", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.size, clazz,
"size", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.touchMajor, clazz,
"touchMajor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.touchMinor, clazz,
"touchMinor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.toolMajor, clazz,
"toolMajor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.toolMinor, clazz,
"toolMinor", "F");
GET_FIELD_ID(gPointerCoordsClassInfo.orientation, clazz,
"orientation", "F");
FIND_CLASS(clazz, "android/view/MotionEvent$PointerProperties");
GET_FIELD_ID(gPointerPropertiesClassInfo.id, clazz,
"id", "I");
GET_FIELD_ID(gPointerPropertiesClassInfo.toolType, clazz,
"toolType", "I");
return 0;
}
int register_android_server_PowerManagerService(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/PowerManagerService",
gPowerManagerServiceMethods, NELEM(gPowerManagerServiceMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
// Callbacks
FIND_CLASS(gPowerManagerServiceClassInfo.clazz, "com/android/server/PowerManagerService");
GET_METHOD_ID(gPowerManagerServiceClassInfo.goToSleep, gPowerManagerServiceClassInfo.clazz,
"goToSleep", "(J)V");
GET_METHOD_ID(gPowerManagerServiceClassInfo.userActivity, gPowerManagerServiceClassInfo.clazz,
"userActivity", "(JZIZ)V");
// Initialize
for (int i = 0; i < POWER_MANAGER_LAST_EVENT; i++) {
gLastEventTime[i] = LLONG_MIN;
}
gScreenOn = true;
gScreenBright = true;
return 0;
}
int register_android_view_InputChannel(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "android/view/InputChannel",
gInputChannelMethods, NELEM(gInputChannelMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
FIND_CLASS(gInputChannelClassInfo.clazz, "android/view/InputChannel");
GET_FIELD_ID(gInputChannelClassInfo.mPtr, gInputChannelClassInfo.clazz,
"mPtr", "I");
GET_METHOD_ID(gInputChannelClassInfo.ctor, gInputChannelClassInfo.clazz,
"<init>", "()V");
return 0;
}
static void input_autodetect_get_device_name(void *data, char *buf, size_t size, int id)
{
struct android_app *android_app = (struct android_app*)data;
buf[0] = '\0';
JavaVM *vm = android_app->activity->vm;
JNIEnv *env = NULL;
(*vm)->AttachCurrentThread(vm, &env, 0);
jclass input_device_class = NULL;
FIND_CLASS(env, input_device_class, "android/view/InputDevice");
if (!input_device_class)
goto end;
jmethodID method = NULL;
GET_STATIC_METHOD_ID(env, method, input_device_class, "getDevice", "(I)Landroid/view/InputDevice;");
if (!method)
goto end;
jobject device = NULL;
CALL_OBJ_STATIC_METHOD_PARAM(env, device, input_device_class, method, (jint)id);
if (!device)
{
RARCH_ERR("Failed to find device for ID: %d\n", id);
goto end;
}
jmethodID getName = NULL;
GET_METHOD_ID(env, getName, input_device_class, "getName", "()Ljava/lang/String;");
if (!getName)
goto end;
jobject name = NULL;
CALL_OBJ_METHOD(env, name, device, getName);
if (!name)
{
RARCH_ERR("Failed to find name for device ID: %d\n", id);
goto end;
}
const char *str = (*env)->GetStringUTFChars(env, name, 0);
if (str)
strlcpy(buf, str, size);
(*env)->ReleaseStringUTFChars(env, name, str);
end:
(*vm)->DetachCurrentThread(vm);
}
JNIEXPORT void JNICALL
Java_sun_awt_gtk_GScrollPanePeer_initIDs (JNIEnv *env, jclass cls)
{
cls = (*env)->FindClass (env, "java/awt/ScrollPane");
if (cls == NULL)
return;
GET_FIELD_ID (java_awt_ScrollPane_scrollbarDisplayPolicyFID, "scrollbarDisplayPolicy", "I");
cls = (*env)->FindClass (env, "sun/awt/gtk/GScrollPanePeer");
if (cls == NULL)
return;
GET_METHOD_ID (GScrollPanePeer_postAdjustableEventMID, "postAdjustableEvent", "(Ljava/awt/Adjustable;I)V");
}
int register_android_view_GraphicBuffer(JNIEnv* env) {
jclass clazz;
FIND_CLASS(clazz, "android/view/GraphicBuffer");
GET_FIELD_ID(gGraphicBufferClassInfo.mNativeObject, clazz, "mNativeObject", "J");
FIND_CLASS(clazz, "android/graphics/Rect");
GET_METHOD_ID(gRectClassInfo.set, clazz, "set", "(IIII)V");
GET_FIELD_ID(gRectClassInfo.left, clazz, "left", "I");
GET_FIELD_ID(gRectClassInfo.top, clazz, "top", "I");
GET_FIELD_ID(gRectClassInfo.right, clazz, "right", "I");
GET_FIELD_ID(gRectClassInfo.bottom, clazz, "bottom", "I");
FIND_CLASS(clazz, "android/graphics/Canvas");
GET_FIELD_ID(gCanvasClassInfo.mFinalizer, clazz, "mFinalizer",
"Landroid/graphics/Canvas$CanvasFinalizer;");
GET_FIELD_ID(gCanvasClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
GET_FIELD_ID(gCanvasClassInfo.mSurfaceFormat, clazz, "mSurfaceFormat", "I");
FIND_CLASS(clazz, "android/graphics/Canvas$CanvasFinalizer");
GET_FIELD_ID(gCanvasFinalizerClassInfo.mNativeCanvas, clazz, "mNativeCanvas", "J");
return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
static bool android_gfx_ctx_get_metrics(void *data,
enum display_metric_types type, float *value)
{
jclass metrics_class;
jobject metrics;
jmethodID getMetrics;
struct android_app *android_app = (struct android_app*)g_android;
JNIEnv *env = (JNIEnv*)jni_thread_getenv();
GET_METHOD_ID(env, getMetrics, android_app->activity, "getMetrics", "()Landroid/util/DisplayMetrics;");
if (!getMetrics)
goto error;
CALL_OBJ_STATIC_METHOD(env, metrics, android_app->activity, getMetrics);
GET_OBJECT_CLASS(env, metrics_class, metrics);
/* Density */
float density = (*env)->GetFloatField(env, metrics, (*env)->GetFieldID(env, metrics_class, "density", "F"));
float scaled_density = (*env)->GetFloatField(env, metrics, (*env)->GetFieldID(env, metrics_class, "scaledDensity", "F"));
int density_dpi = (*env)->GetIntField(env, metrics, (*env)->GetFieldID(env, metrics_class, "densityDpi", "I"));
/* Size */
int width_pixels = (*env)->GetIntField(env, metrics, (*env)->GetFieldID(env, metrics_class, "widthPixels", "I"));
int height_pixels = (*env)->GetIntField(env, metrics, (*env)->GetFieldID(env, metrics_class, "heightPixels", "I"));
/* DPI */
/* Apparently xdpi and ydpi can't be trusted to be implemented correctly, so don't try to rely on it...
*
* https://groups.google.com/forum/#!topic/android-developers/QjUlaRohRPI
*
* "The xdpi and ydpi are supposed to be the real DPI of the screen... though as you've seen,
* many devices don't set it correctly. :( This is our fault, it isn't actually used anywhere
* in the platform, so people don't realize they have a bad value, and we haven't had a CTS
* test to try to make sure it is sane (it's not clear how that test should work). Worse, we
* shipping the original Droid with a graphics driver that reports the wrong value here...
* in fact that reported that same damnable 96."
*
* Unfortunately, I don't have a good solution if you want to get the real exactly screen dots per inch.
* One thing you could do is compare xdpi/ydpi with densityDpi and if they are significantly
* far apart, assume the values are bad and just fall back on densityDpi as an approximation.
*
* Be careful on this, because a correctly working device may have densityDpi fairly different
* than the real dpi -- for example the Samsung TAB uses high density even though its screen's
* really density is a fair amount lower than 240."
*/
float xdpi = (*env)->GetFloatField(env, metrics, (*env)->GetFieldID(env, metrics_class, "xdpi", "F"));
float ydpi = (*env)->GetFloatField(env, metrics, (*env)->GetFieldID(env, metrics_class, "ydpi", "F"));
(void)width_pixels;
(void)height_pixels;
(void)scaled_density;
(void)density;
(void)density_dpi;
switch (type)
{
case DISPLAY_METRIC_MM_WIDTH:
/* can't guarantee this to be accurate - so return false anyway. */
*value = xdpi;
return false;
case DISPLAY_METRIC_MM_HEIGHT:
/* can't guarantee this to be accurate - so return false anyway. */
*value = ydpi;
return false;
case DISPLAY_METRIC_DPI:
/* just go with quantized DPI. */
*value = density_dpi;
break;
case DISPLAY_METRIC_NONE:
default:
*value = 0;
return false;
}
return true;
error:
return false;
}
JNIEXPORT void JNICALL
Java_sun_awt_gtk_GTextFieldPeer_initIDs (JNIEnv *env, jclass cls)
{
GET_METHOD_ID (GTextFieldPeer_postActionEventMID, "postActionEvent", "()V");
}
int register_android_server_tv_TvInputHal(JNIEnv* env) {
int res = jniRegisterNativeMethods(env, "com/android/server/tv/TvInputHal",
gTvInputHalMethods, NELEM(gTvInputHalMethods));
LOG_FATAL_IF(res < 0, "Unable to register native methods.");
(void)res; // Don't complain about unused variable in the LOG_NDEBUG case
jclass clazz;
FIND_CLASS(clazz, "com/android/server/tv/TvInputHal");
GET_METHOD_ID(
gTvInputHalClassInfo.deviceAvailable, clazz,
"deviceAvailableFromNative", "(Landroid/media/tv/TvInputHardwareInfo;)V");
GET_METHOD_ID(
gTvInputHalClassInfo.deviceUnavailable, clazz, "deviceUnavailableFromNative", "(I)V");
GET_METHOD_ID(
gTvInputHalClassInfo.streamConfigsChanged, clazz,
"streamConfigsChangedFromNative", "(I)V");
GET_METHOD_ID(
gTvInputHalClassInfo.firstFrameCaptured, clazz,
"firstFrameCapturedFromNative", "(II)V");
FIND_CLASS(gTvStreamConfigClassInfo.clazz, "android/media/tv/TvStreamConfig");
gTvStreamConfigClassInfo.clazz = jclass(env->NewGlobalRef(gTvStreamConfigClassInfo.clazz));
FIND_CLASS(gTvStreamConfigBuilderClassInfo.clazz, "android/media/tv/TvStreamConfig$Builder");
gTvStreamConfigBuilderClassInfo.clazz =
jclass(env->NewGlobalRef(gTvStreamConfigBuilderClassInfo.clazz));
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.constructor,
gTvStreamConfigBuilderClassInfo.clazz,
"<init>", "()V");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.streamId,
gTvStreamConfigBuilderClassInfo.clazz,
"streamId", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.type,
gTvStreamConfigBuilderClassInfo.clazz,
"type", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.maxWidth,
gTvStreamConfigBuilderClassInfo.clazz,
"maxWidth", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.maxHeight,
gTvStreamConfigBuilderClassInfo.clazz,
"maxHeight", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.generation,
gTvStreamConfigBuilderClassInfo.clazz,
"generation", "(I)Landroid/media/tv/TvStreamConfig$Builder;");
GET_METHOD_ID(
gTvStreamConfigBuilderClassInfo.build,
gTvStreamConfigBuilderClassInfo.clazz,
"build", "()Landroid/media/tv/TvStreamConfig;");
FIND_CLASS(gTvInputHardwareInfoBuilderClassInfo.clazz,
"android/media/tv/TvInputHardwareInfo$Builder");
gTvInputHardwareInfoBuilderClassInfo.clazz =
jclass(env->NewGlobalRef(gTvInputHardwareInfoBuilderClassInfo.clazz));
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.constructor,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"<init>", "()V");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.deviceId,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"deviceId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.type,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"type", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.hdmiPortId,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"hdmiPortId", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.audioType,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"audioType", "(I)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.audioAddress,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"audioAddress", "(Ljava/lang/String;)Landroid/media/tv/TvInputHardwareInfo$Builder;");
GET_METHOD_ID(
gTvInputHardwareInfoBuilderClassInfo.build,
gTvInputHardwareInfoBuilderClassInfo.clazz,
"build", "()Landroid/media/tv/TvInputHardwareInfo;");
return 0;
}
/* Get Java object IDs (via FindClass, GetMethodID, GetFieldID, etc).
* Note that this function should be called from library-loader thread,
* otherwise FindClass, etc, may fail, see:
* http://developer.android.com/training/articles/perf-jni.html#faq_FindClass
*/
static pj_status_t jni_init_ids()
{
JNIEnv *jni_env;
pj_status_t status = PJ_SUCCESS;
pj_bool_t with_attach = jni_get_env(&jni_env);
#define GET_CLASS(class_path, class_name, cls) \
cls = (*jni_env)->FindClass(jni_env, class_path); \
if (cls == NULL || (*jni_env)->ExceptionCheck(jni_env)) { \
(*jni_env)->ExceptionClear(jni_env); \
PJ_LOG(3, (THIS_FILE, "[JNI] Unable to find class '" \
class_name "'")); \
status = PJMEDIA_EVID_SYSERR; \
goto on_return; \
} else { \
jclass tmp = cls; \
cls = (jclass)(*jni_env)->NewGlobalRef(jni_env, tmp); \
(*jni_env)->DeleteLocalRef(jni_env, tmp); \
if (cls == NULL) { \
PJ_LOG(3, (THIS_FILE, "[JNI] Unable to get global ref for " \
"class '" class_name "'")); \
status = PJMEDIA_EVID_SYSERR; \
goto on_return; \
} \
}
#define GET_METHOD_ID(cls, class_name, method_name, signature, id) \
id = (*jni_env)->GetMethodID(jni_env, cls, method_name, signature); \
if (id == 0) { \
PJ_LOG(3, (THIS_FILE, "[JNI] Unable to find method '" method_name \
"' in class '" class_name "'")); \
status = PJMEDIA_EVID_SYSERR; \
goto on_return; \
}
#define GET_SMETHOD_ID(cls, class_name, method_name, signature, id) \
id = (*jni_env)->GetStaticMethodID(jni_env, cls, method_name, signature); \
if (id == 0) { \
PJ_LOG(3, (THIS_FILE, "[JNI] Unable to find static method '" \
method_name "' in class '" class_name "'")); \
status = PJMEDIA_EVID_SYSERR; \
goto on_return; \
}
#define GET_FIELD_ID(cls, class_name, field_name, signature, id) \
id = (*jni_env)->GetFieldID(jni_env, cls, field_name, signature); \
if (id == 0) { \
PJ_LOG(3, (THIS_FILE, "[JNI] Unable to find field '" field_name \
"' in class '" class_name "'")); \
status = PJMEDIA_EVID_SYSERR; \
goto on_return; \
}
/* PjCamera class info */
GET_CLASS(PJ_CAMERA_CLASS_PATH, "PjCamera", jobjs.cam.cls);
GET_METHOD_ID(jobjs.cam.cls, "PjCamera", "<init>",
"(IIIIIJLandroid/view/SurfaceView;)V",
jobjs.cam.m_init);
GET_METHOD_ID(jobjs.cam.cls, "PjCamera", "Start", "()I",
jobjs.cam.m_start);
GET_METHOD_ID(jobjs.cam.cls, "PjCamera", "Stop", "()V",
jobjs.cam.m_stop);
GET_METHOD_ID(jobjs.cam.cls, "PjCamera", "SwitchDevice", "(I)I",
jobjs.cam.m_switch);
/* PjCameraInfo class info */
GET_CLASS(PJ_CAMERA_INFO_CLASS_PATH, "PjCameraInfo", jobjs.cam_info.cls);
GET_SMETHOD_ID(jobjs.cam_info.cls, "PjCameraInfo", "GetCameraCount", "()I",
jobjs.cam_info.m_get_cnt);
GET_SMETHOD_ID(jobjs.cam_info.cls, "PjCameraInfo", "GetCameraInfo",
"(I)L" PJ_CAMERA_INFO_CLASS_PATH ";",
jobjs.cam_info.m_get_info);
GET_FIELD_ID(jobjs.cam_info.cls, "PjCameraInfo", "facing", "I",
jobjs.cam_info.f_facing);
GET_FIELD_ID(jobjs.cam_info.cls, "PjCameraInfo", "orient", "I",
jobjs.cam_info.f_orient);
GET_FIELD_ID(jobjs.cam_info.cls, "PjCameraInfo", "supportedSize", "[I",
jobjs.cam_info.f_sup_size);
GET_FIELD_ID(jobjs.cam_info.cls, "PjCameraInfo", "supportedFormat", "[I",
jobjs.cam_info.f_sup_fmt);
GET_FIELD_ID(jobjs.cam_info.cls, "PjCameraInfo", "supportedFps1000", "[I",
jobjs.cam_info.f_sup_fps);
#undef GET_CLASS_ID
#undef GET_METHOD_ID
#undef GET_SMETHOD_ID
#undef GET_FIELD_ID
/* Register native function */
{
JNINativeMethod m = { "PushFrame", "([BIJ)V", (void*)&OnGetFrame };
if ((*jni_env)->RegisterNatives(jni_env, jobjs.cam.cls, &m, 1)) {
PJ_LOG(3, (THIS_FILE, "[JNI] Failed in registering native "
"function 'OnGetFrame()'"));
status = PJMEDIA_EVID_SYSERR;
}
}
on_return:
jni_detach_env(with_attach);
return status;
}
/**
* JNI Functions
*/
JNIEXPORT void JNICALL
Java_sun_awt_pocketpc_PPCTextFieldPeer_initIDs (JNIEnv *env, jclass cls)
{
GET_METHOD_ID (PPCTextFieldPeer_handleActionMID, "handleAction", "()V");
}
