Desenvolvendo com os pacotes de ativo e dobramento de pacote

Importante

Se você pretende enviar seu aplicativo para a Loja, entre em contato com o suporte ao desenvolvedor do Windows e obtenha aprovação para usar pacotes de ativos e dobramento de pacotes.

Os pacotes de ativos podem diminuir o tamanho geral do empacotamento e o tempo de publicação de seus aplicativos na Loja. Você pode saber mais sobre pacotes de ativos e como eles podem acelerar suas iterações de desenvolvimento em Introdução aos pacotes de ativos.

Se você está pensando em usar pacotes de ativos para seu aplicativo ou já sabe que deseja usá-lo, provavelmente está se perguntando sobre como os pacotes de ativos mudarão seu processo de desenvolvimento. Em suma, o desenvolvimento de aplicativos para você permanece o mesmo - isso é possível por causa da dobragem de pacotes para pacotes de ativos.

Acesso a arquivos após dividir seu aplicativo

Para entender como a dobragem de pacotes não afeta seu processo de desenvolvimento, vamos voltar primeiro para entender o que acontece quando você divide seu aplicativo em vários pacotes (com pacotes de ativos ou pacotes de recursos).

Em um nível alto, quando você divide alguns dos arquivos do seu aplicativo em outros pacotes (que não são pacotes de arquitetura), você não poderá acessar esses arquivos diretamente em relação ao local onde seu código é executado. Isso ocorre porque esses pacotes são todos instalados em diretórios diferentes de onde o pacote de arquitetura está instalado. Por exemplo, se você estiver criando um jogo e seu jogo estiver localizado em francês e alemão e tiver sido criado para máquinas x86 e x64, deverá ter estes arquivos de pacote de aplicativos dentro do pacote de aplicativos do seu jogo:

• MyGame_1.0_x86.appx
• MyGame_1.0_x64.appx
• MyGame_1.0_language-fr.appx
• MyGame_1.0_language-de.appx

Quando o jogo é instalado na máquina de um usuário, cada arquivo de pacote de aplicativo terá sua própria pasta no diretório WindowsApps . Então, para um usuário francês que executa o Windows de 64 bits, seu jogo terá a seguinte aparência:

C:\Program Files\WindowsApps\
|-- MyGame_1.0_x64
|   `-- …
|-- MyGame_1.0_language-fr
|   `-- …
`-- …(other apps)

Observe que os arquivos de pacote do aplicativo que não são aplicáveis ao usuário não serão instalados (os pacotes x86 e alemão).

Para este usuário, o executável principal do seu jogo estará dentro da pasta MyGame_1.0_x64 e será executado a partir daí, e normalmente, ele só terá acesso aos arquivos dentro dessa pasta. Para acessar os arquivos na pasta MyGame_1.0_language-fr , você teria que usar as APIs MRT ou as APIs PackageManager. As APIs MRT podem selecionar automaticamente o arquivo mais apropriado entre os idiomas instalados, você pode descobrir mais sobre APIs MRT em Windows.ApplicationModel.Resources.Core. Como alternativa, você pode encontrar o local instalado do pacote de idioma francês usando a classe PackageManager. Você nunca deve assumir o local instalado dos pacotes do seu aplicativo, pois isso pode mudar e pode variar entre os usuários.

Dobramento do pacote de ativos

Então, como você pode acessar os arquivos em seus pacotes de ativos? Bem, você pode continuar a usar as APIs de acesso a arquivos que você está usando para acessar qualquer outro arquivo em seu pacote de arquitetura. Isso ocorre porque os arquivos do pacote de ativos serão dobrados em seu pacote de arquitetura quando ele for instalado por meio do processo de dobramento do pacote. Além disso, como os arquivos de pacote de ativos devem ser originalmente arquivos dentro de seus pacotes de arquitetura, isso significa que você não precisará alterar o uso da API ao passar da implantação de arquivos soltos para a implantação empacotada em seu processo de desenvolvimento.

Para entender mais sobre como funciona a dobragem de pacotes, vamos começar com um exemplo. Se você tiver um projeto de jogo com a seguinte estrutura de arquivo:

MyGame
|-- Audios
|   |-- Level1
|   |   `-- ...
|   `-- Level2
|       `-- ...
|-- Videos
|   |-- Level1
|   |   `-- ...
|   `-- Level2
|       `-- ...
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe

Se você quiser dividir seu jogo em 3 pacotes: um pacote de arquitetura x64, um pacote de ativos para áudios e um pacote de ativos para vídeos, seu jogo será dividido nestes pacotes:

MyGame_1.0_x64.appx
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe
MyGame_1.0_Audios.appx
`-- Audios
    |-- Level1
    |   `-- ...
    `-- Level2
        `-- ...
MyGame_1.0_Videos.appx
`-- Videos
    |-- Level1
    |   `-- ...
    `-- Level2
        `-- ...

Quando você instala o jogo, o pacote x64 será implantado primeiro. Em seguida, os dois pacotes de ativos ainda serão implantados em suas próprias pastas, assim como MyGame_1.0_language-fr do nosso exemplo anterior. No entanto, devido ao dobramento do pacote, os arquivos do pacote de ativos também serão vinculados para aparecer na pasta MyGame_1.0_x64 (portanto, mesmo que os arquivos apareçam em dois locais, eles não ocupam o dobro do espaço em disco). O local em que os arquivos do pacote de ativos aparecerão é exatamente o local em que eles estão em relação à raiz do pacote. Então, veja como será o layout final do jogo implantado:

C:\Program Files\WindowsApps\
|-- MyGame_1.0_x64
|   |-- Audios
|   |   |-- Level1
|   |   |   `-- ...
|   |   `-- Level2
|   |       `-- ...
|   |-- Videos
|   |   |-- Level1
|   |   |   `-- ...
|   |   `-- Level2
|   |       `-- ...
|   |-- Engine
|   |   `-- ...
|   |-- XboxLive
|   |   `-- ...
|   `-- Game.exe
|-- MyGame_1.0_Audios
|   `-- Audios
|       |-- Level1
|       |   `-- ...
|       `-- Level2
|           `-- ...
|-- MyGame_1.0_Videos
|   `-- Videos
|       |-- Level1
|       |   `-- ...
|       `-- Level2
|           `-- ...
`-- …(other apps)

Ao usar o dobramento de pacotes para pacotes de ativos, você ainda pode acessar os arquivos divididos em pacotes de ativos da mesma maneira (observe que a pasta de arquitetura tem exatamente a mesma estrutura que a pasta de projeto original) e pode adicionar pacotes de ativos ou mover arquivos entre pacotes de ativos sem afetar seu código.

Agora para um exemplo mais complicado de dobragem de pacotes. Digamos que você queira dividir seus arquivos com base no nível e, se quiser manter a mesma estrutura da pasta original do projeto, seus pacotes devem ter a seguinte aparência:

MyGame_1.0_x64.appx
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe
MyGame_Level1.appx
|-- Audios
|   `-- Level1
|       `-- ...
`-- Videos
    `-- Level1
        `-- ...

MyGame_Level2.appx
|-- Audios
|   `-- Level2
|       `-- ...
`-- Videos
    `-- Level2
        `-- ...

Isso permitirá que as pastas e arquivos de Nível 1 no pacote MyGame_Level1 e as pastas e arquivos de Nível 2 no pacote de MyGame_Level2 sejam mesclados nas pastas Áudios e Vídeos durante a dobra do pacote. Portanto, como regra geral, o caminho relativo designado para arquivos empacotados no arquivo de mapeamento ou layout de empacotamento para MakeAppx.exe é o caminho que você deve usar para acessá-los após a dobra do pacote.

Por fim, se houver dois arquivos em pacotes de ativos diferentes que tenham os mesmos caminhos relativos, isso causará uma colisão durante a dobragem do pacote. Se ocorrer uma colisão, a implantação do seu aplicativo resultará em um erro e falhará. Além disso, como o dobramento de pacotes aproveita os links físicos, se você usar pacotes de ativos, seu aplicativo não poderá ser implantado em unidades não NTFS. Se você souber que seu aplicativo provavelmente será movido para unidades removíveis pelos usuários, não deverá usar pacotes de ativos.