Winapp CLI használata a Taurival

Ez az útmutató bemutatja, hogyan használhatja a winapp cli-t egy Tauri-alkalmazással a csomagidentitás hibakereséséhez és az alkalmazás MSIX-ként való csomagolásához.

A csomagidentitás a Windows app modell alapvető fogalma. Lehetővé teszi, hogy az alkalmazás hozzáférjen bizonyos Windows API-khoz (például értesítések, biztonság, AI API-k stb.), tiszta telepítési/eltávolítási felülettel rendelkezik, és így tovább.

Egy teljes munkapéldáért tekintse meg a Tauri-mintát ebben az adattárban.

Előfeltételek

Windows 11
Node.js - winget install OpenJS.NodeJS --source winget
Rust Toolchain – Rust telepítése rustup vagy winget install Rustlang.Rustup --source winget
winapp parancssori felület - winget install microsoft.winappcli --source winget

Tip

Ha már telepítette ezeket, futtassa a winget install parancsokat a frissítések kereséséhez.

1. Új Tauri-alkalmazás létrehozása

Először hozzon létre egy új Tauri-alkalmazást a hivatalos alapozó eszközzel:

npm create tauri-app@latest

Kövesse az utasításokat:

Projektnév: tauri-app (vagy a preferált név)
Előtérbeli nyelv: JavaScript
Csomagkezelő: npm
Felhasználói felületi sablon: Vanilla
Felhasználói felületi íz: JavaScript

Keresse meg a project könyvtárat, és telepítse a függőségeket:

cd tauri-app
npm install

Futtassa az alkalmazást, és győződjön meg arról, hogy minden működik:

npm run tauri dev

2. Kód frissítése az identitás ellenőrzéséhez

Frissítjük az alkalmazást, hogy ellenőrizze, a csomagazonossággal fut-e. A Rust háttérrendszerében található windows láda segítségével fogjuk elérni Windows API-kat, és elérhetővé tesszük az előtéren.

Háttérbeli módosítások (Rust)

Függőség hozzáadása: Nyissa meg src-tauri/Cargo.toml és adja hozzá a következő sorokat a fájl végén. Ez hozzáadja a Windows API-kötéseket, hogy ellenőrizhessük a csomag identitását:
```
[target.'cfg(windows)'.dependencies]
windows = { version = "0.58", features = ["ApplicationModel"] }
```

Parancs hozzáadása: Nyissa meg src-tauri/src/lib.rs és adja hozzá a függvényt get_package_family_name . Helyezze a pub fn run() függvény elé.

#[tauri::command]
fn get_package_family_name() -> String {
    #[cfg(target_os = "windows")]
    {
        use windows::ApplicationModel::Package;
        match Package::Current() {
            Ok(package) => {
                match package.Id() {
                    Ok(id) => match id.FamilyName() {
                        Ok(name) => name.to_string(),
                        Err(_) => "Error retrieving Family Name".to_string(),
                    },
                    Err(_) => "Error retrieving Package ID".to_string(),
                }
            }
            Err(_) => "No package identity".to_string(),
        }
    }
    #[cfg(not(target_os = "windows"))]
    {
        "Not running on Windows".to_string()
    }
}

Parancs regisztrálása: Ugyanabban a fájlban (src-tauri/src/lib.rs) frissítse a függvényt run az új parancs regisztrálásához:

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_opener::init())
        .invoke_handler(tauri::generate_handler![greet, get_package_family_name]) // Add get_package_family_name here
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Előtérbeli módosítások (JavaScript)

HTML frissítése: Nyissa meg a src/index.html fájlt, és adjon hozzá egy bekezdést az eredmény megjelenítéséhez:
```

<p id="pfn-msg"></p>
```

Update Logic: Nyissa meg src/main.js a parancs végrehajtásához és az eredmény megjelenítéséhez.

const { invoke } = window.__TAURI__.core;

// ... existing code ...

async function checkPackageIdentity() {
  const pfn = await invoke("get_package_family_name");
  const pfnMsgEl = document.querySelector("#pfn-msg");

  if (pfn !== "No package identity" && !pfn.startsWith("Error")) {
    pfnMsgEl.textContent = `Package family name: ${pfn}`;
  } else {
    pfnMsgEl.textContent = `Not running with package identity`;
  }
}

window.addEventListener("DOMContentLoaded", () => {
  // ... existing code ...
  checkPackageIdentity();
});

Most futtassa az alkalmazást a szokásos módon:
```
npm run tauri dev
```
Az alkalmazásablakban a "Nem csomagidentitással fut" szövegnek kell megjelennie. Ez megerősíti, hogy a standard fejlesztési build csomagidentitás nélkül fut.

3. A Project inicializálása winapp parancssori felülettel

A winapp init parancs egyetlen lépésben állítja be a szükséges elemeket: az alkalmazásjegyzéket és az eszközöket. A jegyzék meghatározza az alkalmazás identitását (név, közzétevő, verzió), amelyet Windows api-hozzáférés biztosításához használ.

Futtassa a következő parancsot, és kövesse az utasításokat:

winapp init

Amikor a rendszer kéri:

Csomag neve: Nyomja le az Enter billentyűt az alapértelmezett (tauri-app) elfogadásához
Publisher név: Az Enter billentyűt lenyomva fogadja el az alapértelmezett értéket, vagy adja meg a nevét
Verzió: Nyomja le az Enter billentyűt az 1.0.0.0 elfogadásához
Belépési pont: Nyomja le az Enter billentyűt az alapértelmezett (tauri-app.exe) elfogadásához
SDK-k beállítása: Válassza a "Ne állítsd be az SDK-kat" lehetőséget (a Tauri Rust ládakészletét windows használja, nem a C++ SDK-fejléceket)

Ez a parancs a következő lesz:

Létrehozza Package.appxmanifest – az alkalmazás identitását meghatározó jegyzék
Mappa létrehozása Assets – az MSIX-csomagoláshoz és az Áruház beküldéséhez szükséges ikonok

Megjegyzés:

Mivel nem kezelik az SDK-csomagokat, nem winapp.yaml jön létre – a Tauri Rust ládaját windows használja a Cargoon keresztül, így nincs mit winapp restore/update nyomon követnie.

Megnyithatja Package.appxmanifest az olyan tulajdonságok további testreszabásához, mint a megjelenítendő név, a közzétevő és a képességek.

4. Hibakeresés identitással

Az azonosítással végzett hibakereséshez létre kell hoznunk a Rust háttérrendszert, és le kell futtatnunk a következővel winapp run. Mivel npm run tauri dev a folyamat életciklusát kezeli, nehezebb ott beszúrni az identitást. Ehelyett létrehozunk egy egyéni szkriptet. A hibakereséshez nincs szükség tanúsítványra vagy aláírásra.

Szkript hozzáadása: Új szkript package.jsonmegnyitása tauri:dev:withidentity és hozzáadása:
```
"scripts": {
  "tauri": "tauri",
  "tauri:dev:withidentity": "cargo build --manifest-path src-tauri/Cargo.toml && (if not exist dist mkdir dist) && copy /Y src-tauri\\target\\debug\\tauri-app.exe dist\\ >nul && winapp run .\\dist"
}
```
A szkript leírása:
- cargo build ...: Újrafordítja a Rust háttérrendszert.
- copy ... dist\\: Csak az exe-t helyezi egy dist mappába (a target\debug mappa nagyon nagy, és olyan köztes buildösszetevőket tartalmaz, amelyek nem részei az alkalmazásnak).
- winapp run .\\dist: Regisztrál egy laza elrendezési csomagot (csakúgy, mint egy valódi MSIX-telepítés), és elindítja az alkalmazást.
Futtassa a szkriptet:
```
npm run tauri:dev:withidentity
```

Tip

Előfordulhat, hogy egy terminál-/konzolablak jelenik meg az alkalmazásablak mögött – ez a Tauri hibakeresési buildjeinél (ez a Rust-folyamat konzolja).

Most látnia kell az alkalmazás megnyitását, amely megjeleníti a "Csomagcsalád neve" feliratot, megerősítve, hogy az identitással fut! Mostantól megkezdheti a csomagidentitást igénylő API-k használatát és hibakeresését, például értesítéseket vagy az új AI API-kat, például a Phi Silica-t.

Tip

winapp run a csomagot a rendszeren is regisztrálja. Ezért előfordulhat, hogy az MSIX "már telepítve" állapotban jelenik meg, amikor később megpróbálja telepíteni az 5. lépésben. A fejlesztési csomagok megtisztítására használható winapp unregister , ha elkészült.

Tip

A speciális hibakeresési munkafolyamatokat (hibakeresők csatolása, IDE-beállítás, indítási hibakeresés) a hibakeresési útmutatóban találja.

A csomag MSIX-szel

Miután készen áll az alkalmazás terjesztésére, msIX-ként csomagolhatja be, amely biztosítja a csomag identitását az alkalmazásnak.

Először adjon hozzá egy pack:msix szkriptet a package.json elemhez.

"scripts": {
  "tauri": "tauri",
  "tauri:dev:withidentity": "...",
  "pack:msix": "npm run tauri -- build && (if not exist dist mkdir dist) && copy /Y src-tauri\\target\\release\\tauri-app.exe dist\\ >nul && winapp pack .\\dist --cert .\\devcert.pfx"
}

A szkript leírása:

npm run tauri -- build: A Rust háttérrendszert kiadási módban hozza létre.
copy ... dist\\: Csak az exe-t helyezi egy dist mappába (a target\release mappa nagyon nagy, és olyan köztes buildösszetevőket tartalmaz, amelyek nem részei az alkalmazásnak).
winapp pack .\\dist --cert .\\devcert.pfx: MSIX-ként csomagolja és aláírja az alkalmazást.

Fejlesztési tanúsítvány létrehozása

Az MSIX-csomagokat alá kell írni. Helyi teszteléshez hozzon létre egy önaláírt fejlesztési tanúsítványt:

winapp cert generate --if-exists skip

Tip

A tanúsítvány kiadójának meg kell egyeznie a Publisher-vel a Package.appxmanifest-ben. A cert generate parancs ezt automatikusan felolvassa a jegyzékből.

Felépítés, Színpadra állítás és Csomagolás

npm run pack:msix

Tip

A pack parancs automatikusan a Package.appxmanifest fájlt használja az aktuális könyvtárból, és a csomagolás előtt átmásolja a célmappába. A létrehozott .msix fájl az aktuális könyvtárban lesz.

A tanúsítvány telepítése

Az MSIX-csomag telepítése előtt meg kell bíznia a fejlesztési tanúsítványban a számítógépen. Futtassa ezt a parancsot rendszergazdaként (ezt tanúsítványonként csak egyszer kell elvégeznie):

winapp cert install .\devcert.pfx

Telepítés és futtatás

Tip

Ha a 4. lépésben használta winapp run , előfordulhat, hogy a csomag már regisztrálva van a rendszeren. Először winapp unregister távolítsa el a fejlesztési regisztrációt, majd telepítse a kiadási csomagot.

Telepítse a csomagot a létrehozott .msix fájlra duplán kattintva vagy a PowerShell használatával:

Add-AppxPackage .\tauri-app.msix

Tip

Az MSIX fájlnév tartalmazza a verziót és az architektúrát (pl. tauri-app_1.0.0.0_x64.msix). Ellenőrizze a könyvtárban a pontos fájlnevet. Ha a kódmódosítások után újra kell csomagolnia, növelje a Version értékét a Package.appxmanifest-ben – a Windows magasabb verziószámot igényel egy telepített csomag frissítéséhez.

A telepítés után a Start menüből indíthatja el az alkalmazást. Látnia kell, hogy az alkalmazás identitással fut.

Tips

Miután készen áll a terjesztésre, aláírhatja az MSIX-et egy hitelesítésszolgáltató kódaláíró tanúsítványával, hogy a felhasználóknak ne kelljen önaláírt tanúsítványt telepíteniük.
A Microsoft Store aláírja Önnek az MSIX-et, a beküldés előtt nem kell aláírnia.
Előfordulhat, hogy több MSIX-csomagot kell létrehoznia, egyet minden támogatott architektúrához (x64, Arm64).

Következő lépések

Distribute via winget: Küldje el MSIX-ét a Windows Csomagkezelő közösségi adattárba
Tegye közzé a Microsoft Store-ban: Küldje be a csomagot a winapp store segítségével
Set up CI/CD: A setup-WinAppCli GitHub Művelettel automatizálhatja a csomagolást a folyamatban
Explore Windows API-k: Csomagidentitással mostantól használhatja az Értesítések, a helyi eszközi AI, és egyéb identitásfüggő API-kat

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-05-12