android_jni_utils.c

 
#include "android_jni_utils.h"
 
#include <locale.h>
#include <freerdp/channels/channels.h>
#include <freerdp/log.h>
 
#include "android_jni_callback.h"
 
#define TAG CLIENT_TAG("android.utils")
 
JavaVM* g_JavaVm;
 
JavaVM* getJavaVM()
{
  return g_JavaVm;
}
 
JNIEnv* getJNIEnv()
{
  JNIEnv* env = NULL;
  if ((*g_JavaVm)->GetEnv(g_JavaVm, (void**)&env, JNI_VERSION_1_4) != JNI_OK)
  {
    WLog_FATAL(TAG, "Failed to obtain JNIEnv");
    return NULL;
  }
  return env;
}
 
jobject create_string_builder(JNIEnv* env, char* initialStr)
{
  jclass cls;
  jmethodID methodId;
  jobject obj;
 
  // get class
  cls = (*env)->FindClass(env, "java/lang/StringBuilder");
  if (!cls)
    return NULL;
 
  if (initialStr)
  {
    // get method id for constructor
    methodId = (*env)->GetMethodID(env, cls, "<init>", "(Ljava/lang/String;)V");
    if (!methodId)
      return NULL;
 
    // create string that holds our initial string
    jstring jstr = (*env)->NewStringUTF(env, initialStr);
 
    // construct new StringBuilder
    obj = (*env)->NewObject(env, cls, methodId, jstr);
  }
  else
  {
    // get method id for constructor
    methodId = (*env)->GetMethodID(env, cls, "<init>", "()V");
    if (!methodId)
      return NULL;
 
    // construct new StringBuilder
    obj = (*env)->NewObject(env, cls, methodId);
  }
 
  return obj;
}
 
char* get_string_from_string_builder(JNIEnv* env, jobject strBuilder)
{
  jclass cls;
  jmethodID methodId;
  jstring strObj;
  const char* native_str;
  char* result;
 
  // get class
  cls = (*env)->FindClass(env, "java/lang/StringBuilder");
  if (!cls)
    return NULL;
 
  // get method id for constructor
  methodId = (*env)->GetMethodID(env, cls, "toString", "()Ljava/lang/String;");
  if (!methodId)
    return NULL;
 
  // get jstring representation of our buffer
  strObj = (*env)->CallObjectMethod(env, strBuilder, methodId);
 
  // read string
  native_str = (*env)->GetStringUTFChars(env, strObj, NULL);
  if (!native_str)
    return NULL;
  result = _strdup(native_str);
  (*env)->ReleaseStringUTFChars(env, strObj, native_str);
 
  return result;
}
 
jstring jniNewStringUTF(JNIEnv* env, const char* in, int len)
{
  jstring out = NULL;
  jchar* unicode = NULL;
  jint result_size = 0;
  unsigned char* utf8 = (unsigned char*)in;
 
  if (!in)
  {
    return NULL;
  }
  if (len < 0)
    len = strlen(in);
 
  unicode = (jchar*)malloc(sizeof(jchar) * (len + 1));
  if (!unicode)
  {
    return NULL;
  }
 
  for (jint i = 0; i < len; i++)
  {
    unsigned char one = utf8[i];
    switch (one >> 4)
    {
      case 0x00:
      case 0x01:
      case 0x02:
      case 0x03:
      case 0x04:
      case 0x05:
      case 0x06:
      case 0x07:
        unicode[result_size++] = one;
        break;
      case 0x08:
      case 0x09:
      case 0x0a:
      case 0x0b:
        // case 0x0f:
        /*
         * Bit pattern 10xx or 1111, which are illegal start bytes.
         * Note: 1111 is valid for normal UTF-8, but not the
         * modified UTF-8 used here.
         */
        break;
      case 0x0f:
      case 0x0e:
        // Bit pattern 111x, so there are two additional bytes.
        if (i < (len - 2))
        {
          unsigned char two = utf8[i + 1];
          unsigned char three = utf8[i + 2];
          if ((two & 0xc0) == 0x80 && (three & 0xc0) == 0x80)
          {
            i += 2;
            unicode[result_size++] =
                ((one & 0x0f) << 12) | ((two & 0x3f) << 6) | (three & 0x3f);
          }
        }
        break;
      case 0x0c:
      case 0x0d:
        // Bit pattern 110x, so there is one additional byte.
        if (i < (len - 1))
        {
          unsigned char two = utf8[i + 1];
          if ((two & 0xc0) == 0x80)
          {
            i += 1;
            unicode[result_size++] = ((one & 0x1f) << 6) | (two & 0x3f);
          }
        }
        break;
    }
  }
 
  out = (*env)->NewString(env, unicode, result_size);
  free(unicode);
 
  return out;
}