Partager via

Lancer une application pour obtenir des résultats

  • Article

API importantes

Découvrez comment démarrer une application à partir d’une autre, et échanger des données entre les deux. Il s’agit du lancement d’une application pour les résultats. L’exemple ci-dessous vous montre comment utiliser LaunchUriForResultsAsync pour lancer une application pour les résultats.

Les nouvelles API de communication d’application à application dans Windows 10 permettent aux applications Windows (et aux applications web Windows) de lancer une application et d’échanger des données et des fichiers. Cela vous permet de créer des solutions hybrides à partir de plusieurs applications. À l’aide de ces nouvelles API, des tâches complexes qui auraient demandé à l’utilisateur d’utiliser plusieurs applications peuvent désormais être gérées en toute transparence. Par exemple, votre application peut lancer une application de mise en réseau social pour choisir un contact ou lancer une application de paiement pour effectuer un processus de paiement.

L’application que vous lancerez pour les résultats sera appelée application lancée. L’application qui lance l’application sera appelée application appelante. Pour cet exemple, vous allez écrire à la fois l’application appelante et l’application lancée.

Étape 1 : Inscrire le protocole à gérer dans l’application que vous allez lancer pour les résultats

Dans le fichier Package.appxmanifest de l’application lancée, ajoutez une extension de protocole à la section Application>.< L’exemple ici utilise un protocole fictif nommé test-app2app.

L’attribut ReturnResults de l’extension de protocole accepte l’une des valeurs suivantes :

  • facultatif : l’application peut être lancée pour les résultats à l’aide de la méthode LaunchUriForResultsAsync ou non pour les résultats à l’aide de LaunchUriAsync. Lorsque vous utilisez facultatif, l’application lancée doit déterminer si elle a été lancée pour les résultats. Pour ce faire, vérifiez l’argument d’événement OnActivated . Si la propriété IActivatedEventArgs.Kind de l’argument renvoie ActivationKind.ProtocolForResults ou si le type de l’argument d’événement est ProtocolActivatedEventArgs, l’application a été lancée via LaunchUriForResultsAsync.
  • toujours : l’application ne peut être lancée que pour les résultats ; autrement dit, elle ne peut répondre qu’à LaunchUriForResultsAsync.
  • none : l’application ne peut pas être lancée pour les résultats ; elle ne peut répondre qu’à LaunchUriAsync.

Dans cet exemple d’extension de protocole, l’application peut être lancée uniquement pour les résultats. Cela simplifie la logique à l’intérieur de la méthode OnActivated , décrite ci-dessous, car nous devons gérer uniquement le cas « lancé pour les résultats » et non les autres façons dont l’application peut être activée.

<Applications>
   <Application ...>

     <Extensions>
       <uap:Extension Category="windows.protocol">
         <uap:Protocol Name="test-app2app" ReturnResults="always">
           <uap:DisplayName>Test app-2-app</uap:DisplayName>
         </uap:Protocol>
       </uap:Extension>
     </Extensions>

   </Application>
</Applications>

Étape 2 : Remplacer Application.OnActivated dans l’application que vous allez lancer pour les résultats

Si cette méthode n’existe pas déjà dans l’application lancée, créez-la dans la App classe définie dans App.xaml.cs.

Dans une application qui vous permet de choisir vos amis dans un réseau social, cette fonction peut être l’endroit où vous ouvrez la page sélecteur de personnes. Dans cet exemple suivant, une page nommée LaunchedForResultsPage s’affiche lorsque l’application est activée pour les résultats. Vérifiez que l’instruction using est incluse en haut du fichier.

using Windows.ApplicationModel.Activation;
...
protected override void OnActivated(IActivatedEventArgs args)
{
    // Window management
    Frame rootFrame = Window.Current.Content as Frame;
    if (rootFrame == null)
    {
        rootFrame = new Frame();
        Window.Current.Content = rootFrame;
    }

    // Code specific to launch for results
    var protocolForResultsArgs = (ProtocolForResultsActivatedEventArgs)args;
    // Open the page that we created to handle activation for results.
    rootFrame.Navigate(typeof(LaunchedForResultsPage), protocolForResultsArgs);

    // Ensure the current window is active.
    Window.Current.Activate();
}

using namespace winrt::Windows::ApplicationModel::Activation;
...
protected override void OnActivated(IActivatedEventArgs args)
{
    // Window management
    Frame rootFrame{ nullptr };
    auto content = Window::Current().Content();
    if (content)
    {
        rootFrame = content.try_as<Frame>();
    }
    
    if (rootFrame == null)
    {
        rootFrame = Frame();
        Window::Current().Content(rootFrame);
    }

    // Code specific to launch for results
    auto protocolForResultsEventArgs{ args.as<ProtocolForResultsActivatedEventArgs>() };
    // Open the page that we created to handle activation for results.
    rootFrame.Navigate(xaml_typename<LaunchedForResultsPage>(), protocolForResultsArgs);

    // Ensure the current window is active.
    Window::Current().Activate();
}

Étant donné que l’extension de protocole dans le fichier Package.appxmanifest spécifie ReturnResults comme toujours, le code affiché peut être converti args directement en ProtocolForResultsActivatedEventArgs avec confiance que seul ProtocolForResultsActivatedEventArgs sera envoyé à OnActivated pour cette application. Si votre application peut être activée de manière autre que le lancement des résultats, vous pouvez vérifier si la propriété IActivatedEventArgs.Kind retourne ActivationKind.ProtocolForResults pour savoir si l’application a été lancée pour les résultats.

Étape 3 : Ajouter un champ ProtocolForResultsOperation à l’application que vous lancez pour les résultats

private Windows.System.ProtocolForResultsOperation _operation = null;

Windows::System::ProtocolForResultsOperation _operation = nullptr;

Vous allez utiliser le champ ProtocolForResultsOperation pour signaler quand l’application lancée est prête à retourner le résultat à l’application appelante. Dans cet exemple, le champ est ajouté à la classe LaunchForResultsPage , car vous allez effectuer l’opération launch-for-results à partir de cette page et y accéder.

Étape 4 : Remplacer OnNavigatedTo() dans l’application que vous lancez pour les résultats

Remplacez la méthode OnNavigatedTo sur la page que vous allez afficher lorsque votre application est lancée pour les résultats. Si cette méthode n’existe pas déjà, créez-la dans la classe de la page définie dans <le nom> de page.xaml.cs. Vérifiez que l’instruction using suivante est incluse en haut du fichier :

using Windows.ApplicationModel.Activation

using namespace winrt::Windows::ApplicationModel::Activation;

L’objet NavigationEventArgs de la méthode OnNavigatedTo contient les données transmises à partir de l’application appelante. Les données peuvent ne pas dépasser 100 Ko et sont stockées dans un objet ValueSet.

Dans cet exemple de code, l’application lancée s’attend à ce que les données envoyées à partir de l’application appelante se trouvent dans un ValueSet sous une clé nommée TestData, car c’est ce que l’application appelante de l’exemple est codée pour envoyer.

using Windows.ApplicationModel.Activation;
...
protected override void OnNavigatedTo(NavigationEventArgs e)
{
    var protocolForResultsArgs = e.Parameter as ProtocolForResultsActivatedEventArgs;
    // Set the ProtocolForResultsOperation field.
    _operation = protocolForResultsArgs.ProtocolForResultsOperation;

    if (protocolForResultsArgs.Data.ContainsKey("TestData"))
    {
        string dataFromCaller = protocolForResultsArgs.Data["TestData"] as string;
    }
}
...
private Windows.System.ProtocolForResultsOperation _operation = null;

using namespace winrt::Windows::ApplicationModel::Activation;
...
protected override void OnNavigatedTo(NavigationEventArgs e)
{
    auto protocolForResultsArgs = e.Parameter().try_as<ProtocolForResultsActivatedEventArgs>();
    // Set the ProtocolForResultsOperation field.
    _operation = protocolForResultsArgs.ProtocolForResultsOperation();

    if (protocolForResultsArgs.Data().HasKey("TestData"))
    {
        string dataFromCaller{ unbox_value<hstring>(protocolForResultsArgs.Data().Lookup("TestData")) };
    }
}
...
Windows::System::ProtocolForResultsOperation _operation = nullptr;

Étape 5 : Écrire du code pour retourner des données à l’application appelante

Dans l’application lancée, utilisez ProtocolForResultsOperation pour retourner des données à l’application appelante. Dans cet exemple de code, un objet ValueSet est créé qui contient la valeur à retourner à l’application appelante. Le champ ProtocolForResultsOperation est ensuite utilisé pour envoyer la valeur à l’application appelante.

    ValueSet result = new ValueSet();
    result["ReturnedData"] = "The returned result";
    _operation.ReportCompleted(result);

    ValueSet result;
    result.Insert("ReturnedData", "The returned result");
    _operation.ReportCompleted(result);

Étape 6 : Écrire du code pour lancer l’application pour les résultats et obtenir les données retournées

Lancez l’application à partir d’une méthode asynchrone dans votre application appelante, comme illustré dans cet exemple de code. Notez les instructions using , qui sont nécessaires pour le code à compiler :

using System.Threading.Tasks;
using Windows.System;
...

async Task<string> LaunchAppForResults()
{
    var testAppUri = new Uri("test-app2app:"); // The protocol handled by the launched app
    var options = new LauncherOptions();
    options.TargetApplicationPackageFamilyName = "67d987e1-e842-4229-9f7c-98cf13b5da45_yd7nk54bq29ra";

    var inputData = new ValueSet();
    inputData["TestData"] = "Test data";

    string theResult = "";
    LaunchUriResult result = await Windows.System.Launcher.LaunchUriForResultsAsync(testAppUri, options, inputData);
    if (result.Status == LaunchUriStatus.Success &&
        result.Result != null &&
        result.Result.ContainsKey("ReturnedData"))
    {
        ValueSet theValues = result.Result;
        theResult = theValues["ReturnedData"] as string;
    }
    return theResult;
}

Dans cet exemple, un ValueSet contenant la clé TestData est passé à l’application lancée. L’application lancée crée un ValueSet avec une clé nommée ReturnedData qui contient le résultat retourné à l’appelant.

Vous devez générer et déployer l’application que vous allez lancer pour obtenir les résultats avant d’exécuter votre application appelante. Sinon, LaunchUriResult.Status signale LaunchUriStatus.AppUnavailable.

Vous aurez besoin du nom de famille de l’application lancée lorsque vous définissez TargetApplicationPackageFamilyName. Une façon d’obtenir le nom de la famille consiste à effectuer l’appel suivant à partir de l’application lancée :

string familyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;

Notes

L’exemple de ce guide pratique fournit une présentation « hello world » pour lancer une application pour obtenir des résultats. Les éléments clés à noter sont que la nouvelle API LaunchUriForResultsAsync vous permet de lancer de manière asynchrone une application et de communiquer via la classe ValueSet. Le passage de données via un ValueSet est limité à 100 Ko. Si vous devez transmettre de grandes quantités de données, vous pouvez partager des fichiers à l’aide de la classe SharedStorageAccessManager pour créer des jetons de fichier que vous pouvez transmettre entre les applications. Par exemple, en fonction d’un ValueSet nommé inputData, vous pouvez stocker le jeton dans un fichier que vous souhaitez partager avec l’application lancée :

inputData["ImageFileToken"] = SharedStorageAccessManager.AddFile(myFile);

Ensuite, passez-la à l’application lancée via LaunchUriForResultsAsync.