dlxj

init

4e1096a 8 months ago

15.9 kB

#[cfg(target_os = "macos")]
#[macro_use]
extern crate cocoa;

#[cfg(target_os = "macos")]
#[macro_use]
extern crate objc;

#[cfg(target_os = "windows")]
mod windows;

#[cfg(target_os = "android")]
mod android;

use tauri::utils::config::BackgroundThrottlingPolicy;
#[cfg(target_os = "macos")]
use tauri::TitleBarStyle;

use std::path::PathBuf;
use tauri::{AppHandle, Manager};
use tauri_plugin_fs::FsExt;

#[cfg(desktop)]
use tauri::{Listener, Url};
mod dir_scanner;
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
mod discord_rpc;
#[cfg(target_os = "macos")]
mod macos;
mod transfer_file;
use tauri::{command, Emitter, WebviewUrl, WebviewWindowBuilder, Window};
#[cfg(target_os = "android")]
use tauri_plugin_native_bridge::register_select_directory_callback;
#[cfg(target_os = "android")]
use tauri_plugin_native_bridge::{NativeBridgeExt, OpenExternalUrlRequest};
use tauri_plugin_oauth::start;
#[cfg(not(target_os = "android"))]
use tauri_plugin_opener::OpenerExt;
use transfer_file::{download_file, upload_file};

#[cfg(desktop)]
fn allow_file_in_scopes(app: &AppHandle, files: Vec<PathBuf>) {
    let fs_scope = app.fs_scope();
    let asset_protocol_scope = app.asset_protocol_scope();
    for file in &files {
        if let Err(e) = fs_scope.allow_file(file) {
            log::error!("Failed to allow file in fs_scope: {e}");
        } else {
            log::debug!("Allowed file in fs_scope: {file:?}");
        }
        if let Err(e) = asset_protocol_scope.allow_file(file) {
            log::error!("Failed to allow file in asset_protocol_scope: {e}");
        } else {
            log::debug!("Allowed file in asset_protocol_scope: {file:?}");
        }
    }
}

fn allow_dir_in_scopes(app: &AppHandle, dir: &PathBuf) {
    let fs_scope = app.fs_scope();
    let asset_protocol_scope = app.asset_protocol_scope();
    if let Err(e) = fs_scope.allow_directory(dir, true) {
        log::error!("Failed to allow directory in fs_scope: {e}");
    } else {
        log::info!("Allowed directory in fs_scope: {dir:?}");
    }
    if let Err(e) = asset_protocol_scope.allow_directory(dir, true) {
        log::error!("Failed to allow directory in asset_protocol_scope: {e}");
    } else {
        log::info!("Allowed directory in asset_protocol_scope: {dir:?}");
    }
}

#[cfg(desktop)]
fn get_files_from_argv(argv: Vec<String>) -> Vec<PathBuf> {
    let mut files = Vec::new();
    // NOTICE: `args` may include URL protocol (`your-app-protocol://`)
    // or arguments (`--`) if your app supports them.
    // files may also be passed as `file://path/to/file`
    for (_, maybe_file) in argv.iter().enumerate().skip(1) {
        // skip flags like -f or --flag
        if maybe_file.starts_with("-") {
            continue;
        }
        // handle `file://` path urls and skip other urls
        if let Ok(url) = Url::parse(maybe_file) {
            if let Ok(path) = url.to_file_path() {
                files.push(path);
            } else {
                files.push(PathBuf::from(maybe_file))
            }
        } else {
            files.push(PathBuf::from(maybe_file))
        }
    }
    files
}

#[cfg(desktop)]
fn set_window_open_with_files(app: &AppHandle, files: Vec<PathBuf>) {
    let files = files
        .into_iter()
        .map(|f| {
            let file = f
                .to_string_lossy()
                .replace("\\", "\\\\")
                .replace("\"", "\\\"");
            format!("\"{file}\"",)
        })
        .collect::<Vec<_>>()
        .join(",");
    let window = app.get_webview_window("main").unwrap();
    let script = format!("window.OPEN_WITH_FILES = [{files}];");
    if let Err(e) = window.eval(&script) {
        eprintln!("Failed to set open files variable: {e}");
    }
}

#[command]
async fn start_server(window: Window) -> Result<u16, String> {
    start(move |url| {
        // Because of the unprotected localhost port, you must verify the URL here.
        // Preferebly send back only the token, or nothing at all if you can handle everything else in Rust.
        let _ = window.emit("redirect_uri", url);
    })
    .map_err(|err| err.to_string())
}

#[tauri::command]
fn get_environment_variable(name: &str) -> String {
    std::env::var(String::from(name)).unwrap_or(String::from(""))
}

#[tauri::command]
fn get_executable_dir() -> String {
    std::env::current_exe()
        .ok()
        .and_then(|path| path.parent().map(|p| p.to_path_buf()))
        .map(|p| p.to_string_lossy().to_string())
        .unwrap_or_default()
}

#[derive(Clone, serde::Serialize)]
#[allow(dead_code)]
struct SingleInstancePayload {
    args: Vec<String>,
    cwd: String,
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    let builder = tauri::Builder::default()
        .plugin(
            tauri_plugin_log::Builder::new()
                .level(log::LevelFilter::Info)
                .build(),
        )
        .plugin(tauri_plugin_websocket::init())
        .plugin(tauri_plugin_process::init())
        .plugin(tauri_plugin_oauth::init())
        .invoke_handler(tauri::generate_handler![
            start_server,
            download_file,
            upload_file,
            get_environment_variable,
            get_executable_dir,
            dir_scanner::read_dir,
            #[cfg(target_os = "macos")]
            macos::safari_auth::auth_with_safari,
            #[cfg(target_os = "macos")]
            macos::apple_auth::start_apple_sign_in,
            #[cfg(target_os = "macos")]
            macos::traffic_light::set_traffic_lights,
            #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
            discord_rpc::update_book_presence,
            #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
            discord_rpc::clear_book_presence,
        ])
        .plugin(tauri_plugin_fs::init())
        .plugin(tauri_plugin_persisted_scope::init())
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_opener::init())
        .plugin(tauri_plugin_http::init())
        .plugin(tauri_plugin_os::init())
        .plugin(tauri_plugin_dialog::init())
        .plugin(tauri_plugin_sharekit::init())
        .plugin(tauri_plugin_native_bridge::init())
        .plugin(tauri_plugin_native_tts::init());

    #[cfg(desktop)]
    let builder = builder.plugin(tauri_plugin_single_instance::init(|app, argv, cwd| {
        let _ = app
            .get_webview_window("main")
            .expect("no main window")
            .set_focus();
        let files = get_files_from_argv(argv.clone());
        if !files.is_empty() {
            allow_file_in_scopes(app, files.clone());
        }
        app.emit("single-instance", SingleInstancePayload { args: argv, cwd })
            .unwrap();
    }));

    let builder = builder.plugin(tauri_plugin_deep_link::init());

    #[cfg(desktop)]
    let builder = builder.plugin(tauri_plugin_updater::Builder::new().build());

    #[cfg(desktop)]
    let builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());

    #[cfg(target_os = "macos")]
    let builder = builder.plugin(macos::traffic_light::init());

    #[cfg(target_os = "macos")]
    let builder = builder.plugin(macos::safari_auth::init());

    #[cfg(target_os = "ios")]
    let builder = builder.plugin(tauri_plugin_sign_in_with_apple::init());

    #[cfg(any(target_os = "ios", target_os = "android"))]
    let builder = builder.plugin(tauri_plugin_haptics::init());

    builder
        .setup(|#[allow(unused_variables)] app| {
            #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
            {
                use std::sync::{Arc, Mutex};
                let discord_client = Arc::new(Mutex::new(discord_rpc::DiscordRpcClient::new()));
                app.manage(discord_client);
            }

            #[cfg(desktop)]
            {
                let files = get_files_from_argv(std::env::args().collect());
                if !files.is_empty() {
                    let app_handle = app.handle().clone();
                    allow_file_in_scopes(&app_handle, files.clone());
                    app.listen("window-ready", move |_| {
                        println!("Window is ready, proceeding to handle files.");
                        set_window_open_with_files(&app_handle, files.clone());
                    });
                }
            }

            #[cfg(desktop)]
            {
                allow_dir_in_scopes(app.handle(), &PathBuf::from(get_executable_dir()));
            }

            #[cfg(target_os = "android")]
            register_select_directory_callback(app.handle(), move |app, path| {
                allow_dir_in_scopes(app, path);
            });

            #[cfg(any(target_os = "windows", target_os = "linux"))]
            {
                use tauri_plugin_deep_link::DeepLinkExt;
                let _ = app.deep_link().register_all();
            }

            #[cfg(desktop)]
            {
                app.handle().plugin(tauri_plugin_cli::init())?;
            }

            // Check for e-ink device on Android before building the window
            #[cfg(target_os = "android")]
            let is_eink = android::is_eink_device();
            #[cfg(not(target_os = "android"))]
            let is_eink = false;

            #[cfg(desktop)]
            let cli_access = true;
            #[cfg(not(desktop))]
            let cli_access = false;

            #[cfg(target_os = "linux")]
            let is_appimage = std::env::var("APPIMAGE").is_ok()
                || std::env::current_exe()
                    .map(|path| path.to_string_lossy().contains("/tmp/.mount_"))
                    .unwrap_or(false);
            #[cfg(not(target_os = "linux"))]
            let is_appimage = false;

            #[cfg(desktop)]
            let updater_disabled = std::env::var("READEST_DISABLE_UPDATER").is_ok();
            #[cfg(not(desktop))]
            let updater_disabled = false;

            let init_script = format!(
                r#"
                    if ({is_eink}) window.__READEST_IS_EINK = true;
                    if ({cli_access}) window.__READEST_CLI_ACCESS = true;
                    if ({is_appimage}) window.__READEST_IS_APPIMAGE = true;
                    if ({updater_disabled}) window.__READEST_UPDATER_DISABLED = true;
                    window.addEventListener('DOMContentLoaded', function() {{
                        document.documentElement.classList.add('edge-to-edge');
                        const isTauriLocal = window.location.protocol === 'tauri:' ||
                                            window.location.protocol === 'about:' ||
                                            window.location.hostname === 'tauri.localhost';
                        const needsSafeArea = !isTauriLocal;
                        if (needsSafeArea && !document.getElementById('safe-area-style')) {{
                            const style = document.createElement('style');
                            style.id = 'safe-area-style';
                            style.textContent = `
                                body {{
                                    padding-top: env(safe-area-inset-top) !important;
                                    padding-bottom: env(safe-area-inset-bottom) !important;
                                    padding-left: env(safe-area-inset-left) !important;
                                    padding-right: env(safe-area-inset-right) !important;
                                }}
                            `;
                            document.head.appendChild(style);
                        }}
                    }});
                "#,
                is_eink = is_eink,
                cli_access = cli_access,
                is_appimage = is_appimage,
                updater_disabled = updater_disabled
            );

            let app_handle = app.handle().clone();
            let win_builder = WebviewWindowBuilder::new(app, "main", WebviewUrl::default())
                .background_throttling(BackgroundThrottlingPolicy::Disabled)
                .background_color(if is_eink {
                    tauri::window::Color(255, 255, 255, 255)
                } else {
                    tauri::window::Color(50, 49, 48, 255)
                })
                .initialization_script(&init_script)
                .on_navigation(move |url| {
                    if url.scheme() == "alipays" || url.scheme() == "alipay" {
                        let url_str = url.as_str().to_string();
                        #[cfg(target_os = "android")]
                        {
                            let handle = app_handle.clone();
                            tauri::async_runtime::spawn(async move {
                                match handle
                                    .native_bridge()
                                    .open_external_url(OpenExternalUrlRequest { url: url_str })
                                {
                                    Ok(result) => println!("Result: {:?}", result),
                                    Err(e) => eprintln!("Error: {:?}", e),
                                }
                            });
                        }
                        #[cfg(not(target_os = "android"))]
                        {
                            let _ = app_handle.opener().open_url(url_str, None::<&str>);
                        }
                        return false;
                    }
                    true
                });

            #[cfg(desktop)]
            let win_builder = win_builder.inner_size(800.0, 600.0).resizable(true);

            #[cfg(target_os = "macos")]
            let win_builder = win_builder
                .decorations(true)
                .title_bar_style(TitleBarStyle::Overlay)
                .title("");

            #[cfg(all(not(target_os = "macos"), desktop))]
            let win_builder = {
                let mut builder = win_builder
                    .decorations(false)
                    .visible(false)
                    .shadow(true)
                    .title("Readest");

                #[cfg(target_os = "windows")]
                {
                    builder = builder.transparent(false);
                }
                #[cfg(target_os = "linux")]
                {
                    builder = builder
                        .transparent(true)
                        .background_color(tauri::window::Color(0, 0, 0, 0));
                }

                builder
            };

            win_builder.build().unwrap();
            // let win = win_builder.build().unwrap();
            // win.open_devtools();

            #[cfg(target_os = "macos")]
            macos::menu::setup_macos_menu(app.handle())?;

            app.handle().emit("window-ready", ()).unwrap();

            Ok(())
        })
        .build(tauri::generate_context!())
        .expect("error while running tauri application")
        .run(
            #[allow(unused_variables)]
            |app_handle, event| {
                #[cfg(target_os = "macos")]
                if let tauri::RunEvent::Opened { urls } = event {
                    let files = urls
                        .into_iter()
                        .filter_map(|url| url.to_file_path().ok())
                        .collect::<Vec<_>>();

                    let app_handler_clone = app_handle.clone();
                    allow_file_in_scopes(app_handle, files.clone());
                    app_handle.listen("window-ready", move |_| {
                        println!("Window is ready, proceeding to handle files.");
                        set_window_open_with_files(&app_handler_clone, files.clone());
                    });
                }
            },
        );
}

	#[cfg(target_os = "macos")]
	#[macro_use]
	extern crate cocoa;

	#[cfg(target_os = "macos")]
	#[macro_use]
	extern crate objc;

	#[cfg(target_os = "windows")]
	mod windows;

	#[cfg(target_os = "android")]
	mod android;

	use tauri::utils::config::BackgroundThrottlingPolicy;
	#[cfg(target_os = "macos")]
	use tauri::TitleBarStyle;

	use std::path::PathBuf;
	use tauri::{AppHandle, Manager};
	use tauri_plugin_fs::FsExt;

	#[cfg(desktop)]
	use tauri::{Listener, Url};
	mod dir_scanner;
	#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
	mod discord_rpc;
	#[cfg(target_os = "macos")]
	mod macos;
	mod transfer_file;
	use tauri::{command, Emitter, WebviewUrl, WebviewWindowBuilder, Window};
	#[cfg(target_os = "android")]
	use tauri_plugin_native_bridge::register_select_directory_callback;
	#[cfg(target_os = "android")]
	use tauri_plugin_native_bridge::{NativeBridgeExt, OpenExternalUrlRequest};
	use tauri_plugin_oauth::start;
	#[cfg(not(target_os = "android"))]
	use tauri_plugin_opener::OpenerExt;
	use transfer_file::{download_file, upload_file};

	#[cfg(desktop)]
	fn allow_file_in_scopes(app: &AppHandle, files: Vec<PathBuf>) {
	let fs_scope = app.fs_scope();
	let asset_protocol_scope = app.asset_protocol_scope();
	for file in &files {
	if let Err(e) = fs_scope.allow_file(file) {
	log::error!("Failed to allow file in fs_scope: {e}");
	} else {
	log::debug!("Allowed file in fs_scope: {file:?}");
	}
	if let Err(e) = asset_protocol_scope.allow_file(file) {
	log::error!("Failed to allow file in asset_protocol_scope: {e}");
	} else {
	log::debug!("Allowed file in asset_protocol_scope: {file:?}");
	}
	}
	}

	fn allow_dir_in_scopes(app: &AppHandle, dir: &PathBuf) {
	let fs_scope = app.fs_scope();
	let asset_protocol_scope = app.asset_protocol_scope();
	if let Err(e) = fs_scope.allow_directory(dir, true) {
	log::error!("Failed to allow directory in fs_scope: {e}");
	} else {
	log::info!("Allowed directory in fs_scope: {dir:?}");
	}
	if let Err(e) = asset_protocol_scope.allow_directory(dir, true) {
	log::error!("Failed to allow directory in asset_protocol_scope: {e}");
	} else {
	log::info!("Allowed directory in asset_protocol_scope: {dir:?}");
	}
	}

	#[cfg(desktop)]
	fn get_files_from_argv(argv: Vec<String>) -> Vec<PathBuf> {
	let mut files = Vec::new();
	// NOTICE: `args` may include URL protocol (`your-app-protocol://`)
	// or arguments (`--`) if your app supports them.
	// files may also be passed as `file://path/to/file`
	for (_, maybe_file) in argv.iter().enumerate().skip(1) {
	// skip flags like -f or --flag
	if maybe_file.starts_with("-") {
	continue;
	}
	// handle `file://` path urls and skip other urls
	if let Ok(url) = Url::parse(maybe_file) {
	if let Ok(path) = url.to_file_path() {
	files.push(path);
	} else {
	files.push(PathBuf::from(maybe_file))
	}
	} else {
	files.push(PathBuf::from(maybe_file))
	}
	}
	files
	}

	#[cfg(desktop)]
	fn set_window_open_with_files(app: &AppHandle, files: Vec<PathBuf>) {
	let files = files
	.into_iter()
	.map(\|f\| {
	let file = f
	.to_string_lossy()
	.replace("\\", "\\\\")
	.replace("\"", "\\\"");
	format!("\"{file}\"",)
	})
	.collect::<Vec<_>>()
	.join(",");
	let window = app.get_webview_window("main").unwrap();
	let script = format!("window.OPEN_WITH_FILES = [{files}];");
	if let Err(e) = window.eval(&script) {
	eprintln!("Failed to set open files variable: {e}");
	}
	}

	#[command]
	async fn start_server(window: Window) -> Result<u16, String> {
	start(move \|url\| {
	// Because of the unprotected localhost port, you must verify the URL here.
	// Preferebly send back only the token, or nothing at all if you can handle everything else in Rust.
	let _ = window.emit("redirect_uri", url);
	})
	.map_err(\|err\| err.to_string())
	}

	#[tauri::command]
	fn get_environment_variable(name: &str) -> String {
	std::env::var(String::from(name)).unwrap_or(String::from(""))
	}

	#[tauri::command]
	fn get_executable_dir() -> String {
	std::env::current_exe()
	.ok()
	.and_then(\|path\| path.parent().map(\|p\| p.to_path_buf()))
	.map(\|p\| p.to_string_lossy().to_string())
	.unwrap_or_default()
	}

	#[derive(Clone, serde::Serialize)]
	#[allow(dead_code)]
	struct SingleInstancePayload {
	args: Vec<String>,
	cwd: String,
	}

	#[cfg_attr(mobile, tauri::mobile_entry_point)]
	pub fn run() {
	let builder = tauri::Builder::default()
	.plugin(
	tauri_plugin_log::Builder::new()
	.level(log::LevelFilter::Info)
	.build(),
	)
	.plugin(tauri_plugin_websocket::init())
	.plugin(tauri_plugin_process::init())
	.plugin(tauri_plugin_oauth::init())
	.invoke_handler(tauri::generate_handler![
	start_server,
	download_file,
	upload_file,
	get_environment_variable,
	get_executable_dir,
	dir_scanner::read_dir,
	#[cfg(target_os = "macos")]
	macos::safari_auth::auth_with_safari,
	#[cfg(target_os = "macos")]
	macos::apple_auth::start_apple_sign_in,
	#[cfg(target_os = "macos")]
	macos::traffic_light::set_traffic_lights,
	#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
	discord_rpc::update_book_presence,
	#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
	discord_rpc::clear_book_presence,
	])
	.plugin(tauri_plugin_fs::init())
	.plugin(tauri_plugin_persisted_scope::init())
	.plugin(tauri_plugin_shell::init())
	.plugin(tauri_plugin_opener::init())
	.plugin(tauri_plugin_http::init())
	.plugin(tauri_plugin_os::init())
	.plugin(tauri_plugin_dialog::init())
	.plugin(tauri_plugin_sharekit::init())
	.plugin(tauri_plugin_native_bridge::init())
	.plugin(tauri_plugin_native_tts::init());

	#[cfg(desktop)]
	let builder = builder.plugin(tauri_plugin_single_instance::init(\|app, argv, cwd\| {
	let _ = app
	.get_webview_window("main")
	.expect("no main window")
	.set_focus();
	let files = get_files_from_argv(argv.clone());
	if !files.is_empty() {
	allow_file_in_scopes(app, files.clone());
	}
	app.emit("single-instance", SingleInstancePayload { args: argv, cwd })
	.unwrap();
	}));

	let builder = builder.plugin(tauri_plugin_deep_link::init());

	#[cfg(desktop)]
	let builder = builder.plugin(tauri_plugin_updater::Builder::new().build());

	#[cfg(desktop)]
	let builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());

	#[cfg(target_os = "macos")]
	let builder = builder.plugin(macos::traffic_light::init());

	#[cfg(target_os = "macos")]
	let builder = builder.plugin(macos::safari_auth::init());

	#[cfg(target_os = "ios")]
	let builder = builder.plugin(tauri_plugin_sign_in_with_apple::init());

	#[cfg(any(target_os = "ios", target_os = "android"))]
	let builder = builder.plugin(tauri_plugin_haptics::init());

	builder
	.setup(\|#[allow(unused_variables)] app\| {
	#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
	{
	use std::sync::{Arc, Mutex};
	let discord_client = Arc::new(Mutex::new(discord_rpc::DiscordRpcClient::new()));
	app.manage(discord_client);
	}

	#[cfg(desktop)]
	{
	let files = get_files_from_argv(std::env::args().collect());
	if !files.is_empty() {
	let app_handle = app.handle().clone();
	allow_file_in_scopes(&app_handle, files.clone());
	app.listen("window-ready", move \|_\| {
	println!("Window is ready, proceeding to handle files.");
	set_window_open_with_files(&app_handle, files.clone());
	});
	}
	}

	#[cfg(desktop)]
	{
	allow_dir_in_scopes(app.handle(), &PathBuf::from(get_executable_dir()));
	}

	#[cfg(target_os = "android")]
	register_select_directory_callback(app.handle(), move \|app, path\| {
	allow_dir_in_scopes(app, path);
	});

	#[cfg(any(target_os = "windows", target_os = "linux"))]
	{
	use tauri_plugin_deep_link::DeepLinkExt;
	let _ = app.deep_link().register_all();
	}

	#[cfg(desktop)]
	{
	app.handle().plugin(tauri_plugin_cli::init())?;
	}

	// Check for e-ink device on Android before building the window
	#[cfg(target_os = "android")]
	let is_eink = android::is_eink_device();
	#[cfg(not(target_os = "android"))]
	let is_eink = false;

	#[cfg(desktop)]
	let cli_access = true;
	#[cfg(not(desktop))]
	let cli_access = false;

	#[cfg(target_os = "linux")]
	let is_appimage = std::env::var("APPIMAGE").is_ok()
	\|\| std::env::current_exe()
	.map(\|path\| path.to_string_lossy().contains("/tmp/.mount_"))
	.unwrap_or(false);
	#[cfg(not(target_os = "linux"))]
	let is_appimage = false;

	#[cfg(desktop)]
	let updater_disabled = std::env::var("READEST_DISABLE_UPDATER").is_ok();
	#[cfg(not(desktop))]
	let updater_disabled = false;

	let init_script = format!(
	r#"
	if ({is_eink}) window.__READEST_IS_EINK = true;
	if ({cli_access}) window.__READEST_CLI_ACCESS = true;
	if ({is_appimage}) window.__READEST_IS_APPIMAGE = true;
	if ({updater_disabled}) window.__READEST_UPDATER_DISABLED = true;
	window.addEventListener('DOMContentLoaded', function() {{
	document.documentElement.classList.add('edge-to-edge');
	const isTauriLocal = window.location.protocol === 'tauri:' \|\|
	window.location.protocol === 'about:' \|\|
	window.location.hostname === 'tauri.localhost';
	const needsSafeArea = !isTauriLocal;
	if (needsSafeArea && !document.getElementById('safe-area-style')) {{
	const style = document.createElement('style');
	style.id = 'safe-area-style';
	style.textContent = `
	body {{
	padding-top: env(safe-area-inset-top) !important;
	padding-bottom: env(safe-area-inset-bottom) !important;
	padding-left: env(safe-area-inset-left) !important;
	padding-right: env(safe-area-inset-right) !important;
	}}
	`;
	document.head.appendChild(style);
	}}
	}});
	"#,
	is_eink = is_eink,
	cli_access = cli_access,
	is_appimage = is_appimage,
	updater_disabled = updater_disabled
	);

	let app_handle = app.handle().clone();
	let win_builder = WebviewWindowBuilder::new(app, "main", WebviewUrl::default())
	.background_throttling(BackgroundThrottlingPolicy::Disabled)
	.background_color(if is_eink {
	tauri::window::Color(255, 255, 255, 255)
	} else {
	tauri::window::Color(50, 49, 48, 255)
	})
	.initialization_script(&init_script)
	.on_navigation(move \|url\| {
	if url.scheme() == "alipays" \|\| url.scheme() == "alipay" {
	let url_str = url.as_str().to_string();
	#[cfg(target_os = "android")]
	{
	let handle = app_handle.clone();
	tauri::async_runtime::spawn(async move {
	match handle
	.native_bridge()
	.open_external_url(OpenExternalUrlRequest { url: url_str })
	{
	Ok(result) => println!("Result: {:?}", result),
	Err(e) => eprintln!("Error: {:?}", e),
	}
	});
	}
	#[cfg(not(target_os = "android"))]
	{
	let _ = app_handle.opener().open_url(url_str, None::<&str>);
	}
	return false;
	}
	true
	});

	#[cfg(desktop)]
	let win_builder = win_builder.inner_size(800.0, 600.0).resizable(true);

	#[cfg(target_os = "macos")]
	let win_builder = win_builder
	.decorations(true)
	.title_bar_style(TitleBarStyle::Overlay)
	.title("");

	#[cfg(all(not(target_os = "macos"), desktop))]
	let win_builder = {
	let mut builder = win_builder
	.decorations(false)
	.visible(false)
	.shadow(true)
	.title("Readest");

	#[cfg(target_os = "windows")]
	{
	builder = builder.transparent(false);
	}
	#[cfg(target_os = "linux")]
	{
	builder = builder
	.transparent(true)
	.background_color(tauri::window::Color(0, 0, 0, 0));
	}

	builder
	};

	win_builder.build().unwrap();
	// let win = win_builder.build().unwrap();
	// win.open_devtools();

	#[cfg(target_os = "macos")]
	macos::menu::setup_macos_menu(app.handle())?;

	app.handle().emit("window-ready", ()).unwrap();

	Ok(())
	})
	.build(tauri::generate_context!())
	.expect("error while running tauri application")
	.run(
	#[allow(unused_variables)]
	\|app_handle, event\| {
	#[cfg(target_os = "macos")]
	if let tauri::RunEvent::Opened { urls } = event {
	let files = urls
	.into_iter()
	.filter_map(\|url\| url.to_file_path().ok())
	.collect::<Vec<_>>();

	let app_handler_clone = app_handle.clone();
	allow_file_in_scopes(app_handle, files.clone());
	app_handle.listen("window-ready", move \|_\| {
	println!("Window is ready, proceeding to handle files.");
	set_window_open_with_files(&app_handler_clone, files.clone());
	});
	}
	},
	);
	}