zadania w tle systemu watchOS na platformie Xamarin

W systemie watchOS 3 istnieją trzy główne sposoby aktualizowania informacji przez aplikację do oglądania:

• Przy użyciu jednego z kilku nowych zadań w tle.
• Mając jedną z jego komplikacji na twarzy zegarka (dając mu dodatkowy czas na aktualizację).
• Przypinanie użytkownika do aplikacji do nowego doku (gdzie jest przechowywane w pamięci i często aktualizowane).

Aktualizowanie aplikacji

Przed omówieniem wszystkich sposobów, w jakie deweloper może przechowywać dane aplikacji watchOS oraz interfejs użytkownika i zaktualizować, w tej sekcji przyjrzymy się typowym zestawom wzorców użytkowania oraz sposobom, w jaki użytkownik może przechodzić między urządzeniem i Telefon a zegarkiem Apple Watch przez cały dzień na podstawie pory dnia i aktualnie wykonywanej aktywności (na przykład jazdy).

Spójrz na następujący przykład:

1. Rano, czekając w kolejce do kawy, użytkownik przegląda bieżące wiadomości na swojej i Telefon przez kilka minut.
2. Przed opuszczeniem kawiarni szybko sprawdzają pogodę z Komplikacją na twarzy zegarka.
3. Przed lunchem korzystają z aplikacji Mapy na i Telefon, aby znaleźć w pobliżu restaurację i zarezerwować rezerwację, aby spotkać się z klientem.
4. Podczas podróży do restauracji otrzymują powiadomienie na zegarku Apple Watch i z krótkim spojrzeniem, wiedzą, że ich spotkanie na lunch działa późno.
5. Wieczorem używają aplikacji Mapy na urządzeniu i Telefon do sprawdzania ruchu przed jazdą do domu.
6. W drodze do domu otrzymują powiadomienie iMessage na zegarku Apple Watch z prośbą o odebranie mleka i używają funkcji Szybkie odpowiadanie, aby wysłać odpowiedź "OK".

Ze względu na "szybki rzut oka" (mniej niż trzy sekundy) charakter sposobu, w jaki użytkownik chce korzystać z aplikacji Apple Watch, zazwyczaj nie ma wystarczająco dużo czasu, aby aplikacja pobierała żądane informacje i aktualizowała interfejs użytkownika przed wyświetleniem go użytkownikowi.

Korzystając z nowych interfejsów API, które firma Apple włączyła w systemie watchOS 3, aplikacja może zaplanować odświeżanie w tle i przygotować żądane informacje, zanim użytkownik zażąda go. Zapoznaj się z przykładem komplikacji pogodowych omówionych powyżej:

1. Harmonogramy aplikacji zostaną obudzine przez system w określonym czasie.
2. Aplikacja pobiera informacje wymagane do wygenerowania aktualizacji.
3. Aplikacja ponownie generuje interfejs użytkownika, aby odzwierciedlić nowe dane.
4. Gdy użytkownik przegląda komplikacje aplikacji, ma aktualne informacje bez konieczności oczekiwania na aktualizację.

Jak pokazano powyżej, system watchOS wznawia aplikację przy użyciu co najmniej jednego zadania, z których ma bardzo ograniczoną pulę:

Firma Apple sugeruje, aby w pełni wykorzystać to zadanie (ponieważ jest to taki ograniczony zasób do aplikacji), trzymając go do momentu zakończenia procesu aktualizacji samej aplikacji.

System dostarcza te zadania, wywołując nową HandleBackgroundTasks metodę delegata WKExtensionDelegate . Na przykład:

using System;
using Foundation;
using WatchKit;

namespace MonkeyWatch.MonkeySeeExtension
{
  public class ExtensionDelegate : WKExtensionDelegate
  {
    #region Constructors
    public ExtensionDelegate ()
    {
    }
    #endregion

    #region Override Methods
    public override void HandleBackgroundTasks (NSSet<WKRefreshBackgroundTask> backgroundTasks)
    {
      // Handle background request here
      ...
    }
    #endregion
  }
}

Po zakończeniu danego zadania aplikacja zwraca ją do systemu, oznaczając, że została ukończona:

Nowe zadania w tle

watchOS 3 wprowadza kilka zadań w tle, których aplikacja może używać do aktualizowania informacji zapewniających, że ma zawartość wymaganą przez użytkownika przed otwarciem aplikacji, na przykład:

• Odświeżanie aplikacji w tle — zadanie WKApplicationRefreshBackgroundTask umożliwia aplikacji aktualizowanie stanu w tle. Zazwyczaj obejmuje to inne zadanie, takie jak pobieranie nowej zawartości z Internetu przy użyciu NSUrlSession.
• Odświeżanie migawki w tle — zadanie WKSnapshotRefreshBackgroundTask umożliwia aplikacji aktualizowanie zawartości i interfejsu użytkownika przed utworzeniem migawki, która zostanie użyta do wypełnienia obszaru Dock.
• Połączenie ivity zegarka w tle — zadanie WKWatch Połączenie ivityRefreshBackgroundTask jest uruchamiane dla aplikacji, gdy odbiera dane w tle z sparowanego i Telefon.
• Sesja adresu URL w tle — zadanie WKURLSessionRefreshBackgroundTask jest uruchamiane dla aplikacji, gdy transfer w tle wymaga autoryzacji lub ukończenia (pomyślnie lub w błędzie).

Te zadania zostaną szczegółowo omówione w poniższych sekcjach.

WKApplicationRefreshBackgroundTask

Jest WKApplicationRefreshBackgroundTask to ogólne zadanie, które można zaplanować, aby aplikacja została wybudzony w przyszłości:

W czasie wykonywania zadania aplikacja może wykonywać dowolne lokalne przetwarzanie, takie jak aktualizowanie osi czasu komplikacji lub pobieranie niektórych wymaganych danych za pomocą elementu NSUrlSession.

WKURLSessionRefreshBackgroundTask

System wyśle komunikat WKURLSessionRefreshBackgroundTask po zakończeniu pobierania i gotowości danych do przetworzenia przez aplikację:

Aplikacja nie jest uruchomiona, gdy dane są pobierane w tle. Zamiast tego aplikacja planuje żądanie dotyczące danych, a następnie jest zawieszona, a system obsługuje pobieranie danych, tylko ponownie uruchamiając aplikację po zakończeniu pobierania.

WKSnapshotRefreshBackgroundTask

W systemie watchOS 3 firma Apple dodała dock, w którym użytkownicy mogą przypinać swoje ulubione aplikacje i szybko uzyskiwać do nich dostęp. Gdy użytkownik naciśnie przycisk boczny na zegarku Apple Watch, zostanie wyświetlona galeria przypiętych migawek aplikacji. Użytkownik może przesunąć palcem w lewo lub w prawo, aby znaleźć żądaną aplikację, a następnie nacisnąć aplikację, aby uruchomić ją, zastępując migawkę interfejsem uruchomionej aplikacji.

System okresowo tworzy migawki interfejsu użytkownika aplikacji (wysyłając element WKSnapshotRefreshBackgroundTask) i używa tych migawek do wypełnienia obszaru Dock. watchOS daje aplikacji możliwość zaktualizowania zawartości i interfejsu użytkownika przed wykonaniem tej migawki.

Migawki są bardzo ważne w systemie watchOS 3, ponieważ działają zarówno jako wersja zapoznawcza, jak i uruchamiają obrazy dla aplikacji. Jeśli użytkownik osiedli się w aplikacji w Docku, zostanie on rozbudowany do pełnego ekranu, wprowadź pierwszy plan i rozpocznie działanie, dlatego konieczne jest, aby migawka była aktualna:

Ponownie system wyda WKSnapshotRefreshBackgroundTask polecenie , aby aplikacja mogła przygotować (aktualizując dane i interfejs użytkownika) przed wykonaniem migawki:

Gdy aplikacja oznaczy ukończone WKSnapshotRefreshBackgroundTask , system automatycznie utworzy migawkę interfejsu użytkownika aplikacji.

Ważne

Ważne jest, aby zawsze planować po WKSnapshotRefreshBackgroundTask otrzymaniu nowych danych przez aplikację i zaktualizowaniu interfejsu użytkownika lub użytkownik nie będzie widzieć zmodyfikowanych informacji.

Ponadto gdy użytkownik otrzyma powiadomienie z aplikacji i naciśnie ją, aby przenieść aplikację na pierwszy plan, migawka musi być aktualna, ponieważ działa również jako ekran uruchamiania:

Jeśli od czasu interakcji użytkownika z aplikacją systemu watchOS minęło więcej niż godzinę, będzie on mógł powrócić do stanu domyślnego. Stan domyślny może oznaczać różne elementy dla różnych aplikacji i, na podstawie projektu aplikacji, może nie mieć w ogóle stanu domyślnego.

WKWatch Połączenie ivityRefreshBackgroundTask

W systemie watchOS 3 firma Apple zintegrowała łączność zegarków z interfejsem API odświeżania w tle za pośrednictwem nowego WKWatchConnectivityRefreshBackgroundTaskelementu . Korzystając z tej nowej funkcji, aplikacja i Telefon może dostarczać nowe dane do swojego odpowiednika aplikacji do zegarka, podczas gdy aplikacja watchOS działa w tle:

Inicjowanie wypychania komplikacji, kontekstu aplikacji, wysyłania pliku lub aktualizowania informacji o użytkowniku z aplikacji i Telefon spowoduje wznawianie aplikacji Apple Watch w tle.

Gdy aplikacja zegarka zostanie wybudzony za pośrednictwem elementu WKWatchConnectivityRefreshBackgroundTask , będzie musiała użyć standardowych metod interfejsu API do odbierania danych z aplikacji i Telefon.

1. Upewnij się, że sesja została aktywowana.
2. Monitoruj nową HasContentPending właściwość, o ile wartość to true, aplikacja nadal ma dane do przetworzenia. Tak jak wcześniej aplikacja powinna przechowywać zadanie do momentu zakończenia przetwarzania wszystkich danych.
3. Jeśli nie ma więcej danych do przetworzenia (HasContentPending = false), oznacz zadanie ukończone, aby przywrócić je do systemu. Wykonanie tej czynności spowoduje wyczerpanie przydzielonego środowiska uruchomieniowego w tle aplikacji, co spowoduje zgłoszenie o awarii.

Cykl życia interfejsu API w tle

Umieszczenie wszystkich elementów nowego interfejsu API zadań w tle, typowy zestaw interakcji wygląda następująco:

1. Po pierwsze, aplikacja watchOS planuje zadanie w tle, aby obudzić się jako jakiś punkt w przyszłości.
2. Aplikacja jest wybudzony przez system i wysyła zadanie.
3. Aplikacja przetwarza zadanie, aby ukończyć pracę, która była wymagana.
4. W wyniku przetwarzania zadania może być konieczne zaplanowanie większej liczby zadań w tle w celu wykonania większej liczby zadań w tle w przyszłości, takich jak pobieranie większej ilości zawartości przy użyciu elementu NSUrlSession.
5. Aplikacja oznacza ukończone zadanie i zwraca je do systemu.

Odpowiedzialne korzystanie z zasobów

Niezwykle ważne jest, aby aplikacja systemu watchOS zachowywała się odpowiedzialnie w tym ekosystemie przez ograniczenie opróżniania zasobów udostępnionych systemu.

Zapoznaj się z następującym scenariuszem:

1. Użytkownik uruchamia aplikację dla systemu watchOS o godzinie 13:00.
2. Aplikacja planuje zadanie wznawiania i pobierania nowej zawartości o godzinie 2:00.
3. O godzinie 13:50 użytkownik ponownie otworzy aplikację, która umożliwia jej aktualizowanie danych i interfejsu użytkownika w tej chwili.
4. Zamiast ponownie wznawiać zadanie w 10 minut, aplikacja powinna ponownie zaplanować uruchomienie zadania o godzinie później o godzinie 2:50.

Chociaż każda aplikacja jest inna, firma Apple sugeruje znalezienie wzorców użycia, takich jak pokazane powyżej, aby pomóc w oszczędzaniu zasobów systemowych.

Implementowanie zadań w tle

Na przykład ten dokument będzie używać fałszywej aplikacji sportowej MonkeySoccer, która zgłasza wyniki piłki nożnej użytkownikowi.

Zapoznaj się z następującym typowym scenariuszem użycia:

Ulubiona drużyna piłki nożnej użytkownika gra duży mecz od 17:00 do 19:00, więc aplikacja powinna oczekiwać, że użytkownik będzie regularnie sprawdzać wynik i decyduje o 30-minutowym interwale aktualizacji.

1. Użytkownik otworzy aplikację i planuje zadanie aktualizacji w tle 30 minut później. Interfejs API w tle umożliwia uruchamianie tylko jednego typu zadania w tle w danym momencie.
2. Aplikacja otrzymuje zadanie i aktualizuje swoje dane oraz interfejs użytkownika, a następnie planuje kolejne zadanie w tle 30 minut później. Ważne jest, aby deweloper pamiętał o zaplanowaniu innego zadania w tle lub aplikacja nigdy nie zostanie ponownie zdjęta, aby uzyskać więcej aktualizacji.
3. Ponownie aplikacja odbiera zadanie i aktualizuje swoje dane, aktualizuje interfejs użytkownika i planuje kolejne zadanie w tle 30 minut później.
4. Ten sam proces powtarza się ponownie.
5. Ostatnie zadanie w tle jest odbierane, a aplikacja ponownie aktualizuje swoje dane i interfejs użytkownika. Ponieważ jest to ostateczny wynik, nie planuje nowego odświeżania w tle.

Planowanie aktualizacji w tle

Biorąc pod uwagę powyższy scenariusz, aplikacja MonkeySoccer może użyć następującego kodu do zaplanowania aktualizacji w tle:

private void ScheduleNextBackgroundUpdate ()
{
  // Create a fire date 30 minutes into the future
  var fireDate = NSDate.FromTimeIntervalSinceNow (30 * 60);

  // Create
  var userInfo = new NSMutableDictionary ();
  userInfo.Add (new NSString ("LastActiveDate"), NSDate.FromTimeIntervalSinceNow(0));
  userInfo.Add (new NSString ("Reason"), new NSString ("UpdateScore"));

  // Schedule for update
  WKExtension.SharedExtension.ScheduleBackgroundRefresh (fireDate, userInfo, (error) => {
    // Was the Task successfully scheduled?
    if (error == null) {
      // Yes, handle if needed
    } else {
      // No, report error
    }
  });
}

Spowoduje to utworzenie nowego NSDate 30 minut w przyszłości, gdy aplikacja chce zostać zdjęta i utworzy obiekt , aby NSMutableDictionary przechowywać szczegóły żądanego zadania. Metoda ScheduleBackgroundRefreshSharedExtension jest używana do żądania zaplanowanego zadania.

System zwróci NSError wartość , jeśli nie można zaplanować żądanego zadania.

Przetwarzanie aktualizacji

Następnie przyjrzyj się bliżej 5-minutowemu oknie pokazującym kroki wymagane do zaktualizowania wyniku:

1. O godzinie 19:30:02 aplikacja zostanie obudzona przez system i nada zadanie w tle aktualizacji. Pierwszym priorytetem jest uzyskanie najnowszych wyników z serwera. Zobacz Planowanie NSUrlSession poniżej.
2. O godzinie 7:30:05 aplikacja ukończy oryginalne zadanie, system umieszcza aplikację w stanie uśpienia i nadal pobiera żądane dane w tle.
3. Po zakończeniu pobierania system tworzy nowe zadanie w celu wznawiania aplikacji w celu przetworzenia pobranych informacji. Zobacz Obsługa zadań w tle i obsługa kończenia pobierania poniżej.
4. Aplikacja zapisuje zaktualizowane informacje i oznacza zadanie ukończone. Deweloper może być kuszony, aby zaktualizować interfejs użytkownika aplikacji w tej chwili, jednak firma Apple sugeruje zaplanowanie zadania migawki w celu obsługi tego procesu. Zobacz Planowanie aktualizacji migawki poniżej.
5. Aplikacja otrzymuje zadanie migawki, aktualizuje interfejs użytkownika i oznacza zadanie ukończone. Zobacz Obsługa aktualizacji migawki poniżej.

Planowanie NSUrlSession

Poniższy kod może służyć do planowania pobierania najnowszych wyników:

private void ScheduleURLUpdateSession ()
{
  // Create new configuration
  var configuration = NSUrlSessionConfiguration.CreateBackgroundSessionConfiguration ("com.example.urlsession");

  // Create new session
  var backgroundSession = NSUrlSession.FromConfiguration (configuration);

  // Create and start download task
  var downloadTask = backgroundSession.CreateDownloadTask (new NSUrl ("https://example.com/gamexxx/currentScores.json"));
  downloadTask.Resume ();
}

Konfiguruje i tworzy nowy NSUrlSessionelement , a następnie używa tej sesji do utworzenia nowego zadania pobierania CreateDownloadTask przy użyciu metody . Wywołuje metodę Resume zadania pobierania, aby uruchomić sesję.

Obsługa zadań w tle

Przesłaniając metodę HandleBackgroundTasks programu WKExtensionDelegate, aplikacja może obsługiwać przychodzące zadania w tle:

using System;
using System.Collections.Generic;
using Foundation;
using WatchKit;

namespace MonkeySoccer.MonkeySoccerExtension
{
  public class ExtensionDelegate : WKExtensionDelegate
  {
    #region Computed Properties
    public List<WKRefreshBackgroundTask> PendingTasks { get; set; } = new List<WKRefreshBackgroundTask> ();
    #endregion

    ...

    #region Public Methods
    public void CompleteTask (WKRefreshBackgroundTask task)
    {
      // Mark the task completed and remove from the collection
      task.SetTaskCompleted ();
      PendingTasks.Remove (task);
    }
    #endregion

    #region Override Methods
    public override void HandleBackgroundTasks (NSSet<WKRefreshBackgroundTask> backgroundTasks)
    {
      // Handle background request
      foreach (WKRefreshBackgroundTask task in backgroundTasks) {
        // Is this a background session task?
        var urlTask = task as WKUrlSessionRefreshBackgroundTask;
        if (urlTask != null) {
          // Create new configuration
          var configuration = NSUrlSessionConfiguration.CreateBackgroundSessionConfiguration (urlTask.SessionIdentifier);

          // Create new session
          var backgroundSession = NSUrlSession.FromConfiguration (configuration, new BackgroundSessionDelegate (this, task), null);

          // Keep track of all pending tasks
          PendingTasks.Add (task);
        } else {
          // Ensure that all tasks are completed
          task.SetTaskCompleted ();
        }
      }
    }
    #endregion

    ...
  }
}

Metoda HandleBackgroundTasks przechodzi przez wszystkie zadania, które system wysłał aplikację (w systemie backgroundTasks) wyszukując WKUrlSessionRefreshBackgroundTaskelement . Jeśli jeden z nich zostanie znaleziony, dołączy ponownie sesję i dołączy element w NSUrlSessionDownloadDelegate celu obsługi ukończenia pobierania (zobacz Obsługa kończenia pobierania poniżej):

// Create new session
var backgroundSession = NSUrlSession.FromConfiguration (configuration, new BackgroundSessionDelegate (this, task), null);

Utrzymuje dojście do zadania, dopóki nie zostanie ukończone przez dodanie go do kolekcji:

public List<WKRefreshBackgroundTask> PendingTasks { get; set; } = new List<WKRefreshBackgroundTask> ();
...

// Keep track of all pending tasks
PendingTasks.Add (task);

Wszystkie zadania wysyłane do aplikacji muszą zostać ukończone, dla każdego zadania, które nie jest obecnie obsługiwane, oznacz je jako ukończone:

if (urlTask != null) {
  ...
} else {
  // Ensure that all tasks are completed
  task.SetTaskCompleted ();
}

Obsługa kończenia pobierania

Aplikacja MonkeySoccer używa następującego NSUrlSessionDownloadDelegate delegata do obsługi ukończenia pobierania i przetwarzania żądanych danych:

using System;
using Foundation;
using WatchKit;

namespace MonkeySoccer.MonkeySoccerExtension
{
  public class BackgroundSessionDelegate : NSUrlSessionDownloadDelegate
  {
    #region Computed Properties
    public ExtensionDelegate WatchExtensionDelegate { get; set; }

    public WKRefreshBackgroundTask Task { get; set; }
    #endregion

    #region Constructors
    public BackgroundSessionDelegate (ExtensionDelegate extensionDelegate, WKRefreshBackgroundTask task)
    {
      // Initialize
      this.WatchExtensionDelegate = extensionDelegate;
      this.Task = task;
    }
    #endregion

    #region Override Methods
    public override void DidFinishDownloading (NSUrlSession session, NSUrlSessionDownloadTask downloadTask, NSUrl location)
    {
      // Handle the downloaded data
      ...

      // Mark the task completed
      WatchExtensionDelegate.CompleteTask (Task);

    }
    #endregion
  }
}

Po zainicjowaniu utrzymuje uchwyt zarówno do elementu , jak ExtensionDelegate i WKRefreshBackgroundTask , który go zduplikował. Zastępuje metodę DidFinishDownloading do obsługi ukończenia pobierania. Następnie używa CompleteTask metody , ExtensionDelegate aby poinformować zadanie o jego ukończeniu i usunąć je z kolekcji oczekujących zadań. Zobacz Obsługa zadań w tle powyżej.

Planowanie aktualizacji migawek

Za pomocą następującego kodu można zaplanować zadanie migawki w celu zaktualizowania interfejsu użytkownika przy użyciu najnowszych wyników:

private void ScheduleSnapshotUpdate ()
{
  // Create a fire date of now
  var fireDate = NSDate.FromTimeIntervalSinceNow (0);

  // Create user info dictionary
  var userInfo = new NSMutableDictionary ();
  userInfo.Add (new NSString ("lastActiveDate"), NSDate.FromTimeIntervalSinceNow (0));
  userInfo.Add (new NSString ("reason"), new NSString ("UpdateScore"));

  // Schedule for update
  WKExtension.SharedExtension.ScheduleSnapshotRefresh (fireDate, userInfo, (error) => {
    // Was the Task successfully scheduled?
    if (error == null) {
      // Yes, handle if needed
    } else {
      // No, report error
    }
  });
}

Podobnie jak ScheduleURLUpdateSession w przypadku powyższej metody tworzy nowy NSDate element, gdy aplikacja chce zostać zdjęta i tworzy obiekt , aby NSMutableDictionary przechowywać szczegóły żądanego zadania. Metoda ScheduleSnapshotRefreshSharedExtension jest używana do żądania zaplanowanego zadania.

System zwróci NSError wartość , jeśli nie można zaplanować żądanego zadania.

Obsługa aktualizacji migawek

Aby obsłużyć zadanie migawki, HandleBackgroundTasks metoda (zobacz Obsługa zadań w tle powyżej) została zmodyfikowana tak, aby wyglądała następująco:

public override void HandleBackgroundTasks (NSSet<WKRefreshBackgroundTask> backgroundTasks)
{
  // Handle background request
  foreach (WKRefreshBackgroundTask task in backgroundTasks) {
    // Take action based on task type
    if (task is WKUrlSessionRefreshBackgroundTask) {
      var urlTask = task as WKUrlSessionRefreshBackgroundTask;

      // Create new configuration
      var configuration = NSUrlSessionConfiguration.CreateBackgroundSessionConfiguration (urlTask.SessionIdentifier);

      // Create new session
      var backgroundSession = NSUrlSession.FromConfiguration (configuration, new BackgroundSessionDelegate (this, task), null);

      // Keep track of all pending tasks
      PendingTasks.Add (task);
    } else if (task is WKSnapshotRefreshBackgroundTask) {
      var snapshotTask = task as WKSnapshotRefreshBackgroundTask;

      // Update UI
      ...

      // Create a expiration date 30 minutes into the future
      var expirationDate = NSDate.FromTimeIntervalSinceNow (30 * 60);

      // Create user info dictionary
      var userInfo = new NSMutableDictionary ();
      userInfo.Add (new NSString ("lastActiveDate"), NSDate.FromTimeIntervalSinceNow (0));
      userInfo.Add (new NSString ("reason"), new NSString ("UpdateScore"));

      // Mark task complete
      snapshotTask.SetTaskCompleted (false, expirationDate, userInfo);
    } else {
      // Ensure that all tasks are completed
      task.SetTaskCompleted ();
    }
  }
}

Metoda testuje typ przetwarzanego zadania. Jeśli jest to element WKSnapshotRefreshBackgroundTask , uzyskuje dostęp do zadania:

var snapshotTask = task as WKSnapshotRefreshBackgroundTask;

Metoda aktualizuje interfejs użytkownika, a następnie tworzy element , NSDate aby poinformować system, gdy migawka będzie nieaktualna. Tworzy element NSMutableDictionary z informacjami o użytkowniku, aby opisać nową migawkę i oznaczy zadanie migawki ukończone przy użyciu następujących informacji:

// Mark task complete
snapshotTask.SetTaskCompleted (false, expirationDate, userInfo);

Ponadto informuje również zadanie migawki, że aplikacja nie wraca do stanu domyślnego (w pierwszym parametrze). Aplikacje, które nie mają pojęcia stanu domyślnego, powinny zawsze ustawiać tę właściwość na truewartość .

Wydajna praca

Jak pokazano w powyższym przykładzie z pięciominutowego okna, które aplikacja MonkeySoccer podjęła w celu zaktualizowania wyników, wydajnie pracując i korzystając z nowych zadań w tle systemu watchOS 3, aplikacja była aktywna tylko przez 15 sekund:

Zmniejsza to wpływ, jaki aplikacja będzie miała zarówno na dostępne zasoby zegarka Apple Watch, jak i żywotność baterii, a także umożliwia aplikacji lepszą pracę z innymi aplikacjami działającymi na zegarku.

Jak działa planowanie

Podczas gdy na pierwszym planie znajduje się aplikacja systemu watchOS 3, zawsze jest ona uruchamiana i może wykonywać dowolne wymagane przetwarzanie, takie jak aktualizowanie danych lub ponowne rysowanie interfejsu użytkownika. Gdy aplikacja przechodzi w tle, zwykle jest zawieszona przez system, a wszystkie operacje środowiska uruchomieniowego są zatrzymywane.

Aplikacja jest w tle, ale może być przeznaczona dla systemu, aby szybko uruchomić określone zadanie. Dlatego w systemie watchOS 2 system może tymczasowo wznawiać aplikację w tle, aby wykonywać takie czynności, jak obsługa długiego powiadomienia wyglądu lub zaktualizowanie komplikacji aplikacji. W systemie watchOS 3 istnieje kilka nowych sposobów uruchamiania aplikacji w tle.

Gdy aplikacja znajduje się w tle, system nakłada na nią kilka ograniczeń:

• Ukończenie danego zadania zajmuje tylko kilka sekund. System bierze pod uwagę nie tylko ilość czasu, jaki minął, ale także ilość mocy procesora CPU zużywanej przez aplikację w celu uzyskania tego limitu.
• Każda aplikacja, która przekracza limity, zostanie zabita z następującymi kodami błędów:
  • Procesor — 0xc51bad01
  • Czas — 0xc51bad02
• System nałoży różne limity na podstawie typu zadania w tle, które poprosił aplikację o wykonanie. Na przykład WKApplicationRefreshBackgroundTask zadania mają WKURLSessionRefreshBackgroundTask nieco dłuższe środowiska uruchomieniowe w innych typach zadań w tle.

Komplikacje i Aktualizacje aplikacji

Oprócz nowych zadań w tle, które firma Apple dodała do systemu watchOS 3, komplikacje aplikacji systemu watchOS mogą mieć wpływ na sposób i czas odbierania aktualizacji w tle przez aplikację.

Komplikacje to małe elementy wizualne, które zapewniają błyskawiczne przydatne informacje. W zależności od wybranej twarzy zegarka użytkownik ma możliwość dostosowania twarzy zegarka z co najmniej jednym komplikacją, która może być dostarczana przez aplikację do zegarka w systemie watchOS 3.

Jeśli użytkownik zawiera jedną z komplikacji aplikacji na twarzy zegarka, daje aplikacji następujące zaktualizowane korzyści:

• Powoduje to, że system zachowuje aplikację w stanie gotowości do uruchomienia, w którym próbuje uruchomić aplikację w tle, przechowuje ją w pamięci i zapewnia dodatkowy czas na aktualizację.
• Komplikacje są gwarantowane co najmniej 50 aktualizacji wypychania dziennie.

Deweloper powinien zawsze dążyć do tworzenia atrakcyjnych komplikacji dla swoich aplikacji, aby zachęcić użytkownika do dodawania ich do twarzy zegarka ze względów wymienionych powyżej.

W systemie watchOS 2 komplikacje były podstawowym sposobem, w jaki aplikacja otrzymała środowisko uruchomieniowe w tle. W systemie watchOS 3 aplikacja Komplikacja będzie nadal zapewniana, aby otrzymywać wiele aktualizacji na godzinę, jednak może służyć WKExtensions do żądania większej liczby środowisk uruchomieniowych w celu zaktualizowania jej komplikacji.

Przyjrzyj się następującemu kodowi użytemu do zaktualizowania komplikacji z połączonej aplikacji i Telefon:

using System;
using WatchConnectivity;
using UIKit;
using Foundation;
using System.Collections.Generic;
using System.Linq;
...

private void UpdateComplication ()
{

  // Get session and the number of remaining transfers
  var session = WCSession.DefaultSession;
  var transfers = session.RemainingComplicationUserInfoTransfers;

  // Create user info dictionary
  var iconattrs = new Dictionary<NSString, NSObject>
    {
      {new NSString ("lastActiveDate"), NSDate.FromTimeIntervalSinceNow (0)},
      {new NSString ("reason"), new NSString ("UpdateScore")}
    };

  var userInfo = NSDictionary<NSString, NSObject>.FromObjectsAndKeys (iconattrs.Values.ToArray (), iconattrs.Keys.ToArray ());

  // Take action based on the number of transfers left
  if (transfers < 1) {
    // No transfers left, either attempt to send or inform
    // user of situation.
    ...
  } else if (transfers < 11) {
    // Running low on transfers, only send on important updates
    // else conserve for a significant change.
    ...
  } else {
    // Send data
    session.TransferCurrentComplicationUserInfo (userInfo);
  }
}

Używa RemainingComplicationUserInfoTransfers właściwości , WCSession aby zobaczyć, ile transferów o wysokim priorytekcie aplikacja opuściła przez dzień, a następnie podejmuje działania na podstawie tej liczby. Jeśli aplikacja zacznie działać nisko przy transferach, może wstrzymać wysyłanie drobnych aktualizacji i wysyłać informacje tylko wtedy, gdy nastąpiła znacząca zmiana.

Planowanie i dock

W systemie watchOS 3 firma Apple dodała dock, w którym użytkownicy mogą przypinać swoje ulubione aplikacje i szybko uzyskiwać do nich dostęp. Gdy użytkownik naciśnie przycisk boczny na zegarku Apple Watch, zostanie wyświetlona galeria przypiętych migawek aplikacji. Użytkownik może przesunąć palcem w lewo lub w prawo, aby znaleźć żądaną aplikację, a następnie nacisnąć aplikację, aby uruchomić ją, zastępując ją migawką interfejsem uruchomionej aplikacji.

System okresowo tworzy migawki interfejsu użytkownika aplikacji i używa tych migawek do wypełnienia witryny Docs. aplikacja watchOS umożliwia aplikacji aktualizowanie zawartości i interfejsu użytkownika przed wykonaniem tej migawki.

Aplikacje przypięte do docka mogą oczekiwać następujących elementów:

• Otrzymają co najmniej jedną aktualizację na godzinę. Obejmuje to zarówno zadanie odświeżania aplikacji, jak i zadanie migawki.
• Budżet aktualizacji jest dystrybuowany między wszystkie aplikacje w Docku. Dlatego mniej aplikacji przypiętych przez użytkownika, tym więcej potencjalnych aktualizacji będzie otrzymywać każda aplikacja.
• Aplikacja będzie przechowywana w pamięci, aby aplikacja szybko wznowiła działanie po wybraniu z obszaru Dock.

Ostatnia aplikacja, która została uruchomiona przez użytkownika, zostanie uznana za ostatnio używaną aplikację i zajmie ostatnie miejsce w Docku. W tym miejscu użytkownik może wybrać trwałe przypięcie go do obszaru Dock. Ostatnio używane będą traktowane jak każda inna ulubiona aplikacja, która została już przypięta do obszaru Dock.

Ważne

Aplikacje, które zostały dodane tylko do ekranu głównego, nie będą miały żadnego regularnego planowania. Aby otrzymywać regularne aktualizacje planowania i w tle, do docku należy dodać aplikację.

Jak wspomniano wcześniej w tym dokumencie, migawki są bardzo ważne w systemie watchOS 3, ponieważ działają zarówno jako wersja zapoznawcza, jak i uruchamiają obrazy dla aplikacji. Jeśli użytkownik osiedli się w aplikacji w Docku, zostanie on rozbudowany do pełnego ekranu, wprowadź pierwszy plan i zacznie działać, dlatego konieczne jest, aby migawka była aktualna.

Czasami system decyduje, że potrzebuje nowej migawki interfejsu użytkownika aplikacji. W takich sytuacjach żądanie migawki nie będzie wliczać się do budżetu środowiska uruchomieniowego aplikacji. Następujące elementy wyzwolą żądanie migawki systemu:

• Aktualizacja osi czasu komplikacji.
• Interakcja użytkownika z powiadomieniem aplikacji.
• Przełączenie z pierwszego planu na stan Tło.
• Po upływie jednej godziny stanu w tle aplikacja może powrócić do stanu domyślnego.
• Podczas pierwszego rozruchu systemu watchOS.

Najlepsze praktyki

Firma Apple sugeruje następujące najlepsze rozwiązania dotyczące pracy z zadaniami w tle:

• Zaplanuj tak często, jak aplikacja musi zostać zaktualizowana. Za każdym razem, gdy aplikacja będzie uruchamiana, powinna ponownie ocenić przyszłe potrzeby i dostosować ten harmonogram zgodnie z potrzebami.
• Jeśli system wysyła zadanie odświeżania w tle, a aplikacja nie wymaga aktualizacji, odroczyć pracę, dopóki aktualizacja nie będzie rzeczywiście wymagana.
• Rozważ wszystkie możliwości środowiska uruchomieniowego dostępne dla aplikacji:
  • Aktywacja docku i pierwszego planu.
  • Powiadomienia.
  • Aktualizacje komplikacji.
  • Odświeżenia w tle.
• Użyj ScheduleBackgroundRefresh dla środowiska uruchomieniowego w tle ogólnego przeznaczenia, takiego jak:
  • Sondowanie systemu pod kątem informacji.
  • Zaplanuj przyszłość NSURLSessions , aby zażądać danych w tle.
  • Znane przejścia czasowe.
  • Wyzwalanie aktualizacji komplikacji.

Najlepsze rozwiązania dotyczące migawek

Podczas pracy z aktualizacjami migawek firma Apple udostępnia następujące sugestie:

• Unieważniaj migawki tylko wtedy, gdy jest to wymagane, na przykład w przypadku znaczącej zmiany zawartości.
• Unikaj nieprawidłowej migawki o wysokiej częstotliwości. Na przykład aplikacja czasomierza nie powinna aktualizować migawki co sekundę, powinna być wykonywana tylko po zakończeniu czasomierza.

Przepływ danych aplikacji

Firma Apple sugeruje następujące kwestie dotyczące pracy z przepływem danych:

Zdarzenie zewnętrzne (takie jak Watch Połączenie ivity) budzi aplikację. Spowoduje to, że aplikacja zaktualizuje model danych (który reprezentuje bieżący stan aplikacji). W wyniku zmiany modelu danych aplikacja będzie musiała zaktualizować swoje komplikacje, zażądać nowej migawki, ewentualnie uruchomić tło NSURLSession , aby ściągnąć więcej danych i zaplanować dalsze odświeżanie w tle.

Cykl życia aplikacji

Ze względu na dock i możliwość przypinania ulubionych aplikacji do niego, Apple uważa, że użytkownicy będą poruszać się między znacznie większą częściej aplikacją, a następnie zrobili to z systemem watchOS 2. W związku z tym aplikacja powinna być gotowa do obsługi tej zmiany i szybko przechodzić między stanami pierwszego planu i tła.

Firma Apple ma następujące sugestie:

• Upewnij się, że aplikacja zakończy wszystkie zadania w tle tak szybko, jak to możliwe podczas wprowadzania aktywacji pierwszego planu.
• Przed wejściem do tła upewnij się, że zakończono całą pracę na pierwszym planie, wywołując polecenie NSProcessInfo.PerformExpiringActivity.
• Podczas testowania aplikacji w symulatorze systemu watchOS żaden z budżetów zadań nie zostanie wymuszony, aby aplikacja mogła odświeżyć tyle, ile jest potrzebne do prawidłowego przetestowania funkcji.
• Zawsze testuj na prawdziwym sprzęcie Apple Watch, aby upewnić się, że aplikacja nie działa poza budżetami przed opublikowaniem w programie iTunes Połączenie.
• Apple sugeruje utrzymanie zegarka Apple Watch na ładowarki podczas testowania i debugowania.
• Upewnij się, że zarówno zimne uruchamianie, jak i wznawianie aplikacji są dokładnie przetestowane.
• Sprawdź, czy wszystkie zadania aplikacji są ukończone.
• Zmienia liczbę aplikacji przypiętych w docku, aby przetestować zarówno najlepsze, jak i najgorsze scenariusze.

Podsumowanie

W tym artykule omówiono ulepszenia, które firma Apple wprowadziła w systemie watchOS i jak można ich używać do aktualizowania aplikacji do oglądania. Po pierwsze, objęła wszystkie nowe zadania w tle, które firma Apple dodała w systemie watchOS 3. Następnie omówił cykl życia interfejsu API w tle i sposób implementowania zadań w tle w aplikacji Xamarin watchOS. Na koniec omówiła sposób działania planowania i dała pewne najlepsze rozwiązania.