boox-note-parser 0.2.0

A Rust library for parsing .note files from Onyx Boox e-ink devices.
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use crate::{
    error::Result,
    id::PageUuid,
    json::Dimensions,
    utils::{convert_timestamp_to_datetime, parse_json},
};

#[derive(Debug, Clone)]
pub struct VirtualPage {
    pub page_id: PageUuid,
    pub created: chrono::DateTime<chrono::Utc>,
    pub modified: chrono::DateTime<chrono::Utc>,
    pub zoom_scale: f32,
    pub dimensions: Dimensions,
    pub layout: Dimensions,
    pub geo: Dimensions,
    pub geo_layout: String,
    pub template_path: String,
    pub page_number: String,
}

impl VirtualPage {
    pub fn read(mut reader: impl std::io::Read) -> Result<Self> {
        let container = protobuf::VirtualPageContainer::read(&mut reader)?;
        Ok(Self {
            page_id: PageUuid::from_str(&container.virtual_page.page_uuid)?,
            created: convert_timestamp_to_datetime(container.virtual_page.created)?,
            modified: convert_timestamp_to_datetime(container.virtual_page.modified)?,
            zoom_scale: container.virtual_page.zoom_scale,
            dimensions: parse_json(&container.virtual_page.dimensions_json)?,
            layout: parse_json(&container.virtual_page.layout_json)?,
            geo: parse_json(&container.virtual_page.geo_json)?,
            geo_layout: container.virtual_page.geo_layout.clone(),
            template_path: container.virtual_page.template_path.clone(),
            page_number: container.virtual_page.page_number.clone(),
        })
    }
}

pub mod protobuf {
    use prost::Message;

    use crate::error::Result;

    #[derive(Clone, PartialEq, Message)]
    pub struct VirtualPageContainer {
        #[prost(message, required, tag = "1")]
        pub virtual_page: VirtualPage,
    }

    impl VirtualPageContainer {
        pub fn read(mut reader: impl std::io::Read) -> Result<Self> {
            let mut buf = Vec::new();
            reader.read_to_end(&mut buf)?;

            Ok(VirtualPageContainer::decode(&buf[..])?)
        }
    }

    #[derive(Clone, PartialEq, Message)]
    pub struct VirtualPage {
        // Confirmed
        #[prost(string, tag = "1")]
        pub page_uuid: String,
        // Confirmed
        #[prost(uint64, tag = "2")]
        pub created: u64,
        // Confirmed
        #[prost(uint64, tag = "3")]
        pub modified: u64,
        // Uncertain
        #[prost(float, tag = "4")]
        pub zoom_scale: f32,
        // Uncertain
        #[prost(string, tag = "6")]
        pub dimensions_json: String,
        // Uncertain
        #[prost(string, tag = "7")]
        pub layout_json: String,
        // Uncertain
        #[prost(string, tag = "8")]
        pub geo_json: String,
        // Uncertain
        #[prost(string, tag = "9")]
        pub geo_layout: String,
        // Confirmed
        #[prost(string, tag = "10")]
        pub template_path: String,
        // Uncertain
        #[prost(string, tag = "12")]
        pub page_number: String,
    }
}