| /* GConfNativePeer.c -- Implements native methods for class GConfNativePeer |
| Copyright (C) 2003, 2004 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <jni.h> |
| |
| #include <glib.h> |
| #include <gdk/gdk.h> |
| #include <gconf/gconf-client.h> |
| |
| #include "jcl.h" |
| |
| #include "gnu_java_util_prefs_gconf_GConfNativePeer.h" |
| |
| /* |
| * Cached id, methods and objects |
| */ |
| |
| /** Reference count */ |
| static int reference_count = 0; |
| |
| /** GConfEngine backend */ |
| static GConfEngine *engine = NULL; |
| |
| /** java.util.ArrayList class */ |
| static jclass jlist_class = NULL; |
| |
| /** java.util.ArrayList constructor id */ |
| static jmethodID jlist_init_id = NULL; |
| |
| /** ava.util.ArrayList add id */ |
| static jmethodID jlist_add_id = NULL; |
| |
| /* ***** PRIVATE FUNCTIONS DELCARATION ***** */ |
| |
| /** |
| * Gets the reference of the default GConfEngine.. |
| * The client reference should be released with g_object_unref after use. |
| */ |
| static void init_gconf (void); |
| |
| /** |
| * Throws a new runtime exception after a failure, with the given message. |
| */ |
| static void throw_exception (JNIEnv * env, const char *msg); |
| |
| /** |
| * Throws the given exception after a failure, with the given message. |
| */ |
| static void |
| throw_exception_by_name (JNIEnv * env, const char *name, const char *msg); |
| |
| /** |
| * Return a reference to a java.util.ArrayList class. |
| */ |
| static gboolean set_jlist_class (JNIEnv * env); |
| |
| /** |
| * Builds a new reference to a new java.util.ArrayList instace. |
| * The instance should be freed by the caller after use. |
| */ |
| static jclass get_jlist_reference (JNIEnv * env, jclass jlist_class); |
| |
| /* ***** END: PRIVATE FUNCTIONS DELCARATION ***** */ |
| |
| /* ***** NATIVE FUNCTIONS ***** */ |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: init_class |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1class |
| (JNIEnv *env, jclass clazz) |
| { |
| if (reference_count == 0) |
| { |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1id_1cache |
| (env, clazz); |
| return; |
| } |
| |
| reference_count++; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: init_id_chache |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_init_1id_1cache |
| (JNIEnv *env, jclass clazz __attribute__ ((unused))) |
| { |
| reference_count++; |
| |
| init_gconf (); |
| |
| /* if engine is null, there is probably an out of memory */ |
| if (engine == NULL) |
| { |
| /* release the string and throw a runtime exception */ |
| throw_exception (env, |
| "Unable to initialize GConfEngine in native code\n"); |
| return; |
| } |
| |
| /* ***** java.util.ArrayList ***** */ |
| if (set_jlist_class (env) == FALSE) |
| { |
| throw_exception (env, |
| "Unable to get valid reference to java.util.List in native code\n"); |
| return; |
| } |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_all_keys |
| * Signature: (Ljava/lang/String;)Ljava/util/List; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1all_1keys |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) |
| { |
| /* TODO: check all the calls to gdk_threads_enter/leave */ |
| |
| const char *dir = NULL; |
| const char *_val = NULL; |
| const char *_val_unescaped = NULL; |
| |
| GError *err = NULL; |
| GSList *entries = NULL; |
| GSList *tmp; |
| |
| /* java.util.ArrayList */ |
| jobject jlist = NULL; |
| |
| dir = JCL_jstring_to_cstring (env, node); |
| if (dir == NULL) |
| { |
| return NULL; |
| } |
| |
| entries = gconf_engine_all_entries (engine, dir, &err); |
| if (err != NULL) |
| { |
| throw_exception_by_name (env, "java/util/prefs/BackingStoreException", |
| err->message); |
| g_error_free (err); |
| err = NULL; |
| |
| JCL_free_cstring (env, node, dir); |
| return NULL; |
| } |
| |
| jlist = get_jlist_reference (env, jlist_class); |
| if (jlist == NULL) |
| { |
| throw_exception_by_name (env, "java/util/prefs/BackingStoreException", |
| "Unable to get java.util.List reference in native code\n"); |
| JCL_free_cstring (env, node, dir); |
| g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); |
| g_slist_free (entries); |
| return NULL; |
| } |
| |
| tmp = entries; |
| while (tmp != NULL) |
| { |
| _val = gconf_entry_get_key (tmp->data); |
| _val = strrchr (_val, '/'); |
| ++_val; |
| |
| _val_unescaped = gconf_unescape_key (_val, strlen (_val)); |
| |
| (*env)->CallBooleanMethod (env, jlist, jlist_add_id, |
| (*env)->NewStringUTF (env, _val_unescaped)); |
| |
| tmp = g_slist_next (tmp); |
| |
| g_free ((gpointer) _val_unescaped); |
| } |
| |
| /* clean up things */ |
| JCL_free_cstring (env, node, dir); |
| g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); |
| g_slist_free (entries); |
| |
| return jlist; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_all_nodes |
| * Signature: (Ljava/lang/String;)Ljava/util/List; |
| */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1all_1nodes |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) |
| { |
| const char *dir = NULL; |
| const char *_val = NULL; |
| const char *_val_unescaped = NULL; |
| |
| GError *err = NULL; |
| GSList *entries = NULL; |
| GSList *tmp; |
| |
| /* java.util.ArrayList */ |
| jobject jlist = NULL; |
| |
| dir = JCL_jstring_to_cstring (env, node); |
| if (dir == NULL) |
| { |
| return NULL; |
| } |
| |
| entries = gconf_engine_all_dirs (engine, dir, &err); |
| if (err != NULL) |
| { |
| throw_exception_by_name (env, "java/util/prefs/BackingStoreException", |
| err->message); |
| g_error_free (err); |
| err = NULL; |
| JCL_free_cstring (env, node, dir); |
| return NULL; |
| } |
| |
| jlist = get_jlist_reference (env, jlist_class); |
| if (jlist == NULL) |
| { |
| throw_exception_by_name (env, "java/util/prefs/BackingStoreException", |
| "Unable to get java.util.List reference in native code\n"); |
| JCL_free_cstring (env, node, dir); |
| g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); |
| g_slist_free (entries); |
| return NULL; |
| } |
| |
| tmp = entries; |
| while (tmp != NULL) |
| { |
| _val = tmp->data; |
| |
| _val = strrchr (_val, '/'); |
| ++_val; |
| |
| _val_unescaped = gconf_unescape_key (_val, strlen (_val)); |
| |
| (*env)->CallBooleanMethod (env, jlist, jlist_add_id, |
| (*env)->NewStringUTF (env, _val_unescaped)); |
| |
| tmp = g_slist_next (tmp); |
| |
| g_free ((gpointer) _val_unescaped); |
| } |
| |
| /* clean up things */ |
| JCL_free_cstring (env, node, dir); |
| g_slist_foreach (entries, (GFunc) gconf_entry_free, NULL); |
| g_slist_free (entries); |
| |
| return jlist; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_suggest_sync |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1suggest_1sync |
| (JNIEnv *env, jclass clazz __attribute__ ((unused))) |
| { |
| GError *err = NULL; |
| |
| gconf_engine_suggest_sync (engine, &err); |
| if (err != NULL) |
| { |
| throw_exception_by_name (env, "java/util/prefs/BackingStoreException", |
| err->message); |
| g_error_free (err); |
| err = NULL; |
| } |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_unset |
| * Signature: (Ljava/lang/String;)Z |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unset |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring key) |
| { |
| const char *_key = NULL; |
| gboolean result = JNI_FALSE; |
| GError *err = NULL; |
| |
| _key = JCL_jstring_to_cstring (env, key); |
| if (_key == NULL) |
| { |
| return JNI_FALSE; |
| } |
| |
| result = gconf_engine_unset (engine, _key, &err); |
| if (err != NULL) |
| { |
| result = JNI_FALSE; |
| g_error_free (err); |
| err = NULL; |
| } |
| |
| JCL_free_cstring (env, key, _key); |
| |
| return result; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_get_string |
| * Signature: (Ljava/lang/String;)Ljava/lang/String; |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1get_1string |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring key) |
| { |
| const char *_key = NULL; |
| const char *_value = NULL; |
| GError *err = NULL; |
| jstring result = NULL; |
| |
| _key = JCL_jstring_to_cstring (env, key); |
| if (_key == NULL) |
| { |
| return NULL; |
| } |
| |
| _value = gconf_engine_get_string (engine, _key, &err); |
| JCL_free_cstring (env, key, _key); |
| if (err != NULL) |
| { |
| /* just in case */ |
| if (_value != NULL) g_free ((gpointer) _value); |
| g_error_free (err); |
| err = NULL; |
| |
| return NULL; |
| } |
| |
| /* Even if Gconf reported no error it is possible that NULL was returned */ |
| /* and it should be prevented to create a Java string from that value. */ |
| if (_value != NULL) |
| { |
| result = (*env)->NewStringUTF (env, _value); |
| g_free ((gpointer) _value); |
| } |
| |
| gconf_engine_suggest_sync (engine, NULL); |
| |
| return result; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_set_string |
| * Signature: (Ljava/lang/String;Ljava/lang/String;)Z |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1set_1string |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), |
| jstring key, jstring value) |
| { |
| const char *_key = NULL; |
| const char *_value = NULL; |
| GError *err = NULL; |
| |
| gboolean result = JNI_FALSE; |
| |
| /* load an UTF string from the virtual machine. */ |
| _key = JCL_jstring_to_cstring (env, key); |
| _value = JCL_jstring_to_cstring (env, value); |
| if (_key == NULL || _value == NULL) |
| { |
| return JNI_FALSE; |
| } |
| |
| result = gconf_engine_set_string (engine, _key, _value, &err); |
| if (err != NULL) |
| { |
| g_error_free (err); |
| err = NULL; |
| result = JNI_FALSE; |
| } |
| |
| JCL_free_cstring (env, key, _key); |
| JCL_free_cstring (env, value, _value); |
| |
| return (jboolean) result; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: gconf_dir_exists |
| * Signature: (Ljava/lang/String;)Z |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1dir_1exists |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring node) |
| { |
| const char *dir = NULL; |
| GError *err = NULL; |
| jboolean value = JNI_FALSE; |
| |
| dir = JCL_jstring_to_cstring (env, node); |
| if (dir == NULL) |
| return value; |
| |
| /* on error return false */ |
| value = gconf_engine_dir_exists (engine, dir, &err); |
| if (err != NULL) |
| value = JNI_FALSE; |
| |
| JCL_free_cstring (env, node, dir); |
| |
| return value; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: finalize_class |
| * Signature: ()V |
| */ |
| JNIEXPORT void JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_finalize_1class |
| (JNIEnv *env, jclass clazz __attribute__ ((unused))) |
| { |
| if (reference_count == 0) |
| { |
| /* last reference, free all resources and return */ |
| g_object_unref (G_OBJECT (engine)); |
| |
| (*env)->DeleteGlobalRef (env, jlist_class); |
| |
| jlist_class = NULL; |
| jlist_init_id = NULL; |
| jlist_add_id = NULL; |
| |
| return; |
| } |
| |
| reference_count--; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1escape_1key |
| * Signature: (Ljava/lang/String;)Z |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1escape_1key |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring plain) |
| { |
| const char *escaped = NULL; |
| const char *_plain = NULL; |
| jstring result = NULL; |
| |
| _plain = JCL_jstring_to_cstring (env, plain); |
| if (_plain == NULL) |
| { |
| return NULL; |
| } |
| |
| escaped = gconf_escape_key (_plain, strlen (_plain)); |
| |
| JCL_free_cstring (env, plain, _plain); |
| /* check for NULL, if so prevent string creation */ |
| if (escaped != NULL) |
| { |
| result = (*env)->NewStringUTF (env, escaped); |
| g_free ((gpointer) escaped); |
| } |
| |
| return result; |
| } |
| |
| /* |
| * Class: gnu_java_util_prefs_gconf_GConfNativePeer |
| * Method: Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unescape_1key |
| * Signature: (Ljava/lang/String;)Z |
| */ |
| JNIEXPORT jstring JNICALL |
| Java_gnu_java_util_prefs_gconf_GConfNativePeer_gconf_1unescape_1key |
| (JNIEnv *env, jclass clazz __attribute__ ((unused)), jstring escaped) |
| { |
| const char *plain = NULL; |
| const char *_escaped = NULL; |
| jstring result = NULL; |
| |
| _escaped = JCL_jstring_to_cstring (env, escaped); |
| if (_escaped == NULL) |
| { |
| return NULL; |
| } |
| |
| plain = gconf_unescape_key (_escaped, strlen (_escaped)); |
| |
| JCL_free_cstring (env, escaped, _escaped); |
| /* check for NULL, if so prevent string creation */ |
| if (plain != NULL) |
| { |
| result = (*env)->NewStringUTF (env, plain); |
| g_free ((gpointer) plain); |
| } |
| |
| return result; |
| } |
| |
| /* ***** END: NATIVE FUNCTIONS ***** */ |
| |
| /* ***** PRIVATE FUNCTIONS IMPLEMENTATION ***** */ |
| |
| static void throw_exception (JNIEnv *env, const char *msg) |
| { |
| throw_exception_by_name (env, "java/lang/RuntimeException", msg); |
| } |
| |
| static void |
| throw_exception_by_name (JNIEnv *env, const char *name, const char *msg) |
| { |
| JCL_ThrowException (env, name, msg); |
| } |
| |
| static void init_gconf (void) |
| { |
| engine = gconf_engine_get_default (); |
| } |
| |
| static gboolean set_jlist_class (JNIEnv *env) |
| { |
| jclass local_jlist_class = NULL; |
| |
| /* gets a reference to the ArrayList class */ |
| local_jlist_class = JCL_FindClass (env, "java/util/ArrayList"); |
| if (local_jlist_class == NULL) |
| { |
| return FALSE; |
| } |
| |
| jlist_class = (*env)->NewGlobalRef (env, local_jlist_class); |
| (*env)->DeleteLocalRef (env, local_jlist_class); |
| if (jlist_class == NULL) |
| { |
| return FALSE; |
| } |
| |
| /* and initialize it */ |
| jlist_init_id = (*env)->GetMethodID (env, jlist_class, "<init>", "()V"); |
| if (jlist_init_id == NULL) |
| { |
| return FALSE; |
| } |
| |
| jlist_add_id = (*env)->GetMethodID (env, jlist_class, "add", |
| "(Ljava/lang/Object;)Z"); |
| if (jlist_add_id == NULL) |
| { |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static jobject get_jlist_reference (JNIEnv *env, jclass jlist_class) |
| { |
| return (*env)->NewObject (env, jlist_class, jlist_init_id); |
| } |
| |
| /* ***** END: PRIVATE FUNCTIONS IMPLEMENTATION ***** */ |