Share
Ce tutoriel vous apprendra toutes les dernières améliorations multitâches fournies par le SDK iOS 7. En particulier, vous découvrirez les API de recherche en arrière-plan, de notifications à distance et de transfert en arrière-plan. Continuer à lire!
Avec iOS 7, Apple a mis à la disposition des développeurs trois nouvelles API multitâches:
Toutes ces API offrent aux programmeurs la possibilité de développer des applications multitâches qui permettront de mieux utiliser le matériel du périphérique tout en offrant aux utilisateurs une plus grande expérience. Ce tutoriel vous en apprendra plus sur les trois améliorations ci-dessus et sur le moment de les utiliser..
Afin de faire la Fetch d'arrière-plan API plus facile à comprendre, imaginez que vous souhaitiez créer une application de presse. En théorie, nous partons du principe que le contenu de cette application provient du Web et l’une des fonctionnalités essentielles est d’obtenir des mises à jour à chaque lancement de l’application par l’utilisateur..
Avant iOS 7, les développeurs pouvaient faire en sorte que l'application commence à recevoir du nouveau contenu une fois qu'elle a été lancée. Cela fonctionne, mais l'inconvénient est que les utilisateurs devront attendre un moment chaque fois que l'application démarre. En outre, la vitesse de connexion du téléphone devient un facteur important. Imaginez si l'utilisateur se connecte via un réseau cellulaire après une semaine ou deux d'inactivité! Bien sûr, ce n'est pas ce que les développeurs veulent, car cela a tendance à dégrader l'expérience utilisateur..
Sur iOS 7, les choses ont radicalement changé! Avec l'API Background Fetch, notre application hypothétique peut en fait télécharger de nouveaux contenus de manière passive tout en restant en arrière-plan. iOS 7 réveillera l'application, fournira le temps d'exécution en arrière-plan et, une fois la mise à jour terminée, l'application se remettra en veille. Bien sûr, les utilisateurs ne sont pas avertis lorsque cela se produit. Ils trouvent simplement que le nouveau contenu est prêt à être utilisé au lancement de l'application..
Le processus de mise à jour peut avoir lieu à des intervalles prédéfinis définis par le programmeur ou à des intervalles spécifiés par le système d'exploitation. Si vous définissez des intervalles personnalisés, Apple vous recommande de les définir judicieusement et de ne pas extraire les données en arrière-plan très souvent. Cela entraînerait un épuisement de la batterie et un gaspillage des ressources système. Si vous laissez simplement le système d'exploitation gérer les choses, iOS 7 fera des prévisions d'utilisation. Pour ce faire, il observe à quelle fréquence l’application est lancée et à quelle heure. Il anticipe ensuite ce comportement en se connectant et en récupérant du contenu avant qu'il ne soit prédit par l'utilisateur. Par exemple, si un utilisateur de notre application d'informations hypothétique lance l'application tous les après-midi, iOS le constate et décide que l'application doit extraire du contenu dans l'après-midi et avant le lancement habituel. Très sympa!
Le processus de récupération décrit ci-dessus comprend trois étapes:
Accentsconagua
application: performFetchWithCompletionHandler: Examinons les choses plus en détail.
Comme je viens de le dire, la première étape de tout le processus consiste à activer la fonctionnalité d'extraction en arrière-plan de l'application dans Xcode 5. Cela peut être effectué de deux manières. La première consiste à utiliser le .plist fichier, où vous devez ajouter le Modes d'arrière-plan requis clé avec le aller chercher valeur, comme ceci:
Les étapes suivantes constituent une approche alternative:
Par défaut, la valeur initiale de l'intervalle d'extraction est définie sur UIApplicationBackgroundFetchIntervalNever mode, ce qui signifie que la récupération en arrière-plan ne sera jamais effectuée. Si cette valeur ne change pas, l'extraction en arrière-plan ne fonctionnera pas, même si elle est activée avec l'une des deux manières décrites ci-dessus. Pour ce faire, vous devez vous rendre au application: didFinishLaunchingWithOptions: et définissez la valeur de l'intervalle d'extraction minimal comme suit:
- Application (BOOL): application (UIApplication *) didFinishLaunchingWithOptions: (NSDictionary *) launchOptions [application setMinimumBackgroundFetchInterval: UIApplicationBackgroundFetchIntervalMinimum]; retourner OUI;
le UIApplicationBackgroundFetchIntervalMinimum est la valeur de l'intervalle minimum autorisé et géré par le système. Bien sûr, vous pouvez définir un intervalle de temps personnalisé en fournissant simplement à la méthode ci-dessus un NSTimeInterval valeur. Cependant, à moins que cela ne soit nécessaire, il est généralement préférable de laisser iOS décider du moment où l'application doit pouvoir fonctionner en arrière-plan et extraire du nouveau contenu. Si vous définissez un minimum, il est important de réaliser que le UIApplicationBackgroundFetchIntervalMinimum ne détermine pas absolument le timing. Ils ressemblent plus à des suggestions. iOS essaiera de suivre le programme s'il le peut, mais, en fonction des ressources système disponibles, l'extraction peut avoir lieu plus ou moins souvent que souhaité..
La dernière étape requise consiste à mettre en œuvre le nouveau application: performFetchWithCompletionHandler: méthode déléguée. Celui-ci est appelé chaque fois qu’une extraction en arrière-plan doit être effectuée. Le gestionnaire d'achèvement de la méthode accepte l'une des trois valeurs suivantes pour informer iOS des résultats d'extraction:
UIBackgroundFetchResultNewData: Si de nouvelles données ont été trouvées par l'extractionUIBackgroundFetchResultNoData: Si aucune nouvelle donnée n'a été trouvéeUIBackgroundFetchResultFailed: Si une erreur s'est produite pendant le processus de récupérationVoyons cela en action:
-application (void): (UIApplication *) application performFetchWithCompletionHandler: (void (^) (UIBackgroundFetchResult)) completionHandler // Appelez ou écrivez tout code nécessaire à l'obtention de nouvelles données, traitez-les et mettez à jour l'interface utilisateur. // La logique utilisée pour informer iOS des résultats de la récupération dans un langage clair est la suivante: if (/ ** NOUVELLES DONNÉES EXISTANT ET A ÉTÉ TRAITÉES AVEC SUCCÈS ** /) completionHandler (UIBackgroundFetchResultNewData); if (/ ** AUCUNE NOUVELLE DONNÉE EXISTE ** /) completionHandler (UIBackgroundFetchResultNoData); if (/ ** ANY ERROR OCCURS ** /) completionHandler (UIBackgroundFetchResultFailed);
Si de nouvelles données sont trouvées, vous devez également effectuer les mises à jour nécessaires de l'interface utilisateur. Celles-ci doivent se produire immédiatement pour deux raisons: (1) les utilisateurs doivent voir le contenu lors du prochain lancement de l'application et (2) la capture instantanée de l'application restera à jour..
Il y a quelques faits supplémentaires que vous devriez savoir. Tout d'abord, lorsque l'application démarre en arrière-plan, elle dispose d'une trentaine de secondes pour effectuer toutes les tâches requises et appeler le gestionnaire d'achèvement. Si ce délai est dépassé, l'application sera à nouveau suspendue. Pour les applications nécessitant plus de 30 secondes (peut-être en raison de téléchargements de contenu multimédia), vous devez planifier une extraction en arrière-plan à l'aide de l'API du service de transfert en arrière-plan. Nous discuterons de cette option plus tard.
Une fois le mécanisme de récupération configuré et prêt à fonctionner, Apple propose deux méthodes pour tester la récupération en arrière-plan lors de l'utilisation du simulateur..
La première approche suit ces étapes:
Cette méthode est utile pour tester l’API pendant l’exécution de l’application. La deuxième méthode est plus complexe, mais elle vous permet de tester l’application tant qu’elle reste en arrière-plan. Pour essayer ceci, suivez ces étapes:
La récupération en arrière-plan est destinée à être utilisée pour les mises à jour d'applications non critiques, car l'heure à laquelle elles se produisent peut varier. Pour des mises à jour plus critiques, voir la section Notifications à venir à venir. En règle générale, l'API d'extraction en arrière-plan convient aux applications qui souhaitent gérer le contenu de manière transparente. Quelques exemples d’applications incluent les actualités, les réseaux sociaux, la météo et le partage de photos..
Imaginez que nous construisions une application avec des tutoriels écrits et vidéo. Supposons que les utilisateurs puissent télécharger de nouvelles vidéos de didacticiel 2 à 3 fois par mois. Alors, comment informer nos utilisateurs des nouvelles versions de vidéos? Nous ne pouvons pas adopter une solution qui utilise l’API d’extraction en arrière-plan ou quelque chose de similaire, car cela entraînerait à la fois un gaspillage de ressources de périphérique et des demandes inutiles au serveur. Nous ne pouvons pas non plus savoir quand une nouvelle version vidéo est prête. Par conséquent, nous devons utiliser les notifications push. Ainsi, chaque fois qu’un nouveau contenu est créé, nous pouvons en informer nos utilisateurs en les alertant simplement. Nous nous attendons donc à ce que nos utilisateurs lancent l'application et téléchargent un nouveau contenu. Le problème est que cette approche oblige l'utilisateur à attendre le téléchargement de la vidéo et que, si le contenu est suffisamment volumineux, il peut être amené à attendre longtemps. Alors, comment les utilisateurs peuvent-ils obtenir du nouveau contenu dans leur application lorsque ce contenu est disponible mais sans attendre??
C'est ici que les notifications à distance sont utiles. Les notifications à distance sont réellement notifications push silencieuses, signifiant des notifications push qui n'informent pas les utilisateurs de leur existence. Lorsqu'une nouvelle notification à distance arrive, le système réveille l'application de manière silencieuse afin qu'il puisse gérer la notification. L’application est alors responsable du lancement du processus de téléchargement du nouveau contenu. Une fois le téléchargement terminé, un notification locale est envoyé à l'utilisateur. Lorsque l'application est lancée, le nouveau contenu est là, en attente de l'utilisateur.
Tout comme les fonctions d'arrière-plan en arrière-plan, les notifications à distance visent à éliminer le temps d'attente des utilisateurs lorsqu'ils téléchargent un nouveau contenu ou des données sur un serveur. Les deux API fonctionnent dans le thread en arrière-plan et les utilisateurs sont informés de la fin du travail. Cependant, les notifications à distance conviennent dans les cas où le contenu est soit rarement mis à jour, soit essentiel à l'expérience utilisateur..
Pour utiliser les notifications à distance dans une application, vous devez d'abord les activer. Vous pouvez le faire avec le fichier * .plist ou le nouveau Les capacités onglet du projet. Si vous souhaitez utiliser le fichier * .plist, vous devez ajouter le fichier Contexte requis clé avec la valeur de notification à distance comme suit:
Pour utiliser l'onglet Capabilities, procédez comme suit:
La prochaine étape consiste à mettre en œuvre le application: didReceiveRemoteNotification: fetchCompletionHandler: méthode delegate dans votre fichier AppDelegate. Celui-ci est appelé quand une nouvelle notification arrive. Utilisez le gestionnaire d'achèvement pour informer iOS du résultat de l'extraction de données:
-application (void): (UIApplication *) application didReceiveRemoteNotification: (NSDictionary *) userInfo fetchCompletionHandler: (void (^) (UIBackgroundFetchResult)) completionHandler // Appelez ou écrivez le code nécessaire pour télécharger les nouvelles données. completionHandler (UIBackgroundFetchResultNewData);
Rendre une notification silencieuse est assez facile. Dans la charge de notification, il vous suffit d'inclure le code disponible: 1 marquer et omettre toute alerte ou donnée sonore qui en informerait l'utilisateur.
aps content-available: 1
En général, tout ce qui est valide lorsque vous travaillez avec Background Fetch s'applique ici aussi. Par exemple, vous disposez de 30 secondes maximum pour télécharger tout nouveau contenu et avertir le système avec la méthode ci-dessus avant que l'application ne se rende en veille. Si le nouveau contenu a besoin de temps pour être téléchargé, envisagez l’utilisation du Service de transfert en arrière-plan API.
N'oubliez pas qu'Apple contrôle le débit de livraison des notifications à distance (notifications push silencieuses) envoyées par un fournisseur Push. Si le taux est normal, les notifications normales et silencieuses sont immédiatement envoyées. Cependant, lorsque des notifications en mode silencieux sont envoyées assez fréquemment, le service Apple Push les stocke pour les remettre ultérieurement. Assurez-vous d'envoyer judicieusement les notifications à distance.
Une autre grande fonctionnalité d'iOS 7 est la Service de transfert en arrière-plan API. Obtenir ou envoyer de gros volumes de données n’était généralement pas une tâche facile, principalement en raison de contraintes de temps et de gestion des données transférées. Les applications étaient nécessaires pour achever la majeure partie du processus de téléchargement ou de téléchargement lorsqu'elles étaient au premier plan. Cependant, avec iOS 7, les choses sont totalement différentes. Les applications peuvent bénéficier d'une plus grande liberté lors de l'exécution de tâches en arrière-plan. Tout d’abord, avec le service de transfert en arrière-plan, les applications disposent du temps nécessaire pour effectuer un transfert. Qu'ils soient au premier plan ou à l'arrière-plan est sans importance. Il n'y a plus de limite de temps et le système est maintenant responsable de la gestion des données téléchargées ou téléchargées. Même si une application n'est pas en cours d'exécution, iOS la réveille pour gérer les situations dans lesquelles des décisions doivent être prises. Quelques exemples de ceci incluent quand un téléchargement de fichier est terminé ou quand plus d'informations doivent être fournies au serveur.
Le service de transfert en arrière-plan est basé sur le NSURLSession La classe, qui vient d'être introduite avec iOS 7. Cette classe est responsable du transfert de données via HTTP ou HTTPS, et offre la possibilité d'effectuer des tâches liées au réseau en arrière-plan. L’idée de base est simple et repose sur l’utilisation d’un logiciel sessions, où une seule session gère toutes les tâches de transfert de données associées. Il existe différents types de sessions disponibles, mais le sessions de fond C’est celui qui nous intéresse ici, et il fonctionne toujours sur des threads (processus) distincts créés par le système. Les sessions en arrière-plan prennent en charge les deux téléchargements (NSURLSessionDownloadTask) et télécharger (NSURLSesssionUploadTask) tâches, qui sont ajoutées à l'arrière-plan NSURLSession objets.
Un autre fait notable lié aux transferts en arrière-plan est qu’un transfert peut être discrétionnaire ou non. Les transferts non discrétionnaires ne peuvent être initiés que lorsque l'application est au premier plan, mais il existe une option permettant de définir l'état discrétionnaire en fonction des besoins de l'application. Les transferts discrétionnaires sont généralement préférés, car ils permettent au système d'exploitation de gérer plus efficacement l'énergie de l'appareil. Il existe également une limite qui s’applique aux transferts discrétionnaires: ils doivent être effectués uniquement sur des réseaux WiFi. Les transferts de fil en arrière-plan sont toujours initiés en tant que transferts discrétionnaires.
La méthode du délégué application: handleEventsForBackgroundURLSession: completionHandler: est appelé lorsqu'un transfert en arrière-plan est terminé afin que la tâche finie puisse être traitée. Par exemple, si un nouveau contenu a été téléchargé, vous devez implémenter cette méthode de délégué pour le stocker de manière permanente et mettre à jour l'interface utilisateur si nécessaire. Cette méthode est également appelée lorsque des informations d'identification sont requises de l'application pour poursuivre le transfert. En règle générale, dans cette méthode déléguée, vous appliquez toute la logique nécessaire à votre application lorsqu'un processus de téléchargement est terminé et que l'application existe dans le fil d'arrière-plan. Bien sûr, vous utilisez le gestionnaire d'achèvement pour informer le système lorsque vous avez terminé, afin de pouvoir mettre l'application en veille..
Le service de transfert en arrière-plan est idéal pour être utilisé avec les API d'extraction d'arrière-plan et de notification à distance. Compte tenu de ce qui précède, il devient clair que la meilleure pratique consiste à utiliser les méthodes de délégation de l'extraction en arrière-plan et les notifications à distance pour mettre en file d'attente vos transferts et laissez le système faire le travail. Après tout, à moins que les données devant être échangées avec le serveur aient un faible encombrement, dans la plupart des cas, les 30 secondes accordées aux deux méthodes déléguées mentionnées suffisent pour configurer le transfert en arrière-plan et les tâches connexes. Utilisez le NSURLSession classe pour définir tous les transferts souhaités et pour vous assurer que votre application récupérera tout nouveau contenu. Il enverra également toutes les données qui devraient être traitées, quel que soit le temps requis.
Extraction en arrière-plan, notifications à distance et API de service de transfert en arrière-plan sont des fonctionnalités que les développeurs aimeraient avoir vues depuis longtemps. Heureusement, avec la sortie d'iOS 7, Apple facilite plus que jamais le traitement des données d'application. À partir de iOS 7, le contenu des applications peut pratiquement toujours être à jour, mais c'est finalement à chaque développeur de s'en occuper et d'utiliser les outils fournis! Joyeux multitâche et merci d'avoir lu!
