nativeshell 0.1.16

NativeShell Rust package
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use super::{
    binary_messenger::PlatformBinaryMessenger,
    error::{PlatformError, PlatformResult},
};
use crate::shell::platform::platform_impl::utils::{class_from_string, to_nsstring};
use cocoa::base::{id, nil, BOOL, NO};
use log::warn;
use objc::{
    class, msg_send,
    rc::{autoreleasepool, StrongPtr},
    sel, sel_impl,
};

pub type PlatformEngineType = StrongPtr;

pub struct PlatformEngine {
    pub(crate) handle: PlatformEngineType,
    pub(super) view_controller: StrongPtr,
}

pub struct PlatformPlugin {
    pub name: String,
    pub class: String,
}

impl PlatformEngine {
    pub fn new(plugins: &[PlatformPlugin]) -> Self {
        autoreleasepool(|| unsafe {
            let class = class!(FlutterViewController);
            let view_controller: id = msg_send![class, alloc];
            let view_controller = StrongPtr::new(msg_send![view_controller, initWithProject: nil]);
            let engine: id = msg_send![*view_controller, engine];

            // register plugins with this engine
            for plugin in plugins {
                let class = class_from_string(&plugin.class);
                if class.is_null() {
                    warn!(
                        "Plugin {} for plugin {} not found",
                        plugin.name, plugin.class
                    );
                } else {
                    let registrar: id =
                        msg_send![engine, registrarForPlugin: *to_nsstring(&plugin.name)];
                    let () = msg_send![class, registerWithRegistrar: registrar];
                }
            }

            Self {
                handle: StrongPtr::retain(engine),
                view_controller,
            }
        })
    }

    pub fn new_binary_messenger(&self) -> PlatformBinaryMessenger {
        autoreleasepool(|| unsafe {
            let messenger: id = msg_send![*self.handle, binaryMessenger];
            PlatformBinaryMessenger::from_handle(StrongPtr::retain(messenger))
        })
    }

    pub fn launch(&mut self) -> PlatformResult<()> {
        let res: BOOL =
            autoreleasepool(|| unsafe { msg_send![*self.view_controller, launchEngine] });
        if res == NO {
            Err(PlatformError::LaunchEngineFailure)
        } else {
            Ok(())
        }
    }

    pub fn shut_down(&mut self) -> PlatformResult<()> {
        autoreleasepool(|| unsafe {
            let () = msg_send![*self.handle, shutDownEngine];
        });
        Ok(())
    }
}