So wird's gemacht: Aktivieren einer App (DirectX und C++)

Applies to Windows and Windows Phone

In diesem Thema erfahren Sie, wie Sie die Aktivierungsbenutzeroberfläche für eine Windows-Runtime-App mit DirectX und C++ definieren.

Registrieren des Ereignishandlers für die Aktivierung der App

Registrieren Sie zuerst die Behandlung des CoreApplicationView::Activated-Ereignisses, das ausgelöst wird, wenn die App vom Betriebssystem gestartet und initialisiert wird.

  • Applies to Windows Phone

Hinweis  Unter Windows Phone wird diese Methode immer aufgerufen, wenn der Benutzer die App über die Start-Kachel oder App-Liste startet, auch wenn die App angehalten ist. Apps sollten die Aktivierungsparameter prüfen und festlegen, ob die bisherige Darstellung beibehalten oder beim Start mit neuen Parametern ein neuer Bildschirm angezeigt wird.

Fügen Sie Ihrer Implementierung der IFrameworkView::Initialize-Methode Ihres Ansichtsanbieters (in diesem Beispiel MyViewProvider) folgenden Code hinzu:



using namespace concurrency;
using namespace Windows::ApplicationModel;
using namespace Windows::ApplicationModel::Activation;
using namespace Windows::ApplicationModel::Core;
using namespace Windows::UI::Core;
using namespace Windows::UI::ViewManagement;

MyViewProvider::MyViewProvider() :
    // class fields
    // ...
    bool m_visible;
    bool m_windowsClosed;
{

}

void MyViewProvider::Initialize(
    _In_ CoreApplicationView^ applicationView
    )
{

   // ...

    applicationView->Activated +=
        ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &DirectXApp::OnActivated);

   // ...

}


Aktivieren der CoreWindow-Instanz für die App

Beim Start der App müssen Sie einen Verweis auf die CoreWindow-Instanz für Ihre App abrufen. CoreWindow enthält den Meldungsverteiler für Fensterereignisse, mit dem die App Fensterereignisse verarbeitet. Rufen Sie diesen Verweis im Rückruf für das App-Aktivierungsereignis durch Aufrufen von CoreWindow::GetForCurrentThread ab. Gehen Sie nach dem Abrufen des Verweises wie folgt vor:

  • Erstellen Sie einen Ereignishandler CoreWindow::Activated für das Aktivierungsereignis für das Hauptfensters der App, und fügen Sie ihn an. Dieses Ereignis wird ausgelöst, wenn das Hauptfenster der App den Fokus erhält oder verliert.
  • Aktivieren Sie das Hauptfenster der App durch einen Aufruf von CoreWindow::Activate.


void MyViewProvider::OnActivated(
    _In_ CoreApplicationView^ /* applicationView */,
    _In_ IActivatedEventArgs^ /* args */
    )
{
    CoreWindow::GetForCurrentThread()->Activated +=
        ref new TypedEventHandler<CoreWindow^, WindowActivatedEventArgs^>(this, &MyViewProvider::OnWindowActivationChanged);
    CoreWindow::GetForCurrentThread()->Activate();
}


Behandeln von Änderungen des Status des Hauptfensters der App

Implementieren Sie nun eine Methode zur Behandlung von Änderungen des Status des Hauptfensters der App (CoreWindow). Im folgenden Beispiel behandeln Sie Folgendes:

Der gesamte Satz von CoreWindow-Statuswerten ist in CoreWindowActivationState enumeriert.



void MyViewProvider::OnWindowActivationChanged(
    _In_ Windows::UI::Core::CoreWindow^ /* sender */,
    _In_ Windows::UI::Core::WindowActivatedEventArgs^ args
    )
{
    if (args->WindowActivationState == CoreWindowActivationState::Deactivated)
    {
        // CoreWindow does not have focus
    }
    else if (args->WindowActivationState == CoreWindowActivationState::CodeActivated
        || args->WindowActivationState == CoreWindowActivationState::PointerActivated)
    {
        // CoreWindow has focus
    }
}


Beginn der Verarbeitung von Ereignismeldungen für das Hauptfenster der App

Ihre Rückrufe treten als Ereignismeldungen auf, die vom CoreDispatcher des CoreWindow der App verarbeitet werden. Dieser Rückruf wird nicht aufgerufen, wenn Sie in der Hauptschleife der App (in der IFrameworkView::Run-Methode des Ansichtsanbieters implementiert) nicht CoreDispatcher::ProcessEvents aufrufen.


// m_visible and m_windowsClose are class-level bool variables on MyViewProvider.

// ...

void MyViewProvider::Run()
{
    // your app's main loop!
    while (!m_windowClosed) // the app window is NOT closed
    {
        if (m_visible) // and if the app window is visible
        {
            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(
                                                           CoreProcessEventsOption::ProcessAllIfPresent
                                                           );
        }
        else 
        {
            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(
                                                           CoreProcessEventsOption::ProcessOneAndAllPending
                                                           );
        }
    }
}

Verwandte Themen

So wird's gemacht: Anhalten einer App (DirectX und C++)
So wird's gemacht: Reaktivieren einer App (DirectX und C++)
Richtlinien für das Anhalten und Fortsetzen von Apps
App-Lebenszyklus (Store-Apps)

 

 

Anzeigen:
© 2014 Microsoft