Rotating spheres sample

runtime/bin/main_android.cc

Index: runtime/bin/main_android.cc
diff --git a/runtime/bin/main_android.cc b/runtime/bin/main_android.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6de2acc12efc8a95f868035ffd0a1b305580abb6
--- /dev/null
+++ b/runtime/bin/main_android.cc
@@ -0,0 +1,666 @@
+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#include <jni.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <android/log.h>
+
+#include <dart_api.h>
+
+#define LOGX(LOG_LEVEL, ...) do { \
+    __android_log_print(LOG_LEVEL, LOG_TAG, __VA_ARGS__); \
+  } while (0)
+#define LOGI(...) LOGX(ANDROID_LOG_INFO, __VA_ARGS__)
+#define LOGW(...) LOGX(ANDROID_LOG_WARN, __VA_ARGS__)
+#define LOGE(...) LOGX(ANDROID_LOG_ERROR, __VA_ARGS__)
+
+int registerNativeMethods(JNIEnv* env, const char* className,
+    JNINativeMethod* gMethods, int numMethods);
+
+// Provide atexit, not part of Android libc or linker.
+
+extern "C" int atexit(void (*function)(void)) {
+  // Return error code.
+  return 1;
+}
+
+// Provide __dso_handle, not part of Android libc or linker.
+
+__attribute__((weak)) void *__dso_handle;
+
+extern "C" int Dart_SO_Start(int argc, const char** argv,
+    Dart_Isolate* main_isolate);
+extern "C" int Dart_SO_MainLoop(Dart_Isolate main_isolate);
+extern "C" int Dart_SO_Finish(Dart_Isolate main_isolate);
+
+inline Dart_Handle JINT_TO_DART_HANDLE(jint X) {
+  return reinterpret_cast<Dart_Handle>(X);
+}
+
+inline jint DART_HANDLE_TO_JINT(Dart_Handle X) {
+  return reinterpret_cast<jint>(X);
+}
+
+inline Dart_Isolate JINT_TO_DART_ISOLATE(jint X) {
+  return reinterpret_cast<Dart_Isolate>(X);
+}
+
+inline jint DART_ISOLATE_TO_JINT(Dart_Isolate X) {
+  return reinterpret_cast<jint>(X);
+}
+
+#define LOG_TAG "dart_so"
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    dartStart
+ * Signature: ([Ljava/lang/String;)I
+ */
+static jint dartStart(JNIEnv *env, jclass clazz, jobjectArray args) {
+  int argc = env->GetArrayLength(args);
+  const char** argv = new const char*[argc];
+
+  for (int i = 0; i < argc; i++) {
+    jstring string = (jstring) env->GetObjectArrayElement(args, i);
+    argv[i] = env->GetStringUTFChars(string, 0);
+  }
+
+  LOGI("argc: %d", argc);
+
+  for (int i = 0; i < argc; i++) {
+    LOGI("%d: %s", i, argv[i]);
+  }
+
+  Dart_Isolate main_isolate;
+  int result =  Dart_SO_Start(argc, argv, &main_isolate);
+  if (result != 0) {
+    LOGE("Dart_SO_Start returned %d", result);
+    main_isolate = (Dart_Isolate) 0;
+  }
+
+  for (int i = 0; i < argc; i++) {
+    jstring string = (jstring) env->GetObjectArrayElement(args, i);
+    env->ReleaseStringUTFChars(string, argv[i]);
+  }
+  delete[] argv;
+  return DART_ISOLATE_TO_JINT(main_isolate);
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    dartFinish
+ * Signature: (I)I
+ */
+static jint dartFinish(JNIEnv* env, jclass clazz, jint main_isolate) {
+  return Dart_SO_Finish(JINT_TO_DART_ISOLATE(main_isolate));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsError
+ * Signature: (I)Z
+ */
+static jboolean IsError(JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_IsError(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsApiError
+ * Signature: (I)Z
+ */
+static jboolean IsApiError
+  (JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_IsApiError(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsUnhandledExceptionError
+ * Signature: (I)Z
+ */
+static jboolean IsUnhandledExceptionError
+  (JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_IsUnhandledExceptionError(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsCompilationError
+ * Signature: (I)Z
+ */
+static jboolean IsCompilationError
+  (JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_IsCompilationError(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsFatalError
+ * Signature: (I)Z
+ */
+static jboolean IsFatalError
+  (JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_IsFatalError(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    GetError
+ * Signature: (I)Ljava/lang/String;
+ */
+static jstring GetError(JNIEnv* env, jclass clazz, jint handle) {
+  // N.B. the error string from Dart_GetError is good until Dart_ExitScope()
+  const char* error = Dart_GetError(JINT_TO_DART_HANDLE(handle));
+  return env->NewStringUTF(error);
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ErrorHasException
+ * Signature: (I)Z
+ */
+static jboolean ErrorHasException(JNIEnv* env, jclass clazz, jint handle) {
+  return Dart_ErrorHasException(JINT_TO_DART_HANDLE(handle));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ErrorGetException
+ * Signature: (I)I
+ */
+static jint ErrorGetException(JNIEnv* env, jclass clazz, jint handle) {
+  return DART_HANDLE_TO_JINT(
+      Dart_ErrorGetException(JINT_TO_DART_HANDLE(handle)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ErrorGetStacktrace
+ * Signature: (I)I
+ */
+static jint ErrorGetStacktrace(JNIEnv* env, jclass clazz, jint handle) {
+  return DART_HANDLE_TO_JINT(
+      Dart_ErrorGetStacktrace(JINT_TO_DART_HANDLE(handle)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewApiError
+ * Signature: (Ljava/lang/String;)I
+ */
+static jint NewApiError(JNIEnv* env, jclass clazz, jstring message) {
+  const char* messageChars = env->GetStringUTFChars(message, 0);
+  int result = DART_HANDLE_TO_JINT(
+    Dart_NewApiError("%s", messageChars));
+  env->ReleaseStringUTFChars(message, messageChars);
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    EnterScope
+ * Signature: ()V
+ */
+static void EnterScope(JNIEnv* env, jclass clazz) {
+  Dart_EnterScope();
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ExitScope
+ * Signature: ()V
+ */
+static void ExitScope(JNIEnv* env, jclass clazz) {
+  Dart_ExitScope();
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ShutdownIsolate
+ * Signature: ()V
+ */
+static void ShutdownIsolate(JNIEnv* env, jclass clazz) {
+  Dart_ShutdownIsolate();
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    CurrentIsolate
+ * Signature: ()I
+ */
+static jint CurrentIsolate(JNIEnv* env, jclass clazz) {
+  return DART_ISOLATE_TO_JINT(Dart_CurrentIsolate());
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    EnterIsolate
+ * Signature: (I)V
+ */
+static void EnterIsolate(JNIEnv* env, jclass clazz, jint isolate) {
+  Dart_EnterIsolate(JINT_TO_DART_ISOLATE(isolate));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ExitIsolate
+ * Signature: ()V
+ */
+static void ExitIsolate(JNIEnv* env, jclass clazz) {
+  Dart_ExitIsolate();
+}
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    RootLibrary
+ * Signature: ()I
+ */
+static jint RootLibrary(JNIEnv* env, jclass clazz) {
+  return DART_HANDLE_TO_JINT(Dart_RootLibrary());
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    LoadLibrary
+ * Signature: (II)I
+ */
+static jint LoadLibrary(JNIEnv* env, jclass clazz, jint url, jint source) {
+  return DART_HANDLE_TO_JINT(Dart_LoadLibrary(JINT_TO_DART_HANDLE(url),
+      JINT_TO_DART_HANDLE(source)));
+}
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    LoadSource
+ * Signature: (III)I
+ */
+static jint LoadSource(
+    JNIEnv* env, jclass clazz, jint library, jint url, jint source) {
+  return DART_HANDLE_TO_JINT(Dart_LoadSource(
+      JINT_TO_DART_HANDLE(library),
+      JINT_TO_DART_HANDLE(url),
+      JINT_TO_DART_HANDLE(source)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    New
+ * Signature: (II[I)I
+ */
+static jint New(JNIEnv* env, jclass clazz,
+                jint dart_clazz, jint name, jintArray arguments) {
+  int argc = 0;
+  jint* carr = NULL;
+
+  if (arguments != NULL) {
+    argc = env->GetArrayLength(arguments);
+  }
+
+  if (argc != 0) {
+    carr = env->GetIntArrayElements(arguments, NULL);
+
+    if (carr == NULL) {
+      return 0; /* exception ocurred. */
+    }
+  }
+
+  Dart_Handle* argv = NULL;
+
+  if (argc != NULL) {
+    argv = new Dart_Handle[argc];
+    for (int i = 0; i < argc; i++) {
+      argv[i] = JINT_TO_DART_HANDLE(carr[i]);
+    }
+
+    env->ReleaseIntArrayElements(arguments, carr, 0);
+  }
+
+  jint result = DART_HANDLE_TO_JINT(Dart_New(
+      JINT_TO_DART_HANDLE(dart_clazz),
+      JINT_TO_DART_HANDLE(name),
+      argc, argv));
+  delete[] argv;
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    Invoke
+ * Signature: (II[I)I
+ */
+static jint Invoke(JNIEnv* env, jclass clazz,
+                   jint target, jint name, jintArray arguments) {
+  int argc = 0;
+  jint* carr = NULL;
+
+  if (arguments != NULL) {
+    argc = env->GetArrayLength(arguments);
+  }
+
+  if (argc != 0) {
+    carr = env->GetIntArrayElements(arguments, NULL);
+
+    if (carr == NULL) {
+      return 0; /* exception ocurred. */
+    }
+  }
+
+  Dart_Handle* argv = NULL;
+
+  if (argc != NULL) {
+    argv = new Dart_Handle[argc];
+    for (int i = 0; i < argc; i++) {
+      argv[i] = JINT_TO_DART_HANDLE(carr[i]);
+    }
+
+    env->ReleaseIntArrayElements(arguments, carr, 0);
+  }
+
+  jint result = DART_HANDLE_TO_JINT(Dart_Invoke(
+      JINT_TO_DART_HANDLE(target),
+      JINT_TO_DART_HANDLE(name),
+      argc, argv));
+  delete[] argv;
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    GetField
+ * Signature: (II)I
+ */
+static jint GetField(JNIEnv* env, jclass clazz, jint container, jint name) {
+  return DART_HANDLE_TO_JINT(
+      Dart_GetField(
+          JINT_TO_DART_HANDLE(container),
+          JINT_TO_DART_HANDLE(name)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    SetField
+ * Signature: (III)I
+ */
+static jint SetField(JNIEnv* env, jclass clazz, jint container, jint name,
+                     jint value) {
+  return DART_HANDLE_TO_JINT(
+      Dart_SetField(
+          JINT_TO_DART_HANDLE(container),
+          JINT_TO_DART_HANDLE(name),
+          JINT_TO_DART_HANDLE(value)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ToString
+ * Signature: (I)I
+ */
+static jint ToString(JNIEnv* env, jclass clazz, jint object) {
+  return DART_HANDLE_TO_JINT(Dart_ToString(JINT_TO_DART_HANDLE(object)));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    StringToJavaString
+ * Signature: (I)Ljava/lang/String;
+ */
+static jstring StringToJavaString(JNIEnv* env, jclass clazz, jint str) {
+  const uint8_t* bytes = 0;
+  int length = 0;
+  Dart_Handle result = Dart_StringToBytes(JINT_TO_DART_HANDLE(str),
+    & bytes, &length);
+  if (Dart_IsError(result)) {
+    return NULL;
+  }
+  // Make a copy that is null terminated.
+  char* buf = new char[length + 1];
+  memcpy(buf, bytes, length);
+  buf[length] = 0;
+  jstring resultString = env->NewStringUTF(buf);
+  delete[] buf;
+  return resultString;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IdentityEquals
+ * Signature: (II)Z
+ */
+static jboolean IdentityEquals(JNIEnv* env, jclass clazz,
+                               jint obj1, jint obj2) {
+  return Dart_IdentityEquals(JINT_TO_DART_HANDLE(obj1),
+    JINT_TO_DART_HANDLE(obj2));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    RunLoop
+ * Signature: ()I
+ */
+static jint RunLoop(JNIEnv* env, jclass clazz) {
+  return DART_HANDLE_TO_JINT(Dart_RunLoop());
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    Null
+ * Signature: ()I
+ */
+static jint Null(JNIEnv* env, jclass clazz) {
+  return DART_HANDLE_TO_JINT(Dart_Null());
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    IsNull
+ * Signature: (I)Z
+ */
+static jboolean IsNull(JNIEnv* env, jclass clazz, jint object) {
+    return Dart_IsNull(JINT_TO_DART_HANDLE(object));
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewString
+ * Signature: (Ljava/lang/String;)I
+ */
+static jint NewString(JNIEnv* env, jclass clazz, jstring str) {
+  const char* strUtf = env->GetStringUTFChars(str, 0);
+  int result = DART_HANDLE_TO_JINT(Dart_NewString(strUtf));
+  env->ReleaseStringUTFChars(str, strUtf);
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewInteger
+ * Signature: (J)I
+ */
+static jint NewInteger(JNIEnv* env, jclass clazz, jlong value) {
+  int result = DART_HANDLE_TO_JINT(Dart_NewInteger(value));
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewBoolean
+ * Signature: (Z)I
+ */
+static jint NewBoolean(JNIEnv* env, jclass clazz, jboolean value) {
+  int result = DART_HANDLE_TO_JINT(Dart_NewBoolean(value));
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewDouble
+ * Signature: (D)I
+ */
+static jint NewDouble(JNIEnv* env, jclass clazz, jdouble value) {
+  int result = DART_HANDLE_TO_JINT(Dart_NewDouble(value));
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    NewList
+ * Signature: (I)I
+ */
+static jint NewList(JNIEnv* env, jclass clazz, jint length) {
+  int result = DART_HANDLE_TO_JINT(Dart_NewList(length));
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ListLength
+ * Signature: (I)I
+ */
+static jint ListLength(JNIEnv* env, jclass clazz, jint list) {
+  intptr_t length;
+  Dart_Handle result = Dart_ListLength(JINT_TO_DART_HANDLE(list), &length);
+  if (Dart_IsError(result)) {
+    return -1;
+  }
+  return (jint) length;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ListGetAt
+ * Signature: (II)I
+ */
+static jint ListGetAt(JNIEnv* env, jclass clazz, jint list, jint index) {
+  int result = DART_HANDLE_TO_JINT(
+      Dart_ListGetAt(JINT_TO_DART_HANDLE(list), index));
+  return result;
+}
+
+/*
+ * Class:     org_dartlang_Dart
+ * Method:    ListSetAt
+ * Signature: (III)I
+ */
+static jint ListSetAt(JNIEnv* env, jclass clazz,
+                      jint list, jint index, jint value) {
+  int result = DART_HANDLE_TO_JINT(
+      Dart_ListSetAt(JINT_TO_DART_HANDLE(list),
+                     index,
+                     JINT_TO_DART_HANDLE(value)));
+  return result;
+}
+
+static const char *classPathName = "org/dartlang/Dart";
+
+#define JNI_ENTRY(NAME, SIG) {#NAME, SIG, reinterpret_cast<void*>(NAME)},
+
+static JNINativeMethod method_table[] = {
+    JNI_ENTRY(IsError, "(I)Z")
+    JNI_ENTRY(IsApiError, "(I)Z")
+    JNI_ENTRY(IsUnhandledExceptionError, "(I)Z")
+    JNI_ENTRY(IsCompilationError, "(I)Z")
+    JNI_ENTRY(IsFatalError, "(I)Z")
+    JNI_ENTRY(GetError, "(I)Ljava/lang/String;")
+    JNI_ENTRY(ErrorHasException, "(I)Z")
+    JNI_ENTRY(ErrorGetException, "(I)I")
+    JNI_ENTRY(ErrorGetStacktrace, "(I)I")
+    JNI_ENTRY(NewApiError, "(Ljava/lang/String;)I")
+    JNI_ENTRY(EnterScope, "()V")
+    JNI_ENTRY(ExitScope, "()V")
+    JNI_ENTRY(ShutdownIsolate, "()V")
+    JNI_ENTRY(CurrentIsolate, "()I")
+    JNI_ENTRY(EnterIsolate, "(I)V")
+    JNI_ENTRY(ExitIsolate, "()V")
+    JNI_ENTRY(RootLibrary, "()I")
+    JNI_ENTRY(LoadLibrary, "(II)I")
+    JNI_ENTRY(LoadSource, "(III)I")
+    JNI_ENTRY(New, "(II[I)I")
+    JNI_ENTRY(Invoke, "(II[I)I")
+    JNI_ENTRY(GetField, "(II)I")
+    JNI_ENTRY(SetField, "(III)I")
+    JNI_ENTRY(ToString, "(I)I")
+    JNI_ENTRY(StringToJavaString, "(I)Ljava/lang/String;")
+    JNI_ENTRY(IdentityEquals, "(II)Z")
+    JNI_ENTRY(RunLoop, "()I")
+    JNI_ENTRY(Null, "()I")
+    JNI_ENTRY(IsNull, "(I)Z")
+    JNI_ENTRY(NewString, "(Ljava/lang/String;)I")
+    JNI_ENTRY(NewInteger, "(J)I")
+    JNI_ENTRY(NewBoolean, "(Z)I")
+    JNI_ENTRY(NewDouble, "(D)I")
+    JNI_ENTRY(NewList, "(I)I")
+    JNI_ENTRY(ListLength, "(I)I")
+    JNI_ENTRY(ListGetAt, "(II)I")
+    JNI_ENTRY(ListSetAt, "(III)I")
+
+    JNI_ENTRY(dartStart, "([Ljava/lang/String;)I")
+    JNI_ENTRY(dartFinish, "(I)I")
+};
+
+int init_Dart(JNIEnv *env) {
+    if (!registerNativeMethods(env, classPathName, method_table,
+                 sizeof(method_table) / sizeof(method_table[0]))) {
+        return JNI_FALSE;
+    }
+
+    return JNI_TRUE;
+}
+
+/*
+ * Register several native methods for one class.
+ */
+int registerNativeMethods(JNIEnv* env, const char* className,
+    JNINativeMethod* gMethods, int numMethods) {
+    jclass clazz;
+
+    clazz = env->FindClass(className);
+    if (clazz == NULL) {
+        LOGE("Native registration unable to find class '%s'", className);
+        return JNI_FALSE;
+    }
+    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
+        LOGE("RegisterNatives failed for '%s'", className);
+        return JNI_FALSE;
+    }
+
+    return JNI_TRUE;
+}
+
+// ----------------------------------------------------------------------------
+
+/*
+ * This is called by the VM when the shared library is first loaded.
+ */
+
+typedef union {
+    JNIEnv* env;
+    void* venv;
+} UnionJNIEnvToVoid;
+
+extern "C"
+jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    UnionJNIEnvToVoid uenv;
+    uenv.venv = NULL;
+    jint result = -1;
+    JNIEnv* env = NULL;
+
+    LOGI("JNI_OnLoad");
+
+    if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK) {
+        LOGE("GetEnv");
+        goto bail;
+    }
+    env = uenv.env;
+
+    if (init_Dart(env) != JNI_TRUE) {
+        LOGE("init_Dart");
+        goto bail;
+    }
+
+    result = JNI_VERSION_1_4;
+
+  bail:
+    return result;
+}