acid/firmware/acid-firmware/build.rs

use std::env;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};

use const_gen::*;
use indoc::{formatdoc, writedoc};
use json::JsonValue;
use slint_build::{CompilerConfiguration, EmbedResourcesKind};
use xz2::read::XzEncoder;

fn main() {
    let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
    if let Ok(repo) = gix::discover(&manifest_dir) {
        let commit_hash = repo.head_commit().unwrap().short_id().unwrap();
        println!("cargo:rustc-env=GIT_COMMIT_HASH={}", commit_hash);
        println!(
            "cargo:rustc-env=GIT_COMMIT={}",
            repo.find_tag(repo.head_id().unwrap())
                .ok()
                .map(|tag| format!("{} ({})", tag.decode().unwrap().name, commit_hash))
                .unwrap_or_else(|| commit_hash.to_string())
        );
    }

    // Generate vial config at the root of project
    println!("cargo:rerun-if-changed=vial.json");
    generate_vial_config();

    println!("cargo:rustc-link-arg-bins=-Tlinkall.x");

    // Set the extra linker script from defmt
    // println!("cargo:rustc-link-arg=-Tdefmt.x");

    // TODO: Make it a submodule and use relative paths.

    fn link_static_lib(env_var: &str, library: &str) {
        let lib_build_dir = env::var(env_var)
            .unwrap_or_else(|error| panic!("The build directory of lib{library} must be specified using the `{env_var}` environment variable: {error}"));
        let lib_build_dir = PathBuf::from(&lib_build_dir).canonicalize().unwrap();
        let lib_library_path = lib_build_dir
            .join(format!("lib{library}.a"))
            .canonicalize()
            .unwrap();
        let lib_build_dir = lib_build_dir.display();

        if !lib_library_path.is_file() {
            panic!(
                "{}",
                formatdoc! {"
                    The compiled lib{library} library was not found at path {lib_library_path:?}.
                    Most likely, the library was not compiled. See the `README.md` for compilation instructions.
                    If the `{env_var}` environment variable is not set to the build directory you want to use, change it.
                    Currently, `{env_var}` is set to: {lib_build_dir}
                "}
            );
        }

        println!("cargo:rustc-link-search=native={lib_build_dir}");
        println!("cargo:rustc-link-lib=static={library}");
        println!("cargo:rerun-if-changed={lib_build_dir}/lib{library}.a");
    }

    link_static_lib("LIBXKBCOMMON_BUILD_DIR", "xkbcommon");
    link_static_lib("SPECTRE_API_BUILD_DIR", "spectre");

    // Slint config and compilation
    {
        // Don't think this does anything:
        // println!("cargo:rerun-if-env-changed=SLINT_FONT_SIZES");

        let slint_config = CompilerConfiguration::new()
            // .with_scale_factor(2.0)
            .with_style("cosmic-dark".to_string())
            .embed_resources(EmbedResourcesKind::EmbedForSoftwareRenderer);
        slint_build::compile_with_config("ui/main.slint", slint_config)
            .expect("Slint build failed");
        slint_build::print_rustc_flags().unwrap()
    }
}

fn generate_vial_config() {
    // Generated vial config file
    let path = Path::new(&env::var_os("OUT_DIR").unwrap()).join("config_generated.rs");
    let mut out_file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .open(path)
        .unwrap();

    let p = Path::new("vial.json");
    let mut content = String::new();
    match File::open(p) {
        Ok(mut file) => {
            file.read_to_string(&mut content)
                .expect("Cannot read vial.json");
        }
        Err(e) => println!("Cannot find vial.json {p:?}: {e}"),
    };

    let vial_cfg = json::parse(&content).unwrap();
    let vial_cfg_string = json::stringify(vial_cfg.clone());
    let mut keyboard_def_compressed: Vec<u8> = Vec::new();
    XzEncoder::new(vial_cfg_string.as_bytes(), 6)
        .read_to_end(&mut keyboard_def_compressed)
        .unwrap();

    let keyboard_id: Vec<u8> = vec![0xB9, 0xBC, 0x09, 0xB2, 0x9D, 0x37, 0x4C, 0xEA];
    let const_declarations = [
        const_declaration!(pub VIAL_KEYBOARD_DEF = keyboard_def_compressed),
        const_declaration!(pub VIAL_KEYBOARD_ID = keyboard_id),
    ]
    .map(|s| "#[allow(clippy::redundant_static_lifetimes)]\n".to_owned() + s.as_str())
    .join("\n");

    writeln!(out_file, "{}", const_declarations).unwrap();

    writedoc!(
        out_file,
        "
        #[allow(dead_code, non_camel_case_types)]
        #[repr(u8)]
        pub enum CustomKeycodes {{
        "
    )
    .unwrap();

    // const CUSTOM_KEYCODE_FIRST: u16 = 0x840;

    #[allow(clippy::collapsible_if)]
    if let JsonValue::Object(vial_cfg) = vial_cfg {
        if let Some(JsonValue::Array(custom_keycodes)) = vial_cfg.get("customKeycodes") {
            for (index, custom_keycode) in custom_keycodes.iter().enumerate() {
                if let JsonValue::Object(custom_keycode) = custom_keycode {
                    let name = custom_keycode
                        .get("name")
                        .expect("A custom keycode in vial.json is missing a name.")
                        .as_str()
                        .expect("A custom keycode's name must be a string.");
                    writeln!(
                        out_file,
                        "    {} = {},",
                        name,
                        // CUSTOM_KEYCODE_FIRST + index as u16
                        index as u8
                    )
                    .unwrap();
                }
            }
        }
    }

    writeln!(out_file, "}}").unwrap();
}