Ekhlass/Flutter_Documentation · Datasets at Hugging Face

text stringlengths 1 474
the macOS code written in the previous step. If an unknown method
is called, report that instead.
<code_start>batteryChannel.setMethodCallHandler { (call, result) in
switch call.method {
case "getBatteryLevel":
guard let level = getBatteryLevel() else {
result(
FlutterError(
code: "UNAVAILABLE",
message: "Battery level not available",
details: nil))
return
}
result(level)
default:
result(FlutterMethodNotImplemented)
}
}<code_end>
You should now be able to run the application on macOS.
If your device doesn’t have a battery,
it displays ‘Battery level not available’.<topic_end>
<topic_start>
Step 7: Add a Linux platform-specific implementation
For this example you need to install the upower developer headers.
This is likely available from your distribution, for example with:Start by opening the Linux host portion of your Flutter app in the editor
of your choice. The instructions below are for Visual Studio Code with the
“C/C++” and “CMake” extensions installed, but can be adjusted for other IDEs.Launch Visual Studio Code.Open the linux directory inside your project.Choose Yes in the prompt asking: Would you like to configure project "linux"?.
This enables C++ autocomplete.Open the file my_application.cc.First, add the necessary includes to the top of the file, just
after #include <flutter_linux/flutter_linux.h:
<code_start>#include <math.h>
#include <upower.h><code_end>
Add an FlMethodChannel to the _MyApplication struct:
<code_start>struct _MyApplication {
GtkApplication parent_instance;
char** dart_entrypoint_arguments;
FlMethodChannel* battery_channel;
};<code_end>
Make sure to clean it up in my_application_dispose:
<code_start>static void my_application_dispose(GObject* object) {
MyApplication* self = MY_APPLICATION(object);
g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
g_clear_object(&self->battery_channel);
G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}<code_end>
Edit the my_application_activate method and initialize
battery_channel using the channel name
samples.flutter.dev/battery, just after the call to
fl_register_plugins:
<code_start>static void my_application_activate(GApplication* application) {
// ...
fl_register_plugins(FL_PLUGIN_REGISTRY(self->view));
g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
self->battery_channel = fl_method_channel_new(
fl_engine_get_binary_messenger(fl_view_get_engine(view)),
"samples.flutter.dev/battery", FL_METHOD_CODEC(codec));
fl_method_channel_set_method_call_handler(
self->battery_channel, battery_method_call_handler, self, nullptr);
gtk_widget_grab_focus(GTK_WIDGET(self->view));
}<code_end>
Next, add the C code that uses the Linux battery APIs to
retrieve the battery level. This code is exactly the same as
you would write in a native Linux application.Add the following as a new function at the top of
my_application.cc just after the G_DEFINE_TYPE line:
<code_start>static FlMethodResponse* get_battery_level() {
// Find the first available battery and report that.
g_autoptr(UpClient) up_client = up_client_new();
g_autoptr(GPtrArray) devices = up_client_get_devices2(up_client);
if (devices->len == 0) {
return FL_METHOD_RESPONSE(fl_method_error_response_new(
"UNAVAILABLE", "Device does not have a battery.", nullptr));
}
UpDevice* device = (UpDevice*)(g_ptr_array_index(devices, 0));
double percentage = 0;
g_object_get(device, "percentage", &percentage, nullptr);
g_autoptr(FlValue) result =
fl_value_new_int(static_cast<int64_t>(round(percentage)));
return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
}<code_end>
Finally, add the battery_method_call_handler function referenced
in the earlier call to fl_method_channel_set_method_call_handler.
You need to handle a single platform method, getBatteryLevel,
so test for that in the method_call argument.
The implementation of this function calls
the Linux code written in the previous step. If an unknown method
is called, report that instead.Add the following code after the get_battery_level function:
<code_start>static void battery_method_call_handler(FlMethodChannel* channel,
FlMethodCall* method_call,
gpointer user_data) {
g_autoptr(FlMethodResponse) response = nullptr;
if (strcmp(fl_method_call_get_name(method_call), "getBatteryLevel") == 0) {
response = get_battery_level();
} else {
response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
}
g_autoptr(GError) error = nullptr;
if (!fl_method_call_respond(method_call, response, &error)) {
g_warning("Failed to send response: %s", error->message);
}
}<code_end>
You should now be able to run the application on Linux.

the macOS code written in the previous step. If an unknown method

is called, report that instead.

<code_start>batteryChannel.setMethodCallHandler { (call, result) in

switch call.method {

case "getBatteryLevel":

guard let level = getBatteryLevel() else {

result(

FlutterError(

code: "UNAVAILABLE",

message: "Battery level not available",

details: nil))

return

}

result(level)

default:

result(FlutterMethodNotImplemented)

}

}<code_end>

You should now be able to run the application on macOS.

If your device doesn’t have a battery,

it displays ‘Battery level not available’.<topic_end>

<topic_start>

Step 7: Add a Linux platform-specific implementation

For this example you need to install the upower developer headers.

This is likely available from your distribution, for example with:Start by opening the Linux host portion of your Flutter app in the editor

of your choice. The instructions below are for Visual Studio Code with the

“C/C++” and “CMake” extensions installed, but can be adjusted for other IDEs.Launch Visual Studio Code.Open the linux directory inside your project.Choose Yes in the prompt asking: Would you like to configure project "linux"?.

This enables C++ autocomplete.Open the file my_application.cc.First, add the necessary includes to the top of the file, just

after #include <flutter_linux/flutter_linux.h:

<code_start>#include <math.h>

#include <upower.h><code_end>

Add an FlMethodChannel to the _MyApplication struct:

<code_start>struct _MyApplication {

GtkApplication parent_instance;

char** dart_entrypoint_arguments;

FlMethodChannel* battery_channel;

};<code_end>

Make sure to clean it up in my_application_dispose:

<code_start>static void my_application_dispose(GObject* object) {

MyApplication* self = MY_APPLICATION(object);

g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);

g_clear_object(&self->battery_channel);

G_OBJECT_CLASS(my_application_parent_class)->dispose(object);

}<code_end>

Edit the my_application_activate method and initialize

battery_channel using the channel name

samples.flutter.dev/battery, just after the call to

fl_register_plugins:

<code_start>static void my_application_activate(GApplication* application) {

// ...

fl_register_plugins(FL_PLUGIN_REGISTRY(self->view));

g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();

self->battery_channel = fl_method_channel_new(

fl_engine_get_binary_messenger(fl_view_get_engine(view)),

"samples.flutter.dev/battery", FL_METHOD_CODEC(codec));

fl_method_channel_set_method_call_handler(

self->battery_channel, battery_method_call_handler, self, nullptr);

gtk_widget_grab_focus(GTK_WIDGET(self->view));

}<code_end>

Next, add the C code that uses the Linux battery APIs to

retrieve the battery level. This code is exactly the same as

you would write in a native Linux application.Add the following as a new function at the top of

my_application.cc just after the G_DEFINE_TYPE line:

<code_start>static FlMethodResponse* get_battery_level() {

// Find the first available battery and report that.

g_autoptr(UpClient) up_client = up_client_new();

g_autoptr(GPtrArray) devices = up_client_get_devices2(up_client);

if (devices->len == 0) {

return FL_METHOD_RESPONSE(fl_method_error_response_new(

"UNAVAILABLE", "Device does not have a battery.", nullptr));

}

UpDevice* device = (UpDevice*)(g_ptr_array_index(devices, 0));

double percentage = 0;

g_object_get(device, "percentage", &percentage, nullptr);

g_autoptr(FlValue) result =

fl_value_new_int(static_cast<int64_t>(round(percentage)));

return FL_METHOD_RESPONSE(fl_method_success_response_new(result));

}<code_end>

Finally, add the battery_method_call_handler function referenced

in the earlier call to fl_method_channel_set_method_call_handler.

You need to handle a single platform method, getBatteryLevel,

so test for that in the method_call argument.

The implementation of this function calls

the Linux code written in the previous step. If an unknown method

is called, report that instead.Add the following code after the get_battery_level function:

<code_start>static void battery_method_call_handler(FlMethodChannel* channel,

FlMethodCall* method_call,

gpointer user_data) {

g_autoptr(FlMethodResponse) response = nullptr;

if (strcmp(fl_method_call_get_name(method_call), "getBatteryLevel") == 0) {

response = get_battery_level();

} else {

response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());

}

g_autoptr(GError) error = nullptr;

if (!fl_method_call_respond(method_call, response, &error)) {

g_warning("Failed to send response: %s", error->message);

}

}<code_end>

You should now be able to run the application on Linux.