Android rayshader sample.

samples/android_sample/jni/vm_glue.cc

Index: samples/android_sample/jni/vm_glue.cc
===================================================================
--- samples/android_sample/jni/vm_glue.cc	(revision 0)
+++ samples/android_sample/jni/vm_glue.cc	(revision 0)
@@ -0,0 +1,355 @@
+#include "jni/vm_glue.h"
+
+#include <math.h>
+#include <unistd.h>
+
+#include "bin/eventhandler.h"
+#include "bin/isolate_data.h"
+#include "bin/log.h"
+#include "bin/platform.h"
+#include "bin/process.h"
+#include "vm/flags.h"
+
+// snapshot_buffer points to a snapshot if we link in a snapshot otherwise
+// it is initialized to NULL.
+extern const uint8_t* snapshot_buffer;
+
+VMGlue::VMGlue(Graphics* graphics)
+    : graphics_(graphics),
+      isolate_(NULL),
+      initialized_vm_(false),
+      initialized_script_(false) {
+  Log::Print("Creating VMGlue");
+}
+
+int VMGlue::ErrorExit(const char* format, ...) {
+  va_list arguments;
+  va_start(arguments, format);
+  Log::VPrintErr(format, arguments);
+  va_end(arguments);
+  Dart_ExitScope();
+  Dart_ShutdownIsolate();
+  Log::PrintErr("Shutdown isolate");
+  return -1;
+}
+
+Dart_Handle VMGlue::SetupRuntimeOptions(CommandLineOptions* options,
+                                           const char* executable_name,
+                                           const char* script_name) {
+  int options_count = 0;
+  Dart_Handle dart_executable = DartUtils::NewString(executable_name);
+  if (Dart_IsError(dart_executable)) {
+    return dart_executable;
+  }
+  Dart_Handle dart_script = DartUtils::NewString(script_name);
+  if (Dart_IsError(dart_script)) {
+    return dart_script;
+  }
+  Dart_Handle dart_arguments = Dart_NewList(0);
+  if (Dart_IsError(dart_arguments)) {
+    return dart_arguments;
+  }
+  Dart_Handle core_lib_url = DartUtils::NewString("dart:core");
+  if (Dart_IsError(core_lib_url)) {
+    return core_lib_url;
+  }
+  Dart_Handle core_lib = Dart_LookupLibrary(core_lib_url);
+  if (Dart_IsError(core_lib)) {
+    return core_lib;
+  }
+  Dart_Handle runtime_options_class_name =
+      DartUtils::NewString("_OptionsImpl");
+  if (Dart_IsError(runtime_options_class_name)) {
+    return runtime_options_class_name;
+  }
+  Dart_Handle runtime_options_class = Dart_GetClass(
+      core_lib, runtime_options_class_name);
+  if (Dart_IsError(runtime_options_class)) {
+    return runtime_options_class;
+  }
+  Dart_Handle executable_name_name = DartUtils::NewString("_nativeExecutable");
+  if (Dart_IsError(executable_name_name)) {
+    return executable_name_name;
+  }
+  Dart_Handle set_executable_name =
+      Dart_SetField(runtime_options_class,
+                    executable_name_name,
+                    dart_executable);
+  if (Dart_IsError(set_executable_name)) {
+    return set_executable_name;
+  }
+  Dart_Handle script_name_name = DartUtils::NewString("_nativeScript");
+  if (Dart_IsError(script_name_name)) {
+    return script_name_name;
+  }
+  Dart_Handle set_script_name =
+      Dart_SetField(runtime_options_class, script_name_name, dart_script);
+  if (Dart_IsError(set_script_name)) {
+    return set_script_name;
+  }
+  Dart_Handle native_name = DartUtils::NewString("_nativeArguments");
+  if (Dart_IsError(native_name)) {
+    return native_name;
+  }
+  return Dart_SetField(runtime_options_class, native_name, dart_arguments);
+}
+
+#define CHECK_RESULT(result)                                                   \
+  if (Dart_IsError(result)) {                                                  \
+    *error = strdup(Dart_GetError(result));                                    \
+    Log::PrintErr(*error);                                                     \
+    Dart_ExitScope();                                                          \
+    Dart_ShutdownIsolate();                                                    \
+    return false;                                                              \
+  }
+
+// Returns true on success, false on failure.
+bool VMGlue::CreateIsolateAndSetupHelper(const char* script_uri,
+                                           const char* main,
+                                           void* data,
+                                           char** error) {
+  Log::Print("Creating isolate %s, %s", script_uri, main);
+  Dart_Isolate isolate =
+      Dart_CreateIsolate(script_uri, main, snapshot_buffer, data, error);
+  if (isolate == NULL) {
+    Log::PrintErr("Couldn't create isolate: %s", error);
+    return false;
+  }
+
+  Log::Print("Entering scope");
+  Dart_EnterScope();
+
+  if (snapshot_buffer != NULL) {
+    // Setup the native resolver as the snapshot does not carry it.
+    Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
+    Builtin::SetNativeResolver(Builtin::kIOLibrary);
+  }
+
+  // Set up the library tag handler for this isolate.
+  Log::Print("Setting up library tag handler");
+  Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
+  CHECK_RESULT(result);
+
+  // Load the specified application script into the newly created isolate.
+  Dart_Handle library;
+
+  // Prepare builtin and its dependent libraries for use to resolve URIs.
+  Log::Print("Preparing uriLibrary");
+  Dart_Handle uri_lib = Builtin::LoadAndCheckLibrary(Builtin::kUriLibrary);
+  CHECK_RESULT(uri_lib);
+  Log::Print("Preparing builtinLibrary");
+  Dart_Handle builtin_lib =
+      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  CHECK_RESULT(builtin_lib);
+
+  // Prepare for script loading by setting up the 'print' and 'timer'
+  // closures and setting up 'package root' for URI resolution.
+  char* package_root = NULL;
+  Log::Print("Preparing for script loading");
+  result = DartUtils::PrepareForScriptLoading(package_root, builtin_lib);
+  CHECK_RESULT(result);
+
+  Log::Print("Loading script %s", script_uri);
+  library = DartUtils::LoadScript(script_uri, builtin_lib);
+
+  CHECK_RESULT(library);
+  if (!Dart_IsLibrary(library)) {
+    Log::PrintErr("Expected a library when loading script: %s",
+             script_uri);
+    Dart_ExitScope();
+    Dart_ShutdownIsolate();
+    return false;
+  }
+  Dart_ExitScope();
+  return true;
+}
+
+bool VMGlue::CreateIsolateAndSetup(const char* script_uri,
+                                  const char* main,
+                                  void* data, char** error) {
+  return CreateIsolateAndSetupHelper(script_uri,
+                                     main,
+                                     new IsolateData(),
+                                     error);
+}
+
+#define VMHOSTNAME  "android_dart_host"
+#define MAINSCRIPT  "/data/data/com.google.dartndk/app_dart/main.dart"
+
+void VMGlue::ShutdownIsolate(void* callback_data) {
+  IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
+  EventHandler* handler = isolate_data->event_handler;
+  if (handler != NULL) handler->Shutdown();
+  delete isolate_data;
+}
+
+int VMGlue::InitializeVM() {
+  // Perform platform specific initialization.
+  Log::Print("Initializing platform");
+  if (!Platform::Initialize()) {
+    Log::PrintErr("Initialization failed\n");
+    return -1;
+  }
+
+  // We need the next call to get Datrt_Initialize not to bail early.
+  Log::Print("Processing command line flags");
+  dart::Flags::ProcessCommandLineFlags(0, NULL);
+
+  // Initialize the Dart VM, providing the callbacks to use for
+  // creating and shutting down isolates.
+  Log::Print("Initializing Dart");
+  if (!Dart_Initialize(CreateIsolateAndSetup,
+                       NULL,
+                       NULL,
+                       ShutdownIsolate)) {
+    Log::PrintErr("VM initialization failed\n");
+    return -1;
+  }
+  DartUtils::SetOriginalWorkingDirectory();
+  initialized_vm_ = true;
+  return 0;
+}
+
+int VMGlue::StartMainIsolate() {
+  if (!initialized_vm_) {
+    int rtn = InitializeVM();
+    if (rtn != 0) return rtn;
+  }
+
+  // Create an isolate and loads up the application script.
+  char* error = NULL;
+  if (!CreateIsolateAndSetup(MAINSCRIPT, "main", NULL, &error)) {
+    Log::PrintErr("CreateIsolateAndSetup: %s\n", error);
+    free(error);
+    return -1;
+  }
+
+  Log::Print("Created isolate");
+
+  isolate_ = Dart_CurrentIsolate();
+  Dart_ExitIsolate();
+  return 0;
+}
+
+int VMGlue::CallSetup() {
+  if (!initialized_script_) {
+    initialized_script_ = true;
+    Log::Print("Invoking setup");
+    Dart_EnterIsolate(isolate_);
+    Dart_EnterScope();
+    Dart_Handle args[2];
+    args[0] = Dart_NewInteger(graphics_->width());
+    args[1] = Dart_NewInteger(graphics_->height());
+    int rtn = Invoke("setup", 2, args);
+    Dart_ExitScope();
+    Dart_ExitIsolate();
+    Log::Print("Done setup");
+    return rtn;
+  }
+  return 0;
+}
+
+int VMGlue::CallUpdate() {
+  if (initialized_script_) {
+    Log::Print("Invoking update");
+    Dart_EnterIsolate(isolate_);
+    Dart_EnterScope();
+    int rtn = Invoke("update", 0, 0);
+    Dart_ExitScope();
+    Dart_ExitIsolate();
+    Log::Print("Done update");
+    return rtn;
+  }
+  return -1;
+}
+
+int VMGlue::OnMotionEvent(const char* pFunction, int64_t pWhen,
+                  float pMoveX, float pMoveY) {
+  if (initialized_script_) {
+    Log::Print("Invoking %s", pFunction);
+    Dart_EnterIsolate(isolate_);
+    Dart_EnterScope();
+    Dart_Handle args[3];
+    args[0] = Dart_NewInteger(pWhen);
+    args[1] = Dart_NewDouble(pMoveX);
+    args[2] = Dart_NewDouble(pMoveY);
+    int rtn = Invoke(pFunction, 3, args);
+    Dart_ExitScope();
+    Dart_ExitIsolate();
+    Log::Print("Done %s", pFunction);
+    return rtn;
+  }
+  return -1;
+}
+
+int VMGlue::OnKeyEvent(const char* function, int64_t when, int32_t flags,
+           int32_t key_code, int32_t meta_state, int32_t repeat) {
+  if (initialized_script_) {
+    Log::Print("Invoking %s", function);
+    Dart_EnterIsolate(isolate_);
+    Dart_EnterScope();
+    Dart_Handle args[5];
+    args[0] = Dart_NewInteger(when);
+    args[1] = Dart_NewInteger(flags);
+    args[2] = Dart_NewInteger(key_code);
+    args[3] = Dart_NewInteger(meta_state);
+    args[4] = Dart_NewInteger(repeat);
+    int rtn = Invoke(function, 5, args);
+    Dart_ExitScope();
+    Dart_ExitIsolate();
+    Log::Print("Done %s", function);
+    return rtn;
+  }
+  return -1;
+}
+
+int VMGlue::Invoke(const char* function, int argc, Dart_Handle* args) {
+  Dart_Handle result;
+
+  Log::Print("in invoke(%s)", function);
+
+  // Create a dart options object that can be accessed from dart code.
+  Log::Print("setting up runtime options");
+  CommandLineOptions dart_options(0);
+  Dart_Handle options_result =
+      SetupRuntimeOptions(&dart_options, VMHOSTNAME, MAINSCRIPT);
+  if (Dart_IsError(options_result)) {
+    return ErrorExit("%s\n", Dart_GetError(options_result));
+  }
+
+  // Lookup the library of the root script.
+  Log::Print("looking up the root library");
+  Dart_Handle library = Dart_RootLibrary();
+  if (Dart_IsNull(library)) {
+     return ErrorExit("Unable to find root library\n");
+  }
+
+  // Lookup and invoke the appropriate function.
+  result = Dart_Invoke(library, DartUtils::NewString(function), argc, args);
+
+  if (Dart_IsError(result)) {
+    return ErrorExit("%s\n", Dart_GetError(result));
+  }
+
+  // Keep handling messages until the last active receive port is closed.
+  Log::Print("Entering Dart message loop");
+  result = Dart_RunLoop();
+  if (Dart_IsError(result)) {
+    return ErrorExit("%s\n", Dart_GetError(result));
+  }
+
+  Log::Print("out invoke");
+  return 0;
+}
+
+void VMGlue::FinishMainIsolate() {
+  Log::Print("Finish main isolate");
+  Dart_EnterIsolate(isolate_);
+  // Shutdown the isolate.
+  Dart_ShutdownIsolate();
+  // Terminate process exit-code handler.
+  Process::TerminateExitCodeHandler();
+  isolate_ = NULL;
+  initialized_script_ = false;
+}
+