tonic Namespace Reference

Namespaces
namespace	DartError

Classes
class	DartApiScope
struct	DartArgHolder
class	DartArgIterator
class	DartByteData
class	DartClassLibrary
class	DartClassProvider
struct	DartConverter
struct	DartConverter< bool >
struct	DartConverter< const char * >
struct	DartConverter< Dart_Handle >
struct	DartConverter< DartByteData >
struct	DartConverter< DartList >
struct	DartConverter< double >
struct	DartConverter< flutter::Paint >
struct	DartConverter< flutter::PaintData >
struct	DartConverter< flutter::RRect >
struct	DartConverter< int >
struct	DartConverter< long int >
struct	DartConverter< long long >
struct	DartConverter< PTR< T > >
struct	DartConverter< std::string >
struct	DartConverter< std::u16string >
struct	DartConverter< std::vector< T > >
struct	DartConverter< T *, typename std::enable_if< std::is_convertible< T *, const DartWrappable * >::value >::type >
struct	DartConverter< T, typename std::enable_if< std::is_enum< T >::value >::type >
struct	DartConverter< TypedList< kTypeName, ElemType > >
struct	DartConverter< unsigned >
struct	DartConverter< unsigned long >
struct	DartConverter< unsigned long long >
struct	DartConverter< void >
struct	DartConverterInteger
struct	DartConverterTypes
struct	DartConverterWrappable
class	DartDispatcher
struct	DartDispatcher< IndicesHolder< indices... >, ResultType(*)(ArgTypes...)>
struct	DartDispatcher< IndicesHolder< indices... >, ResultType(C::*)(ArgTypes...)>
struct	DartDispatcher< IndicesHolder< indices... >, ReturnType(C::*)(ArgTypes...) const >
struct	DartDispatcher< IndicesHolder< indices... >, void(*)(ArgTypes...)>
struct	DartDispatcher< IndicesHolder< indices... >, void(C::*)(ArgTypes...)>
class	DartIsolateScope
class	DartLibraryNatives
class	DartList
struct	DartListFactory
class	DartMessageHandler
class	DartMicrotaskQueue
class	DartPersistentValue
class	DartState
class	DartWeakPersistentValue
class	DartWrappable
struct	DartWrapperInfo
struct	FfiDispatcher
struct	FfiDispatcher< C, Return(C::*)(Args...) const, method >
struct	FfiDispatcher< C, Return(C::*)(Args...), method >
struct	FfiDispatcher< C, void(C::*)(Args...), method >
struct	FfiDispatcher< void, Return(*)(Args...), function >
struct	FfiDispatcher< void, void(*)(Args...), function >
class	FileLoader
class	IndicesForSignature
struct	IndicesForSignature< ResultType(*)(ArgTypes...)>
struct	IndicesForSignature< ResultType(C::*)(ArgTypes...) const >
struct	IndicesForSignature< ResultType(C::*)(ArgTypes...)>
struct	IndicesGenerator
struct	IndicesGenerator< 0, indices... >
struct	IndicesHolder
class	PackagesMap
class	TypedList

Typedefs
typedef void(*	DartWrappableAccepter) (DartWrappable *)

Enumerations
enum	DartErrorHandleType { kNoError , kUnknownErrorType , kApiErrorType , kCompilationErrorType }

Functions
void	Log (const char *format,...)
void	SetLogHandler (std::function< void(const char *)> handler)
Dart_Handle	LookupNonNullableType (const std::string &library_name, const std::string &type_name)
template<typename T , std::enable_if_t< std::is_same< std::string, T >::value, int > = 0>
Dart_Handle	ToDartTypeHandle ()
template<typename T >
Dart_Handle	CreateZeroInitializedDartObject (Dart_Handle type_handle_or_null=::Dart_Null())
template<typename T >
Dart_Handle	ToDart (const T &object)
Dart_Handle	StdStringToDart (const std::string &val)
std::string	StdStringFromDart (Dart_Handle handle)
Dart_Handle	ToDart (const char *val)
template<typename T >
void	DartReturn (T result, Dart_NativeArguments args)
template<typename Sig >
void	DartCall (Sig func, Dart_NativeArguments args)
template<typename Sig >
void	DartCallStatic (Sig func, Dart_NativeArguments args)
template<typename Sig >
void	DartCallConstructor (Sig func, Dart_NativeArguments args)
template<typename Arg , typename... Args>
void	WriteFfiArguments (std::ostringstream *stream)
template<typename Arg , typename... Args>
void	WriteDartArguments (std::ostringstream *stream)
template<typename Arg , typename... Args>
bool	AllowedInLeafCall ()
template<typename T >
T *	GetReceiver (Dart_NativeArguments args)
void	SetUnhandledExceptionReporter (DartError::UnhandledExceptionReporter reporter)
bool	CheckAndHandleError (Dart_Handle handle)
DartErrorHandleType	GetErrorHandleType (Dart_Handle handle)
int	GetErrorExitCode (Dart_Handle handle)
Dart_Handle	DartInvokeField (Dart_Handle target, const char *name, std::initializer_list< Dart_Handle > args)
Dart_Handle	DartInvoke (Dart_Handle closure, std::initializer_list< Dart_Handle > args)
Dart_Handle	DartInvokeVoid (Dart_Handle closure)

Typedef Documentation

DartWrappableAccepter

typedef void(* tonic::DartWrappableAccepter) (DartWrappable *)

Definition at line 13 of file dart_wrapper_info.h.

Enumeration Type Documentation

DartErrorHandleType

enum tonic::DartErrorHandleType

Enumerator
kNoError
kUnknownErrorType
kApiErrorType
kCompilationErrorType

Definition at line 67 of file dart_error.h.

                         {
  kNoError,
  kUnknownErrorType,
  kApiErrorType,
  kCompilationErrorType,
};

Function Documentation

AllowedInLeafCall()

template<typename Arg , typename... Args>

bool tonic::AllowedInLeafCall

(

)

Definition at line 295 of file dart_args.h.

                         {
  bool result = tonic::DartConverter<typename std::remove_const<
      typename std::remove_reference<Arg>::type>::type>::AllowedInLeafCall();
  if constexpr (sizeof...(Args) > 0) {
    result &= AllowedInLeafCall<Args...>();
  }
  return result;
}

CheckAndHandleError()

bool tonic::CheckAndHandleError

(

Dart_Handle

handle

)

Check if a Dart_Handle is an error or exception.

If it is an error or exception, this method will return true.

If it is an unhandled error or exception, the closure in |SetUnhandledExceptionReporter| is called. The DartVMInitializer provides that closure, which checks with UIDartState::Current() if it is available and falls back to simply printing the exception and stack to an error log if the settings callback is not provided.

If UIDartState::Current() is available, it can provide an onError callback that forwards to PlatformConfiguration.instance.onError. If that callback is not set, the callback from Settings.unhandled_exception_callback is invoked. If that callback is not set, a simple error log is printed.

If the PlatformDispatcher callback throws an exception, the at least two separate exceptions and stacktraces will be handled by either the Settings.unhandled_exception_callback or the error printer: one for the original exception, and one for the exception thrown in the callback. If the callback returns false, the original exception and stacktrace are logged. If it returns true, no additional logging is done.

Leaving the PlatformDispatcher.instance.onError callback unset or returning false from it matches the behavior of Flutter applications before the introduction of PlatformDispatcher.onError, which is to print to the error log.

Dart has errors that are not considered unhandled exceptions, such as Dart_* API usage errors. In these cases, Dart_IsUnhandledException returns false but Dart_IsError returns true. Such errors are logged to stderr or some similar mechanism provided by the platform such as logcat on Android. Depending on which type of error occurs, the process may crash and the Dart isolate may be unusable. Errors that fall into this category include compilation errors, Dart API errors, and unwind errors that will terminate the Dart VM.

Historically known as LogIfError.

Definition at line 33 of file dart_error.cc.

                                             {
  // Specifically handle UnhandledExceptionErrors first. These exclude fatal
  // errors that are shutting down the vm and compilation errors in source code.
  if (Dart_IsUnhandledExceptionError(handle)) {
    Dart_Handle exception_handle = Dart_ErrorGetException(handle);
    Dart_Handle stack_trace_handle = Dart_ErrorGetStackTrace(handle);
 
    ReportUnhandledException(exception_handle, stack_trace_handle);
    return true;
  } else if (Dart_IsFatalError(handle)) {
    // An UnwindError designed to shutdown isolates. This is thrown by
    // Isolate.exit. This is ordinary API usage, not actually an error, so
    // silently shut down the isolate. The actual isolate shutdown happens in
    // DartMessageHandler::UnhandledError.
    return true;
  } else if (Dart_IsError(handle)) {
    tonic::Log("Dart Error: %s", Dart_GetError(handle));
    return true;
  } else {
    return false;
  }
}

CreateZeroInitializedDartObject()

template<typename T >

Dart_Handle tonic::CreateZeroInitializedDartObject

(

Dart_Handle

type_handle_or_null = ::Dart_Null()

)

Definition at line 432 of file dart_converter.h.

                                                   {
  if constexpr (std::is_same<std::string, T>::value) {
    return ::Dart_EmptyString();
  } else if constexpr (std::is_integral<T>::value) {
    return ::Dart_NewIntegerFromUint64(0u);
  } else if constexpr (std::is_floating_point<T>::value) {
    return ::Dart_NewDouble(0.0);
  } else {
    auto object = ::Dart_New(type_handle_or_null, ::Dart_Null(), 0, nullptr);
    CheckAndHandleError(object);
    return object;
  }
  return ::Dart_Null();
}

DartCall()

template<typename Sig >

void tonic::DartCall	(	Sig	func,
		Dart_NativeArguments	args
	)

Definition at line 210 of file dart_args.h.

                                                   {
  DartArgIterator it(args);
  using Indices = typename IndicesForSignature<Sig>::type;
  DartDispatcher<Indices, Sig> decoder(&it);
  if (it.had_exception())
    return;
  decoder.Dispatch(func);
}

DartCallConstructor()

template<typename Sig >

void tonic::DartCallConstructor	(	Sig	func,
		Dart_NativeArguments	args
	)

Definition at line 230 of file dart_args.h.

                                                              {
  DartArgIterator it(args);
  using Indices = typename IndicesForSignature<Sig>::type;
  using Wrappable = typename DartDispatcher<Indices, Sig>::CtorResultType;
  Wrappable wrappable;
  {
    DartDispatcher<Indices, Sig> decoder(&it);
    if (it.had_exception())
      return;
    wrappable = decoder.DispatchCtor(func);
  }
 
  Dart_Handle wrapper = Dart_GetNativeArgument(args, 0);
  TONIC_CHECK(!CheckAndHandleError(wrapper));
 
  intptr_t native_fields[DartWrappable::kNumberOfNativeFields];
  TONIC_CHECK(!CheckAndHandleError(Dart_GetNativeFieldsOfArgument(
      args, 0, DartWrappable::kNumberOfNativeFields, native_fields)));
  TONIC_CHECK(!native_fields[DartWrappable::kPeerIndex]);
 
  wrappable->AssociateWithDartWrapper(wrapper);
}

DartCallStatic()

template<typename Sig >

void tonic::DartCallStatic	(	Sig	func,
		Dart_NativeArguments	args
	)

Definition at line 220 of file dart_args.h.

                                                         {
  DartArgIterator it(args, 0);
  using Indices = typename IndicesForSignature<Sig>::type;
  DartDispatcher<Indices, Sig> decoder(&it);
  if (it.had_exception())
    return;
  decoder.Dispatch(func);
}

DartInvoke()

Dart_Handle tonic::DartInvoke	(	Dart_Handle	closure,
		std::initializer_list< Dart_Handle >	args
	)

Definition at line 20 of file dart_invoke.cc.

                                                              {
  int argc = args.size();
  Dart_Handle* argv = const_cast<Dart_Handle*>(args.begin());
  Dart_Handle handle = Dart_InvokeClosure(closure, argc, argv);
  CheckAndHandleError(handle);
  return handle;
}

DartInvokeField()

Dart_Handle tonic::DartInvokeField	(	Dart_Handle	target,
		const char *	name,
		std::initializer_list< Dart_Handle >	args
	)

Definition at line 12 of file dart_invoke.cc.

                                                                   {
  Dart_Handle field = Dart_NewStringFromCString(name);
  return Dart_Invoke(target, field, args.size(),
                     const_cast<Dart_Handle*>(args.begin()));
}

DartInvokeVoid()

Dart_Handle tonic::DartInvokeVoid

(

Dart_Handle

closure

)

Definition at line 29 of file dart_invoke.cc.

                                                {
  Dart_Handle handle = Dart_InvokeClosure(closure, 0, nullptr);
  CheckAndHandleError(handle);
  return handle;
}

DartReturn()

template<typename T >

void tonic::DartReturn	(	T	result,
		Dart_NativeArguments	args
	)

Definition at line 99 of file dart_args.h.

                                                     {
  DartConverter<T>::SetReturnValue(args, std::move(result));
}

GetErrorExitCode()

int tonic::GetErrorExitCode

(

Dart_Handle

handle

)

Definition at line 68 of file dart_error.cc.

                                         {
  if (Dart_IsCompilationError(handle)) {
    return 254;  // dart::bin::kCompilationErrorExitCode
  } else if (Dart_IsApiError(handle)) {
    return 253;  // dart::bin::kApiErrorExitCode
  } else if (Dart_IsError(handle)) {
    return 255;  // dart::bin::kErrorExitCode
  } else {
    return 0;
  }
}

GetErrorHandleType()

DartErrorHandleType tonic::GetErrorHandleType

(

Dart_Handle

handle

)

Definition at line 56 of file dart_error.cc.

                                                           {
  if (Dart_IsCompilationError(handle)) {
    return kCompilationErrorType;
  } else if (Dart_IsApiError(handle)) {
    return kApiErrorType;
  } else if (Dart_IsError(handle)) {
    return kUnknownErrorType;
  } else {
    return kNoError;
  }
}

GetReceiver()

template<typename T >

T * tonic::GetReceiver ( Dart_NativeArguments  args )

inline

Definition at line 198 of file dart_wrappable.h.

                                                 {
  intptr_t receiver;
  Dart_Handle result = Dart_GetNativeReceiver(args, &receiver);
  TONIC_DCHECK(!Dart_IsError(result));
  if (!receiver)
    Dart_ThrowException(ToDart("Object has been disposed."));
  return static_cast<T*>(reinterpret_cast<DartWrappable*>(receiver));
}

Log()

void tonic::Log	(	const char *	format,
			...
	)

Definition at line 19 of file log.cc.

                                  {
  va_list ap;
  va_start(ap, format);
  int result = vsnprintf(nullptr, 0, format, ap);
  va_end(ap);
 
  if (result < 0) {
    return;
  }
 
  int size = result + 1;
  std::unique_ptr<char[]> message = std::make_unique<char[]>(size);
  va_start(ap, format);
  result = vsnprintf(message.get(), size, format, ap);
  va_end(ap);
 
  if (result < 0) {
    return;
  }
 
  if (log_handler) {
    log_handler(message.get());
  } else {
    printf("%s\n", message.get());
  }
}

LookupNonNullableType()

Dart_Handle tonic::LookupNonNullableType ( const std::string &  library_name, const std::string &  type_name  )

inline

Definition at line 396 of file dart_converter.h.

                                                                     {
  auto library =
      Dart_LookupLibrary(DartConverter<std::string>::ToDart(library_name));
  if (CheckAndHandleError(library)) {
    return library;
  }
  auto type_string = DartConverter<std::string>::ToDart(type_name);
  if (CheckAndHandleError(type_string)) {
    return type_string;
  }
  auto type = Dart_GetNonNullableType(library, type_string, 0, nullptr);
  if (CheckAndHandleError(type)) {
    return type;
  }
  return type;
}

SetLogHandler()

void tonic::SetLogHandler

(

std::function< void(const char *)>

handler

)

Definition at line 46 of file log.cc.

                                                           {
  log_handler = handler;
}

SetUnhandledExceptionReporter()

void tonic::SetUnhandledExceptionReporter

(

DartError::UnhandledExceptionReporter

reporter

)

The fallback mechanism to log errors if the platform configuration error handler returns false.

Normally, UIDartState registers with this method in its constructor.

Definition at line 28 of file dart_error.cc.

                                                  {
  log_unhandled_exception.store(reporter);
}

StdStringFromDart()

std::string tonic::StdStringFromDart ( Dart_Handle  handle )

inline

Definition at line 590 of file dart_converter.h.

                                                       {
  return DartConverter<std::string>::FromDart(handle);
}

StdStringToDart()

Dart_Handle tonic::StdStringToDart ( const std::string &  val )

inline

Definition at line 586 of file dart_converter.h.

                                                         {
  return DartConverter<std::string>::ToDart(val);
}

ToDart() [1/2]

Dart_Handle tonic::ToDart ( const char *  val )

inline

Definition at line 595 of file dart_converter.h.

                                           {
  return Dart_NewStringFromCString(val);
}

ToDart() [2/2]

template<typename T >

Dart_Handle tonic::ToDart

(

const T &

object

)

Definition at line 579 of file dart_converter.h.

                                    {
  return DartConverter<T>::ToDart(object);
}

ToDartTypeHandle()

template<typename T , std::enable_if_t< std::is_same< std::string, T >::value, int > = 0>

Dart_Handle tonic::ToDartTypeHandle

(

)

Definition at line 416 of file dart_converter.h.

                               {
  return LookupNonNullableType("dart:core", "String");
}

WriteDartArguments()

template<typename Arg , typename... Args>

void tonic::WriteDartArguments

(

std::ostringstream *

stream

)

Definition at line 283 of file dart_args.h.

                                                  {
  *stream << tonic::DartConverter<
      typename std::remove_const<typename std::remove_reference<Arg>::type>::
          type>::GetDartRepresentation();
  if constexpr (sizeof...(Args) > 0) {
    *stream << ", ";
    WriteDartArguments<Args...>(stream);
  }
}

WriteFfiArguments()

template<typename Arg , typename... Args>

void tonic::WriteFfiArguments

(

std::ostringstream *

stream

)

Definition at line 270 of file dart_args.h.

                                                 {
  *stream << tonic::DartConverter<typename std::remove_const<
      typename std::remove_reference<Arg>::type>::type>::GetFfiRepresentation();
  if constexpr (sizeof...(Args) > 0) {
    *stream << ", ";
    WriteFfiArguments<Args...>(stream);
  }
}