rs1090 0.5.2

Rust library to decode Mode S and ADS-B signals
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use rusqlite::Connection;
use std::collections::BTreeMap;
use std::fs::{self, File};
use std::io::{copy, BufReader, Cursor};
use zip::read::ZipArchive;

#[derive(Debug)]
pub struct Aircraft {
    /// The ICAO 24-bit transponder address
    icao24: String,
    /// The ICAO typecode of the aircraft, e.g. A320, B789, etc.
    pub typecode: Option<String>,
    /// The last known tail number of the aircraft
    pub registration: Option<String>,
}

type Result<T> =
    std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;

async fn download_file(url: &str, destination: &str) -> Result<()> {
    let response = reqwest::get(url).await?.bytes().await?;
    let mut file = File::create(destination)?;
    let mut content = Cursor::new(response);
    copy(&mut content, &mut file)?;
    Ok(())
}

pub async fn update_db() -> Result<()> {
    let mut cache_path = dirs::cache_dir().unwrap_or_default();
    cache_path.push("jet1090");
    if !cache_path.exists() {
        let msg =
            format!("failed to create {:?}", cache_path.to_str().unwrap());
        fs::create_dir_all(&cache_path).expect(&msg);
    }

    let zip_url =
        "https://jetvision.de/resources/sqb_databases/basestation.zip";
    let zip_file_path = "basestation.zip";
    cache_path.push(zip_file_path);

    println!("Downloading basestation.zip...");
    download_file(zip_url, cache_path.to_str().unwrap()).await?;

    // Open the zip file
    let file = File::open(&cache_path)?;
    let reader = BufReader::new(file);
    let mut archive = ZipArchive::new(reader)?;
    let mut sqlite_in_archive = archive.by_index(0)?;

    // Unzip the sqb file
    let cache_dir = cache_path.parent().unwrap();
    let mut sqlite_path = cache_dir.to_path_buf();
    sqlite_path.push(sqlite_in_archive.mangled_name());
    let mut sqlite_file = File::create(&sqlite_path)?;
    copy(&mut sqlite_in_archive, &mut sqlite_file)?;
    Ok(())
}

pub async fn aircraft() -> BTreeMap<String, Aircraft> {
    let mut cache_path = dirs::cache_dir().unwrap_or_default();
    cache_path.push("jet1090");
    if !cache_path.exists() {
        let msg =
            format!("failed to create {:?}", cache_path.to_str().unwrap());
        fs::create_dir_all(&cache_path).expect(&msg);
    }

    let zip_url =
        "https://jetvision.de/resources/sqb_databases/basestation.zip";
    let zip_file_path = "basestation.zip";
    cache_path.push(zip_file_path);

    // Check if the zip file exists
    if !cache_path.exists() {
        println!("Downloading basestation.zip...");
        download_file(zip_url, cache_path.to_str().unwrap())
            .await
            .expect("Failed to download basestation.zip");
    }

    // Open the zip file
    let file = File::open(&cache_path).unwrap();
    let reader = BufReader::new(file);
    let mut archive = ZipArchive::new(reader).unwrap();
    let mut sqlite_in_archive = archive.by_index(0).unwrap();

    // Unzip the sqb file
    let cache_dir = cache_path.parent().unwrap();
    let mut sqlite_path = cache_dir.to_path_buf();
    sqlite_path.push(sqlite_in_archive.mangled_name());
    let mut sqlite_file = File::create(&sqlite_path).unwrap();
    copy(&mut sqlite_in_archive, &mut sqlite_file).unwrap();

    // Read the SQLite file and establish a connection
    let sqlite_connection = Connection::open(sqlite_path).unwrap();

    let mut stmt = sqlite_connection
        .prepare("SELECT ModeS, Registration, ICAOTypeCode FROM Aircraft")
        .unwrap();

    let mut aircraftdb = BTreeMap::new();

    let rows = stmt
        .query_map([], |row| {
            Ok(Aircraft {
                icao24: row.get(0).unwrap(),
                registration: row.get(1).unwrap_or_default(),
                typecode: row.get(2).unwrap_or_default(),
            })
        })
        .unwrap();

    for entry in rows.flatten() {
        aircraftdb.insert(
            entry.icao24.to_owned().to_lowercase(),
            Aircraft {
                icao24: entry.icao24.to_owned().to_lowercase(),
                registration: entry.registration,
                typecode: entry.typecode,
            },
        );
    }

    aircraftdb
}