appx 0.1.0

Managing appx packages
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! `HKCR\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository`<br>
//! [Windows::Management::Deployment::PackageManager](https://docs.microsoft.com/en-us/uwp/api/windows.management.deployment.packagemanager?view=winrt-19041)

// TODO: winrt alternatives to most of these APIs might be nice

use crate::{PackageFamilyName, PackageFullName, WString};
use crate::reg;

use std::io;
use std::path::Path;



/// Get the [PackageFamilyName]s installed on this computer
///
/// ### Examples
///
/// ```rust
/// for fam in appx::repository::families().unwrap() {
///     println!("{}", fam);
/// }
/// ```
pub fn families() -> io::Result<impl Iterator<Item = PackageFamilyName>> { imp::families() }

/// Get the [PackageFullName]s installed on this computer
///
/// ### Examples
///
/// ```rust
/// for pkg in appx::repository::packages().unwrap() {
///     println!("{}", pkg);
/// }
/// ```
pub fn packages() -> io::Result<impl Iterator<Item = PackageFullName>> { imp::packages() }

/// Get the [PackageFullName]s installed on this computer for a given [PackageFamilyName]
///
/// ### Examples
///
/// ```rust
/// let fam = appx::PackageFamilyName::new("NcsiUwpApp_8wekyb3d8bbwe");
/// for pkg in appx::repository::packages_for_family(&fam).unwrap() {
///     println!("{}", pkg);
/// }
/// ```
pub fn packages_for_family(family: &PackageFamilyName) -> io::Result<impl Iterator<Item = PackageFullName>> { imp::packages_for_family(family) }


/// Check if the [PackageFamilyName] appears on this computer
pub fn has_family(fam: &PackageFamilyName) -> bool {
    if !cfg!(windows) { return false; }
    let key = reg::Key::hkcr(winstr0!(r"Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Families"), reg::Options::NONE, reg::SAM::READ_ONLY);
    key.ok().and_then(|key| key.subkey(fam.units0(), reg::Options::NONE, reg::SAM::READ_ONLY).ok()).is_some()
}

/// Check if the [PackageFullName] appears on this computer
pub fn has_package(pfn: &PackageFullName) -> bool {
    if !cfg!(windows) { return false; }
    let key = reg::Key::hkcr(winstr0!(r"Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Packages"), reg::Options::NONE, reg::SAM::READ_ONLY);
    key.ok().and_then(|key| key.subkey(pfn.units0(), reg::Options::NONE, reg::SAM::READ_ONLY).ok()).is_some()
}

/// `powershell Add-AppxPackage -Path [path]` or equivalent - install `path` as an appx package
///
/// Might use [winrt](https://docs.rs/winrt/) in the future, possibly behind a feature for WinRT app compatability
pub fn add_appx_package(path: impl AsRef<Path>) -> io::Result<()> {
    if !cfg!(windows) { return Err(io::Error::new(io::ErrorKind::Other, "add_appx_package: not implemented on this platform")); }

    let path = path.as_ref();
    if !path.exists() { return Err(io::Error::new(io::ErrorKind::NotFound, "add_appx_package: `path` does not exist")); }
    let mut cmd = std::process::Command::new("powershell");
    cmd.arg("Add-AppxPackage");
    cmd.arg("-Path").arg(path);
    let status = cmd.status().map_err(|err| io::Error::new(err.kind(), "add_appx_package: `powershell Add-AppxPackage -Path ...` failed to launch"))?;
    match status.code() {
        Some(0) => Ok(()),
        Some(n) => Err(io::Error::new(io::ErrorKind::Other, format!("add_appx_package: `powershell Add-AppxPackage -Path ...` failed (exit code {})", n))),
        None    => Err(io::Error::new(io::ErrorKind::Other,         "add_appx_package: `powershell Add-AppxPackage -Path ...` failed (signal)")),
    }
}



#[cfg(not(windows))] mod imp {
    use super::*;
    pub(super) fn families() -> io::Result<impl Iterator<Item = PackageFamilyName>> { Ok(None.into_iter()) }
    pub(super) fn packages() -> io::Result<impl Iterator<Item = PackageFullName  >> { Ok(None.into_iter()) }
    pub(super) fn packages_for_family(_family: &PackageFamilyName) -> io::Result<impl Iterator<Item = PackageFullName>> { Ok(None.into_iter()) }
}



#[cfg(windows)] mod imp {
    use super::*;

    pub(super) fn families() -> io::Result<impl Iterator<Item = PackageFamilyName>> {
        Ok(FamiliesIter {
            key: reg::Key::hkcr(winstr0!(r"Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Families"), reg::Options::NONE, reg::SAM::READ_ONLY)?,
            index: 0,
        })
    }

    struct FamiliesIter {
        key:    reg::Key,
        index:  u32,
    }

    impl Iterator for FamiliesIter {
        type Item = PackageFamilyName;
        fn next(&mut self) -> Option<Self::Item> {
            let mut pfn = Default::default();
            let pfn = self.key.enum_key_w(self.index, &mut pfn).ok()??;
            self.index += 1;
            Some(PackageFamilyName(WString::new(pfn)))
        }
    }

    pub(super) fn packages() -> io::Result<impl Iterator<Item = PackageFullName>> {
        Ok(PackagesIter {
            key: reg::Key::hkcr(winstr0!(r"Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Packages"), reg::Options::NONE, reg::SAM::READ_ONLY)?,
            index: 0,
        })
    }

    pub(super) fn packages_for_family(family: &PackageFamilyName) -> io::Result<impl Iterator<Item = PackageFullName>> {
        Ok(PackagesIter {
            key: reg::Key::hkcr(winstr0!(r"Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel\Repository\Families"), reg::Options::NONE, reg::SAM::READ_ONLY)?
                .subkey(family.units0(), reg::Options::NONE, reg::SAM::READ_ONLY)?,
            index: 0,
        })
    }

    struct PackagesIter {
        key:    reg::Key,
        index:  u32,
    }

    impl Iterator for PackagesIter {
        type Item = PackageFullName;
        fn next(&mut self) -> Option<Self::Item> {
            let mut pfn = Default::default();
            let pfn = self.key.enum_key_w(self.index, &mut pfn).ok()??;
            self.index += 1;
            Some(PackageFullName(WString::new(pfn)))
        }
    }
}