cargo-ohos-app 0.1.81

Cargo subcommand for packaging Rust GUI apps as OHOS applications
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

use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};

use crate::cli::BuildCommand;
use crate::commands::command_env;
use crate::config::AppContext;
use crate::errors::{HarmonyAppError, Result};
use crate::runner::{CommandRunner, CommandSpec};

pub fn run<R: CommandRunner, W: Write>(
    command: &BuildCommand,
    cwd: &Path,
    runner: &mut R,
    stdout: &mut W,
) -> Result<()> {
    let app = AppContext::load(&command.common, cwd)?;
    let plan = build_plan(&app);

    if command.common.dry_run {
        writeln!(stdout, "[dry-run] {}", plan.command.display())?;
        writeln!(
            stdout,
            "[dry-run] copy {} -> {}",
            plan.source.display(),
            plan.destination.display()
        )?;
        return Ok(());
    }

    runner.run(&plan.command)?;
    if !plan.source.exists() {
        return Err(HarmonyAppError::MissingFile {
            path: plan.source.clone(),
        });
    }
    remove_legacy_shared_artifact(&plan.legacy_shared_destination)?;
    if let Some(parent) = plan.destination.parent() {
        fs::create_dir_all(parent).map_err(|source| HarmonyAppError::io(parent, source))?;
    }
    fs::copy(&plan.source, &plan.destination)
        .map_err(|source| HarmonyAppError::io(&plan.destination, source))?;

    writeln!(
        stdout,
        "Built Rust staticlib and copied it to {}",
        plan.destination.display()
    )?;
    Ok(())
}

pub(crate) struct BuildPlan {
    pub command: CommandSpec,
    pub source: PathBuf,
    pub destination: PathBuf,
    pub legacy_shared_destination: PathBuf,
}

pub(crate) fn build_plan(app: &AppContext) -> BuildPlan {
    let mut args = vec![
        "rustc".to_string(),
        "--lib".to_string(),
        "--manifest-path".to_string(),
        app.project.manifest_path.display().to_string(),
        "--target".to_string(),
        app.config.target.clone(),
    ];
    if app.config.profile_dir == "release" {
        args.push("--release".to_string());
    }
    args.push("--".to_string());
    args.push("--crate-type".to_string());
    args.push("staticlib".to_string());

    let source = app
        .project
        .static_artifact_path(&app.config.target, &app.config.profile_dir);
    let destination = app
        .config
        .output_dir
        .join("entry")
        .join("src")
        .join("main")
        .join("cpp")
        .join("libs")
        .join(&app.config.abi)
        .join(format!("lib{}.a", app.project.lib_name));

    BuildPlan {
        command: CommandSpec {
            program: PathBuf::from("cargo"),
            args,
            cwd: app.project.project_dir.clone(),
            env: command_env(app),
        },
        source,
        destination,
        legacy_shared_destination: app
            .config
            .output_dir
            .join("entry")
            .join("src")
            .join("main")
            .join("cpp")
            .join("libs")
            .join(&app.config.abi)
            .join(format!("lib{}.so", app.project.lib_name)),
    }
}

fn remove_legacy_shared_artifact(path: &Path) -> Result<()> {
    if path.exists() {
        fs::remove_file(path).map_err(|source| HarmonyAppError::io(path, source))?;
    }
    Ok(())
}