kodik-mpv-plugin 0.1.0

mpv plugin to get direct links to Kodik
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
80
81

use std::ffi::c_int;

use log::LevelFilter;
use mpv_client::{Event, Handle, mpv_handle};

mod cache;
mod config;
mod events;
mod kodik;
mod logger;
mod mpv_ext;
mod shiki;
mod state;

use crate::cache::Cache;
use crate::state::PluginState;

#[allow(unsafe_code)]
#[unsafe(no_mangle)]
extern "C" fn mpv_open_cplugin(handle: *mut mpv_handle) -> c_int {
    let mpv = Handle::from_ptr(handle);
    log::set_max_level(LevelFilter::Error);

    let mut state = match PluginState::new(mpv) {
        Ok(state) => state,
        Err(err) => {
            log::error!("failed to initialize plugin state: {err:?}");
            return 1;
        }
    };

    logger::init_logger(mpv.name(), state.config().log_level());

    let mut cache = match Cache::load(mpv) {
        Ok(cache) => cache,
        Err(err) => {
            log::error!("failed to load cache: {err:?}");
            return 1;
        }
    };

    if let Err(err) = events::register(mpv) {
        log::error!("failed to register hooks: {err:?}");
        return 1;
    }

    loop {
        match mpv.wait_event(-1.) {
            Event::Shutdown => break,
            Event::Hook(reply, hook) => {
                if let Err(err) = events::handle_event(&mut state, mpv, reply) {
                    log::error!("hook `{}` failed: {err:?}", hook.name());
                }

                if let Err(err) = mpv.hook_continue(hook.id()) {
                    log::error!("failed to continue hook `{}`: {:?}", hook.name(), err);
                }
            }
            Event::ClientMessage(data) => {
                if let ["key-binding", "watched", "d--" | "dm-", ..] = data.args().as_slice()
                    && let Err(err) = events::mark_as_watched(&mut state, mpv)
                {
                    log::error!("failed to mark as watched: {err:?}");
                }
            }
            Event::PropertyChange(reply, property) => {
                if let Err(err) = events::handle_event(&mut state, mpv, reply) {
                    log::error!("observe `{}` failed: {err:?}", property.name());
                }
            }
            _ => {}
        }
    }

    if let Err(err) = cache.update_and_save() {
        log::error!("failed to update and save cache: {err}");
        return 1;
    }

    0
}