Automatizzare l'avvio di app UWP di Windows 10

  • Articolo

Introduzione

Gli sviluppatori hanno diverse opzioni per ottenere l'avvio automatico delle app piattaforma UWP (Universal Windows Platform). In questo documento verranno esaminati i metodi di avvio di un'app usando l'attivazione del protocollo e l'attivazione dell'avvio.

L'attivazione del protocollo consente a un'app di registrarsi come gestore per un determinato protocollo.

L'attivazione dell'avvio è il normale avvio di un'app, ad esempio l'avvio dal riquadro dell'app.

Con ogni metodo di attivazione è possibile usare la riga di comando o un'applicazione di avvio. Per tutti i metodi di attivazione, se l'app è attualmente in esecuzione, l'attivazione porterà l'app in primo piano (che la riattiva) e fornirà i nuovi argomenti di attivazione. In questo modo è possibile usare i comandi di attivazione per fornire nuovi messaggi all'app. È importante notare che il progetto deve essere compilato e distribuito affinché il metodo di attivazione esegua l'app appena aggiornata.

Attivatore del protocollo

Seguire questa procedura per configurare l'attivazione del protocollo per le app:

  1. Aprire il file Package.appxmanifest in Visual Studio.

  2. Selezionare la scheda Dichiarazioni.

  3. Nell'elenco a discesa Dichiarazioni disponibili selezionare Protocollo e quindi selezionare Aggiungi.

  4. In Proprietà immettere un nome univoco per avviare l'app nel campo Nome.

    Protocol activation

  5. Salvare il file e distribuire il progetto.

  6. Dopo la distribuzione del progetto, è necessario impostare l'attivazione del protocollo.

  7. Passare a Pannello di controllo\Tutti gli elementi Pannello di controllo\Programmi predefiniti e selezionare Associa un tipo di file o un protocollo a un programma specifico. Scorrere fino alla sezione Protocolli per verificare se il protocollo è elencato.

Ora che l'attivazione del protocollo è stata configurata, sono disponibili due opzioni (l'applicazione della riga di comando o dell'utilità di avvio) per attivare l'app usando il protocollo.

Riga di comando

L'app può essere attivata dal protocollo usando la riga di comando con l'avvio del comando seguito dal nome del protocollo impostato in precedenza, due punti (":") ed eventuali parametri. I parametri possono essere qualsiasi stringa arbitraria; tuttavia, per sfruttare le funzionalità URI (Uniform Resource Identifier), è consigliabile seguire il formato URI standard:

scheme://username:password@host:port/path.extension?query#fragment

L'oggetto Uri include metodi per analizzare una stringa URI in questo formato. Per ulteriori informazioni, vedere Classe Uri (MSDN).

Esempi:

>start bingnews:
>start myapplication:protocol-parameter
>start myapplication://single-player/level3?godmode=1&ammo=200

L'attivazione della riga di comando del protocollo supporta caratteri Unicode fino a un limite di 2038 caratteri nell'URI non elaborato.

Applicazione launcher

Per l'avvio, creare un'applicazione separata che supporti l'API WinRT. Il codice C++ per l'avvio con l'attivazione del protocollo in un programma di avvio è illustrato nell'esempio seguente, dove PackageURI è l'URI per l'applicazione con qualsiasi argomento, ad esempio myapplication: o myapplication:protocol activation arguments.

bool ProtocolLaunchURI(Platform::String^ URI)
{
       IAsyncOperation<bool>^ protocolLaunchAsyncOp;
       try
       {
              protocolLaunchAsyncOp = Windows::System::Launcher::LaunchUriAsync(ref new 
Uri(URI));
       }
       catch (Platform::Exception^ e)
       {
              Platform::String^ dbgStr = "ProtocolLaunchURI Exception Thrown: " 
+ e->ToString() + "\n";
              OutputDebugString(dbgStr->Data());
              return false;
       }

       concurrency::create_task(protocolLaunchAsyncOp).wait();

       if (protocolLaunchAsyncOp->Status == AsyncStatus::Completed)
       {
              bool LaunchResult = protocolLaunchAsyncOp->GetResults();
              Platform::String^ dbgStr = "ProtocolLaunchURI " + URI 
+ " completed. Launch result " + LaunchResult + "\n";
              OutputDebugString(dbgStr->Data());
              return LaunchResult;
       }
       else
       {
              Platform::String^ dbgStr = "ProtocolLaunchURI " + URI + " failed. Status:" 
+ protocolLaunchAsyncOp->Status.ToString() + " ErrorCode:" 
+ protocolLaunchAsyncOp->ErrorCode.ToString() + "\n";
              OutputDebugString(dbgStr->Data());
              return false;
       }
}

L'attivazione del protocollo con l'applicazione launcher presenta le stesse limitazioni per gli argomenti dell'attivazione del protocollo con la riga di comando. Entrambi supportano caratteri Unicode fino a un limite di 2038 caratteri nell'URI non elaborato.

Avviare l'attivazione

È anche possibile avviare l'app usando l'attivazione dell'avvio. Non è necessaria alcuna configurazione, ma è necessario l'ID modello utente applicazione (AUMID) dell'app UWP. L'AUMID è il nome della famiglia di pacchetti seguito da un punto esclamativo e dall'ID applicazione.

Il modo migliore per ottenere il nome della famiglia di pacchetti consiste nel completare questi passaggi:

  1. Salvare il file Package.appxmanifest.

  2. Nella scheda Creazione pacchetti immettere il Nome del pacchetto.

    Launch activation

  3. Se il nome della famiglia di pacchetti non è elencato, aprire PowerShell ed eseguire >get-appxpackage MyPackageName per trovare PackageFamilyName.

L'ID applicazione è disponibile nel file Package.appxmanifest (aperto in visualizzazione XML) nell'elemento <Applications>.

Riga di comando

Uno strumento per eseguire un'attivazione di avvio di un'app UWP viene installato con Windows 10 SDK. Può essere eseguito dalla riga di comando e accetta l'AUMID dell'app da avviare come argomento.

C:\Program Files (x86)\Windows Kits\10\App Certification Kit\microsoft.windows.softwarelogo.appxlauncher.exe <AUMID>

L'output dovrebbe essere simile al seguente:

"C:\Program Files (x86)\Windows Kits\10\App Certification Kit\microsoft.windows.softwarelogo.appxlauncher.exe" MyPackageName_ph1m9x8skttmg!AppId

Questa opzione non supporta gli argomenti della riga di comando.

Applicazione launcher

È possibile creare un'applicazione separata che supporti l'uso di COM per l'avvio. L'esempio seguente illustra il codice C++ per l'avvio con l'attivazione di avvio in un programma di avvio. Con questo codice, è possibile creare un oggetto ApplicationActivationManager e chiamare ActivateApplication passando l'AUMID trovato in precedenza ed eventuali argomenti. Per altre informazioni sugli altri parametri, vedere Metodo IApplicationActivationManager::ActivateApplication (MSDN).

#include <ShObjIdl.h>
#include <atlbase.h>

HRESULT LaunchApp(LPCWSTR AUMID)
{
     HRESULT hr = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
     if (FAILED(hr))
     {
            wprintf(L"LaunchApp %s: Failed to init COM. hr = 0x%08lx \n", AUMID, hr);
     }
     {
            CComPtr<IApplicationActivationManager> AppActivationMgr = nullptr;
            if (SUCCEEDED(hr))
            {
                   hr = CoCreateInstance(CLSID_ApplicationActivationManager, nullptr,  
CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&AppActivationMgr));
                   if (FAILED(hr))
                   {
                         wprintf(L"LaunchApp %s: Failed to create Application Activation 
Manager. hr = 0x%08lx \n", AUMID, hr);
                   }
            }
            if (SUCCEEDED(hr))
            {
                   DWORD pid = 0;
                   hr = AppActivationMgr->ActivateApplication(AUMID, nullptr, AO_NONE, 
&pid);
                   if (FAILED(hr))
                   {
                         wprintf(L"LaunchApp %s: Failed to Activate App. hr = 0x%08lx 
\n", AUMID, hr);
                   }
            }
     }
     CoUninitialize();
     return hr;
}

Vale la pena notare che questo metodo supporta l'esecuzione di argomenti passati, a differenza del metodo precedente per l'avvio , ovvero l'uso della riga di comando.

Accettazione di argomenti

Per accettare argomenti passati all'attivazione dell'app UWP, si deve aggiungere codice all'app. Per determinare se si è verificata l'attivazione del protocollo o l'attivazione dell'avvio, eseguire l'override dell'evento OnActivated e controllare il tipo di argomento e quindi ottenere i valori pre-analizzati della stringa non elaborata o dell'oggetto Uri.

In questo esempio viene illustrato come ottenere la stringa non elaborata.

void OnActivated(IActivatedEventArgs^ args)
{
		// Check for launch activation
		if (args->Kind == ActivationKind::Launch)
		{
			auto launchArgs = static_cast<LaunchActivatedEventArgs^>(args);	
			Platform::String^ argval = launchArgs->Arguments;
			// Manipulate arguments …
		}

		// Check for protocol activation
		if (args->Kind == ActivationKind::Protocol)
		{
			auto protocolArgs = static_cast< ProtocolActivatedEventArgs^>(args);
			Platform::String^ argval = protocolArgs->Uri->ToString();
			// Manipulate arguments …
		}
}

Riepilogo

In sintesi, si possono usare vari metodi per avviare l'app UWP. A seconda dei requisiti e dei casi d'uso, metodi diversi possono essere più adatti rispetto ad altri.

Vedi anche