90 lines
2.7 KiB
Rust
90 lines
2.7 KiB
Rust
mod config;
|
|
mod downloader;
|
|
mod grandmother;
|
|
mod m3u8;
|
|
mod offlineparser;
|
|
mod onlineparser;
|
|
mod opt;
|
|
pub mod parser;
|
|
mod playlist;
|
|
|
|
use std::{io::{stdin, stdout, Stdin, StdoutLock, Write}, rc::Rc};
|
|
|
|
use async_recursion::async_recursion;
|
|
pub use config::Configuration;
|
|
pub use downloader::download_with_progress;
|
|
pub use grandmother::GrandMother;
|
|
pub use m3u8::{M3u8, OfflineEntry};
|
|
pub use offlineparser::OfflineParser;
|
|
pub use onlineparser::OnlineParser;
|
|
pub use opt::{Mode, Opt};
|
|
pub use parser::{GetM3u8, GetPlayPath, WatchedFind};
|
|
pub use playlist::Playlist;
|
|
|
|
pub const JSON_CONFIG_FILENAME: &'static str = "config.json";
|
|
pub const APP_IDENTIFIER: [&'static str; 3] = ["com", "billenius", "ilovetv"];
|
|
pub const STANDARD_PLAYLIST_FILENAME: &'static str = "playlist.m3u8";
|
|
pub const STANDARD_SEEN_LINKS_FILENAME: &'static str = "watched_links.json";
|
|
pub const STANDARD_OFFLINE_FILENAME: &'static str = "ilovetv_offline.json";
|
|
pub const MAX_TRIES: u8 = 4;
|
|
|
|
pub struct Readline<'a> {
|
|
stdout: StdoutLock<'a>,
|
|
stdin: Stdin,
|
|
}
|
|
|
|
impl<'a> Readline<'a> {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
stdout: stdout().lock(),
|
|
stdin: stdin(),
|
|
}
|
|
}
|
|
|
|
pub fn input(&mut self, toprint: &str) -> String {
|
|
print!("{}", toprint);
|
|
self.stdout.flush().unwrap();
|
|
let mut buffer = String::new();
|
|
self.stdin.read_line(&mut buffer).unwrap();
|
|
buffer
|
|
}
|
|
}
|
|
|
|
/**
|
|
* I know that this isn't considered true rusty code, but the places it's used in is
|
|
* safe. For this I'll leave the funciton as unsafe, so to better see it's uses.
|
|
* This solution makes the uses BLAZINGLY FAST which moreover is the most rusty you can get.
|
|
*/
|
|
pub unsafe fn get_mut_ref<T>(reference: &T) -> &mut T {
|
|
let ptr = reference as *const T as *mut T;
|
|
&mut *ptr
|
|
}
|
|
|
|
#[async_recursion(?Send)]
|
|
pub async fn get_gm(
|
|
mode: Mode,
|
|
readline: &mut Readline<'_>,
|
|
config: Rc<Configuration>,
|
|
) -> Result<GrandMother, String> {
|
|
match mode {
|
|
Mode::Online => GrandMother::new_online(config).await,
|
|
Mode::Offline => Ok(GrandMother::new_offline(config)),
|
|
Mode::Ask => loop {
|
|
let input = readline
|
|
.input("Online/Offline mode? [1/2] ")
|
|
.trim()
|
|
.parse::<u8>();
|
|
if let Ok(num) = input {
|
|
if num == 1 {
|
|
return get_gm(Mode::Online, readline, config).await;
|
|
} else if num == 2 {
|
|
return get_gm(Mode::Offline, readline, config).await;
|
|
}
|
|
println!("Has to be either 1 (Onine) or 2 (Offline)");
|
|
} else {
|
|
println!("Has to be a number");
|
|
}
|
|
},
|
|
}
|
|
}
|