Windows 8 Metro Connected Apps

This course takes an in-depth look at some of the key Windows 8 features that make Metro apps feel connected.
Course info
Rating
(34)
Level
Intermediate
Updated
Jul 11, 2012
Duration
4h 9m
Table of contents
Course Introduction
Accessing HTTP Services
Background Transfers
Tiles and Toasts
Push Notifications
Description
Course info
Rating
(34)
Level
Intermediate
Updated
Jul 11, 2012
Duration
4h 9m
Description

We dive into the HTTP client stack and learn how to access a cloud service from our Metro app, how to authenticate with a service using the WebAuthenticationBroker, and how to work with syndicated content using the new Syndication and AtomPub APIs. We explore Windows 8 background transfers, and learn how to control them, track them and reconnect to them across Metro lifecycle events from our foreground app. We discuss Windows live tiles and toast notifications, and how they keep our apps alive and connected. And finally we take a serious look at the push notification architecture, and the way push features can light up our app, for example by leveraging tile and toast updates to it. This course assumes basic familiarity with the Windows 8 platform, XAML UIs and the C# async pattern.

About the author
About the author

Yacine has been involved in the development of database-driven, n-tier web applications for over 10 years. Over time he has taken on various roles, including development, project management, offshore platform management and technical consulting. He has helped build a few solutions for Microsoft North Africa.

More from the author
Introduction to Windows Phone 8
Intermediate
3h 59m
Apr 3, 2013
Windows 8 Store Apps Hands-on in 20 Lessons
Intermediate
5h 48m
Jan 28, 2013
More courses by Yacine Khammal
Section Introduction Transcripts
Section Introduction Transcripts

Accessing HTTP Services
Welcome to Module 1 of this course on Windows 8 Connected Apps. In this module, we'll learn how to interact with HTTP services from a Metro app using the Windows 8 HTTP stack. So we'll look at common scenarios such as retrieving data from a cloud service and sending data to a service, authenticating with a service and working with syndication feeds. So we begin this module by an overview of what it means to access and interact with a cloud service using the HTTP request response paradigm. Then we look at the Windows 8 HTTP client and the System. Net. Http Namespace that we used to interact over the web. And in particular, we explore the APIs that are available to us for retrieving data from a cloud service in various formats using the C# Async-Await pattern which lets us perform the most common data access scenarios with ease. We also learn how to send data to a cloud service for creating or updating a web resource by inserting contents into a Post or Put request using the client APIs. We discuss how to handle different content types and also how to access the full HTTP client stack for a more advanced HTTP requirements. Next, we discuss authenticating with a cloud service through the web authentication broker API. And finally, we discuss web syndication in the Windows 8 syndication API, and we'll see that the API lets us just work with syndicated content in a straightforward way by shielding from low level details. We also look at the AtomPub API that lets us create or update syndicated resources from our Windows app.

Background Transfers
Hi. This is Yacine Khammal with Pluralsight and welcome back to this course on Windows 8's connected apps. In this module, we'll look at Background Transfers, downloading or uploading a file from or to a called service is a common requirement when building apps. Your Metro app can create a transfer in the background that runs independently of your app and can persist across app suspensions and relaunches. So we start with an overview of the way that background transfers work and the capabilities that they offer. We then examine at API and learn how to create, configure and start a transfer operation that runs in the background. Then we would dive into more specific scenarios that involve controlling Background Transfers from the foreground app. Namely, we'll look at how to track the progress of one or more transfer operations using both the negative WinRT async types and the Task Parallel Library. Likewise, we'll learn how to implement cancellation semantics using both of these approaches. We'll also look at the pause and resume capabilities exposed by the API. And finally, we'll look at the way that Background Transfer operations interact with the Metro app lifecycle and we'll see how our foreground app can manage just transfers across the system suspensions and terminations.

Tiles and Toasts
Hello, this is Yacine Khammal for Pluralsight and welcome back to this course on Windows 8 connected apps. In this module, we do a deep dive into Windows 8's Live tiles and toast notifications. Two great features that help keep the user connected to and engaged in your app. This module is also a requirement for the next module covering Push notifications. So as usual, we start this module with a high level overview of the tiles and toast features. And we begin with a quick look at the app's default tile configuration. From there we move on to learning how to build and raise tile notifications using the tile API and the built in tile templates available in Windows 8. We also take a look at tile cycling and expiration and learn how to send badge updates to an app tile. Then we focus on secondary tiles which act as deep links into your Metro app. We'll learn how to use the API to let the user pin or unpin one or more secondary tiles, how to send updates to these tiles, and how to provide launch parameters to the tiles. And finally, we explore toast notifications. Probably the most eye-catching and intrusive alert mechanism in Windows. And we'll learn how to create and raise these toasts, customize them, and use them in an effective way in our apps.

Push Notifications
Hi. This is Yacine Khammal for Pluralsight and you're watching the Windows 8 connected apps course. In this module, we explore push notifications from the standpoint of a Windows 8 Metro Style app. The push notification architecture is relatively simple to understand. Although, implementing push in your app can involve quite a few steps and it's easy to get bogged down on details. So in this module, I'll try to give you a clear roadmap of how to work with push. Now before we get started on push notifications, I'd like to briefly discuss periodic notifications which can be seen as an alternative to push notifications. Now the approach has limitations which will help us better understand the case for the push approach. From there, I'll introduce an example scenario that involves a push approach and I'll dive into the overall architecture of a push enabled app. I'll walk you through the typical interactions that occur among the various components of the overall setup. Now through our concrete example, we'll then go through each part of the architecture and implement it in a simplified manner. And we'll start by defining a simple cloud service that will eventually build out to send push notifications to registered Windows devices. Then we'll create a Metro client app and we'll register the app with both the Windows Notifications Service and our own cloud service. We'll then look at how to authenticate our cloud service with WNS to enable communication between these two. In the next step, we'll see how to issue notifications of different types, so, toast, tile, badge, or raw notification from our cloud service through WNS. And finally, we'll explore how to catch and process push messages including raw data messages in our Windows app.