Microsoft 70-485 Advanced Windows Store App Development...

Explore how Windows 8 emphasizes movement through animations and transforms, adapting to touch, pins, mice, and keyboard on mobile devices in a varied orientation environment.

Explore the Windows 8 ecosystem and bring Windows Store apps to life with animations and transitions, covering theme transitions, localization, globalization, branding, and snippets-based animation techniques.

Explore the Windows 8 ecosystem, tracing how a small app like Xun helped Windows 8 come to life and how Zune influenced its evolution.

Analyze how the Zune software prioritized content over chrome, reduced windows and menus, and used context menus and modal dialogs to create an easy, navigation-friendly interface that foreshadowed Windows 8.

Discover how Windows 8 updates navigation, the login and startup screens, and how to integrate app data into the startup screen for store apps.

Navigate the Windows 8 start screen, a gesture-based interface where live tiles replace the start menu, with desktop tiles static and icons supporting consistent branding.

Explores designing a search feature to help users find applications when they're not visible on screen.

Explore instantaneous search in Windows apps, launching results like the animation samples app, and learn how a strong icon design boosts user engagement and sales.

This lecture explains Windows Store app lifecycles differ from desktop apps, with suspended state and no minimize or close buttons. Close options include Task Manager, drag gesture, or keyboard shortcut.

Map mouse gestures to touch gestures in Windows 8 and test apps on touch devices like tablets, using a table of common touch and mouse features and keyboard shortcuts.

Explore how Windows 8 changes development with a moving, dynamically updating user experience, and leverage animations to help integrate apps into this new world.

Discover how to animate Windows store apps by varying the value of a dependency property over time to drive motion, transforms, rotations, and color changes, using small Zambal and C# snippets in Visual Studio.

Explore animation support in Windows Store apps, featuring theme transitions and theme animations, and learn to implement standard and custom animations that power the Windows 8 user experience.

Master theme transitions to animate user interfaces with hardware-accelerated, independent animations that match built-in Windows styles in Windows Store apps, while automatically handling timing and easing for consistent, high-quality apps.

Apply theme transitions to UI elements using a transitions property and themed transition objects, such as entrez themes transition, and watch a button fade and glide into place.

Explore the entrance theme animation that makes the main screen buttons slide in and subtly swing at the bottom, reappearing when you return to the page.

Wrap theme transition elements in an explicit transaction collection element when configuring transitions in XML, since transitions default to null; use item container or content transitions to apply across elements.

Explore the eight theme transitions in Windows 8 and apply an entrance transition to a stacked panel with child transitions, using a horizontal offset to animate content.

Explore the eight theme transitions, focusing on the entrance theme transition with staggering and offsets. See how loaded events and visibility shape the initial render and element behavior.

Learn how the pop up theme transition animates temporary overlays with entrance and fade-out, using horizontal and vertical offsets, and contrast it with content and edge UI theme transitions.

Pane theme transition slides in from the right, docks to the app edge, and clips content in paint transition, with an edge property differing from edge UI theme transition.

Learn the add delete theme transition for collections. See elements appear with a fade-in and grow, then fade out and shrink when removed as siblings glide to new positions.

discover how layout changes trigger animations and how transitions animate elements during add, delete, and repositioning. apply transitions to specific elements to control which items glide during layout shifts.

Explore the reposition theme transition that animates layout changes, including entrance/exit behavior and staggering, compare it with add/delete transitions, and see practical examples with a stacked panel.

Explore how the reorder theme transition enables automatic drag-and-drop item reordering in list and grid views, with sophisticated effects and staggered layout changes.

Explore theme animations in advanced windows store app development, learn how to trigger 14 custom actions via the storyboard mechanism, and implement them in Visual Studio.

Apply fade out and fade in theme animations via four page storyboards, triggered by a mouse click, with storyboards stored in resources and linked by the target name property.

Learn how the storyboard exposes methods to control animations like a video clip, enabling you to begin, pause, resume, seek, and stop.

Start initial animations on page appearance with careful timing of theme transitions, ensuring the splash screen delay doesn’t hide the animation; explore adjustments in Visual Studio to learn.

Trigger the initial animations on the first window activated event using a host window activated handler, with a first-activation flag to prevent repeats and ensure fading is synchronized.

Explore triggering animations without C# by using a storyboard in the visual state and the triggers property on framework elements, with a Visual Studio demo for WP and Silverlight compatibility.

Explore declarative animations in Windows Store apps using a storyboard and a routed event trigger attached to the framework element loaded, shown by a green button disappearing without code behind.

This lecture outlines the fourteen Windows 8 theme animations, including fade and pop variants, pointer down/up, reposition, swipe, drag, and split open and split clothes theme animations.

Examine how theme animations expose Timeline properties and a completed event from Timeline, with storyboard deriving from it, enabling delays, speed changes, and reverse playback, including a fadeout that repeats.

Learn how to tune theme animations with duration and speed ratio, apply them for Windows‑style visuals, and why fade‑in theme animations may fail due to internal opacity handling.

Explore seven custom animation classes in zambo UI framework that animate doubles, points, colors, and objects, and implement a double animation to fade a button's opacity from 0 to 1.

Learn how to implement custom double animations by binding a storyboard to a property like opacity, fading a button in over one second, and compare linear interpolation with theme transitions.

Explore how animation classes target dependency properties, why visibility cannot be animated to fade, and how to animate grid column widths using min width and max width properties.

Explore independent vs. dependent animations. Repurpose a double animation to drive button opacity via a dependency property of type double, and evaluate if it works by default.

Independent animations run on the GPU using opacity, render transform, or projection via canvas left and top attach properties, while dependent animations require layout updates and inner contents changes.

Discover how Windows prevents non hardware-accelerated animations by default and how setting the dependent animation property to true lets such animations run.

Explore independent vs dependent animations and see how an update to a preceding page animates a pick button, while examining performance considerations.

Explore independent vs. dependent animations and how a static timeline setting can disable all dependent animations, helping you spot performance issues and enforce consistent behavior.

Master independent animations with scale and translate transforms to animate size and location, note the duration, compare with dependent animations, and set duration via the timeline using time span parser.

Explains using the duration type in animations, including automatic and forever values, and shows how to prevent jumps by omitting from and using from/by in storyboards triggered by pointer enter/exit.

Explore negative values in a double animation and how a missing from value makes the pointer scale grow, with from and to properties in custom animations double, color, and point.

Learn how missing from and to values and disabled dependent animations cause silent animation failures; add explicit initial or end values and ensure dependent animations are enabled.

set and control animation timing with begin time, including delays and negative starts, to sequence animations. adjust speed ratio, auto reverse, and repeat behavior to shape duration and looping.

Explore how an animation's true duration is determined by a formula beyond begin time, speed ratio, auto reverse, and repeat behavior.

Compute the total timeline length (ttl) by combining begin time, natural duration, auto reverse, speed ratio, and repeat to predict animation timing.

Use storyboards to combine two animations that scale a button, each targeting a different property, with begin times, duration, auto reverse speed ratio, repeat behavior, and fill behavior stop.

Set the property value in the animation, not the storyboard, and use indirect targeting with a property path to animate nested properties like the color of a solid color brush.

Learn how to format and use property paths for storyboard target properties, such as text block foreground, and how solid color brush color syntax works in windows store app development.

Explore property paths by parsing syntax as parts, using dot separators to unambiguously identify a property's type, then step into an object's sub properties to target a specific value.

Explore how apps access user files, save work in progress. Learn how permissions govern access via file picker or capabilities, and explore libraries and special folders.

Explain how to navigate property paths, including target properties and ambiguous paths, by using parentheses to specify the fill property's type and name so animations resolve correctly.

Explore how attached properties require valid property paths to resolve target properties in animations. Recognize syntax errors tied to declaring property paths, illustrated by gradient stops and linear gradient brushes.

See how a storyboard uses timeline properties like duration, begin time, speed ratio, auto reverse, and repeat behavior to drive animations and control the sequence.

Discover seven custom animation classes and how keyframes provide specific values at specific times, and learn to distinguish them by their names.

Explore double animations using keyframes to create zigzag motion with canvas left and top. Learn the four keyframe types: linear, spline, discrete, and easing, and how they interpolate values.

Learn how spline keyframes replace linear animations by using a key spline to drive motion as a cubic bezier curve with 0 to 1 endpoints, optionally via a type converter.

Explore custom keyframe animations by mixing discrete, linear, and spline keyframes to control interpolation, including discrete object keyframes, and see how these affect text transformations over time.

Explore how linear and spline frames use easing keyframe classes to customize interpolation with an easing function, enabling double, color, and point animations across the main custom animation classes.

Explore 11 easing functions in three modes, including quadratic ease, that control acceleration and deceleration in animations via a base easing function class and easing mode.

Explore how back, elastic, and other ease functions can produce negative values and why, using quadratic interpolation to illustrate ease in, ease out, and symmetry with half-time behavior.

Learn manual animations with a timer and callback, including dispatcher timer usage and start-stop control, but this approach isn’t in sync with refresh rates or hardware acceleration and isn’t recommended.

Explain how dispatcher timer runs on the main thread and enable frame-based animations using the composition target rendering event for high-fidelity per-frame updates, such as collision detection, with tradeoffs.

Learn how globalization and localization enable apps to serve diverse markets by adapting languages, cultures, and regions, and applying best practices for international readiness.

Learn to globalize a Windows app by placing strings in language-specific resource files, setting the default language in the app manifest, and binding those resources into markup.

Learn localization and globalization for Windows store apps by adding language resources and using a resource loader to adapt Zig-Zag text and titles to French and German.

Test localization and globalization by switching system languages and cultures (German, French), load localized resources, and adapt UI text and assets dynamically using resource files.

Explore how branding defines your app’s qualities and differentiates it, showing before and after examples that incorporate brand essence to make a bakery app more compelling.

Explore branding through visual elements like color palettes, graphics, layouts, and photography to create a repeatable, recognizable look across media and windows store apps.

Leverage brand colors, consistent graphics, and your logo to unify the Windows Store app, and craft thoughtful typography and splash and extended splash screens to reinforce identity.

Explore branding visual elements by examining an extended splash screen and logo usage. Update the user during loading to deliver a smooth, crisp experience.

Explore strategies to prevent flicker between the Windows splash screen and the extended splash screen, using fragments or on top painting, and manage activation deferral and events asynchronously.

Learn to design compliant splash screens and extended splash screens for Windows Store apps, avoiding ads, preserving brand identity, and providing smooth loading with scale-specific images and progress indicators.

Explore customizing the splash experience by implementing an extended splash screen with a splash screen extension, handling size changes, deferrals, and navigation to the main page after dismissal.

Brand windows store apps to create a consistent look and feel across your company’s apps. Visit the windows dev center for branding guidelines to ensure your app follows established standards.

Explore how Windows 8 introduces live tiles, full-screen design, and new animation options to shape store apps, while learning to optimize performance with a frame rate counter and overdraw maps.

Develop a Windows application that animates a bouncing ball, counts bounces, and localizes the count in French, English, and German, exploring animation and globalization properties.

Explore caching data to boost performance and enable offline access, and learn to create reusable templates, controls, and runtime components to write once and deploy across apps.

Explore advanced data scenarios, decide where data should reside, and build reusable controls and runtime components, while learning about local caching and the application data roaming folder.

Explore how to plan and manage data for Windows Store apps across devices, choosing between remote and local storage, and identifying what data to store and when it's used.

Access data from local sources or remote endpoints using file pickers and contracts, and blend data from the People app, cloud services, and public APIs, while considering data size.

Compare storage needs across devices, noting surface tablet 32 or 64 gigabytes and phone 16 gigabytes, and how text-based files, relational DB files, images, video, and music fill space quickly.

Examine how to store persistent app data with local and roaming settings and private app files using the Windows storage application data class. Understand isolation, uninstall deletion, and subfolder limits.

Understand that user data are files visible to users and stored outside your app. Use file pickers and permissions to grant access to music, pictures, videos, and documents.

Learn how Windows 8 apps access network data via http requests, background transfers, sockets and web sockets, and consume rss/atom feeds, with sequel lite and Sky Drive as storage options.

Explore network data and other data options by building a SkyDrive app using the Windows Live SDK in Visual Studio 2012, adding Calisto controls via NuGet, and previewing deployment.

The lecture shows building a sky drive photo app with the live sdk, including installing the sdk, establishing a live connection, and accessing sky drive photos.

Explore the Windows storage api with local, roaming, and temporary data stores for app data, settings, and files, enabling roaming across devices via cloud and access to installation location.

Cache data to disk to keep your app fast and fluid, with roaming data and the Windows application data class for mutable, app-specific state and preferences.

Cache network content as app data using roaming and temporary folders, manage roaming storage quotas, and ensure files are closed after use for fast offline access across devices.

Create a blog reader in Visual Studio that fetches RSS and Atom feeds with the syndication client, uses a date converter, caches data, and navigates between list and detail pages.

Cache blog content to a roaming storage file and render it in a web view via the content view, handling selection changes and file IO.

Create reusable controls using data templating to maintain a consistent look and feel across multiple applications, and extend them with shared business logic.

Create data-bound custom controls from data templates to standardize list items across Windows Store apps, using a generic.xaml implicit style and a default style key.

Create a custom control with a control template, expose bindable properties via dependency properties, and use template binding with the s.cs file, then animate a blink with a dispatcher timer.

Create and bind a custom control within a data template, exposing dependency properties and template properties, and bind them to a view model to control blinking behavior.

Learn to create a Windows runtime component from managed code for Windows store apps, exposing Windows runtime types and navigating overloads, root namespace, and language differences.

Implement asynchronous methods in a windows runtime component by returning IAsyncAction or IAsyncOperation and wrapping tasks with the async info class to enable cancellation and progress.

Create a Windows runtime component within a library project, generate a winmd file, reference the roach book library from another project, and access its classes in the view model.

Cache data with roaming or local folders for offline use. Create custom controls with data templates and dependency properties for binding, and share Windows runtime components for a consistent look.

Build a custom control that combines a grid view and semantic zoom into a zoom grid with level-based view states. Cache last zoom level to restore it at app launch.

Explore advanced contracts in windows store app development, implementing printing, windows push notification services, and media capture and manipulation (video, audio, pictures), with a deep dive into background tasks.

Explore contracts and extensions as a new way to interact with Windows, other apps, and attached devices.

examine the print contract and leverage it for mobile and desktop contexts, then cover push notification services, capturing media (pictures and video), and background tasks.

Learn how to implement printing in Windows 8 store apps, covering touch, tablets, mobile devices, and PCs, and understand why printing support matters for modern apps.

Register for the print contract to print from a Windows Store app, create a print task, handle print events, and format content for the printer using print UI and preview.

Register the print contract for each app screen to enable printing using the custom control app as base; unregister on exit and register for the next screen.

Register for printing in a Windows Store app by creating a print document, wiring preview and print task events, and unregistering on navigation.

Learn how to register for the print contract on each page, print from a Windows app to OneNote, and configure print options like orientation and paper size.

Customize print preview options in a Windows Store app by using standard print task options class and handling print task event to add, order, and set defaults for supported options.

Override print task request to display a customized list of printer options—copies, orientation, media, size, collation, duplex—set default North American legal size, and clear display options before adding.

Add custom print options beyond built-in ones by defining values, creating a print task options details list, and integrating them into the print UI in Visual Studio.

Add a print button outside the printable area to ensure only the content prints, not the button, using the root canvas and grid area to control what prints.

Learn how Windows Push Notification Services (WNS) lets developers send tile and badge updates from their cloud service, delivering new updates power efficiently and reliably to users.

Discover the process of push notifications, from creating a push channel and channel URI with the notification client platform to authenticating your cloud service and delivering the payload via WNS.

Authenticate a cloud service with the Windows notification service via ssl; obtain an access token using client credentials and reuse it to post channelUri notifications.

Explore how to implement push notifications in a Windows Store app, including scheduling update intervals such as every half hour or daily news titles, and integrating with a cloud server.

Demonstrates how to implement sending a push notification via an http post to WNS, with four required headers (x-wns-type, content-type, content-length, authorization), and how to manage access tokens and responses.

Compose an http post request to deliver the notification to your app; you have registered and authenticated your cloud server and defined the notification content.

Request a push notification channel uri, a unique address for a user on a device, and send it securely to your server via a https post request, authenticating the app.

Request a new channel each invocation, compare with the locally stored previous channel, and push to the web service when it changes.

Close the push notification channel to stop all delivery of toast, tile, badge, or raw notifications, then call the tile update or clear method to remove the previous user's data.

Register your app in the Windows Store dashboard to obtain the package security identifier and client secret, then securely authenticate your cloud service with WNS to receive an access token.

Explore media concepts, including cameras, video, and audio, in part 1 of the PlayTo api within the Microsoft 70-485 advanced Windows Store app development course.

Use the play to API to stream audio, video, or images to devices on the home network by implementing the play to contract and handling the source requested event.

Explore how the PlayTo API streams media to a selected target device, using set source to pass the media element, and maintain playback when the app moves to the background.

Enable play-to functionality in apps to stream video, images, or audio to remote devices while letting users continue navigating the app during playback.

Explore how to implement PlayTo in Windows Store apps, keeping the media element in scope so users can use PlayTo without navigating to a dedicated page.

Configure manifest capabilities for video, pictures, and music, then use a media element UI to load and display video, audio, or image files via play-to.

Set up and manage counters for video, music, and image selections; advance indices on each load; guard against out-of-range access; and enable graceful, iterative playback for video and audio.

Learn to capture video from a webcam in a Windows Store app using Visual Studio, starting a project named camera lab and implementing webcam video capture.

Practice capturing video from a webcam in a Windows Store app, continuing from part 1 to implement video camera capture.

Learn to implement web cam capture with a reset, rotate to 0/90/180/270 degrees, and snap a picture using a capture preview element and related code.

Utilize the camera capture UI to deliver a full-screen photo and video capture experience, switch modes, and use a timer in your Windows Store app.

Utilize a camera capture user interface to snap photos, save them to a storage file, and reload the last photo on startup with configurable photo and video settings.

Learn how Windows Store apps run code in the background with a new background task model, manage resources, and optimize battery life through per-app controls and lock screen personalization.

Learn to update your app tile and content while suspended using push notifications, the background transfer API, and playback manager, and create background tasks to optimize performance and battery life.

Run background code when suspended to support real-time apps like mail and chat. Provide limited resources for small, non-interactive work; long-running tasks drain battery.

Identify appropriate background task scenarios, such as downloading mail in the background or sending notifications for incoming VIP calls or chat messages, and avoid UI or audio interactions.

Implement a background task in a Windows Store app that runs when a trigger fires, may include conditions, and is built with a class implementing the background task interface.

Register a background task with the background task builder; the background task infrastructure launches associated class when a trigger fires, and the system infrastructure activates it in the app container.

Design lock screen apps that provide useful glance information and reflect real-time updates using a background task, such as a control channel timer or push notification.

Learn how lock screen apps implement background tasks—control channel, timer, or push notification—to reflect up-to-date information, while staying on the lock screen to enable triggers and avoid access denied errors.

Explore managing a lock screen app: remove app to conserve resources, register background tasks for lock screen add/remove triggers, and add app via the background execution manager.

Launch a background task in the system provided host executable or in the app process across running, suspended, and terminated states for faster performance and appropriate activation.

Register background tasks with a single trigger and persistent conditions; they launch automatically even after restarts, waiting until all conditions are satisfied, a process called latching.

Register a progress handler to receive background task progress and update the foreground UI. Use a completion handler to report completion status or exceptions and persist results for later resume.

Register a background task cancellation handler. Use the cancellation reason parameter of the background task canceled event, and save state before exiting if the task doesn't respond within five seconds.

Learn how a store app launched from a terminated state enumerates background tasks using background task registration.allTasks and re-associates progress and completion handlers with those registrations.

Associate progress and completion handlers, or event delegates, after app launch when the manifest lacks class-name entry points; resumed suspended apps retain background task handlers and do not require re-association.

Enumerate background tasks, associate their handlers, and ensure registrations persist across updates; verify entry points, manage updates by registering or deleting tasks, and note that uninstalling clears all registrations.

Register background tasks in a class library that can run in the main app or the system provided host, with time triggers requiring at least 15 minutes.

Examine how the background task library test class implements the background task interface, with the run method receiving a task instance detailing the trigger and conditions and the class sealed.

Learn to manage asynchronous work in the run method of a background task using the deferral; call complete after all operations finish to ensure work completes.

Demonstrate the background task class implementation by showing how the run method uses NRT asynchronous operation instances, with the completion handler calling complete once all work completes.

Add a C sharp class library implementing the background task interface, reference it from the main window store app, and configure manifest entries for background task extension contracts and triggers.

Understand background task constraints guard battery life: two seconds of CPQ time every 15 minutes on the lock screen, and one second every two hours off it; use it.

Explore how network resource constraints affect background tasks on Windows Store apps, detailing AC power behavior, CPE usage, and energy costs of downloads versus uploads over Wi-Fi vs cellular.

Examine how a wifi interface behaves under minimal interference and ideal conditions. See network throughput for background tasks on a DC power supply using wifi.

Real time apps using the control channel or push notifications receive guaranteed resource quotas and network for their critical background tasks.

Design background tasks to be short lived and display timely information on the lock screen when needed. Register progress, completion, and cancellation handlers, and use persistent storage for shared data.

Register a background task by implementing the background task interface, use a deferral for asynchronous work, and connect it to a Windows runtime component for live tile updates.

Register and configure a background task inside the app, check existing registrations to prevent duplicates, and use a background task builder with a system trigger such as times changed.

Register and condition a background task with a user-present requirement, handle completion, and update the UI asynchronously using local settings.

Register a background task and handle its completed event. Declare the task in the app manifest with a system event trigger and specify the entry point.

Fetch the latest five blogs via a background task and update the live tile with an SML-based template using the tile update manager.

Register the background task in code and declare the timer in the manifest. Update the live tile with the feed and debug on a local machine, forcing runs.

Print different parts of your application, define the print area, and update the layout for the printer using the printer UI and options. Then explore the Windows push notification service.

Explain the push notification flow from DNS-created channel to the URI, then your cloud service posting via HTTP POST with SSL authentication, to the device through WNS.

Explain push notification channel lifecycle and the requirement to request a new channel, then summarize media features—play-to streaming, media element playback, pictures library, camera capture UI, and lock-screen background tasks.

Create a new class to handle background update notifications; when you capture a new picture, trigger a push or update notification and add the image to the live tile.

Explore sensors and geolocation in advanced Windows Store app development, including device orientation, tilt, pressure sensing, and how these capabilities integrate with media contracts.

Explore sensors in windows 8, learn about different devices and what you can do with them, and discover geolocation to determine your location for navigation and related apps.

Explore how the Windows Sensor Platform abstracts hardware sensors to let apps react to changes in acceleration, orientation, ambient light, touch, and proximity across diverse devices.

Explore how the Windows runtime supports mobility across x86 and arm architectures and how the Windows sensor platform APIs access accelerometer, compass, gyrometer, and orientation sensors.

Explore Windows sensor platform hardware certification requirements, including 3D accelerometer, 3D gyro meter, 3-D magneto meter, GPS, and mobile broadband, plus the hardware certification kit for driver developers and testers.

Explore how the Windows sensor platform uses sensor fusion with accelerometer, gyro meter, and magnetometer to synthesize virtual compass, inclinometer, and device orientation data.

Explore the 3d accelerometer by first briefing its overview and class diagram, then dive into Visual Studio to access and use the sensor, while noting sensor availability across form factors.

Understand how the accelerometer measures acceleration and g-forces across x, y, z axes, enabling screen orientation changes and app responses via reading change events and shaken events at 50 hertz.

Explore accelerometer sensing in a sample app by initializing the accelerometer, handling reading changes to display x, y, z, while testing on a desktop before porting to a tablet.

Explore building a compass using the Kompas sensor to detect magnetic and true north headings, handle reading changed events, and use sensor fusion in a Windows Store app.

Explore how the 3d gyrometer measures angular velocity along the x, y, and z axes and fires a reading changed event with a timestamp for each reading.

Explore how the inclinometer sensor measures pitch, roll, and yaw angles for tilt and slope, enabling flight-simulator style input in Windows Store apps through sensor fusion and reading changed events.

Explore how to use an ambient light sensor to measure luminance in lux, handle the reading changed event, and access luminance and the time of change from light sensor reading.

Use orientation sensor data in a game to adjust the user's perspective, check device support first, and apply the rotation matrix and orientation data as with other Windows sensors.

Learn how the orientation sensor raises a reading change event, exposing its rotation matrix, quaternion (w, x, y, z), and a time stamp, with update handling.

Learn how the simple orientation sensor detects device orientation and whether the screen is face up or face down, via a single reading changed event and an orientation property.

Port the code to a tablet and run the sensory deprivation app, which updates the orientation sensor's x, y, z data; observe a static compass reading when movement is minimal.

Install orientation sensors and verify that the code runs as expected, displaying sensor reading information and showing that other examples would work the same way.

Learn how geolocation and location awareness enable Windows Store apps to determine real-world locations and meaningful addresses, and to share location on social networks.

Explore how the locator class enables location awareness in Windows 8 store apps, determining latitude and longitude and handling devices without GPS for directions.

Learn how the locator uses GPS sensors to determine a device's position and switches to network data when GPS is unavailable, with latitude and longitude defining coordinates to pinpoint locations.

Geolocation in the Geo locality project shows instantiating a locator, setting high position accuracy, and updating the main page's geo locators via status and position changes.

Learn how geolocation updates trigger a status changed event, and why you must use the dispatcher to update UI text blocks from non-UI threads.

Explore the geolocator's position changed event to make your Windows Store app location aware, leveraging the geo position class's latitude and longitude.

Enable the location capability in the app manifest, request user permission to access location, and retrieve latitude and longitude via GPS to determine your position.

Explore the Bing Maps SDK for Windows 8 to display the user’s current location on a map within a Windows Store app, and learn its core features for integration.

Install the Bing Maps SDK for Windows Store apps by adding Windows extensions and runtime packages, and install the SDK via Visual Studio 2012 extensions or the Visual Studio gallery.

Install the Bing Maps SDK, include the Bing Maps for C-Sharp and the Microsoft Visual C++ runtime references, and configure the map control with a key from the portal.

Add pushpins to the Bing Maps SDK using the pushpin class and tapped events to mark map locations. Switch between road, aerial, and bird's eye views with traffic on.

Learn to add directions to location aware Windows Store apps by calling a routes web API to compute walking, driving, or public transit routes between two locations using waypoints.

Learn to render route paths with maneuvering points on a map, switch to point-based outputs for visual representation, and optimize performance when calculating thousands of points via a web API.

Learn to use sensors such as accelerometers, gyrometers, and an inclinometer, with ambient light, to build Windows Store apps that react to orientation and environment, including geolocation and map routing.

Build a Bing Maps SDK app that lets users enter an address and display it on the map, tackling a challenging lab task.

Explore revenue generating concepts and learn how to secure our application, then diagnose performance issues in the app using a profiling tool.

Explore revenue models for monetizing your Windows Store apps, implement security with Windows authentication via the Live SDK using the Microsoft ID, and profile your app to boost performance.

Explore revenue generation and secure your Windows Store app by authenticating with a Microsoft ID, then use diagnostics to optimize performance.

Explore revenue models for Windows Store apps, from full-price downloads and free trials to in-app purchases, advertising, and third-party transactions.

Offer a free trial version of your Windows Store app with limited or full functionality for a set period, then upgrade to the full version by purchasing.

Learn to implement in-app purchases to sell content and new app features inside your app, manage license duration, and describe offers in your dashboard, with no purchases in trial versions.

Design your app so in-app purchase features are separate from the core experience, preserving basic functionality if users don’t buy, and model licensing to keep features compartmentalized.

Explore how to monetize Windows Store apps with in-app purchases and ads, align with Windows app certification requirements, use the Microsoft Advertising SDK, and support ad removal through purchases.

Set price tiers to control sales prices across 60 currencies, offering free or paid options with currency-based increments, while considering value added tax and exchange rates on in-app proceeds.

Understand how the Windows Store fee changes with sales: 30 percent up to $25,000, then 20 percent thereafter. Fees apply only to in-store sales, not third-party transactions, per the app developers agreement.

Learn how the Windows Store pays developers by detailing store fees on every sale, pricing options, monthly thresholds, and how to set up payment and developer accounts and tax forms.

Sign the app developer agreement with the Microsoft Store; per-app fees start at 30% up to $25k, then 20%, and apply to all store sales and in-app purchases.

Identify how Windows Store earnings move through reserved, pending, and paid categories and explain the $200 payout threshold needed for monthly payments.

Learn how app sales convert to proceeds after the Windows Store fee. Track payment eligibility using the $200 threshold across all markets and review financial reports.

Explore implementing free trials and in-app purchases in Windows Store apps, including time-based feature limits, banners or watermarks, and license state handling to tailor trials for games and utilities.

Learn how trial licenses expire during use or before launch, prompt users to buy, and handle license changes with event handlers to enable full features after purchase.

Initialize the app license information and attach a license-changed handler to monitor status. Reload license information to determine trial, active, or purchased status and enable features.

Learn how to display trial expiration, format expiration dates, calculate days remaining, and test licensing using the Windows Store simulator, then switch to the current app before submission.

Explain how your app behaves during and after the free trial, and enable in-app purchases to create revenue streams by offering products and features within the app.

Set up licensing information, test in-app offers with the current app simulator, and implement purchase UI. Configure in-app offers in the Windows Store with tokens, prices, and language descriptions.

Explore monetizing your Windows Store app with ads using Microsoft Advertising and the ads in apps resources. Learn to protect your investment, app, and customers.

Explore how encryption protects data using symmetric and asymmetric keys, and why authentication and hashing are essential to detect tampering.

Explain how encryption uses symmetric and asymmetric keys, with private keys secret and public keys shared, and that keys strengthen security and enable signing and computing a message authentication code.

Learn to create or import keys in windows store apps, and study block ciphers, ECB, CBC, and GCM modes with initialization vectors and padding for secure encryption.

Explore symmetric stream ciphers, block ciphers that encrypt fixed-size blocks with a keystream, and modes like output feedback and counter that turn block ciphers into stream ciphers.

Master asymmetric key cryptography with public and private keys for encryption, decryption, and signing. Understand how data protection provider secures data to Active Directory principals, X.509 keys, or symmetric keys.

Explore how Windows authentication with Live Connect enables password roaming via Microsoft accounts across devices, enabling single sign-on for apps and websites and automatic sign-in without extra credentials.

Utilize web authentication broker to isolate user credentials in Windows security namespace and sign in to web sites. Access and share contacts across apps via Windows application model.

Explore how the live software SDK and live connect enable seamless app integration and personalization, with guidance to search the dev center for using live connect to tailor apps.

Explore a password vault lab to save, look up, and delete password credentials, demonstrating practical vault operations for secure credential management.

Learn how to store passwords in the credential locker via the Windows security credentials namespace, tied to a specific app or service, with roaming enabled by default.

Create and store credentials in a Windows password vault by constructing a password credential with app name, username, and password, then add it to the vault using the add method.

Enumerate, retrieve, and remove credentials stored in a password vault using find all by resource or find all by username, with error handling and encryption and decryption.

Learn to profile Windows Store apps using the Visual Studio CPE profiler, create performance sessions, and analyze hot paths, function timelines, and sampling results.

Create and run a performance session with the Visual Studio performance wizard, using sampling by default. Exercise the app to collect profiling data and review it in the Performance Explorer.

Analyze sampling data from a Visual Studio performance session by examining the hot path, top functions, and the summary timeline, noting profiling suggestions, warnings, and sampling limitations.

Identify the hot path with the highest inclusive samples to target performance optimization, and inspect function details view, timelines, and exclusive versus inclusive counts to locate bottlenecks.

Open performance explorer from the view menu, rerun the session with profiling, add new data files to reports, and compare performance reports to see whether changes improve or degrade performance.

Explore how to use diagnostics by visiting the dev center and searching for system diagnostics namespaces to enhance debugging and performance analysis in Windows Store app development.

Launch the CPU profiler in Visual Studio and observe it run in action using the blog sampler as a test example.

Launch and analyze a Windows Store app's performance by starting a CPU profiler in Visual Studio, running the app, collecting samples, and examining hot paths, timeline, and function breakdowns.

Master revenue models for Windows Store apps, including upfront purchases, in-app purchases, and trial apps, plus ads, authentication, encryption, and cp proof profiler.

Add paid features by licensing animations in the animation lab, restrict access to paid animations, test via the app simulator, and practice building Windows Store apps.

Concludes the section lab on add paid features part 2, acknowledging the final conversation and signaling that there is no next topic planned.

Thank you for exploring advanced Windows Store development; apply the tricks and tidbits to make your apps better in Windows Store, and leverage the strong development environment toward self-sufficient entrepreneurship.

Explore the key resources behind advanced Windows Store app development, featuring Windows 8 metro app development with C# and XML and guidance from the Windows Dev Center.