use std::path::{Path, PathBuf};
use std::process::Command;
pub const RELEASE_MAJOR_MINOR: u32 = 0x0002_0005;
pub const RUNTIME_VERSION: &str = "2.5.1";
pub const FRAMEWORK_PACKAGE: &str = "Microsoft.WindowsAppRuntime.2";
pub const PACKAGES: &[(&str, &str)] = &[
("microsoft.windowsappsdk.foundation", "2.3.12"),
("microsoft.windowsappsdk.winui", "2.3.9"),
("microsoft.windowsappsdk.interactiveexperiences", "2.1.9"),
("microsoft.web.webview2", "1.0.3719.77"),
("microsoft.graphics.win2d", "1.4.0"),
];
#[derive(Debug, Clone)]
pub struct WinAppSdk {
pub projection: PathBuf,
pub includes: Vec<PathBuf>,
pub bootstrap_dll: PathBuf,
pub canvas_dll: PathBuf,
}
fn arch_dir(target_arch: &str) -> Result<&'static str, String> {
match target_arch {
"aarch64" => Ok("arm64"),
"x86_64" => Ok("x64"),
"x86" => Ok("x86"),
other => Err(format!(
"the Windows App SDK has no build for target arch {other:?}"
)),
}
}
pub fn cache_root() -> PathBuf {
if let Ok(v) = std::env::var("DAY_WINAPPSDK_CACHE") {
return PathBuf::from(v);
}
let base = std::env::var("LOCALAPPDATA")
.map(PathBuf::from)
.unwrap_or_else(|_| std::env::temp_dir());
base.join("day").join("winappsdk")
}
pub fn resolve(cppwinrt_include: &Path, target_arch: &str) -> Result<WinAppSdk, String> {
let arch = arch_dir(target_arch)?;
let root = packages_root()?;
let _projection_lock = cache_lock(&root, "projection")?;
let pkg = |id: &str| package_dir(&root, id);
let foundation = pkg("microsoft.windowsappsdk.foundation");
let winui = pkg("microsoft.windowsappsdk.winui");
let ie = pkg("microsoft.windowsappsdk.interactiveexperiences");
let wv2 = pkg("microsoft.web.webview2");
let win2d = pkg("microsoft.graphics.win2d");
let canvas_dll = win2d
.join("runtimes")
.join(format!("win-{arch}"))
.join("native/Microsoft.Graphics.Canvas.dll");
if !canvas_dll.exists() {
return Err(format!("{} is missing", canvas_dll.display()));
}
let bootstrap_dll = foundation
.join("runtimes")
.join(format!("win-{arch}"))
.join("native")
.join("Microsoft.WindowsAppRuntime.Bootstrap.dll");
if !bootstrap_dll.exists() {
return Err(format!("{} is missing", bootstrap_dll.display()));
}
let sdk_version = cppwinrt_include
.parent()
.and_then(Path::file_name)
.map(|v| v.to_string_lossy().into_owned())
.ok_or_else(|| {
format!(
"cannot tell the SDK version of {}",
cppwinrt_include.display()
)
})?;
let winui_version = PACKAGES
.iter()
.find(|(id, _)| *id == "microsoft.windowsappsdk.winui")
.map_or("", |(_, v)| *v);
let projection = root.join(format!(
"projection-{sdk_version}-winui{winui_version}-win2d1.4.0"
));
if !projection
.join("winrt")
.join("Microsoft.UI.Xaml.Controls.h")
.exists()
{
let exe = cppwinrt_exe(cppwinrt_include, &sdk_version)?;
let staging = root.join(format!("projection-{sdk_version}.partial"));
let _ = std::fs::remove_dir_all(&staging);
let ie_meta = ie.join("metadata").join("10.0.18362.0");
let status = Command::new(&exe)
.arg("-in")
.arg(winui.join("metadata"))
.arg("-in")
.arg(&ie_meta)
.arg("-in")
.arg(foundation.join("metadata"))
.arg("-in")
.arg(wv2.join("lib").join("Microsoft.Web.WebView2.Core.winmd"))
.arg("-in")
.arg(win2d.join("lib/uap10.0/Microsoft.Graphics.Canvas.winmd"))
.args(["-ref", "sdk", "-out"])
.arg(&staging)
.status()
.map_err(|e| format!("running {}: {e}", exe.display()))?;
if !status.success() {
return Err(format!("{} failed ({status})", exe.display()));
}
let _ = std::fs::remove_dir_all(&projection);
std::fs::rename(&staging, &projection)
.map_err(|e| format!("publishing {}: {e}", projection.display()))?;
}
Ok(WinAppSdk {
projection,
includes: vec![foundation.join("include"), ie.join("include")],
bootstrap_dll,
canvas_dll,
})
}
fn packages_root() -> Result<PathBuf, String> {
match std::env::var("DAY_WINAPPSDK") {
Ok(v) => Ok(PathBuf::from(v)),
Err(_) => {
let root = cache_root();
for (id, version) in PACKAGES {
fetch_package(&root, id, version)?;
}
Ok(root)
}
}
}
fn package_dir(root: &Path, id: &str) -> PathBuf {
let version = PACKAGES
.iter()
.find(|(i, _)| *i == id)
.map(|(_, v)| *v)
.unwrap_or("");
root.join(format!("{id}.{version}"))
}
const RUNTIME_PACKAGES: &[&str] = &[
"microsoft.windowsappsdk.foundation",
"microsoft.windowsappsdk.winui",
"microsoft.windowsappsdk.interactiveexperiences",
];
pub fn self_contained_payload(target_arch: &str) -> Result<Vec<(PathBuf, PathBuf)>, String> {
let arch = arch_dir(target_arch)?;
let root = packages_root()?;
let mut out = Vec::new();
out.push((
package_dir(&root, "microsoft.graphics.win2d")
.join("runtimes")
.join(format!("win-{arch}"))
.join("native/Microsoft.Graphics.Canvas.dll"),
PathBuf::from("Microsoft.Graphics.Canvas.dll"),
));
for id in RUNTIME_PACKAGES {
let pkg = package_dir(&root, id);
let native = pkg
.join("runtimes-framework")
.join(format!("win-{arch}"))
.join("native");
walk(&native, &native, &mut |src, rel| {
let name = rel.to_string_lossy().to_ascii_lowercase();
let keep = [".dll", ".pri", ".xbf", ".xaml", ".mui", ".png", ".winmd"]
.iter()
.any(|ext| name.ends_with(ext))
|| name.ends_with("restartagent.exe")
|| name.ends_with("map.html")
|| (name.contains("workloads") && name.ends_with(".json"));
if keep {
out.push((src.to_path_buf(), rel.to_path_buf()));
}
})?;
for meta in [
pkg.join("metadata"),
pkg.join("metadata").join("10.0.18362.0"),
] {
let Ok(entries) = std::fs::read_dir(&meta) else {
continue;
};
for e in entries.flatten() {
let p = e.path();
if p.extension()
.is_some_and(|x| x.eq_ignore_ascii_case("winmd"))
{
out.push((p.clone(), PathBuf::from(e.file_name())));
}
}
}
}
let loader = package_dir(&root, "microsoft.web.webview2")
.join("runtimes")
.join(format!("win-{arch}"))
.join("native")
.join("WebView2Loader.dll");
if loader.exists() {
out.push((loader, PathBuf::from("WebView2Loader.dll")));
}
let core = package_dir(&root, "microsoft.web.webview2")
.join("runtimes")
.join(format!("win-{arch}"))
.join("native_uap")
.join("Microsoft.Web.WebView2.Core.dll");
if core.exists() {
out.push((core, PathBuf::from("Microsoft.Web.WebView2.Core.dll")));
}
out.sort_by(|a, b| a.1.cmp(&b.1));
out.dedup_by(|a, b| a.1 == b.1);
Ok(out)
}
pub fn self_contained_manifest() -> Result<String, String> {
let root = packages_root()?;
let mut out = String::from(
"<?xml version='1.0' encoding='utf-8' standalone='yes'?>\n\
<assembly manifestVersion='1.0'\n \
xmlns:asmv3='urn:schemas-microsoft-com:asm.v3'\n \
xmlns:winrtv1='urn:schemas-microsoft-com:winrt.v1'\n \
xmlns='urn:schemas-microsoft-com:asm.v1'>\n",
);
for id in RUNTIME_PACKAGES {
let fragment = package_dir(&root, id)
.join("runtimes-framework")
.join("package.appxfragment");
let xml = std::fs::read_to_string(&fragment)
.map_err(|e| format!("reading {}: {e}", fragment.display()))?;
for server in elements(&xml, "InProcessServer") {
let Some(dll) = element_text(server, "Path") else {
continue;
};
out.push_str(&format!(" <asmv3:file name='{dll}'>\n"));
for class in start_tags(server, "ActivatableClass") {
if let Some(name) = attribute(class, "ActivatableClassId") {
out.push_str(&format!(
" <winrtv1:activatableClass name='{name}' threadingModel='both'/>\n"
));
}
}
out.push_str(" </asmv3:file>\n");
}
for stub in elements(&xml, "ProxyStub") {
let Some(dll) = element_text(stub, "Path") else {
continue;
};
if dll == "PushNotificationsLongRunningTask.ProxyStub.dll" {
continue;
}
let Some(clsid) = attribute(stub, "ClassId") else {
continue;
};
out.push_str(&format!(" <asmv3:file name='{dll}'>\n"));
out.push_str(&format!(" <asmv3:comClass clsid='{{{clsid}}}'/>\n"));
for iface in start_tags(stub, "Interface") {
if let (Some(name), Some(iid)) =
(attribute(iface, "Name"), attribute(iface, "InterfaceId"))
{
out.push_str(&format!(
" <asmv3:comInterfaceProxyStub name='{name}' iid='{{{iid}}}'/>\n"
));
}
}
out.push_str(" </asmv3:file>\n");
}
}
out.push_str("</assembly>\n");
Ok(out)
}
pub fn merge_resource_indexes(payload: &Path, scratch: &Path) -> Result<(), String> {
let native = |p: &Path| PathBuf::from(p.to_string_lossy().replace('/', "\\"));
let (payload, scratch) = (native(payload), native(scratch));
let (payload, scratch) = (payload.as_path(), scratch.as_path());
let makepri = crate::windows_kit_tool("makepri.exe")
.ok_or("makepri.exe not found (it ships with the Windows 10/11 SDK)")?;
let _ = std::fs::remove_dir_all(scratch);
std::fs::create_dir_all(scratch).map_err(|e| format!("creating {}: {e}", scratch.display()))?;
let mut names = Vec::new();
let entries =
std::fs::read_dir(payload).map_err(|e| format!("reading {}: {e}", payload.display()))?;
for e in entries.flatten() {
let name = e.file_name().to_string_lossy().into_owned();
if name.to_ascii_lowercase().ends_with(".pri")
&& !name.eq_ignore_ascii_case("resources.pri")
{
std::fs::copy(e.path(), scratch.join(&name)).map_err(|e| e.to_string())?;
names.push(name);
}
}
if names.is_empty() {
return Err(format!("no .pri files in {}", payload.display()));
}
names.sort();
let list: String = names.iter().map(|n| format!("{n}\n")).collect();
std::fs::write(scratch.join("pri.resfiles"), list).map_err(|e| e.to_string())?;
let config = scratch.join("priconfig.xml");
std::fs::write(&config, PRI_MERGE_CONFIG).map_err(|e| e.to_string())?;
let out = Command::new(&makepri)
.arg("new")
.arg("/pr")
.arg(scratch)
.arg("/cf")
.arg(&config)
.arg("/of")
.arg(payload.join("resources.pri"))
.args(["/in", "DayApp", "/o"])
.output()
.map_err(|e| format!("running {}: {e}", makepri.display()))?;
if !out.status.success() {
let text = |b: &[u8]| String::from_utf8_lossy(b).replace('\0', "");
return Err(format!(
"makepri failed: {}{}",
text(&out.stdout).trim(),
text(&out.stderr).trim()
));
}
Ok(())
}
const PRI_MERGE_CONFIG: &str = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<resources targetOsVersion="10.0.0" majorVersion="1">
<index root="\" startIndexAt="pri.resfiles">
<default>
<qualifier name="Language" value="en-US"/>
<qualifier name="Contrast" value="standard"/>
<qualifier name="Scale" value="100"/>
<qualifier name="HomeRegion" value="001"/>
<qualifier name="TargetSize" value="256"/>
<qualifier name="LayoutDirection" value="LTR"/>
<qualifier name="Theme" value="dark"/>
<qualifier name="AlternateForm" value=""/>
<qualifier name="DXFeatureLevel" value="DX9"/>
<qualifier name="Configuration" value=""/>
<qualifier name="DeviceFamily" value="Universal"/>
<qualifier name="Custom" value=""/>
</default>
<indexer-config type="RESFILES" qualifierDelimiter="."/>
<indexer-config type="PRI"/>
</index>
</resources>
"#;
fn walk(base: &Path, dir: &Path, f: &mut dyn FnMut(&Path, &Path)) -> Result<(), String> {
let entries = std::fs::read_dir(dir).map_err(|e| format!("reading {}: {e}", dir.display()))?;
for e in entries.flatten() {
let p = e.path();
if p.is_dir() {
walk(base, &p, f)?;
} else if let Ok(rel) = p.strip_prefix(base) {
f(&p, rel);
}
}
Ok(())
}
fn elements<'a>(xml: &'a str, tag: &str) -> Vec<&'a str> {
let (open, close) = (format!("<{tag}"), format!("</{tag}>"));
let mut out = Vec::new();
let mut rest = xml;
while let Some(start) = rest.find(&open) {
let after = &rest[start..];
if !after[open.len()..].starts_with([' ', '>', '\r', '\n', '\t']) {
rest = &after[open.len()..];
continue;
}
let Some(end) = after.find(&close) else { break };
out.push(&after[..end + close.len()]);
rest = &after[end + close.len()..];
}
out
}
fn start_tags<'a>(xml: &'a str, tag: &str) -> Vec<&'a str> {
let open = format!("<{tag}");
let mut out = Vec::new();
let mut rest = xml;
while let Some(start) = rest.find(&open) {
let after = &rest[start..];
let Some(end) = after.find('>') else { break };
if after[open.len()..].starts_with([' ', '>', '/', '\r', '\n', '\t']) {
out.push(&after[..=end]);
}
rest = &after[end + 1..];
}
out
}
fn element_text<'a>(xml: &'a str, tag: &str) -> Option<&'a str> {
let open = format!("<{tag}>");
let start = xml.find(&open)? + open.len();
let end = xml[start..].find(&format!("</{tag}>"))?;
Some(xml[start..start + end].trim())
}
fn attribute<'a>(tag: &'a str, name: &str) -> Option<&'a str> {
let key = format!("{name}=\"");
let start = tag.find(&key)? + key.len();
let end = tag[start..].find('"')?;
Some(&tag[start..start + end])
}
pub fn shim_includes(cppwinrt_include: &Path) -> Vec<PathBuf> {
if !shim_is_winui() {
return vec![cppwinrt_include.to_path_buf()];
}
let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
let sdk = resolve_for_build_script(cppwinrt_include, &arch)
.unwrap_or_else(|e| panic!("the Windows App SDK (winui): {e}"));
let mut includes = vec![sdk.projection];
includes.extend(sdk.includes);
includes.push(cppwinrt_include.to_path_buf());
includes
}
pub fn shim_is_winui() -> bool {
std::env::var("CARGO_FEATURE_WINUI").is_ok()
}
pub fn resolve_for_build_script(
cppwinrt_include: &Path,
target_arch: &str,
) -> Result<WinAppSdk, String> {
for var in ["DAY_WINAPPSDK", "DAY_WINAPPSDK_CACHE"] {
println!("cargo:rerun-if-env-changed={var}");
}
resolve(cppwinrt_include, target_arch)
}
fn cppwinrt_exe(cppwinrt_include: &Path, sdk_version: &str) -> Result<PathBuf, String> {
let kits = cppwinrt_include
.parent()
.and_then(Path::parent)
.and_then(Path::parent)
.ok_or_else(|| {
format!(
"{} is not under a Windows Kits root",
cppwinrt_include.display()
)
})?;
let hosts: &[&str] = if cfg!(target_arch = "aarch64") {
&["arm64", "x64", "x86"]
} else {
&["x64", "x86"]
};
for host in hosts {
let exe = kits
.join("bin")
.join(sdk_version)
.join(host)
.join("cppwinrt.exe");
if exe.exists() {
return Ok(exe);
}
}
Err(format!(
"no cppwinrt.exe for Windows SDK {sdk_version} under {}",
kits.join("bin").display()
))
}
fn fetch_package(root: &Path, id: &str, version: &str) -> Result<(), String> {
let _package_lock = cache_lock(root, &format!("{id}.{version}"))?;
let dest = root.join(format!("{id}.{version}"));
if dest.join(".complete").exists() {
return Ok(());
}
std::fs::create_dir_all(root).map_err(|e| format!("creating {}: {e}", root.display()))?;
let staging = root.join(format!("{id}.{version}.partial"));
let _ = std::fs::remove_dir_all(&staging);
std::fs::create_dir_all(&staging)
.map_err(|e| format!("creating {}: {e}", staging.display()))?;
let nuget_cache = std::env::var("NUGET_PACKAGES")
.map(PathBuf::from)
.or_else(|_| {
std::env::var("USERPROFILE").map(|h| PathBuf::from(h).join(".nuget").join("packages"))
})
.ok()
.map(|p| p.join(id).join(version))
.filter(|p| p.is_dir());
if let Some(src) = nuget_cache {
copy_dir(&src, &staging).map_err(|e| format!("copying {}: {e}", src.display()))?;
} else {
let nupkg = root.join(format!("{id}.{version}.nupkg"));
let url =
format!("https://api.nuget.org/v3-flatcontainer/{id}/{version}/{id}.{version}.nupkg");
run("curl", &["-sSfL", "-o", &nupkg.to_string_lossy(), &url])?;
run(
"tar",
&[
"-xf",
&nupkg.to_string_lossy(),
"-C",
&staging.to_string_lossy(),
],
)?;
let _ = std::fs::remove_file(&nupkg);
}
std::fs::write(staging.join(".complete"), b"").map_err(|e| e.to_string())?;
let _ = std::fs::remove_dir_all(&dest);
std::fs::rename(&staging, &dest).map_err(|e| format!("publishing {}: {e}", dest.display()))
}
fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
std::fs::create_dir_all(to)?;
for entry in std::fs::read_dir(from)? {
let entry = entry?;
let target = to.join(entry.file_name());
if entry.file_type()?.is_dir() {
copy_dir(&entry.path(), &target)?;
} else {
std::fs::copy(entry.path(), target)?;
}
}
Ok(())
}
fn cache_lock(root: &Path, name: &str) -> Result<std::fs::File, String> {
std::fs::create_dir_all(root).map_err(|e| format!("creating {}: {e}", root.display()))?;
let path = root.join(format!("{name}.lock"));
let file = std::fs::OpenOptions::new()
.create(true)
.truncate(false)
.read(true)
.write(true)
.open(&path)
.map_err(|e| format!("opening {}: {e}", path.display()))?;
file.lock()
.map_err(|e| format!("locking {}: {e}", path.display()))?;
Ok(file)
}
fn run(cmd: &str, args: &[&str]) -> Result<(), String> {
let out = Command::new(cmd)
.args(args)
.output()
.map_err(|e| format!("running {cmd}: {e}"))?;
if out.status.success() {
Ok(())
} else {
Err(format!(
"{cmd} {} failed: {}",
args.join(" "),
String::from_utf8_lossy(&out.stderr).trim()
))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cache_publishers_are_serialized() {
let root = std::env::temp_dir().join(format!(
"day-winappsdk-lock-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("count"), "0").unwrap();
std::thread::scope(|scope| {
for _ in 0..8 {
let root = &root;
scope.spawn(move || {
for _ in 0..10 {
let _lock = cache_lock(root, "package").unwrap();
let count: usize = std::fs::read_to_string(root.join("count"))
.unwrap()
.parse()
.unwrap();
std::thread::yield_now();
std::fs::write(root.join("count"), (count + 1).to_string()).unwrap();
}
});
}
});
assert_eq!(std::fs::read_to_string(root.join("count")).unwrap(), "80");
std::fs::remove_dir_all(root).unwrap();
}
const FRAGMENT: &str = r#"<Fragment><Extensions>
<Extension Category="windows.activatableClass.inProcessServer">
<InProcessServer>
<Path>Microsoft.UI.Xaml.dll</Path>
<ActivatableClass ActivatableClassId="Microsoft.UI.Xaml.Application" ThreadingModel="both" />
<ActivatableClass ActivatableClassId="Microsoft.UI.Xaml.Window" ThreadingModel="both" />
</InProcessServer>
</Extension>
<Extension Category="windows.activatableClass.proxyStub">
<ProxyStub ClassId="71201C0F-21E1-4B80-945F-7B0A10F90883">
<Path>Microsoft.WindowsAppRuntime.dll</Path>
<Interface Name="IFoo" InterfaceId="11111111-2222-3333-4444-555555555555" />
</ProxyStub>
</Extension>
</Extensions></Fragment>"#;
#[test]
fn fragments_yield_servers_classes_and_stubs() {
let servers = elements(FRAGMENT, "InProcessServer");
assert_eq!(servers.len(), 1);
assert_eq!(
element_text(servers[0], "Path"),
Some("Microsoft.UI.Xaml.dll")
);
let classes: Vec<_> = start_tags(servers[0], "ActivatableClass")
.into_iter()
.filter_map(|t| attribute(t, "ActivatableClassId"))
.collect();
assert_eq!(
classes,
["Microsoft.UI.Xaml.Application", "Microsoft.UI.Xaml.Window"]
);
let stubs = elements(FRAGMENT, "ProxyStub");
assert_eq!(stubs.len(), 1);
assert_eq!(
attribute(stubs[0], "ClassId"),
Some("71201C0F-21E1-4B80-945F-7B0A10F90883")
);
let ifaces = start_tags(stubs[0], "Interface");
assert_eq!(
attribute(ifaces[0], "InterfaceId"),
Some("11111111-2222-3333-4444-555555555555")
);
}
}