fl_task_runner.h File Reference

#include <glib-object.h>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"

Go to the source code of this file.

Functions
G_BEGIN_DECLS	G_DECLARE_FINAL_TYPE (FlTaskRunner, fl_task_runner, FL, TASK_RUNNER, GObject)
FlTaskRunner *	fl_task_runner_new (FlEngine *engine)
void	fl_task_runner_post_flutter_task (FlTaskRunner *task_runner, FlutterTask task, uint64_t target_time_nanos)
void	fl_task_runner_post_callback (FlTaskRunner *task_runner, void(*callback)(gpointer data), gpointer data)
void	fl_task_runner_block_main_thread (FlTaskRunner *task_runner)
void	fl_task_runner_release_main_thread (FlTaskRunner *self)

Function Documentation

fl_task_runner_block_main_thread()

void fl_task_runner_block_main_thread

(

FlTaskRunner *

task_runner

)

fl_task_runner_block_main_thread: @task_runner: an #FlTaskRunner.

Blocks main thread until fl_task_runner_release_main_thread is called. While main thread is blocked tasks posted to #FlTaskRunner are executed as usual. Must be invoked on main thread.

Definition at line 203 of file fl_task_runner.cc.

                                                          {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  g_return_if_fail(self->blocking_main_thread == FALSE);
 
  g_object_ref(self);
 
  self->blocking_main_thread = true;
  while (self->blocking_main_thread) {
    g_cond_wait_until(&self->cond, &self->mutex,
                      fl_task_runner_next_task_expiration_time_locked(self));
    fl_task_runner_process_expired_tasks_locked(self);
  }
 
  // Tasks might have changed in the meanwhile, reschedule timeout
  fl_task_runner_tasks_did_change_locked(self);
 
  g_object_unref(self);
}

References fl_task_runner_next_task_expiration_time_locked(), fl_task_runner_process_expired_tasks_locked(), and fl_task_runner_tasks_did_change_locked().

Referenced by fl_compositor_opengl_wait_for_frame().

fl_task_runner_new()

FlTaskRunner* fl_task_runner_new

(

FlEngine *

engine

)

fl_task_runner_new: @engine: the #FlEngine owning the task runner.

Creates new task runner instance.

Returns: an #FlTaskRunner.

Definition at line 167 of file fl_task_runner.cc.

                                                   {
  FlTaskRunner* self =
      FL_TASK_RUNNER(g_object_new(fl_task_runner_get_type(), nullptr));
  g_weak_ref_init(&self->engine, G_OBJECT(engine));
  return self;
}

Referenced by fl_engine_init().

fl_task_runner_post_callback()

void fl_task_runner_post_callback	(	FlTaskRunner *	task_runner,
		void(*)(gpointer data)	callback,
		gpointer	data
	)

fl_task_runner_post_callback: @task_runner: an #FlTaskRunner. @callback: callback to be scheduled @data: data to be passed to the callback

Schedules arbitrary callback to be executed on main thread. The callback will be executed in next run loop turn. This function is thread safe and may be called from any thread.

Definition at line 189 of file fl_task_runner.cc.

                                                 {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  FlTaskRunnerTask* runner_task = g_new0(FlTaskRunnerTask, 1);
  runner_task->callback = callback;
  runner_task->callback_data = data;
 
  self->pending_tasks = g_list_append(self->pending_tasks, runner_task);
  fl_task_runner_tasks_did_change_locked(self);
}

References _FlTaskRunnerTask::callback, _FlTaskRunnerTask::callback_data, and fl_task_runner_tasks_did_change_locked().

Referenced by fl_compositor_opengl_present_layers().

fl_task_runner_post_flutter_task()

void fl_task_runner_post_flutter_task	(	FlTaskRunner *	task_runner,
		FlutterTask	task,
		uint64_t	target_time_nanos
	)

fl_task_runner_post_flutter_task: @task_runner: an #FlTaskRunner. @task: Flutter task being scheduled @target_time_nanos: absolute time in nanoseconds

Posts a Flutter task to be executed on main thread. This function is thread safe and may be called from any thread.

Definition at line 174 of file fl_task_runner.cc.

                                                                  {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  FlTaskRunnerTask* runner_task = g_new0(FlTaskRunnerTask, 1);
  runner_task->task = task;
  runner_task->task_time_micros =
      target_time_nanos / kMicrosecondsPerNanosecond;
 
  self->pending_tasks = g_list_append(self->pending_tasks, runner_task);
  fl_task_runner_tasks_did_change_locked(self);
}

References fl_task_runner_tasks_did_change_locked(), kMicrosecondsPerNanosecond, _FlTaskRunnerTask::task, and _FlTaskRunnerTask::task_time_micros.

Referenced by fl_engine_post_task().

fl_task_runner_release_main_thread()

void fl_task_runner_release_main_thread

(

FlTaskRunner *

self

)

fl_task_runner_release_main_thread: @task_runner: an #FlTaskRunner.

Unblocks main thread. This will resume normal processing of main loop. Can be invoked from any thread.

Definition at line 224 of file fl_task_runner.cc.

                                                            {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  g_return_if_fail(self->blocking_main_thread == TRUE);
 
  self->blocking_main_thread = FALSE;
  g_cond_signal(&self->cond);
}

References TRUE.

Referenced by fl_compositor_opengl_unblock_main_thread().

G_DECLARE_FINAL_TYPE()

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE	(	FlTaskRunner	,
		fl_task_runner	,
		FL	,
		TASK_RUNNER	,
		GObject
	)