Фоновые задачи watchOS в Xamarin

Статья
03/13/2017

В watchOS 3 есть три основных способа, которыми приложение для просмотра может поддерживать актуальность своей информации:

Использование одной из нескольких новых фоновых задач.
Имея одно из его осложнений на лице часы (давая ему дополнительное время для обновления).
При закреплении пользователя к приложению к новому док-станции (где он хранится в памяти и часто обновляется).

Поддержание актуальности приложения

Прежде чем обсуждать все способы, которыми разработчик может сохранить данные приложения watchOS и пользовательский интерфейс, в этом разделе рассматривается типичный набор шаблонов использования и как пользователь может перемещаться между своими i Телефон и Их Apple Watch в течение дня на основе времени дня и действий, которые они делают (например, вождение).

Возьмем следующий пример:

Утром, ожидая в очереди на кофе, пользователь просматривает текущие новости на их i Телефон в течение нескольких минут.
Перед выходом из кафе они быстро проверка погоду с осложнением на лице их наблюдения.
Перед обедом они используют приложение Карты на i Телефон найти близлежащий ресторан и забронировать резервирование для встречи с клиентом.
Во время поездки в ресторан, они получают уведомление об их Apple Watch и с кратким взглядом, они знают, что их обед встречи работает поздно.
Вечером они используют приложение Карты на i Телефон, чтобы проверка трафик перед поездкой домой.
На пути домой они получают уведомление iMessage об их Apple Watch с просьбой забрать молоко, и они используют функцию быстрого ответа для отправки ответа "ОК".

Из-за "быстрого просмотра" (менее трех секунд) природы того, как пользователь хочет использовать приложение Apple Watch, обычно недостаточно времени для получения требуемой информации и обновления пользовательского интерфейса перед отображением его пользователю.

Используя новые API Apple, включенные в watchOS 3, приложение может запланировать фоновое обновление и подготовить нужную информацию, прежде чем пользователь запрашивает его. Рассмотрим пример синхосложнения, рассмотренного выше:

Приложение планирует проснуться системой в определенное время.
Приложение получает сведения, необходимые для создания обновления.
Приложение повторно создает пользовательский интерфейс, чтобы отразить новые данные.
Когда пользователь смотрит на сложности приложения, он имеет актуальные сведения без необходимости ждать обновления.

Как показано выше, система watchOS просыпает приложение с помощью одной или нескольких задач, из которых она имеет очень ограниченный пул доступных:

Apple предлагает сделать большую часть этой задачи (так как это такой ограниченный ресурс для приложения), удерживая его, пока приложение не завершит процесс обновления себя.

Система предоставляет эти задачи путем вызова нового HandleBackgroundTasks метода делегата WKExtensionDelegate . Например:

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
  }
}

После завершения данной задачи приложение возвращает его в систему, помечая его выполнение:

Новые фоновые задачи

WatchOS 3 представляет несколько фоновых задач, которые приложение может использовать для обновления сведений, обеспечивая наличие содержимого, необходимого пользователю перед открытием приложения, например:

Фоновое обновление приложения — задача WKApplicationRefreshBackgroundTask позволяет приложению обновлять состояние в фоновом режиме. Обычно это будет включать в себя другую задачу, например скачивание нового содержимого из Интернета с помощью NSUrlSession.
Обновление фонового моментального снимка — задача WKSnapshotRefreshBackgroundTask позволяет приложению обновлять содержимое и пользовательский интерфейс, прежде чем система примет моментальный снимок, который будет использоваться для заполнения док-станции.
Фоновые часы Подключение ivity — задача WKWatch Подключение ivityRefreshBackgroundTask запускается для приложения при получении фоновых данных из парного i Телефон.
Фоновый СЕАНС URL-адресов— задача WKURLSessionRefreshBackgroundTask запускается для приложения, когда для фоновой передачи требуется авторизация или завершение (успешно или ошибка).

Эти задачи подробно рассматриваются в разделах ниже.

WKApplicationRefreshBackgroundTask

Это WKApplicationRefreshBackgroundTask универсальная задача, которая может быть запланирована, чтобы приложение проснулось в будущем:

В среде выполнения задачи приложение может выполнять любую локальную обработку, например обновить временная шкала осложнений или получить необходимые данные с помощью NSUrlSession.

WKURLSessionRefreshBackgroundTask

Система отправит WKURLSessionRefreshBackgroundTask данные после завершения загрузки и готовности к обработке приложением:

Приложение не остается запущенным во время скачивания данных в фоновом режиме. Вместо этого приложение планирует запрос на получение данных, а затем оно приостановлено, а система обрабатывает загрузку данных только после завершения скачивания приложения.

WKSnapshotRefreshBackgroundTask

В watchOS 3 Apple добавила док-станцию, где пользователи могут закрепить свои любимые приложения и быстро получить к ним доступ. Когда пользователь нажимает боковую кнопку в Apple Watch, отобразится коллекция закрепленных моментальных снимков приложений. Пользователь может проводите пальцем влево или вправо, чтобы найти нужное приложение, а затем коснитесь приложения, чтобы запустить его, чтобы заменить моментальный снимок интерфейсом запущенного приложения.

Система периодически принимает моментальные снимки пользовательского интерфейса приложения (отправляя a WKSnapshotRefreshBackgroundTask) и использует эти моментальные снимки для заполнения док-станции. WatchOS предоставляет приложению возможность обновить его содержимое и пользовательский интерфейс до создания этого моментального снимка.

Моментальные снимки очень важны в watchOS 3, так как они работают как предварительный просмотр, так и запуск образов для приложения. Если пользователь поселится в приложении в док-станции, он будет развернут до полноэкранного экрана, введите передний план и начните работать, поэтому крайне важно, чтобы моментальный снимок был актуальным:

Опять же, система выдает так WKSnapshotRefreshBackgroundTask , чтобы приложение может подготовить (обновив данные и пользовательский интерфейс) перед созданием моментального снимка:

Когда приложение помечает WKSnapshotRefreshBackgroundTask завершенное, система автоматически примет моментальный снимок пользовательского интерфейса приложения.

Внимание

Важно всегда планировать WKSnapshotRefreshBackgroundTask , когда приложение получило новые данные и обновило его пользовательский интерфейс или пользователь не увидит измененную информацию.

Кроме того, когда пользователь получает уведомление от приложения и касается его, чтобы перенести приложение на передний план, моментальный снимок должен быть актуальным, так как он выступает в качестве экрана запуска, а также:

Если с момента взаимодействия пользователя с приложением watchOS прошло более одного часа, он сможет вернуться в состояние по умолчанию. Состояние по умолчанию может означать разные вещи для разных приложений и, в зависимости от дизайна приложения, оно может вообще не иметь состояния по умолчанию.

WKWatch Подключение ivityRefreshBackgroundTask

В watchOS 3 Apple интегрировала подключение часов с API фонового обновления с помощью нового WKWatchConnectivityRefreshBackgroundTask. Используя эту новую функцию, приложение i Телефон может доставлять свежие данные в его аналог приложения watch, в то время как приложение watchOS работает в фоновом режиме:

Инициирование push-отправки осложнений, контекста приложения, отправки файла или обновления сведений о пользователе из приложения i Телефон запустит приложение Apple Watch в фоновом режиме.

Когда приложение наблюдения проснется через WKWatchConnectivityRefreshBackgroundTask приложение, оно потребуется использовать стандартные методы API для получения данных из приложения i Телефон.

Убедитесь, что сеанс активирован.
Отслеживайте новое HasContentPending свойство до тех пор, пока значение равно true, приложение по-прежнему имеет данные для обработки. Как и раньше, приложение должно держаться на задаче, пока она не завершит обработку всех данных.
Если больше данных не требуется обрабатывать (HasContentPending = false), пометьте задачу, завершенную, чтобы вернуть ее в систему. Это приведет к нехватке выделенной фоновой среды выполнения приложения, что приведет к сбою отчета о сбоях.

Жизненный цикл фонового API

Размещение всех частей нового API фоновых задач вместе, типичный набор взаимодействий будет выглядеть следующим образом:

Во-первых, приложение watchOS планирует фоновую задачу проснуться в будущем.
Приложение проснулось системой и отправило задачу.
Приложение обрабатывает задачу, чтобы завершить все необходимые действия.
В результате обработки задачи приложению может потребоваться запланировать дополнительные фоновые задачи, чтобы завершить большую работу в будущем, например скачать больше содержимого с помощью NSUrlSession.
Приложение помечает завершенную задачу и возвращает ее в систему.

Использование ресурсов ответственно

Важно, чтобы приложение watchOS ведет себя ответственно в этой экосистеме, ограничивая его утечку общих ресурсов системы.

Ознакомьтесь со следующим сценарием:

Пользователь запускает приложение watchOS в 1:00.
Приложение планирует задачу проснуться и скачать новое содержимое в час в 2:00 вечера.
В 1:50 пользователь повторно открывает приложение, которое позволяет обновлять данные и пользовательский интерфейс в настоящее время.
Вместо того, чтобы разрешить приложению снова проснуть приложение в течение 10 минут, приложение должно перепланировать задачу, чтобы выполнить задачу через час в 2:50 вечера.

Хотя каждое приложение отличается, Apple предлагает найти шаблоны использования, как показано выше, чтобы помочь сохранить системные ресурсы.

Реализация фоновых задач

В качестве примера этот документ будет использовать поддельные спортивное приложение MonkeySoccer, которое сообщает футбольные оценки пользователю.

Ознакомьтесь со следующим типичным сценарием использования:

Любимая футбольная команда пользователя играет большой матч с 7:00 по 9:00 вечера, чтобы приложение должно ожидать, что пользователь будет проверка оценки регулярно и решает на 30 минут интервал обновления.

Пользователь открывает приложение и планирует задачу для фонового обновления 30 минут спустя. Фоновый API позволяет выполнять только один тип фоновой задачи в определенное время.
Приложение получает задачу и обновляет свои данные и пользовательский интерфейс, а затем планируется для другой фоновой задачи 30 минут спустя. Важно, чтобы разработчик не забывал планировать другую фоновую задачу, или приложение никогда не будет повторно проснуться, чтобы получить больше обновлений.
Опять же, приложение получает задачу и обновляет свои данные, обновляет пользовательский интерфейс и планирует другую фоновую задачу 30 минут спустя.
Тот же процесс повторяется снова.
Последняя фоновая задача получена, и приложение снова обновляет свои данные и пользовательский интерфейс. Так как это окончательная оценка, она не планируется для нового фонового обновления.

Планирование фонового обновления

Учитывая приведенный выше сценарий, приложение MonkeySoccer может использовать следующий код для планирования фонового обновления:

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
    }
  });
}

Он создает новый NSDate 30 минут в будущем, когда приложение хочет проснуться и создаст NSMutableDictionary для хранения сведений о запрошенной задаче. Метод ScheduleBackgroundRefreshSharedExtension используется для запроса задачи.

Система вернет значение, NSError если не удалось запланировать запрошенную задачу.

Обработка обновления

Затем ознакомьтесь с 5-минутным окном, в котором показаны шаги, необходимые для обновления оценки:

В 7:30:02 приложение пробуждается системой и получает фоновую задачу обновления. Его первым приоритетом является получение последних показателей с сервера. См . раздел "Планирование NSUrlSession " ниже.
В 7:30:05 приложение завершает исходную задачу, система помещает приложение в спящий режим и продолжает загружать запрошенные данные в фоновом режиме.
Когда система завершит скачивание, она создает новую задачу для пробуждения приложения, чтобы он смог обработать скачанные сведения. См. раздел "Обработка фоновых задач " и обработка завершения загрузки ниже.
Приложение сохраняет обновленные сведения и помечает завершенную задачу. Разработчик может заманить обновление пользовательского интерфейса приложения в настоящее время, однако Apple предлагает планировать задачу моментального снимка для обработки этого процесса. См . статью "Планирование обновления моментального снимка" ниже.
Приложение получает задачу моментального снимка, обновляет пользовательский интерфейс и помечает завершенную задачу. См. раздел "Обработка обновления моментального снимка" ниже.

Планирование NSUrlSession

Следующий код можно использовать для планирования скачивания последних показателей:

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 ();
}

Он настраивает и создает новый NSUrlSession, а затем использует этот сеанс для создания новой задачи загрузки с помощью CreateDownloadTask метода. Он вызывает Resume метод задачи скачивания для запуска сеанса.

Обработка фоновых задач

Переопределив HandleBackgroundTasks метод приложения WKExtensionDelegate, приложение может обрабатывать входящие фоновые задачи:

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

    ...
  }
}

Метод HandleBackgroundTasks циклит по всем задачам, которые система отправила приложению (в backgroundTasks) поиск WKUrlSessionRefreshBackgroundTask. Если он найден, он повторно присоединяется к сеансу и присоединяет NSUrlSessionDownloadDelegate его для обработки завершения скачивания (см. раздел "Обработка завершения загрузки ниже").

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

Он сохраняет дескриптор задачи до тех пор, пока он не завершится, добавив его в коллекцию:

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

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

Все задачи, отправленные приложению, должны быть завершены, для любой задачи, не обрабатываемой в данный момент, пометьте его завершенным:

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

Обработка завершения загрузки

Приложение MonkeySoccer использует следующий NSUrlSessionDownloadDelegate делегат для обработки завершения загрузки и обработки запрошенных данных:

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
  }
}

При инициализации дескриптор сохраняет дескриптор как для ExtensionDelegate того, так и для WKRefreshBackgroundTask этого. Он переопределяет DidFinishDownloading метод для обработки завершения загрузки. Затем использует CompleteTask метод ExtensionDelegate задачи, чтобы сообщить о завершении задачи и удалить ее из коллекции ожидающих задач. См . инструкции по обработке фоновых задач выше.

Планирование обновления моментального снимка

Следующий код можно использовать для планирования задачи моментального снимка для обновления пользовательского интерфейса с последними оценками:

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
    }
  });
}

ScheduleURLUpdateSession Как и приведенный выше метод, он создает новый NSDate объект, когда приложение хочет проснуться и создает для NSMutableDictionary хранения сведений о запрошенной задаче. Метод ScheduleSnapshotRefreshSharedExtension используется для запроса задачи.

Система вернет значение, NSError если не удалось запланировать запрошенную задачу.

Обработка обновления моментальных снимков

Чтобы обработать задачу моментального снимка, HandleBackgroundTasks метод (см . выше об обработке фоновых задач ) изменяется следующим образом:

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 ();
    }
  }
}

Метод проверяет тип обрабатываемой задачи. Если он получает WKSnapshotRefreshBackgroundTask доступ к задаче:

var snapshotTask = task as WKSnapshotRefreshBackgroundTask;

Метод обновляет пользовательский интерфейс, а затем создает NSDate систему, когда моментальный снимок будет устаревшим. Он создает NSMutableDictionary сведения о пользователе, чтобы описать новый моментальный снимок и помечает задачу моментального снимка, завершенную с помощью этой информации:

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

Кроме того, он также сообщает задаче моментального снимка, что приложение не возвращается в состояние по умолчанию (в первом параметре). Приложения, которые не имеют понятия о состоянии по умолчанию, всегда должны задать для этого свойства trueзначение.

Эффективная работа

Как показано в приведенном выше примере пятиминутного окна, которое приложение MonkeySoccer взяло для обновления своих показателей, эффективно работая и используя новые фоновые задачи watchOS 3, приложение было активно только в течение 15 секунд:

Это снижает влияние, которое приложение будет иметь как на доступные ресурсы Apple Watch, так и время работы батареи, а также позволяет приложению лучше работать с другими приложениями, работающими на часах.

Принцип работы планирования

Хотя приложение watchOS 3 находится на переднем плане, оно всегда планируется запустить и может выполнять любой тип обработки, необходимый для обновления данных или перераскрыть пользовательский интерфейс. Когда приложение переходит в фон, оно обычно приостановлено системой, и все операции среды выполнения остановлены.

Хотя приложение находится в фоновом режиме, оно может быть предназначено системой для быстрого выполнения конкретной задачи. Таким образом, в watchOS 2 система может временно проснуть фоновое приложение для выполнения таких действий, как обработка длинного уведомления или обновление сложности приложения. В watchOS 3 есть несколько новых способов запуска приложения в фоновом режиме.

Хотя приложение находится в фоновом режиме, система накладывает на него несколько ограничений:

Для выполнения любой данной задачи предоставляется всего несколько секунд. Система учитывает не только время, прошедшее, но и сколько ресурсов ЦП, потребляемых приложением для получения этого ограничения.
Любое приложение, превышающее его ограничения, будет убито со следующими кодами ошибок:
- ЦП — 0xc51bad01
- Время — 0xc51bad02
Система налагает различные ограничения на основе типа фоновой задачи, которая попросила приложение выполнить. Например, WKApplicationRefreshBackgroundTask и WKURLSessionRefreshBackgroundTask задачи получают немного больше времени выполнения по сравнению с другими типами фоновых задач.

Осложнения и Обновления приложений

Помимо новых фоновых задач, которые Apple добавила в watchOS 3, осложнения приложения watchOS могут повлиять на то, как и когда приложение получает фоновые обновления.

Осложнения — это небольшие визуальные элементы, которые предоставляют полезную информацию на первый взгляд. В зависимости от выбранного лица часы пользователь может настроить лицо с одним или несколькими осложнениями, которые могут быть предоставлены приложением часов в watchOS 3.

Если пользователь включает в себя одно из осложнений приложения на лице, оно дает приложению следующие обновленные преимущества:

Это приводит к тому, что система сохраняет приложение в состоянии готовности к запуску, когда он пытается запустить приложение в фоновом режиме, сохраняет его в памяти и дает дополнительное время для обновления.
Осложнения гарантированы по крайней мере 50 push-обновлений в день.

Разработчик всегда должен стремиться к созданию убедительных осложнений для своих приложений, чтобы заставить пользователя добавлять их на свое лицо наблюдения по причинам, перечисленным выше.

В watchOS 2 осложнения были основным способом, которым приложение получило среду выполнения в фоновом режиме. В watchOS 3 приложение "Осложнение" по-прежнему будет гарантировать получение нескольких обновлений в час, однако оно может использовать WKExtensions для запроса больше среды выполнения для обновления его осложнений.

Ознакомьтесь со следующим кодом, используемым для обновления сложности из подключенного приложения i Телефон:

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);
  }
}

Он использует RemainingComplicationUserInfoTransfers свойство объекта WCSession , чтобы узнать, сколько высокоприоритетных передач приложение осталось в течение дня, а затем принимает меры на основе этого числа. Если приложение начинает работать с низким уровнем передачи, оно может отложить отправку дополнительных обновлений и отправлять сведения только при наличии значительных изменений.

Планирование и закрепление

Система периодически принимает моментальные снимки пользовательского интерфейса приложения и использует эти моментальные снимки для заполнения документации. WatchOS предоставляет приложению возможность обновить его содержимое и пользовательский интерфейс до создания этого моментального снимка.

Приложения, закрепленные на док-станции, могут ожидать следующее:

Они получат не менее одного обновления в час. Это включает как задачу обновления приложения, так и задачу моментального снимка.
Бюджет обновления распределяется между всеми приложениями в док-станции. Таким образом, чем меньше приложений, закрепленных пользователем, тем больше потенциальных обновлений каждое приложение получит.
Приложение будет храниться в памяти, поэтому приложение будет быстро возобновляться при выборе из док-станции.

Последнее приложение, запущенное пользователем, будет считаться приложением последнего использования и займет последний слот в док-станции. Оттуда пользователь может выбрать постоянное закрепление его на док-станции. Последнее использование будет рассматриваться как любое другое любимое приложение, которое пользователь уже закреплен на док-станции.

Внимание

Приложения, которые были добавлены только на начальный экран, не будут предоставлены ни одного регулярного планирования. Чтобы получать регулярные обновления планирования и фоновых обновлений, приложение должно быть добавлено в док-станцию.

Как упоминалось ранее в этом документе, моментальные снимки очень важны в watchOS 3, так как они работают как предварительный просмотр, так и запуск изображений для приложения. Если пользователь поселится в приложении в док-станции, он будет развернут до полноэкранного экрана, введите передний план и начните работать, поэтому крайне важно, чтобы моментальный снимок был актуальным.

Может возникнуть время, когда система решает, что она нуждается в новом моментальном снимке пользовательского интерфейса приложения. В таких ситуациях запрос моментального снимка не будет учитываться в бюджете среды выполнения приложения. Ниже будет запущен системный запрос моментального снимка:

Обновление временная шкала осложнений.
Взаимодействие пользователя с уведомлением приложения.
Переключение с переднего плана на фоновое состояние.
После одного часа работы в фоновом состоянии, чтобы приложение вернется к состоянию по умолчанию.
При первой загрузке watchOS.

Поток данных приложения

Apple предлагает следующее для работы с потоком данных:

Внешнее событие (например, просмотр Подключение ivity) просыпает приложение. Это заставляет приложение обновлять модель данных (которая представляет текущее состояние приложений). В результате изменения модели данных приложению потребуется обновить его сложности, запросить новый моментальный снимок, возможно, запустить фон NSURLSession для извлечения дополнительных данных и запланировать дальнейшее фоновое обновление.

Жизненный цикл приложения

Из-за док-станции и возможности закрепить к нему избранные приложения, Apple считает, что пользователи будут перемещаться между гораздо больше приложений, гораздо чаще, а затем они сделали с watchOS 2. В результате приложение должно быть готово к этому изменению и быстро перемещаться между передним планом и фоновыми состояниями.

Apple предлагает следующие предложения:

Убедитесь, что приложение завершит любую фоновую задачу как можно скорее после ввода активации переднего плана.
Перед вводом фона перед вводом NSProcessInfo.PerformExpiringActivityфона необходимо завершить все действия переднего плана.
При тестировании приложения в симуляторе watchOS ни один из бюджетов задач не будет применяться, чтобы приложение может обновляться столько, сколько необходимо для правильного тестирования функции.
Всегда тестируйте реальное оборудование Apple Watch, чтобы убедиться, что приложение не работает мимо своих бюджетов перед публикацией в iTunes Подключение.
Apple предлагает сохранить Apple Watch на зарядном устройстве во время тестирования и отладки.
Убедитесь, что и холодный запуск, и возобновление приложения тщательно тестируются.
Убедитесь, что все задачи приложения завершены.
Зависит количество приложений, закрепленных в dock, чтобы протестировать как лучшие, так и худшие сценарии.

Итоги

В этой статье рассматриваются усовершенствования Apple, сделанные для просмотра и того, как они могут использоваться для поддержания актуальности приложения для просмотра. Во-первых, он рассмотрел все новые фоновые задачи Apple добавил в watchOS 3. Затем он рассмотрел жизненный цикл фонового API и как реализовать фоновые задачи в приложении Xamarin watchOS. Наконец, он рассказал о том, как работает планирование и дал некоторые рекомендации.

Поделиться через