Flutter Desktop native Plugins

┌native_file_lib
├──.dart-tool
├─┬example
│ ├⋯
│ ⋮
├─┬lib
│ ├──native_file_lib.dart
│ ├──native_file_lib_method_channel.dart
│ └──native_file_lib_platform_interface.dart
├─┬linux
│ ├─┬include
│ │ └─┬native_file_lib
│ │   └──native_file_lib_plugin.h
│ ├──CMakeList.txt
│ └──native_file_lib_plugin.cc
├──test
├─┬windows
│ ├─┬include
│ │ └─┬native_file_lib
│ │   └──native_file_lib_plugin_c_api.h
│ ├──.gitignore
│ ├──CMakeList.txt
│ ├──native_file_lib_plugin.cpp
│ ├──native_file_lib_plugin.h
│ └──native_file_lib_plugin_c_api.cpp
├──.gitignore
├──.metadata
├──analysis_options.yaml
├──CHANGELOG.md
├──LICENSE
├──native_file_lib.iml
├──pubspec.lock
├──pubspec.yaml
└──README.md

import 'package:plugin_platform_interface/plugin_platform_interface.dart';

import 'native_file_lib_method_channel.dart';

abstract class NativeFileLibPlatform extends PlatformInterface {
  /// Constructs a MethodChannelsPlatform.
  NativeFileLibPlatform() : super(token: _token);

  static final Object _token = Object();

  static NativeFileLibPlatform _instance = MethodChannelNativeFileLib();

  /// The default instance of [HelloWorldPlatform] to use.
  ///
  /// Defaults to [MethodChannelHelloWorldLib].
  static NativeFileLibPlatform get instance => _instance;

  /// Platform-specific implementations should set this with their own
  /// platform-specific class that extends [MethodChannelsPlatform] when
  /// they register themselves.
  static set instance(NativeFileLibPlatform instance) {
    PlatformInterface.verifyToken(instance, _token);
    _instance = instance;
  }

  Future<String?> getPlatformVersion() {
    throw UnimplementedError('platformVersion() has not been implemented.');
  }
  
  /// Saves a file.
  Future<void> saveFile({
    required String filepath,
    required String content,
  }) {
    throw UnimplementedError('saveFile() has not been implemented,');
  }
  
  /// Loads a file
  Future<String?> loadFile(String filepath) {
    throw UnimplementedError('saveFile() has not been implemented,');
  }
}

import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';

import 'native_file_lib_platform_interface.dart';

/// An implementation of [NativeFileLibPlatform] that uses method channels.
class MethodChannelNativeFileLib extends NativeFileLibPlatform {
  /// The method channel used to interact with the native platform.
  @visibleForTesting
  final methodChannel = const MethodChannel('native_file_lib');

  @override
  Future<String?> getPlatformVersion() =>
     methodChannel.invokeMethod<String>('getPlatformVersion');
  
  @override
  Future<void> saveFile({
    required String filepath,
    required String content,
  }) => methodChannel.invokeMethod('save', {
     'filepath': filepath, 
     'content': chontent,
  });
  
  @override
  Future<String?> loadFile(String filepath) => 
     methodChannel.invokeMethod<String>('load', filepath);
}

import 'native_file_lib_platform_interface.dart';

class NativeFileLib {
  Future<String?> getPlatformVersion() {
    return NativeFileLibPlatform.instance.getPlatformVersion();
  }
  
  Future<void> saveFile({
    required String filepath,
    required String content,
  }) {
    return NativeFileLibPlatform.instance.saveFile(
      filepath: filepath,
      content: content,
    );
  }
  
  Future<String?> loadFile(String filepath) {
    return NativeFileLibPlatform.instance.loadFile(filepath);
  }
}

#ifndef FLUTTER_PLUGIN_NATIVE_FILE_LIB_PLUGIN_H_
#define FLUTTER_PLUGIN_NATIVE_FILE_LIB_PLUGIN_H_

#include <flutter/method_channel.h>
#include <flutter/plugin_registrar_windows.h>

#include <memory>

namespace native_file_lib {

class NativeFileLibPlugin : public flutter::Plugin {
 public:
  static void RegisterWithRegistrar(flutter::PluginRegistrarWindows *registrar);

  NativeFileLibPlugin();

  virtual ~NativeFileLibPlugin();

  // Disallow copy and assign.
  NativeFileLibPlugin(const NativeFileLibPlugin&) = delete;
  NativeFileLibPlugin& operator=(const NativeFileLibPlugin&) = delete;

 private:
  // Called when a method is called on this plugin's channel from Dart.
  void HandleMethodCall(
      const flutter::MethodCall<flutter::EncodableValue> &method_call,
      std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
      
  // These are the two additional methods, that we need.
  void SaveFile(const std::string &filepath, const std::string &content);
  std::unique_ptr<std::string> LoadFile(const std::string *filepath);
};

}  // namespace native_file_lib

#endif  // FLUTTER_PLUGIN_NATIVE_FILE_LIB_PLUGIN_H_

void NativeFileLibPlugin::SaveFile(const std::string &filepath, const std::string &content) {
    std::ofstream out;
    out.open(filepath, std::ios_base::app);
    out << content.c_str() << std::endl;
    out.close();
}

std::unique_ptr<std::string> NativeFileLibPlugin::LoadFile(const std::string *filepath) {
    std::ifstream in;
    std::string buffer;        
    auto content = std::make_unique<std::string>();
    in.open(filepath->c_str());

    while (std::getline(in, buffer))
        content->append(buffer);
        
    in.close();
    return std::move(content);
}

void NativeFileLibPlugin::HandleMethodCall(
    const flutter::MethodCall<flutter::EncodableValue> &method_call,
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
  if (method_call.method_name().compare("getPlatformVersion") == 0) {
    std::ostringstream version_stream;
    version_stream << "Windows ";
    if (IsWindows10OrGreater()) {
      version_stream << "10+";
    } else if (IsWindows8OrGreater()) {
      version_stream << "8";
    } else if (IsWindows7OrGreater()) {
      version_stream << "7";
    }
    result->Success(flutter::EncodableValue(version_stream.str()));
  } else if (method_call.method_name().compare("save") == 0) {
       /* ↓ saving */
      if (auto* args = std::get_if<flutter::EncodableMap>(method_call.arguments())) {
          try {
              const std::string filepath = std::get<std::string>(args->at(flutter::EncodableValue("filepath")));
              const std::string content = std::get<std::string>(args->at(flutter::EncodableValue("content")));
              SaveFile(filepath, content);
              result->Success(flutter::EncodableValue(nullptr));

          } catch (const std::system_error& ex) {
              result->Error(std::to_string(ex.code().value()), ex.what());
          }          
      } else {
          result->Error("0x01", "Invalid arguments: filepath and content are required.");
      }     
      /* ↑ */
  } else if (method_call.method_name().compare("load") == 0) {
      /* ↓ loading */
      if (auto filepath = std::get_if<std::string>(method_call.arguments())) {
          try {
              auto content = LoadFile(filepath);
              result->Success(flutter::EncodableValue(content->c_str()));

          } catch (const std::system_error& ex) {
              result->Error(std::to_string(ex.code().value()), ex.what());
          }
      } else {
          result->Error("0x01", "Invalid arguments: filepath is required.");
      }
      /* ↑ */
  } else {
    result->NotImplemented();
  }
}

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'dart:async';

import 'package:flutter/services.dart';
import 'package:native_file_lib/native_file_lib.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  String _content = 'Unknown';
  final _nativeFileLibPlugin = NativeFileLib();

  @override
  void initState() {
    super.initState();
    initPlatformState();
  }

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> initPlatformState() async {
    String? platformVersion;
    String? content;
    // Platform messages may fail, so we use a try/catch PlatformException.
    // We also handle the message potentially returning null.
    try {
      platformVersion =
          await _nativeFileLibPlugin.getPlatformVersion();
		  
	    content = await _nativeFileLibPlugin.loadFile('test.txt');
    } on PlatformException {
      platformVersion ??= 'unknown platform version';
      content ??= 'Hello World from $platformVersion';
      await _nativeFileLibPlugin.saveFile(
        filepath: 'test.txt',
        content: 'Hello World from $platformVersion',
      );

    }

    // If the widget was removed from the tree while the asynchronous platform
    // message was in flight, we want to discard the reply rather than calling
    // setState to update our non-existent appearance.
    if (!mounted) return;

    if (kDebugMode) print(content);

    setState(() {
      _content = content!;
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Plugin example app'),
        ),
        body: Center(
          child: Text(_content),
        ),
      ),
    );
  }
}