Hello windows 10: An overview of the new features for developers in WIndows 10

Hello Windows 10
@gillcleeren
@nicovermeir

http://windows.Microsoft.com
About Gill
Gill Cleeren
Microsoft Windows Platform MVP & Regional Director
Ordina architect – Practice Manager
Pluralsight author
Speaker
Book author
@gillcleeren
gill@snowball.be
www.snowball.be

About Nico
Nico Vermeir
Microsoft Windows Platform MVP
RealDolmen software engineer .NET / Mobile
Speaker
Book author
@NicoVermeir
nico_vermeir@hotmail.com
http://www.spikie.be

Agenda
• The Story of 10
• XAML: then and now
• Data binding improvements
• Adaptive, adaptive and more adaptive
• New in Live Tiles
• The App Lifecycle
• (Optional) App-to-App communication
• (Optional) App Services

Windows Core
The refactored common core
One hardware platform
Universal hardware driver
Standard network and I/O
Phone
Device
Xbox
Device
Desktop
Device
Windows Core
Desktop
SKU
Phone
SKU
Xbox
SKU

One Windows
Desktop
SKU
PC
2 in 1
Mobile
SKU
Tablet
Phablet
Phone
Xbox
SKU
Xbox
IoT
SKU
Band
IoT headless
SKU
Raspberry Pi
Home
Automation
Surface Hub
SKU
Surface Hub
Holographic
SKU
HoloLens

Each family adds features
to the one it inherits

Easy for users to get
& stay current
Unified core
and app platform
The convergence journey
Windows 10
Converged
OS kernel
Converged
app model

Phone Small Tablet
2-in-1s
(Tablet or Laptop)
Desktops
& All-in-OnesPhablet Large Tablet
Classic
Laptop
Xbox IoTSurface Hub Holographic
Windows 10

One Store +
One Dev Center
Reuse
Existing Code
One SDK +
Tooling
Adaptive
User Interface
Natural
User Inputs
One Universal Windows Platform

Universal Windows Platform
A single API surface
A guaranteed API surface
The same on all devices
Phone
Device
Xbox
Device
Desktop
Device
Windows Core

Windows app
A single binary
Running on any device
Testing for capabilities
Adjusting to devices
Phone
Device
Xbox
Device
Desktop
Device
Windows Core
Windows App

The developer story
When writing for iOS,
A developer writes for iPad & iPhone
When writing for Android,
A developer writes for all supported devices
When writing for Windows 8,
A developer writes for each devices
When writing for Windows 10,
A developer writes for every device

Platform extensions
Device-specific API
Family-specific capabilities
Compatible across devices
Unique update cadence
Phone
Device
Xbox
Device
Desktop
Device
Windows Core
Windows App
Phone
extension
Xbox
extension
Desktop
extension

Extensions don't invalidate
binaries on other devices

UAP
Windows Core Windows Core Windows Core Windows Core
UAP UAP UAP
Desktop Mobile Xbox More…

Test capabilities at runtime
Use Adaptive Code to light-up
your app on specific devices
var api = "Windows.Phone.UI.Input.HardwareButtons";
if (Windows.Foundation.Metadata.ApiInformation.IsTypePresent(api))
{
Windows.Phone.UI.Input.HardwareButtons.CameraPressed
+= CameraButtonPressed;
}

Windows 10
operating system
Bridging technologies
Win32
desktop
Web
hosted
Java
Android
Obj.C
iOS
WWAC++
& CX
.Net
languages
HTML
DirectX
XAML
C++
.Net
languages
MFCWFWPF
.Net
runtime

Windows 8/10 Layout controls
<Border Thickness="" Brush="" />
<Canvas />
<Grid />
<RelativePanel />
<ScrollViewer />
<SplitView DisplayMode="" />
<StackPanel Orientation="" />
<VariableSizedWrapGrid />
<ViewBox Stretch="" />

RelativePanel
Defines an area within which you can position and align child objects in relation to
each other or the parent panel.
RelativePanel is a constraint based layout container that you can use to create UIs
by expressing spatial relationships between elements.
Using RelativePanel’s attached properties, you can position a UI element relative to
another UI element (A is RelativePanel.Below B) as well as relative to the panel (A is
RelativePanel.AlignTopWithPanel).
-MSDN

RelativePanel
Some child elements
act as anchors
Most child elements
relate to others
It's a layout technique
friendly with States
See Adaptive Triggers later!

Important properties
Attached properties
• Above & Below
• AlignBottomWith & AlignTopWith
• AlignBottomWithPanel & AlignTopWithPanel
• AlignHorizontalCenterWith & AlignVerticalCenterWith
• AlignHorizontalCenterWithPanel & AlignVerticalCenterWithPanel
• AlignLeftWith & AlignRightWith
• AlignLeftWithPanel & AlignRightWithPanel
• LeftOf & RightOf

Some RelativePanel samples
<RelativePanel>
<Border Width="100" Height="100" Background="Blue"
RelativePanel.AlignHorizontalCenterWithPanel="True"
RelativePanel.AlignVerticalCenterWithPanel="True"/>
</RelativePanel>

We wanted this for a long time

Now available: the SplitView!
<SplitView x:Name="SplitView" Background="Black" OpenPaneLength="240" CompactPaneLength="48"
DisplayMode="CompactOverlay" IsPaneOpen="False"
Content="{Binding}">
<SplitView.Pane>
<StackPanel x:Name="SplitViewPanePanel">
<RadioButton x:Name="BackRadioButton" Click="BackRadioButton_Click"
Style="{StaticResource NavRadioButtonStyle}" Content="Back" GroupName="Back"/>
<RadioButton x:Name="HamburgerRadioButton" Click="HamburgerRadioButton_Click"
Style="{StaticResource NavRadioButtonStyle}" Content="Menu" GroupName="Hamburger"/>
</StackPanel>
</SplitView.Pane>
</SplitView>

SplitView
IsPaneOpen="True" IsPaneOpen="False"
DisplayMode=
"Inline"
DisplayMode=
"Overlay"
DisplayMode=
"CompactInline"
DisplayMode=
"CompactOverlay"

Sample SplitView
<SplitView x:Name="MySplitView" DisplayMode="CompactOverlay" IsPaneOpen="False"
CompactPaneLength="50" OpenPaneLength="150">
<SplitView.Pane>
<StackPanel Background="Gray">
<Button x:Name="HamburgerButton" FontFamily="Segoe MDL2 Assets" Content=""
Width="50" Height="50" Background="Transparent" Click="HamburgerButton_Click"/>
<StackPanel Orientation="Horizontal">
<Button x:Name="MenuButton1" FontFamily="Segoe MDL2 Assets" Content=""
Width="50" Height="50" Background="Transparent"/>
<TextBlock Text="Button 1" FontSize="18" VerticalAlignment="Center" />
</StackPanel>
…
</StackPanel>
</SplitView.Pane>
<SplitView.Content>
<Grid>
<TextBlock Text="SplitView Basic" FontSize="54" Foreground="White"/>
</Grid>
</SplitView.Content>
</SplitView>

The resulting SplitView

Buttons
<Button Content="" />
<HyperlinkButton />
<RepeatButton />
<ToggleButton IsChecked="" />

Text controls
<TextBox Text="" />
<PasswordBox Text="" />
<TextBlock Text="" />
<AutoSuggestBox />
<RichEditBox Content="" />
<RichTextBlock Content="" />
<BitmapIcon UriSource="" />
<FontIcon Glyph="" />
<SymbolIcon Icon="" />
<PathIcon Data="" />

AutoSuggestBox

Selection and picker controls
<CalendarView />
<DatePicker Date="" />
<TimePicker Time="" />
<ToggleSwitch IsChecked="" />
<CheckBox IsCHecked="" />
<RadioButton IsChecked="" />
<ComboBox />
<ListBox />
<Slider Minimum="" Maximum="" />

CalendarView
Windows uses this one itself!

Collection/data controls
<ItemsControl ItemsSource="" />
<FlipView />
<GridView />
<ListView />
<SematicZoom />
<Pivot />
<Hub Orientation="" />
<ContentControl ControlTemplate="" />

Pivot

App bars and commands
<AppBar />
<CommandBar />
<AppBarButton Label="" Icon="" />
<AppBarToggleButton IsChecked="" />
<AppBarSeparator />

Flyout controls
<Popup IsOpen="" />
<ContentDialog Title="" Content="" />
<Flyout Placement="" />
<MenuFlyout />
<ToolTip />

ContentDialog

DEMO
Flyout controls &
ContentDialog

Progress, Media & Inking controls
<ProgressBar IsIntermediate="" />
<ProgressRing IsActive="" />
<Image />
<InkCanvas />
<MediaElement />

InkCanvas
Extremely complex control to start using!
<Grid>

<InkCanvas/>
</Grid>

Maps

Live Visual Tree

x:Bind
Compiled binding
Bindings are committed at compile-time
Strongly-typed binding
Duck binding is not supported
Default mode is OneTime
OneWay and TwoWay are still available
Standard binding approaches
INotifyPropertyChanged, IObservableVector, INotifyCollectionChanged

The data context of x:Bind
is the code-behind class

Syntax
<TextBox Text="{Binding
Converter
ConverterLanguage
ConverterParameter
ElementName
FallbackValue
Mode
Path
RelativeSource
Source
TargetNullValue
UpdateSourceTrigger}
<TextBox Text="{x:Bind
Converter
ConverterLanguage
ConverterParameter
ElementName
FallbackValue
Mode
Path
RelativeSource
Source
TargetNullValue
UpdateSourceTrigger}

DEMO
Using the
Compiled binding

<ListView ItemsSource="{x:Bind ViewModel.Employees}">
<ListView.ItemTemplate>
<DataTemplate x:DataType="model:Employee">
<Grid>
<TextBlock Text="{x:Bind Name}"/>
</Grid>
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
Data Templates

Syntax differences
<ListView ItemsSource="{Binding Items}" Header="Classic" Grid.Column="0">
<DataTemplate>
<TextBlock Text="{Binding Title}" />
</DataTemplate>
</ListView>
<ListView ItemsSource="{x:Bind ViewModel.Items}" xmlns:m="using:Blank3.Models"
Header="Compiled" Grid.Column="1">
<DataTemplate x:DataType="m:TodoItem">
<TextBlock Text="{x:Bind Title}" />
</DataTemplate>
</ListView>

Resource dictionaries
<ResourceDictionary
x:Class="MyNamespace.MyTemplates"
xmlns:model="using:xBindSampleModel">
<DataTemplate
x:Key="MyTemplate"
x:DataType="model:Employee">
<TextBlock Text="{x:Bind Name}" />
</DataTemplate>
</ResourceDictionary>
namespace MyNamespace
{
public class MyTemplates
{
public MyTemplates()
{
InitializeComponent();
}
}
}

Referencing a dictionary
</UserControl.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<local:MyTemplates/>
<ResourceDictionary Source="filename" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</UserControl.Resources>

Binding for Events
<Button Click="PokeEmployee">Poke Employee</Button>
<Button Click="{x:Bind Employee.Poke}">Poke Employee</Button>
Signature
Have no parameters - void Poke()
Match event parameters - void Poke(object sender, RoutedEventArgs e)
Match event base types - void Poke(object sender, object e)
Overloading is not supported
Because all events are eligible:
This may replace ICommand & EventToCommand
Note: this does not include parameter or CanExecute

Page.ViewModel
public sealed partial class MainPage : Page
{
public MainPage()
{
InitializeComponent();
this.DataContextChanged += (s, e) =>
{
ViewModel = DataContext as ViewModels.MainPageViewModel;
};
}
// strongly-typed view models enable x:bind
public ViewModels.MainPageViewModel ViewModel { get; set; }
}

DEMO
Using a ViewModel
declaratively

When to use classic binding
Duck Typing
Text=“{Binding Age}” works for both PersonModel & WineModel
Dictionary graphs
Use {Binding} with JSON or other untyped objects
Code-behind binding: adding and removing
bindings on the fly
Can add/remove {x:Bind} @ runtime
Use in a style
{x:Bind} can’t be used in a style for setters
{x:Bind} can be used in a DataTemplate that is defined in the style

{x:Bind} is not for
every situation right now.
It will in the future.

x:Bind can meet your binding
needs most of the time.
Let’s say around 80%

Tailored design
Build pages/code for individual families
Use MRT in App.xaml.cs to determine the family
One-handed interface?
Typically phone or small tablets
Test diagonal screen size (<7")
if (physical_diagonal_size <= 7)
// optimized for one-handed operation
rootFrame.Navigate(typeof(MainPage_OneHanded), e.Arguments);
else
rootFrame.Navigate(typeof(MainPage), e.Arguments);

Nothing is stopping you from
creating a multi-headed solution

Dedicated, targeted apps

Visual States
Define XAML views
Unique layout for distinct states
Simplify animation
Automatically implement state transitions
Build in Blend
Design and preview states and transitions

DEMO
Visual states /
Adaptive triggers /
Custom triggers

How Windows
makes design easier

Adaptive controls

Input intelligence

Three core adaptive approaches
Responsive design
Resize your content
Reflow your content
Adaptive design
Reposition your content
Redesign your content
Tailored design

Resize

Reflow

Reposition

Redesign

Don't assume you will use
only one technique.

Adaptive Code and API versions

Using Specific Versions of an API
Adaptive code techniques are not only for handling
device family-specific code
You write your app against a base UWP version, but 6
months later, UWP v.Next ships to users machines
Applies to Extension SDKs and Packages as well – new versions may offer new functionality
You want to keep supporting customers who haven’t
updated yet, but take advantage of up-level APIs for those
who have

Package Dependency
<Dependencies>
<PackageDependency
Name="Microsoft.WinJS 1.0"
Publisher="CN=Microsoft Corporation, O=Microsoft Corporation,
L=Redmond, S=Washington, C=US"
minVersion ="1.5.0.0" />
</Dependencies>

Gate use of up-level APIs
var contract = "Devices.Scanners.ScannerDeviceContract";
int majorVersionRequired = 3;
if (Windows.Foundation.Metadata.ApiInformation.
IsApiContractPresent(contract, majorVersionRequired ))
{
// Call the API that is present in V3 and above
...
}
else
{
// Your original code supporting users who haven’t upgraded yet
...
}

What about shared projects?
Shared Projects share code
at the code level, pre-
compilation
Share with Windows 8.1 projects, Xamarin projects,
anything…
Still completely supported
#if Compilation directives used to conditionally include
code by those projects referencing the Shared Project
1. WINDOWS_APP
2. WINDOWS_PHONE_APP
3. WINDOWS_UAP (new)

Use Adaptive Code in Shared too!
#if WINDOWS_PHONE_APP
// Processing for Windows Phone 8.1 only
+= this.Camera_Pressed;
#elif WINDOWS_UAP
// Processing for Windows UWP – Desktop AND Mobile
if (Windows.Foundation.Metadata.ApiInformation
.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons";))
{
// But this is only for UWP AND Mobile
+= this.Camera_Pressed;
}
#endif

Basic State
Plate
App Logo
Short Name
Plate
App Logo
Short Name
Semi-Live State
Plate
App Logo
Short Name
Badge
Plate
App Logo
Short Name
Badge
Live State
Plate
App Icon
Short Name
Badge
Content
Plate
Short Name
Badge
App Icon
Content
Tile anatomy

Updating tiles
Scheduled
Set template and time with “ScheduledTileNotification”
Periodic
Pull from URL 30m / 60m / 6h / 12h / 24h
Local
Update from (foreground/background) app
Push
Use push services
Update badge

Update tile badge
// build badge
var type = BadgeTemplateType.BadgeNumber;
var xml = BadgeUpdateManager.GetTemplateContent(type);
// update element
var elements = xml.GetElementsByTagName("badge");
var element = elements[0] as Windows.Data.Xml.Dom.XmlElement;
element.SetAttribute("value", "47");
// send to lock screen
var updator = BadgeUpdateManager.CreateBadgeUpdaterForApplication();
var notification = new BadgeNotification(xml);
updator.Update(notification);

Responsive tiles
Tiles are not
always the same size
Tiles adapt to
the screen they are on
Since the Start grid has different densities
and adapts to the screen size of your device,
so do our tiles and the content within them.
High density exampleLow density example

Legacy templates
If a template meets your
needs, go ahead and use it.
Previous templates remain
Phone and Windows templates have been merged
There are over 80 templates available

Create a secondary tile
var tileId = "DetailsTile";
var pinned = SecondaryTile.Exists(tileId);
if (!pinned)
{
var tile = new SecondaryTile(tileId)
{
DisplayName = "Record details",
Arguments = "123"
};
// extra details
var success = await tile.RequestCreateAsync();
}

Use secondary tiles
to deep-link into your app

Adaptive tiles
<tile>
<visual>
<binding template="TileMedium">
<group> <subgroup>
<text hint-style="subtitle">John Doe</text>
<text hint-style="subtle">Photos from our trip</text>
<text hint-style="subtle">Thought you might…</text>
</subgroup>
</group>
<group> <subgroup>
…
</subgroup>
</group>
</binding>
</visual>
</tile> Min. Med Size Max Med. Size

Adaptive tiles
<tile>
<visual>
<binding template="TileMedium">
<image source="Assetsimage.png" placement="background" />
<text hint-wrap="true">
Microsoft HoloLens: A
Sensational Vision of the PC’s Future
</text>
</binding>
</visual>
</tile>
Min. Med Size Max Med. Size

Sample: Small Tile
<binding template="TileSmall"
branding="none" hint-textStacking="center">
</binding>

Sample 1: Medium Tile
<binding template="TileMedium"
branding="Name" displayName="Hipstame">
<text hint-style="caption">
9:50 AM, Wednesday</text>
<text hint-style="captionsubtle" hint-wrap="true">
263 Grove St, San Francisco, CA 94102</text>
</binding>

Sample: Wide Tile
<binding template="TileWide" displayName="Hipstame">
<group>
<subgroup hint-weight="33">
<image placement="inline" src="http://image.jpg" />
</subgroup>
<subgroup>
<text hint-style="captionsubtle"
hint-wrap="true" hint-maxLines="3">
</subgroup>
</group>
</binding>

Sample: Large Tile
<binding template="TileLarge" displayName="Hipstame">
<group>
<subgroup hint-weight="33">
<image placement="inline" src="http://image.jpg" />
</subgroup>
<subgroup>
<text hint-style="captionsubtle"
hint-wrap="true" hint-maxLines="3">
</subgroup>
</group>
<image placement="inline" src="http://map.jpg"/>
</binding>

Adaptive
Templates

App Lifecycle we’ve had already with
Windows 8.1

The result:
Predictable behavior
on every Windows device

Application Lifetime
Running Suspended Running Suspended Not Running
Launched Suspended
(5 seconds)
Activated Suspended
(5 seconds)
Memory
Terminated
(no event)

Important note:
Desktop device-family apps suspend
when they are minimized

Handling suspension
public App()
{
this.InitializeComponent();
this.Suspending += (s, e) =>
{
// Save data
};
this.Resuming += (s, e) =>
{
// Load data
};
}

Navigation state
Frame.GetNavigationState()
Frame.SetNavigationState()
Recommended to use strings as parameters

OnNavigatedFrom
public override Task OnNavigatedFromAsync(IDictionary<string, object> state, bool suspending)
{
if (suspending)
{
state["FirstName"] = this.FirstName;
state["LastName"] = this.LastName;
state["Email"] = this.Email;
}
return Task.FromResult<object>(null);
}

OnNavigatedTo
public override void OnNavigatedTo(string parameter, NavigationMode mode,
IDictionary<string, object> state)
{
try
{
this.FirstName = state["FirstName"]?.ToString();
this.LastName = state["LastName"]?.ToString();
this.Email = state["Email"]?.ToString();
}
finally { state.Clear(); }
}

Extended execution
Requesting extended execution
There is no guarantee resources are available
Extended execution has no UI
Scenario “I have data this time”
Handle the Revoked event (1 second warning)
Scenario “I’m a special kind of app”
These apps run indefinitely
Special kinds of apps
1. Turn-by-turn (location tracking) app
2. Audio & VOIP application

There is a balance between load
speed & shutdown time

Extended execution (type 1)Memory
Running Extend
Suspended
(5 seconds)
Request
Revoked
(1 second)
Suspended
No UI
(short)
Suspended
(No event)

Requesting extension in suspend
private async void OnSuspending(object sender, SuspendingEventArgs args)
{
var deferral = args.SuspendingOperation.GetDeferral();
using (var session = new ExtendedExecutionSession{ Reason = ExtendedExecutionReason.SavingData })
{
session.Description = "Upload Data";
session.Revoked += (s, e) => { Log("Save incomplete"); };
try
{
if (await session.RequestExtensionAsync() == ExtendedExecutionResult.Denied)
// takes 3 seconds
UploadBasicData();
else
// takes 8 seconds
await UploadDataAsync(session);
Log("Save complete");
}
catch { Log("Save failed"); }
finally { deferral.Complete(); }
}
}

Extend the suspension
of a foreground app

Extended execution (type 2)Memory
Running Extend
Navigate
away
Special Request
(during runtime)
Revoked
(1 second)
Suspended
No UI
(long running)
Suspended
(No event)
Automatic
extension

Prevent the termination
of a foreground app

Requesting extension in app
private async void InvokeMyExtension()
{
if (this._session == null)
{
this._session = new ExtendedExecutionSession{ Reason = ExtendedExecutionReason.LocationTracking }
this._session.Description = “Driving directions";
if (await this._ session.RequestExtensionAsync() == ExtendedExecutionResult.Allowed)
{
// todo approved
}
else
{
// todo denied
}
}
}

Enum VALUES
[ContractVersion(typeof(UniversalApiContract), 65536)]
public enum ExtendedExecutionReason
{
Unspecified = 0,
LocationTracking = 1,
SavingData = 2
}
[ContractVersion(typeof(UniversalApiContract), 65536)]
public enum ExtendedExecutionResult
{
Allowed = 0,
Denied = 1
}

The global pool
supports burst events

Launcher.LaunchUriAsync(new Uri("sampleapp:?ID=aea6"));
Launcher.LaunchFileAsync(file);
App to App in Windows 8.1
URI/Protocol Activation
User/OS chooses target

App to App in Windows 8.1
Share Contract
DataTransferManager.ShowShareUI();
User chooses target

Enhanced App to App in Windows 10
Send file token, send data
Launch a *specific* app
App Services
Launch for Results

URI Activation++
Invoke a specific app
var options = new LauncherOptions();
options.TargetApplicationPackageFamilyName = "24919.InstapaperIt";
var launchUri = new Uri("instapaper:?AddUrl=http%3A%2F%2Fbing.com");
await Launcher.LaunchUriAsync(launchUri, options);

URI Activation++
Send Files
options.TargetApplicationPackageFamilyName = "24919.InstapaperIt";
var token = SharedStorageAccessManager.AddFile (gpxFile);
ValueSet inputData = new ValueSet();
inputData.Add("Token", token);
await Launcher.LaunchUriAsync(launchUri, options, inputData);

Query URI Support
Discover if app already installed to handle a Uri
var queryUri = new Uri("instapaper:");
await Launcher.QueryUriSupportAsync(queryUri, LaunchUriType.LaunchUri);
?
var queryUri = new Uri("instapaper:");
string packageFamilyName = "24919.InstapaperIt";
await Launcher.QueryUriSupportAsync(queryUri, LaunchUriType.LaunchUriForResults, packageFamilyName);

App Services
Client App A
Client App B Background Task
App with App Service

URI Activation for Device Settings
Category Settings page Mobile and/or Desktop Uri
System
Display (on desktop)
Screen (on mobile)
Both ms-settings://screenrotation
Notifications Both ms-settings://notifications
Storage Sense Both ms-settings://storagesense
Battery Saver Both ms-settings://batterysaver
Maps Both ms-settings://maps
Devices Bluetooth Both ms-settings://bluetooth
Network and Wi-fi
Wi-Fi Both ms-settings://network/wifi
Airplane mode Both ms-settings://network/airplanemode
Cellular Both ms-settings://network/cellular
Data Sense Both ms-settings://datasense
NFC Mobile only ms-settings://proximity
Proxy Desktop only ms-settings://network/proxy
More… [See documentation for complete list]

Launch for Results
Launching the app
options.TargetApplicationPackageFamilyName = "24919.Instap";
await Launcher.LaunchUriForResultsAsync(launchUri, options, data);
var resultData = new ValueSet();
resultData.Add("Result", value);
operation.ProtocolForResultsOperation.ReportCompleted(resultData);
App1 App2

With App Services, store
applications can provide services to
other store applications

What are App Services?
UWP offers many APIs that allow apps to interact with the
platform
• Windows.ApplicationModel.Contacts
• Windows.ApplicationModel.Email
• Windows.System.Launcher.LaunchUriAsync to launch settings, maps, store etc…
• more…
UWP also allows apps to interact with each other
• Uri Associations using LaunchUriAsync
• File associations using LaunchFileAsync
• Launch for results using LaunchUriForResultsAsync
• App Services

Think ‘Web Services on device’
Client App A
Client App B
Background Task
App with App Service

Scenario: Bar Code Scanning
Bar Code decoding
App Service
Image bytes in
ValueSet or FileToken
Decoded data

Scenario: Enterprise suite of apps
App Service
Maintains Inventory cache
Client App A
Client App B
Interact with
cloud services
App Service
Proximity Reading Services

AppServiceConnection connection = new AppServiceConnection();
connection.AppServiceName = "microsoftDX-appservicesdemo";
connection.PackageFamilyName = "24919ArunjeetSingh.InstapaperIt";
AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();
if (connectionStatus == AppServiceConnectionStatus.Success)
{
//Send data to the service
var message = new ValueSet();
message.Add("Command", "CalcSum");
message.Add("Value1", Int32.Parse(Value1.Text));
message.Add("Value2", Int32.Parse(Value2.Text));
//Send message and wait for response
AppServiceResponse response = await connection.SendMessageAsync(message);
if (response.Status == AppServiceResponseStatus.Success)
{
int sum = (int)response.Message["Result"];
new MessageDialog("Result=" + sum).ShowAsync();
}
}
else
{
//Drive the user to store to install the app that provides the app service
}
App Services – Client

namespace AppServicesDemoTask
{
public sealed class AppServiceTask : IBackgroundTask
{
private static BackgroundTaskDeferral _serviceDeferral;
public void Run(IBackgroundTaskInstance taskInstance)
{
// Associate a cancellation handler with the background task.
taskInstance.Canceled += TaskInstance_Canceled;
// Get the deferral object from the task instance
_serviceDeferral = taskInstance.GetDeferral();
var appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
if (appService.Name == "microsoftDX-appservicesdemo")
{
//Maybe ValidateCaller(appService.CallerPackageFamilyName) ??
appService.AppServiceConnection.RequestReceived += RequestReceived;
}
}
...
App Services – Service (1/2)

private async void RequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args)
{
var message = args.Request.Message;
// This service uses a Command keyed entry for the client to invoke services from the App Service
string command = message["Command"] as string;
switch (command)
{
case "DoIt": {
var messageDeferral = args.GetDeferral();
int value1 = (int)message["Value1"];
... Do some processing
//Set a result to return to the caller
var returnMessage = new ValueSet();
returnMessage.Add("Result", result);
var responseStatus = await args.Request.SendResponseAsync(returnMessage);
messageDeferral.Complete();
break;
}
case "Quit": {
//Service was asked to quit. Complete service deferral so platform can terminate
_serviceDeferral.Complete();
break;
}
App Services – Service (2/2)

Declaring App Service
<?xml version="1.0" encoding="utf-8"?>
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" ... >
<Applications>
<Application Id="App“
... >
<Extensions>
<uap:Extension Category="windows.appService“
EntryPoint="AppServicesDemoTask.AppServiceTask">
<uap:AppService Name="microsoftDX-appservicesdemo" />
</uap:Extension>
</Extensions>
</Application>
</Applications>
<Capabilities>
<Capability Name="internetClient" />
</Capabilities>
</Package>

Two-way Communication
Client and server can keep a two-way chatty
communication channel open
Client can attach a RequestReceived event handler to its own
AppServiceConnection instance
Both client and server can send and receive messages
AppServiceConnectionStatus connectionStatus = await connection.OpenAsync();
if (connectionStatus == AppServiceConnectionStatus.Success)
{
connection.RequestReceived += OnRequestReceived;
}

Summary
Windows 10 allows for REAL universal apps
Knowledge of WinRT is still very relevant

Let’s enjoy Windows 10
…and some BBQ!

Hello windows 10: An overview of the new features for developers in WIndows 10

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Hello windows 10: An overview of the new features for developers in WIndows 10

Similar to Hello windows 10: An overview of the new features for developers in WIndows 10 (20)

More from Visug

More from Visug (7)

Recently uploaded

Recently uploaded (20)

Hello windows 10: An overview of the new features for developers in WIndows 10

Editor's Notes