nyne/flutter_qjs
1
0
Fork 0
mirror of https://github.com/wgh136/flutter_qjs.git synced 2025-09-27 05:27:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1 from mabDc/master

Browse Source 
add linux default
This commit is contained in:
ekibun
2020-08-17 21:34:07 +08:00
committed by GitHub
parent 7c1c7ceee9 751394bfe2
commit 10f46c504b
15 changed files with 602 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
cxx/libquickjs.so Executable file
View File

Binary file not shown.

1
example/linux/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
flutter/ephemeral

99
example/linux/CMakeLists.txt Normal file
View File

@@ -0,0 +1,99 @@
cmake_minimum_required(VERSION 3.10)
project(runner LANGUAGES CXX)
set(BINARY_NAME "flutter_qjs_example")
set(APPLICATION_ID "soko.ekibun.flutter_qjs")
cmake_policy(SET CMP0063 NEW)
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
# Configure build options.
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE "Debug" CACHE
STRING "Flutter build mode" FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Profile" "Release")
endif()
# Compilation settings that should be applied to most targets.
function(APPLY_STANDARD_SETTINGS TARGET)
target_compile_features(${TARGET} PUBLIC cxx_std_17)
# target_compile_options(${TARGET} PRIVATE -Wall -Werror)
target_compile_options(${TARGET} PRIVATE -Wall)
target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
# Flutter library and tool build rules.
add_subdirectory(${FLUTTER_MANAGED_DIR})
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
# Application build
add_executable(${BINARY_NAME}
"main.cc"
"my_application.cc"
"${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)
apply_standard_settings(${BINARY_NAME})
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
add_dependencies(${BINARY_NAME} flutter_assemble)
# Generated plugin build rules, which manage building the plugins and adding
# them to the application.
include(flutter/generated_plugins.cmake)
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
endif()
# Start with a clean build bundle directory every time.
install(CODE "
file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
" COMPONENT Runtime)
set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
COMPONENT Runtime)
install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
COMPONENT Runtime)
install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
if(PLUGIN_BUNDLED_LIBRARIES)
install(FILES "${PLUGIN_BUNDLED_LIBRARIES}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endif()
# Fully re-copy the assets directory on each build to avoid having stale files
# from a previous install.
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "
file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
" COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
# Install the AOT library on non-Debug builds only.
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endif()

86
example/linux/flutter/CMakeLists.txt Normal file
View File

@@ -0,0 +1,86 @@
cmake_minimum_required(VERSION 3.10)
set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
# TODO: Move the rest of this into files in ephemeral. See
# https://github.com/flutter/flutter/issues/57146.
# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
# which isn't available in 3.10.
function(list_prepend LIST_NAME PREFIX)
set(NEW_LIST "")
foreach(element ${${LIST_NAME}})
list(APPEND NEW_LIST "${PREFIX}${element}")
endforeach(element)
set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
# === Flutter Library ===
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
list(APPEND FLUTTER_LIBRARY_HEADERS
"fl_basic_message_channel.h"
"fl_binary_codec.h"
"fl_binary_messenger.h"
"fl_dart_project.h"
"fl_engine.h"
"fl_json_message_codec.h"
"fl_json_method_codec.h"
"fl_message_codec.h"
"fl_method_call.h"
"fl_method_channel.h"
"fl_method_codec.h"
"fl_method_response.h"
"fl_plugin_registrar.h"
"fl_plugin_registry.h"
"fl_standard_message_codec.h"
"fl_standard_method_codec.h"
"fl_string_codec.h"
"fl_value.h"
"fl_view.h"
"flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
"${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
PkgConfig::GTK
PkgConfig::GLIB
PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
# === Flutter tool backend ===
# _phony_ is a non-existent file to force this command to run every time,
# since currently there's no way to get a full input/output list from the
# flutter tool.
add_custom_command(
OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
${CMAKE_CURRENT_BINARY_DIR}/_phony_
COMMAND ${CMAKE_COMMAND} -E env
${FLUTTER_TOOL_ENVIRONMENT}
"${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
linux-x64 ${CMAKE_BUILD_TYPE}
)
add_custom_target(flutter_assemble DEPENDS
"${FLUTTER_LIBRARY}"
${FLUTTER_LIBRARY_HEADERS}
)

13
example/linux/flutter/generated_plugin_registrant.cc Normal file
View File

@@ -0,0 +1,13 @@
//
// Generated file. Do not edit.
//
#include "generated_plugin_registrant.h"
#include <flutter_qjs/flutter_qjs_plugin.h>
void fl_register_plugins(FlPluginRegistry* registry) {
g_autoptr(FlPluginRegistrar) flutter_qjs_registrar =
fl_plugin_registry_get_registrar_for_plugin(registry, "FlutterQjsPlugin");
flutter_qjs_plugin_register_with_registrar(flutter_qjs_registrar);
}

13
example/linux/flutter/generated_plugin_registrant.h Normal file
View File

@@ -0,0 +1,13 @@
//
// Generated file. Do not edit.
//
#ifndef GENERATED_PLUGIN_REGISTRANT_
#define GENERATED_PLUGIN_REGISTRANT_
#include <flutter_linux/flutter_linux.h>
// Registers Flutter plugins.
void fl_register_plugins(FlPluginRegistry* registry);
#endif // GENERATED_PLUGIN_REGISTRANT_

16
example/linux/flutter/generated_plugins.cmake Normal file
View File

@@ -0,0 +1,16 @@
#
# Generated file, do not edit.
#
list(APPEND FLUTTER_PLUGIN_LIST
flutter_qjs
)
set(PLUGIN_BUNDLED_LIBRARIES)
foreach(plugin ${FLUTTER_PLUGIN_LIST})
add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin})
target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin)
list(APPEND PLUGIN_BUNDLED_LIBRARIES $<TARGET_FILE:${plugin}_plugin>)
list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries})
endforeach(plugin)

10
example/linux/main.cc Normal file
View File

@@ -0,0 +1,10 @@
#include "my_application.h"
int main(int argc, char** argv) {
// Only X11 is currently supported.
// Wayland support is being developed: https://github.com/flutter/flutter/issues/57932.
gdk_set_allowed_backends("x11");
g_autoptr(MyApplication) app = my_application_new();
return g_application_run(G_APPLICATION(app), argc, argv);
}

46
example/linux/my_application.cc Normal file
View File

@@ -0,0 +1,46 @@
#include "my_application.h"
#include <flutter_linux/flutter_linux.h>
#include "flutter/generated_plugin_registrant.h"
struct _MyApplication {
GtkApplication parent_instance;
};
G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
// Implements GApplication::activate.
static void my_application_activate(GApplication* application) {
GtkWindow* window =
GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
GtkHeaderBar *header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
gtk_widget_show(GTK_WIDGET(header_bar));
gtk_header_bar_set_title(header_bar, "flutter_qjs_example");
gtk_header_bar_set_show_close_button(header_bar, TRUE);
gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
gtk_window_set_default_size(window, 1280, 720);
gtk_widget_show(GTK_WIDGET(window));
g_autoptr(FlDartProject) project = fl_dart_project_new();
FlView* view = fl_view_new(project);
gtk_widget_show(GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
fl_register_plugins(FL_PLUGIN_REGISTRY(view));
gtk_widget_grab_focus(GTK_WIDGET(view));
}
static void my_application_class_init(MyApplicationClass* klass) {
G_APPLICATION_CLASS(klass)->activate = my_application_activate;
}
static void my_application_init(MyApplication* self) {}
MyApplication* my_application_new() {
return MY_APPLICATION(g_object_new(my_application_get_type(),
"application-id", APPLICATION_ID,
nullptr));
}

18
example/linux/my_application.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef FLUTTER_MY_APPLICATION_H_
#define FLUTTER_MY_APPLICATION_H_
#include <gtk/gtk.h>
G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION,
GtkApplication)
/**
* my_application_new:
*
* Creates a new Flutter-based application.
*
* Returns: a new #MyApplication.
*/
MyApplication* my_application_new();
#endif // FLUTTER_MY_APPLICATION_H_

24
linux/CMakeLists.txt Normal file
View File

@@ -0,0 +1,24 @@
cmake_minimum_required(VERSION 3.10)
set(PROJECT_NAME "flutter_qjs")
project(${PROJECT_NAME} LANGUAGES CXX)
set(PLUGIN_NAME "${PROJECT_NAME}_plugin")
add_library(${PLUGIN_NAME} SHARED
"${PLUGIN_NAME}.cc"
)
apply_standard_settings(${PLUGIN_NAME})
set_target_properties(${PLUGIN_NAME} PROPERTIES
CXX_VISIBILITY_PRESET hidden)
target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
target_include_directories(${PLUGIN_NAME} INTERFACE
"${CMAKE_CURRENT_SOURCE_DIR}/include")
target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)
target_link_libraries(${PLUGIN_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../cxx/libquickjs.so")
target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
# List of absolute paths to libraries that should be bundled with the plugin
set(flutter_qjs_bundled_libraries
""
PARENT_SCOPE
)

169
linux/dart_js_wrapper.hpp Normal file
View File

@@ -0,0 +1,169 @@
/*
* @Description:
* @Author: ekibun
* @Date: 2020-08-14 21:45:02
* @LastEditors: ekibun
* @LastEditTime: 2020-08-15 15:42:55
*/
#include "../cxx/js_engine.hpp"
// #include <flutter/standard_method_codec.h>
#include <flutter_linux/flutter_linux.h>
#include <variant>
namespace std
{
template <>
struct hash<qjs::Value>
{
std::size_t operator()(const qjs::Value &key) const
{
return std::hash<std::string>()((std::string)key);
}
};
template <>
struct hash<FlValue>
{
std::size_t operator()(const FlValue *&key) const
{
return 0;
}
};
} // namespace std
namespace qjs
{
JSValue dartToJsAtom(JSContext *ctx, FlValue *val)
{
FlValueType valType = fl_value_get_type(val);
switch (valType)
{
case FL_VALUE_TYPE_BOOL:
return JS_NewBool(ctx, fl_value_get_bool(val));
case FL_VALUE_TYPE_INT:
return JS_NewInt64(ctx, fl_value_get_int(val));
case FL_VALUE_TYPE_FLOAT:
return JS_NewFloat64(ctx, fl_value_get_float(val));
case FL_VALUE_TYPE_STRING:
return JS_NewString(ctx, fl_value_get_string(val));
case FL_VALUE_TYPE_UINT8_LIST:
return JS_NewArrayBufferCopy(ctx, fl_value_get_uint8_list(val), fl_value_get_length(val));
case FL_VALUE_TYPE_INT32_LIST:
return JS_NewArrayBufferCopy(ctx, (uint8_t *)fl_value_get_int32_list(val), fl_value_get_length(val));
case FL_VALUE_TYPE_INT64_LIST:
return JS_NewArrayBufferCopy(ctx, (uint8_t *)fl_value_get_int64_list(val), fl_value_get_length(val));
// case FL_VALUE_TYPE_FLOAT_LIST:
// auto buf = fl_value_get_float_list(val);
// auto size = fl_value_get_length(val);
// JSValue array = JS_NewArray(ctx);
// for (size_t i = 0; i < size; i++)
// JS_DefinePropertyValue(
// ctx, array, JS_NewAtomUInt32(ctx, i), JS_NewFloat64(ctx, buf[i]),
// JS_PROP_C_W_E);
// return array;
default:
return JS_UNDEFINED;
}
}
JSValue dartToJs(JSContext *ctx, FlValue *val, std::unordered_map<FlValue *, JSValue> cache = std::unordered_map<FlValue *, JSValue>())
{
if (fl_value_get_type(val) == FL_VALUE_TYPE_NULL)
return JS_UNDEFINED;
if (cache.find(val) != cache.end())
return cache[val];
{
JSValue atomValue = dartToJsAtom(ctx, val);
if (!JS_IsUndefined(atomValue))
return atomValue;
}
// if (std::holds_alternative<flutter::EncodableList>(val))
// {
// auto list = std::get<flutter::EncodableList>(val);
// JSValue array = JS_NewArray(ctx);
// cache[val] = array;
// auto size = (uint32_t)list.size();
// for (uint32_t i = 0; i < size; i++)
// JS_DefinePropertyValue(
// ctx, array, JS_NewAtomUInt32(ctx, i), dartToJs(ctx, list[i], cache),
// JS_PROP_C_W_E);
// return array;
// }
// if (std::holds_alternative<flutter::EncodableMap>(val))
// {
// auto map = std::get<flutter::EncodableMap>(val);
// JSValue obj = JS_NewObject(ctx);
// cache[val] = obj;
// for (auto iter = map.begin(); iter != map.end(); ++iter)
// JS_DefinePropertyValue(
// ctx, obj, JS_ValueToAtom(ctx, dartToJs(ctx, iter->first, cache)), dartToJs(ctx, iter->second, cache),
// JS_PROP_C_W_E);
// return obj;
// }
return JS_UNDEFINED;
}
FlValue *jsToDart(Value val, std::unordered_map<Value, FlValue *> cache = std::unordered_map<Value, FlValue *>())
{
if (cache.find(val) != cache.end())
return cache[val];
if (JS_IsBool(val.v))
return fl_value_new_bool((bool)val);
if (JS_IsNumber(val.v))
return fl_value_new_float((double)val);
if (JS_IsString(val.v))
return fl_value_new_string(((std::string)val).c_str());
{ // ArrayBuffer
size_t size;
uint8_t *buf = JS_GetArrayBuffer(val.ctx, &size, val.v);
if (buf)
// return (std::vector<uint8_t>(buf, buf + size));
return fl_value_new_uint8_list(buf, size);
}
FlValue *ret;
if (JS_IsUndefined(val.v) || JS_IsNull(val.v) || JS_IsUninitialized(val.v))
goto exception;
// if (JS_IsObject(val.v))
// {
// if (JS_IsFunction(val.ctx, val.v))
// {
// flutter::EncodableMap retMap;
// retMap[std::string("__js_function__")] = (int64_t) new JSValue{JS_DupValue(val.ctx, val.v)};
// ret = retMap;
// }
// else if (JS_IsArray(val.ctx, val.v) > 0)
// {
// flutter::EncodableList retList;
// cache[val] = retList;
// uint32_t arrlen = (uint32_t)val["length"];
// for (uint32_t i = 0; i < arrlen; i++)
// {
// retList.push_back(jsToDart(val[i], cache));
// }
// ret = retList;
// }
// else
// {
// qjs::JSPropertyEnum *ptab;
// uint32_t plen;
// if (JS_GetOwnPropertyNames(val.ctx, &ptab, &plen, val.v, -1))
// goto exception;
// flutter::EncodableMap retMap;
// cache[val] = retMap;
// for (uint32_t i = 0; i < plen; i++)
// {
// retMap[jsToDart({val.ctx, JS_AtomToValue(val.ctx, ptab[i].atom)}, cache)] =
// jsToDart({val.ctx, JS_GetProperty(val.ctx, val.v, ptab[i].atom)}, cache);
// JS_FreeAtom(val.ctx, ptab[i].atom);
// }
// js_free(val.ctx, ptab);
// ret = retMap;
// }
// goto done;
// }
exception:
ret = fl_value_new_null();
done:
return ret;
}
} // namespace qjs

79
linux/flutter_qjs_plugin.cc Normal file
View File

@@ -0,0 +1,79 @@
#include "include/flutter_qjs/flutter_qjs_plugin.h"
#include <flutter_linux/flutter_linux.h>
#include <gtk/gtk.h>
#include <sys/utsname.h>
#include "dart_js_wrapper.hpp"
#define FLUTTER_QJS_PLUGIN(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), flutter_qjs_plugin_get_type(), \
FlutterQjsPlugin))
struct _FlutterQjsPlugin
{
GObject parent_instance;
};
G_DEFINE_TYPE(FlutterQjsPlugin, flutter_qjs_plugin, g_object_get_type())
// Called when a method call is received from Flutter.
static void flutter_qjs_plugin_handle_method_call(
FlutterQjsPlugin *self,
FlMethodCall *method_call)
{
g_autoptr(FlMethodResponse) response = nullptr;
const gchar *method = fl_method_call_get_name(method_call);
if (strcmp(method, "getPlatformVersion") == 0)
{
struct utsname uname_data = {};
uname(&uname_data);
g_autofree gchar *version = g_strdup_printf("Linux %s", uname_data.version);
g_autoptr(FlValue) result = fl_value_new_string(version);
response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
}
else
{
response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
}
fl_method_call_respond(method_call, response, nullptr);
}
static void flutter_qjs_plugin_dispose(GObject *object)
{
G_OBJECT_CLASS(flutter_qjs_plugin_parent_class)->dispose(object);
}
static void flutter_qjs_plugin_class_init(FlutterQjsPluginClass *klass)
{
G_OBJECT_CLASS(klass)->dispose = flutter_qjs_plugin_dispose;
}
static void flutter_qjs_plugin_init(FlutterQjsPlugin *self) {}
static void method_call_cb(FlMethodChannel *channel, FlMethodCall *method_call,
gpointer user_data)
{
FlutterQjsPlugin *plugin = FLUTTER_QJS_PLUGIN(user_data);
flutter_qjs_plugin_handle_method_call(plugin, method_call);
}
void flutter_qjs_plugin_register_with_registrar(FlPluginRegistrar *registrar)
{
FlutterQjsPlugin *plugin = FLUTTER_QJS_PLUGIN(
g_object_new(flutter_qjs_plugin_get_type(), nullptr));
g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
g_autoptr(FlMethodChannel) channel =
fl_method_channel_new(fl_plugin_registrar_get_messenger(registrar),
"flutter_qjs",
FL_METHOD_CODEC(codec));
fl_method_channel_set_method_call_handler(channel, method_call_cb,
g_object_ref(plugin),
g_object_unref);
g_object_unref(plugin);
}

26
linux/include/flutter_qjs/flutter_qjs_plugin.h Normal file
View File

@@ -0,0 +1,26 @@
#ifndef FLUTTER_PLUGIN_FLUTTER_QJS_PLUGIN_H_
#define FLUTTER_PLUGIN_FLUTTER_QJS_PLUGIN_H_
#include <flutter_linux/flutter_linux.h>
G_BEGIN_DECLS
#ifdef FLUTTER_PLUGIN_IMPL
#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
#else
#define FLUTTER_PLUGIN_EXPORT
#endif
typedef struct _FlutterQjsPlugin FlutterQjsPlugin;
typedef struct {
GObjectClass parent_class;
} FlutterQjsPluginClass;
FLUTTER_PLUGIN_EXPORT GType flutter_qjs_plugin_get_type();
FLUTTER_PLUGIN_EXPORT void flutter_qjs_plugin_register_with_registrar(
FlPluginRegistrar* registrar);
G_END_DECLS
#endif // FLUTTER_PLUGIN_FLUTTER_QJS_PLUGIN_H_

2
pubspec.yaml
View File

@@ -34,6 +34,8 @@ flutter:
# ------------------- # -------------------
windows: windows:
pluginClass: FlutterQjsPlugin pluginClass: FlutterQjsPlugin
linux:
pluginClass: FlutterQjsPlugin
android: android:
pluginClass: FlutterQjsPlugin pluginClass: FlutterQjsPlugin
package: soko.ekibun.flutter_qjs package: soko.ekibun.flutter_qjs