flutter::DartServiceIsolate Class Reference

Utility methods for interacting with the DartVM managed service isolate present in debug and profile runtime modes. More...

#include <dart_service_isolate.h>

Public Types
using	CallbackHandle = ptrdiff_t
using	DartVMServiceServerStateCallback = std::function< void(const std::string &vm_service_uri)>

Static Public Member Functions
static bool	Startup (const std::string &server_ip, intptr_t server_port, Dart_LibraryTagHandler embedder_tag_handler, bool disable_origin_check, bool disable_service_auth_codes, bool enable_service_port_fallback, char **error)
	Start the service isolate. This call may only be made in the Dart VM initiated isolate creation callback. It is only valid to make this call when the VM explicitly requests the creation of the service isolate. The VM does this by specifying the script URI to be DART_VM_SERVICE_ISOLATE_NAME. The isolate to be designated as the service isolate must already be created (but not running) when this call is made.
static CallbackHandle	AddServerStatusCallback (const DartVMServiceServerStateCallback &callback)
	Add a callback that will get invoked when the VM Service starts up. If the VM Service has already started before this call is made, the callback is invoked immediately.
static bool	RemoveServerStatusCallback (CallbackHandle handle)
	Removed a callback previously registered via AddServiceStatusCallback.

Detailed Description

Utility methods for interacting with the DartVM managed service isolate present in debug and profile runtime modes.

Definition at line 22 of file dart_service_isolate.h.

Member Typedef Documentation

CallbackHandle

using flutter::DartServiceIsolate::CallbackHandle = ptrdiff_t

The handle used to refer to callbacks registered with the service isolate.

Definition at line 27 of file dart_service_isolate.h.

DartVMServiceServerStateCallback

using flutter::DartServiceIsolate::DartVMServiceServerStateCallback = std::function<void(const std::string& vm_service_uri)>

A callback made by the Dart VM when the VM Service is ready. The argument indicates the VM Service URI.

Definition at line 33 of file dart_service_isolate.h.

Member Function Documentation

AddServerStatusCallback()

DartServiceIsolate::CallbackHandle flutter::DartServiceIsolate::AddServerStatusCallback ( const DartVMServiceServerStateCallback &  callback )

static

Add a callback that will get invoked when the VM Service starts up. If the VM Service has already started before this call is made, the callback is invoked immediately.

This method is thread safe.

Parameters

[in]

callback

The callback with information about the VM Service.

Returns

A handle for the callback that can be used later in RemoveServerStatusCallback.

Definition at line 84 of file dart_service_isolate.cc.

                                                                        {
  if (!callback) {
    return 0;
  }
 
  auto callback_pointer =
      std::make_unique<DartServiceIsolate::DartVMServiceServerStateCallback>(
          callback);
 
  auto handle = reinterpret_cast<CallbackHandle>(callback_pointer.get());
 
  {
    std::scoped_lock lock(callbacks_mutex_);
    callbacks_.insert(std::move(callback_pointer));
  }
 
  if (!g_vm_service_uri.empty()) {
    callback(g_vm_service_uri);
  }
 
  return handle;
}

RemoveServerStatusCallback()

bool flutter::DartServiceIsolate::RemoveServerStatusCallback ( CallbackHandle  handle )

static

Removed a callback previously registered via AddServiceStatusCallback.

This method is thread safe.

Parameters

[in]

handle

The handle

Returns

If the callback was unregistered. This may fail if there was no such callback with that handle.

Definition at line 108 of file dart_service_isolate.cc.

                                    {
  std::scoped_lock lock(callbacks_mutex_);
  auto found = std::find_if(
      callbacks_.begin(), callbacks_.end(),
      [callback_handle](const auto& item) {
        return reinterpret_cast<CallbackHandle>(item.get()) == callback_handle;
      });
 
  if (found == callbacks_.end()) {
    return false;
  }
 
  callbacks_.erase(found);
  return true;
}

Startup()

bool flutter::DartServiceIsolate::Startup ( const std::string &  server_ip, intptr_t  server_port, Dart_LibraryTagHandler  embedder_tag_handler, bool  disable_origin_check, bool  disable_service_auth_codes, bool  enable_service_port_fallback, char **  error  )

static

Start the service isolate. This call may only be made in the Dart VM initiated isolate creation callback. It is only valid to make this call when the VM explicitly requests the creation of the service isolate. The VM does this by specifying the script URI to be DART_VM_SERVICE_ISOLATE_NAME. The isolate to be designated as the service isolate must already be created (but not running) when this call is made.

Parameters

[in]	server_ip	The service protocol IP address.
[in]	server_port	The service protocol port.
[in]	embedder_tag_handler	The library tag handler.
[in]	disable_origin_check	If websocket origin checks must be enabled.
[in]	disable_service_auth_codes	If service auth codes must be enabled.
[in]	enable_service_port_fallback	If fallback to port 0 must be enabled when the bind fails.
	error	The error when this method returns false. This string must be freed by the caller using free.

Returns

If the startup was successful. Refer to the error for details on failure.

Definition at line 129 of file dart_service_isolate.cc.

                                               {
  Dart_Isolate isolate = Dart_CurrentIsolate();
  FML_CHECK(isolate);
 
  // Remember the embedder's library tag handler.
  g_embedder_tag_handler = embedder_tag_handler;
  FML_CHECK(g_embedder_tag_handler);
 
  // Setup native entries.
  if (!g_natives) {
    g_natives = new tonic::DartLibraryNatives();
    g_natives->Register({
        {"VMServiceIO_NotifyServerState", NotifyServerState, 1, true},
        {"VMServiceIO_Shutdown", Shutdown, 0, true},
    });
  }
 
  Dart_Handle uri = Dart_NewStringFromCString("dart:vmservice_io");
  Dart_Handle library = Dart_LookupLibrary(uri);
  SHUTDOWN_ON_ERROR(library);
  Dart_Handle result = Dart_SetRootLibrary(library);
  SHUTDOWN_ON_ERROR(result);
  result = Dart_SetNativeResolver(library, GetNativeFunction, GetSymbol);
  SHUTDOWN_ON_ERROR(result);
 
  library = Dart_RootLibrary();
  SHUTDOWN_ON_ERROR(library);
 
  // Set the HTTP server's ip.
  result = Dart_SetField(library, Dart_NewStringFromCString("_ip"),
                         Dart_NewStringFromCString(server_ip.c_str()));
  SHUTDOWN_ON_ERROR(result);
  // If we have a port specified, start the server immediately.
  bool auto_start = server_port >= 0;
  if (server_port < 0) {
    // Adjust server_port to port 0 which will result in the first available
    // port when the HTTP server is started.
    server_port = 0;
  }
  // Set the HTTP's servers port.
  result = Dart_SetField(library, Dart_NewStringFromCString("_port"),
                         Dart_NewInteger(server_port));
  SHUTDOWN_ON_ERROR(result);
  result = Dart_SetField(library, Dart_NewStringFromCString("_autoStart"),
                         Dart_NewBoolean(auto_start));
  SHUTDOWN_ON_ERROR(result);
  result =
      Dart_SetField(library, Dart_NewStringFromCString("_originCheckDisabled"),
                    Dart_NewBoolean(disable_origin_check));
  SHUTDOWN_ON_ERROR(result);
  result =
      Dart_SetField(library, Dart_NewStringFromCString("_authCodesDisabled"),
                    Dart_NewBoolean(disable_service_auth_codes));
  SHUTDOWN_ON_ERROR(result);
  result = Dart_SetField(
      library, Dart_NewStringFromCString("_enableServicePortFallback"),
      Dart_NewBoolean(enable_service_port_fallback));
  SHUTDOWN_ON_ERROR(result);
 
  // Make runnable.
  Dart_ExitScope();
  Dart_ExitIsolate();
  *error = Dart_IsolateMakeRunnable(isolate);
  if (*error) {
    Dart_EnterIsolate(isolate);
    Dart_ShutdownIsolate();
    return false;
  }
  Dart_EnterIsolate(isolate);
  Dart_EnterScope();
 
  return true;
}

---

The documentation for this class was generated from the following files:

• runtime/dart_service_isolate.h
• runtime/dart_service_isolate.cc