/*
* Copyright (C) 2012, Collabora Ltd.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
* Copyright (C) 2013, Fluendo S.A.
* Author: Andoni Morales <amorales@fluendo.com>
* Copyright (C) 2014, Sebastian Dröge <sebastian@centricular.com>
* Copyright (C) 2014, Collabora Ltd.
* Author: Matthieu Bouron <matthieu.bouron@collabora.com>
* Copyright (C) 2015, Sebastian Dröge <sebastian@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <pthread.h>
#include <gmodule.h>
#include "gstjniutils.h"
static GModule *java_module;
static jint (*get_created_java_vms) (JavaVM ** vmBuf, jsize bufLen,
jsize * nVMs);
static jint (*create_java_vm) (JavaVM ** p_vm, JNIEnv ** p_env, void *vm_args);
static JavaVM *java_vm;
static gboolean started_java_vm = FALSE;
static pthread_key_t current_jni_env;
static jobject (*get_class_loader) (void);
jclass
gst_amc_jni_get_class (JNIEnv * env, GError ** err, const gchar * name)
{
jclass tmp, ret = NULL;
GST_DEBUG ("Retrieving Java class %s", name);
tmp = (*env)->FindClass (env, name);
if ((*env)->ExceptionCheck (env) || !tmp) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to find class %s", name);
goto done;
}
ret = (*env)->NewGlobalRef (env, tmp);
if (!ret) {
GST_ERROR ("Failed to get %s class global reference", name);
}
done:
if (tmp)
(*env)->DeleteLocalRef (env, tmp);
tmp = NULL;
return ret;
}
jmethodID
gst_amc_jni_get_method_id (JNIEnv * env, GError ** err, jclass klass,
const gchar * name, const gchar * signature)
{
jmethodID ret;
ret = (*env)->GetMethodID (env, klass, name, signature);
if ((*env)->ExceptionCheck (env) || !ret) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to get method ID %s (%s)", name,
signature);
}
return ret;
}
jmethodID
gst_amc_jni_get_static_method_id (JNIEnv * env, GError ** err, jclass klass,
const gchar * name, const gchar * signature)
{
jmethodID ret;
ret = (*env)->GetStaticMethodID (env, klass, name, signature);
if ((*env)->ExceptionCheck (env) || !ret) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to get static method ID %s (%s)",
name, signature);
}
return ret;
}
jfieldID
gst_amc_jni_get_field_id (JNIEnv * env, GError ** err, jclass klass,
const gchar * name, const gchar * type)
{
jfieldID ret;
ret = (*env)->GetFieldID (env, klass, name, type);
if ((*env)->ExceptionCheck (env) || !ret) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to get field ID %s (%s)", name, type);
}
return ret;
}
jfieldID
gst_amc_jni_get_static_field_id (JNIEnv * env, GError ** err, jclass klass,
const gchar * name, const gchar * type)
{
jfieldID ret;
ret = (*env)->GetStaticFieldID (env, klass, name, type);
if ((*env)->ExceptionCheck (env) || !ret) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to get static field ID %s (%s)", name,
type);
}
return ret;
}
jobject
gst_amc_jni_new_object (JNIEnv * env, GError ** err, gboolean global,
jclass klass, jmethodID constructor, ...)
{
jobject tmp;
va_list args;
va_start (args, constructor);
tmp = (*env)->NewObjectV (env, klass, constructor, args);
va_end (args);
if ((*env)->ExceptionCheck (env) || !tmp) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to create object");
return NULL;
}
if (global)
return gst_amc_jni_object_make_global (env, tmp);
else
return tmp;
}
jobject
gst_amc_jni_new_object_from_static (JNIEnv * env, GError ** err,
gboolean global, jclass klass, jmethodID method, ...)
{
jobject tmp;
va_list args;
va_start (args, method);
tmp = (*env)->CallStaticObjectMethodV (env, klass, method, args);
va_end (args);
if ((*env)->ExceptionCheck (env) || !tmp) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to create object");
return NULL;
}
if (global)
return gst_amc_jni_object_make_global (env, tmp);
else
return tmp;
}
jobject
gst_amc_jni_object_make_global (JNIEnv * env, jobject object)
{
jobject ret;
ret = (*env)->NewGlobalRef (env, object);
if (!ret) {
GST_ERROR ("Failed to create global reference");
}
gst_amc_jni_object_local_unref (env, object);
return ret;
}
jobject
gst_amc_jni_object_ref (JNIEnv * env, jobject object)
{
jobject ret;
ret = (*env)->NewGlobalRef (env, object);
if (!ret) {
GST_ERROR ("Failed to create global reference");
}
return ret;
}
void
gst_amc_jni_object_unref (JNIEnv * env, jobject object)
{
g_return_if_fail (object != NULL);
(*env)->DeleteGlobalRef (env, object);
}
void
gst_amc_jni_object_local_unref (JNIEnv * env, jobject object)
{
g_return_if_fail (object != NULL);
(*env)->DeleteLocalRef (env, object);
}
jstring
gst_amc_jni_string_from_gchar (JNIEnv * env, GError ** err,
gboolean global, const gchar * string)
{
jstring tmp;
tmp = (*env)->NewStringUTF (env, string);
if ((*env)->ExceptionCheck (env)) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to call Java method");
tmp = NULL;
}
if (global)
return gst_amc_jni_object_make_global (env, tmp);
else
return tmp;
}
gchar *
gst_amc_jni_string_to_gchar (JNIEnv * env, jstring string, gboolean release)
{
const gchar *s = NULL;
gchar *ret = NULL;
s = (*env)->GetStringUTFChars (env, string, NULL);
if (!s) {
GST_ERROR ("Failed to convert string to UTF8");
goto done;
}
ret = g_strdup (s);
(*env)->ReleaseStringUTFChars (env, string, s);
done:
if (release) {
(*env)->DeleteLocalRef (env, string);
}
return ret;
}
/* getExceptionSummary() and getStackTrace() taken from Android's
* platform/libnativehelper/JNIHelp.cpp
* Modified to work with normal C strings and without C++.
*
* Copyright (C) 2006 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.
*/
/*
* Returns a human-readable summary of an exception object. The buffer will
* be populated with the "binary" class name and, if present, the
* exception message.
*/
static gchar *
getExceptionSummary (JNIEnv * env, jthrowable exception)
{
GString *gs = g_string_new ("");
jclass exceptionClass = NULL, classClass = NULL;
jmethodID classGetNameMethod, getMessage;
jstring classNameStr = NULL, messageStr = NULL;
const char *classNameChars, *messageChars;
/* get the name of the exception's class */
exceptionClass = (*env)->GetObjectClass (env, exception);
classClass = (*env)->GetObjectClass (env, exceptionClass);
classGetNameMethod =
(*env)->GetMethodID (env, classClass, "getName", "()Ljava/lang/String;");
classNameStr =
(jstring) (*env)->CallObjectMethod (env, exceptionClass,
classGetNameMethod);
if (classNameStr == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<error getting class name>");
goto done;
}
classNameChars = (*env)->GetStringUTFChars (env, classNameStr, NULL);
if (classNameChars == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<error getting class name UTF-8>");
goto done;
}
g_string_append (gs, classNameChars);
(*env)->ReleaseStringUTFChars (env, classNameStr, classNameChars);
/* if the exception has a detail message, get that */
getMessage =
(*env)->GetMethodID (env, exceptionClass, "getMessage",
"()Ljava/lang/String;");
messageStr = (jstring) (*env)->CallObjectMethod (env, exception, getMessage);
if (messageStr == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
goto done;
}
g_string_append (gs, ": ");
messageChars = (*env)->GetStringUTFChars (env, messageStr, NULL);
if (messageChars != NULL) {
g_string_append (gs, messageChars);
(*env)->ReleaseStringUTFChars (env, messageStr, messageChars);
} else {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<error getting message>");
}
done:
if (exceptionClass)
(*env)->DeleteLocalRef (env, exceptionClass);
if (classClass)
(*env)->DeleteLocalRef (env, classClass);
if (classNameStr)
(*env)->DeleteLocalRef (env, classNameStr);
if (messageStr)
(*env)->DeleteLocalRef (env, messageStr);
return g_string_free (gs, FALSE);
}
/*
* Returns an exception (with stack trace) as a string.
*/
static gchar *
getStackTrace (JNIEnv * env, jthrowable exception)
{
GString *gs = g_string_new ("");
jclass stringWriterClass = NULL, printWriterClass = NULL;
jclass exceptionClass = NULL;
jmethodID stringWriterCtor, stringWriterToStringMethod;
jmethodID printWriterCtor, printStackTraceMethod;
jobject stringWriter = NULL, printWriter = NULL;
jstring messageStr = NULL;
const char *utfChars;
stringWriterClass = (*env)->FindClass (env, "java/io/StringWriter");
if (stringWriterClass == NULL) {
g_string_append (gs, "<error getting java.io.StringWriter class>");
goto done;
}
stringWriterCtor =
(*env)->GetMethodID (env, stringWriterClass, "<init>", "()V");
stringWriterToStringMethod =
(*env)->GetMethodID (env, stringWriterClass, "toString",
"()Ljava/lang/String;");
printWriterClass = (*env)->FindClass (env, "java/io/PrintWriter");
if (printWriterClass == NULL) {
g_string_append (gs, "<error getting java.io.PrintWriter class>");
goto done;
}
printWriterCtor =
(*env)->GetMethodID (env, printWriterClass, "<init>",
"(Ljava/io/Writer;)V");
stringWriter = (*env)->NewObject (env, stringWriterClass, stringWriterCtor);
if (stringWriter == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<error creating new StringWriter instance>");
goto done;
}
printWriter =
(*env)->NewObject (env, printWriterClass, printWriterCtor, stringWriter);
if (printWriter == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<error creating new PrintWriter instance>");
goto done;
}
exceptionClass = (*env)->GetObjectClass (env, exception);
printStackTraceMethod =
(*env)->GetMethodID (env, exceptionClass, "printStackTrace",
"(Ljava/io/PrintWriter;)V");
(*env)->CallVoidMethod (env, exception, printStackTraceMethod, printWriter);
if ((*env)->ExceptionCheck (env)) {
(*env)->ExceptionClear (env);
g_string_append (gs, "<exception while printing stack trace>");
goto done;
}
messageStr = (jstring) (*env)->CallObjectMethod (env, stringWriter,
stringWriterToStringMethod);
if (messageStr == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<failed to call StringWriter.toString()>");
goto done;
}
utfChars = (*env)->GetStringUTFChars (env, messageStr, NULL);
if (utfChars == NULL) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
g_string_append (gs, "<failed to get UTF chars for message>");
goto done;
}
g_string_append (gs, utfChars);
(*env)->ReleaseStringUTFChars (env, messageStr, utfChars);
done:
if (stringWriterClass)
(*env)->DeleteLocalRef (env, stringWriterClass);
if (printWriterClass)
(*env)->DeleteLocalRef (env, printWriterClass);
if (exceptionClass)
(*env)->DeleteLocalRef (env, exceptionClass);
if (stringWriter)
(*env)->DeleteLocalRef (env, stringWriter);
if (printWriter)
(*env)->DeleteLocalRef (env, printWriter);
if (messageStr)
(*env)->DeleteLocalRef (env, messageStr);
return g_string_free (gs, FALSE);
}
static JNIEnv *
gst_amc_jni_attach_current_thread (void)
{
JNIEnv *env;
JavaVMAttachArgs args;
gint ret;
GST_DEBUG ("Attaching thread %p", g_thread_self ());
args.version = JNI_VERSION_1_6;
args.name = NULL;
args.group = NULL;
if ((ret = (*java_vm)->AttachCurrentThread (java_vm, &env, &args)) != JNI_OK) {
GST_ERROR ("Failed to attach current thread: %d", ret);
return NULL;
}
return env;
}
static void
gst_amc_jni_detach_current_thread (void *env)
{
gint ret;
GST_DEBUG ("Detaching thread %p", g_thread_self ());
if ((ret = (*java_vm)->DetachCurrentThread (java_vm)) != JNI_OK) {
GST_DEBUG ("Failed to detach current thread: %d", ret);
}
}
static JavaVM *
get_application_java_vm (void)
{
GModule *module = NULL;
JavaVM *(*get_java_vm) (void);
JavaVM *vm = NULL;
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
if (!module) {
return NULL;
}
if (g_module_symbol (module, "gst_android_get_java_vm",
(gpointer *) & get_java_vm) && get_java_vm) {
vm = get_java_vm ();
}
g_module_close (module);
return vm;
}
static gboolean
check_nativehelper (void)
{
GModule *module;
void **jni_invocation = NULL;
gboolean ret = FALSE;
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
if (!module)
return ret;
/* Check if libnativehelper is loaded in the process and if
* it has these awful wrappers for JNI_CreateJavaVM and
* JNI_GetCreatedJavaVMs that crash the app if you don't
* create a JniInvocation instance first. If it isn't we
* just fail here and don't initialize anything.
* See this code for reference:
* https://android.googlesource.com/platform/libnativehelper/+/master/JniInvocation.cpp
*/
if (!g_module_symbol (module, "_ZN13JniInvocation15jni_invocation_E",
(gpointer *) & jni_invocation)) {
ret = TRUE;
} else {
ret = (jni_invocation != NULL && *jni_invocation != NULL);
}
g_module_close (module);
return ret;
}
static gboolean
load_java_module (const gchar * name)
{
java_module = g_module_open (name, G_MODULE_BIND_LOCAL);
if (!java_module)
goto load_failed;
if (!g_module_symbol (java_module, "JNI_CreateJavaVM",
(gpointer *) & create_java_vm)) {
GST_ERROR ("Could not find 'JNI_CreateJavaVM' in '%s': %s",
GST_STR_NULL (name), g_module_error ());
create_java_vm = NULL;
}
if (!g_module_symbol (java_module, "JNI_GetCreatedJavaVMs",
(gpointer *) & get_created_java_vms))
goto symbol_error;
return TRUE;
load_failed:
{
GST_ERROR ("Failed to load Java module '%s': %s", GST_STR_NULL (name),
g_module_error ());
return FALSE;
}
symbol_error:
{
GST_ERROR ("Failed to locate required JNI symbols in '%s': %s",
GST_STR_NULL (name), g_module_error ());
g_module_close (java_module);
java_module = NULL;
return FALSE;
}
}
static gboolean
check_application_class_loader (void)
{
gboolean ret = TRUE;
GModule *module = NULL;
module = g_module_open (NULL, G_MODULE_BIND_LOCAL);
if (!module) {
return FALSE;
}
if (!g_module_symbol (module, "gst_android_get_application_class_loader",
(gpointer *) & get_class_loader)) {
ret = FALSE;
}
g_module_close (module);
return ret;
}
static gboolean
initialize_classes (void)
{
if (!check_application_class_loader ()) {
GST_ERROR ("Could not find application class loader provider");
return FALSE;
}
return TRUE;
}
static gboolean
gst_amc_jni_initialize_java_vm (void)
{
jsize n_vms;
gint ret;
if (java_vm) {
GST_DEBUG ("Java VM already provided by the application");
return initialize_classes ();
}
java_vm = get_application_java_vm ();
if (java_vm) {
GST_DEBUG ("Java VM successfully requested from the application");
return initialize_classes ();
}
/* Returns TRUE if we can safely
* a) get the current VMs and
* b) start a VM if none is started yet
*
* FIXME: On Android >= 4.4 we won't be able to safely start a
* VM on our own without using private C++ API!
*/
if (!check_nativehelper ()) {
GST_ERROR ("Can't safely check for VMs or start a VM");
return FALSE;
}
if (!load_java_module (NULL)) {
if (!load_java_module ("libdvm"))
return FALSE;
}
n_vms = 0;
if ((ret = get_created_java_vms (&java_vm, 1, &n_vms)) != JNI_OK)
goto get_created_failed;
if (n_vms > 0) {
GST_DEBUG ("Successfully got existing Java VM %p", java_vm);
} else if (create_java_vm) {
JNIEnv *env;
JavaVMInitArgs vm_args;
JavaVMOption options[4];
GST_DEBUG ("Found no existing Java VM, trying to start one");
options[0].optionString = "-verbose:jni";
options[1].optionString = "-verbose:gc";
options[2].optionString = "-Xcheck:jni";
options[3].optionString = "-Xdebug";
vm_args.version = JNI_VERSION_1_4;
vm_args.options = options;
vm_args.nOptions = 4;
vm_args.ignoreUnrecognized = JNI_TRUE;
if ((ret = create_java_vm (&java_vm, &env, &vm_args)) != JNI_OK)
goto create_failed;
GST_DEBUG ("Successfully created Java VM %p", java_vm);
started_java_vm = TRUE;
} else {
GST_ERROR ("JNI_CreateJavaVM not available");
java_vm = NULL;
}
if (java_vm == NULL)
return FALSE;
return initialize_classes ();
get_created_failed:
{
GST_ERROR ("Failed to get already created VMs: %d", ret);
g_module_close (java_module);
java_module = NULL;
return FALSE;
}
create_failed:
{
GST_ERROR ("Failed to create a Java VM: %d", ret);
g_module_close (java_module);
java_module = NULL;
return FALSE;
}
}
static void
gst_amc_jni_set_error_string (JNIEnv * env, GError ** err, GQuark domain,
gint code, const gchar * message)
{
jthrowable exception;
if (!err) {
if ((*env)->ExceptionCheck (env))
(*env)->ExceptionClear (env);
return;
}
if ((*env)->ExceptionCheck (env)) {
if ((exception = (*env)->ExceptionOccurred (env))) {
gchar *exception_description, *exception_stacktrace;
/* Clear exception so that we can call Java methods again */
(*env)->ExceptionClear (env);
exception_description = getExceptionSummary (env, exception);
exception_stacktrace = getStackTrace (env, exception);
g_set_error (err, domain, code, "%s: %s\n%s", message,
exception_description, exception_stacktrace);
g_free (exception_description);
g_free (exception_stacktrace);
(*env)->DeleteLocalRef (env, exception);
} else {
(*env)->ExceptionClear (env);
g_set_error (err, domain, code, "%s", message);
}
} else {
g_set_error (err, domain, code, "%s", message);
}
}
G_GNUC_PRINTF (5, 6)
void gst_amc_jni_set_error (JNIEnv * env, GError ** err, GQuark domain,
gint code, const gchar * format, ...)
{
gchar *message;
va_list var_args;
va_start (var_args, format);
message = g_strdup_vprintf (format, var_args);
va_end (var_args);
gst_amc_jni_set_error_string (env, err, domain, code, message);
g_free (message);
}
static gpointer
gst_amc_jni_initialize_internal (gpointer data)
{
pthread_key_create (¤t_jni_env, gst_amc_jni_detach_current_thread);
return gst_amc_jni_initialize_java_vm ()? GINT_TO_POINTER (1) : NULL;
}
/* Allow the application to set the Java VM */
void
gst_amc_jni_set_java_vm (JavaVM * vm)
{
GST_DEBUG ("Application provides Java VM %p", vm);
java_vm = vm;
}
gboolean
gst_amc_jni_initialize (void)
{
GOnce once = G_ONCE_INIT;
g_once (&once, gst_amc_jni_initialize_internal, NULL);
return once.retval != NULL;
}
JNIEnv *
gst_amc_jni_get_env (void)
{
JNIEnv *env;
if ((env = pthread_getspecific (current_jni_env)) == NULL) {
env = gst_amc_jni_attach_current_thread ();
pthread_setspecific (current_jni_env, env);
}
return env;
}
gboolean
gst_amc_jni_is_vm_started (void)
{
return started_java_vm;
}
jclass
gst_amc_jni_get_application_class (JNIEnv * env, const gchar * name,
GError ** err)
{
jclass tmp = NULL;
jclass class = NULL;
jstring name_jstr = NULL;
jobject class_loader = NULL;
jclass class_loader_cls = NULL;
jmethodID load_class_id = 0;
GST_LOG ("attempting to retrieve class %s", name);
if (!get_class_loader) {
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
"Could not retreive application class loader function");
goto done;
}
class_loader = get_class_loader ();
if (!class_loader) {
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
"Could not retreive application class loader");
goto done;
}
class_loader_cls = (*env)->GetObjectClass (env, class_loader);
if (!class_loader_cls) {
g_set_error (err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED,
"Could not retreive application class loader java class");
goto done;
}
load_class_id =
gst_amc_jni_get_method_id (env, err, class_loader_cls, "loadClass",
"(Ljava/lang/String;)Ljava/lang/Class;");
if (!load_class_id) {
goto done;
}
name_jstr = gst_amc_jni_string_from_gchar (env, err, FALSE, name);
if (!name_jstr) {
goto done;
}
if (gst_amc_jni_call_object_method (env, err, class_loader,
load_class_id, &tmp, name_jstr)) {
class = gst_amc_jni_object_make_global (env, tmp);
}
done:
gst_amc_jni_object_local_unref (env, name_jstr);
gst_amc_jni_object_local_unref (env, class_loader_cls);
return class;
}
#define CALL_STATIC_TYPE_METHOD(_type, _name, _jname) \
gboolean gst_amc_jni_call_static_##_name##_method (JNIEnv *env, GError ** err, jclass klass, jmethodID methodID, _type * value, ...) \
{ \
gboolean ret = TRUE; \
va_list args; \
va_start(args, value); \
*value = (*env)->CallStatic##_jname##MethodV(env, klass, methodID, args); \
if ((*env)->ExceptionCheck (env)) { \
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
"Failed to call static Java method"); \
ret = FALSE; \
} \
va_end(args); \
return ret; \
}
CALL_STATIC_TYPE_METHOD (gboolean, boolean, Boolean);
CALL_STATIC_TYPE_METHOD (gint8, byte, Byte);
CALL_STATIC_TYPE_METHOD (gshort, short, Short);
CALL_STATIC_TYPE_METHOD (gint, int, Int);
CALL_STATIC_TYPE_METHOD (gchar, char, Char);
CALL_STATIC_TYPE_METHOD (gint64, long, Long);
CALL_STATIC_TYPE_METHOD (gfloat, float, Float);
CALL_STATIC_TYPE_METHOD (gdouble, double, Double);
CALL_STATIC_TYPE_METHOD (jobject, object, Object);
gboolean
gst_amc_jni_call_static_void_method (JNIEnv * env, GError ** err, jclass klass,
jmethodID methodID, ...)
{
gboolean ret = TRUE;
va_list args;
va_start (args, methodID);
(*env)->CallStaticVoidMethodV (env, klass, methodID, args);
if ((*env)->ExceptionCheck (env)) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to call static Java method");
ret = FALSE;
}
va_end (args);
return ret;
}
#define CALL_TYPE_METHOD(_type, _name, _jname) \
gboolean gst_amc_jni_call_##_name##_method (JNIEnv *env, GError ** err, jobject obj, jmethodID methodID, _type *value, ...) \
{ \
gboolean ret = TRUE; \
va_list args; \
va_start(args, value); \
*value = (*env)->Call##_jname##MethodV(env, obj, methodID, args); \
if ((*env)->ExceptionCheck (env)) { \
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
"Failed to call Java method"); \
ret = FALSE; \
} \
va_end(args); \
return ret; \
}
CALL_TYPE_METHOD (gboolean, boolean, Boolean);
CALL_TYPE_METHOD (gint8, byte, Byte);
CALL_TYPE_METHOD (gshort, short, Short);
CALL_TYPE_METHOD (gint, int, Int);
CALL_TYPE_METHOD (gchar, char, Char);
CALL_TYPE_METHOD (gint64, long, Long);
CALL_TYPE_METHOD (gfloat, float, Float);
CALL_TYPE_METHOD (gdouble, double, Double);
CALL_TYPE_METHOD (jobject, object, Object);
gboolean
gst_amc_jni_call_void_method (JNIEnv * env, GError ** err, jobject obj,
jmethodID methodID, ...)
{
gboolean ret = TRUE;
va_list args;
va_start (args, methodID);
(*env)->CallVoidMethodV (env, obj, methodID, args);
if ((*env)->ExceptionCheck (env)) {
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR,
GST_LIBRARY_ERROR_FAILED, "Failed to call Java method");
ret = FALSE;
}
va_end (args);
return ret;
}
#define GET_TYPE_FIELD(_type, _name, _jname) \
gboolean gst_amc_jni_get_##_name##_field (JNIEnv *env, GError ** err, jobject obj, jfieldID fieldID, _type *value) \
{ \
gboolean ret = TRUE; \
\
*value = (*env)->Get##_jname##Field(env, obj, fieldID); \
if ((*env)->ExceptionCheck (env)) { \
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
"Failed to get Java field"); \
ret = FALSE; \
} \
return ret; \
}
GET_TYPE_FIELD (gboolean, boolean, Boolean);
GET_TYPE_FIELD (gint8, byte, Byte);
GET_TYPE_FIELD (gshort, short, Short);
GET_TYPE_FIELD (gint, int, Int);
GET_TYPE_FIELD (gchar, char, Char);
GET_TYPE_FIELD (gint64, long, Long);
GET_TYPE_FIELD (gfloat, float, Float);
GET_TYPE_FIELD (gdouble, double, Double);
GET_TYPE_FIELD (jobject, object, Object);
#define GET_STATIC_TYPE_FIELD(_type, _name, _jname) \
gboolean gst_amc_jni_get_static_##_name##_field (JNIEnv *env, GError ** err, jclass klass, jfieldID fieldID, _type *value) \
{ \
gboolean ret = TRUE; \
\
*value = (*env)->GetStatic##_jname##Field(env, klass, fieldID); \
if ((*env)->ExceptionCheck (env)) { \
gst_amc_jni_set_error (env, err, GST_LIBRARY_ERROR, GST_LIBRARY_ERROR_FAILED, \
"Failed to get static Java field"); \
ret = FALSE; \
} \
return ret; \
}
GET_STATIC_TYPE_FIELD (gboolean, boolean, Boolean);
GET_STATIC_TYPE_FIELD (gint8, byte, Byte);
GET_STATIC_TYPE_FIELD (gshort, short, Short);
GET_STATIC_TYPE_FIELD (gint, int, Int);
GET_STATIC_TYPE_FIELD (gchar, char, Char);
GET_STATIC_TYPE_FIELD (gint64, long, Long);
GET_STATIC_TYPE_FIELD (gfloat, float, Float);
GET_STATIC_TYPE_FIELD (gdouble, double, Double);
GET_STATIC_TYPE_FIELD (jobject, object, Object);