Morning good to see you. I know it's early on a Friday I know Excel is not always the easiest place to get to so thank you for coming along I really do appreciate it's great to see you here if we didn't meet somewhere before my name is Mike Tolte

I work for Microsoft here in the UK. I have contact details on the slide for Twitter and email I'll put them up again at the end of the talk so if you want to copy those later on I'm great and What we're going to talk about here is I called this something like the essence of the Windows 10 Universal Windows platform, and that's what we're going to talk about here this morning

We're going to do that mostly by way of demonstration what we're going to do is build ourselves a little application We'll have a little bit of fun that plays with this remote control Sphero ball will control this over Bluetooth hopefully and Play with this I don't have a ton of slides for you today most of what we're going to do

I know it's the first session of the morning But most of what we're going to do is going to be in Visual Studio with code And that's how we're going to work on things I hope that's going to work for you And so let's start off exactly as we mean to go on by leaving PowerPoint and wandering over to Visual Studio So over on my other desktop. Let's run up Visual Studio. Let's drop into Visual Studio here

I'm using Enterprise Edition because I work at Microsoft and they give it to me so hey why not and you can do Everything I do here in the free community edition You don't need Enterprise Edition to do what I'm doing here today, and we'll start off by making a new project So I'm going to say file new project, and we're going to drop into a new

Just soon as the dialogue pops up. I'm going to write a C-Sharp Windows Universal Platform project I'm going to use the blank application template. What should we call this NDC Friday something like that? We'll call it NDC Friday and press okay. I should say oh, we've already been to NDC on a Friday

When was that NDC Friday again? Let's try that don't remember going to NDC on a Friday before While we're doing this I'm going to work in XAML and C-Sharp and .NET You could do what I'm doing in C++ and XAML you could do what I'm doing in HTML and JavaScript In all honesty my C++ is rusty these days

It's not what it used to be and in all honesty my JavaScript Was never very good, and so I'm going to work in .NET and C-Sharp I hope that doesn't offend anybody, and I don't think I'm going to do anything That's going to freak you out in any way. I don't think that's going to be an issue I wouldn't expect so anyway Let's just close down these windows that visual studio wants me to have open and let's pop to the solution explorer over here and

Let me just expand a few out things out over here, huh, let's zoom in just for a second If you've built any kind of XAML based application in the past who has built some kind of XAML based application That's what it's most of you So this is going to look very familiar to you straight away And what you get is you get an application here that starts off being made up of a class called app

App is created from XAML and C-Sharp and Essentially app is the class that represents the sort of lifetime of your application. It's where your application starts It's where your application creates windows. It's where your application is suspended by the system and so on and so forth

There's one for the whole app the whole running instance And it kind of deals with the lifetime of stuff one of the things it does is it creates your window? And it puts your main UI in it at least if you use this template and your main UI is Represented here by main page dot XAML again with some code behind in that file

The other thing we get here is a description of the application It's an XML file that we call a manifest it describes the application to the system it describes the application to the store if you put The application in the store we get a whole bunch of pictures in here And if you were building a real app you'd make lots more pictures, and then we get references We've got a reference to Microsoft dot net core dot net core is a modern refactored version of dot net we use it here in

Windows 10 we also use it in the new version of asp.net if you're not so familiar with dot net core versus dot net Framework I'd encourage you to go read one of those articles on the web about dot net core versus dot net framework It's quite a different thing and it's worth understanding the differences between the two

I'm not going to go off on an hour of why these two things are different here That's not my topic today The other thing that you get here is a reference to universal windows and prior to Windows 10 You would not have had that reference. This is the core of this talk This is the universal windows platform, and it's worth explaining what that is

So I'm going to pop back over to a picture for a second and just talk about that Where this comes from is that Windows 10 is running on more types of devices? Than we have ever run on with Windows before so sure You'll have seen windows in the past one of the windows 8-point something versions was running on phones and tablets and laptops

desktops all-in-ones convertibles all those things Windows 10 continues to do that it does it in a different way, but it continues to do that But we also run on whole new classes of device and from left to right from big to small and The surface hub devices if you haven't seen those things they are big

Collaboration devices we have two there's a 55 inch There's an 84 inch which is literally like basking in a glow of pixels. It's an amazing thing to stand in front of Ideally what they're about is for you And I to gather around a big screen and collaborate on something it might be something as simple as a Skype call It might be something like a 3d map of a power plant or something like that their collaboration devices

They have a ton of sensors in them. They have cameras. They have microphones. They have proximity They have a hundred points of touch so ten people with ten fingers can get around that screen make a big mess on it And they have pen they're very pen based devices from the point of view of what we talk about here today

They run Windows 10 So does the Xbox one the new Xbox experience if you've got Xbox one you'll know that this has been rolling out for I'm gonna say about eight weeks. Maybe ten weeks something like that Xbox one is picking up and running Windows 10 Our holographic computing platform, which is starting to ship in developer previews in the US and Canada unfortunately not the UK yet

Which is very sad and very sad about that Also runs Windows 10 the HoloLens runs Windows 10 too, and then coming down to the very small And our IOT or maker devices and the most common of those is the Raspberry Pi 2 But there are other devices there are Intel based devices like the minnow board

There's more arm based devices like the Qualcomm 410 C and they run Windows 10 too on those little devices It's fair to say that it's not exactly the same Windows 10 It doesn't make sense to pretend an IOT device is a phone or a phone is an Xbox that doesn't really make any sense

What these things are is they're built from a common set of underlying components So we build out a set of operating system components and where they would show up on two devices They'll be the same and then we build up from there as any good engineering practice would say that that's what you're supposed to do

What this allows us to do? Is put on top of these things the thing that we're talking about here today the universal Windows platform and what that is is The set of API's For an app developer now when we say app you might be thinking metro app or store app Whatever you want to call it for an app developer a modern app developer

The universal Windows platform is the set of API's that is available on all of those devices Basically if it runs Windows 10, it's got the universal Windows platform API's that's the basic rule There's a little bit of terminology that creeps in here We sometimes talk about grouping these API's into things that we call contracts

it's just a set of API's and we group those contracts into things that we call platform and The universal Windows platform and you can go into the SDK and you can see this It's a list of contracts and the contracts are a list of API's And that's all it is

Okay, let's drop back over to our em our code example So we said we're going to control this ball over Bluetooth So the first thing I need to do is make sure that this application can use Bluetooth So I'm going to go into my package manifest I'm going to make sure that this application can use Bluetooth So let's go to our capabilities here and let's say we want to use Bluetooth

So I'll just take that the other thing I've done is I've built a little library that helps me talk to this ball It's sitting on top of somebody else's library. Of course, that's how software gets built And but what I've done is I put it into a new get package So I'm just going to go to my references here add a reference to Let's just see local packages browse. There's only one in this store

This guy here is my little library for talking to the ball. So we're going to install that as well let's just let new get do whatever it is and you get does and Then what I want to do is start building a couple of user controls We will have one user control for when we are connecting to the ball We'll have one user control for when we are driving the ball. Should we ever get that far?

Let's see how we get on. So what I'm going to do is I'm just going to add into the project to user controls Let's add a new item into here. So add. Oh, no, no, no not show on code map That's not where we wanted to go. No, no, not right now. Thanks very much Let's go back to a solution Explorer and let's right mouse and let's add a new item in here And we will have a user control and I'm going to call this one connecting control and

Then as soon as visual studio comes back to I'm going to add another control Let's see how we get on add another control new item User control and we'll call this one driving control

So we've got a connecting control and driving control I'll warn you I'm working on one of these podiums where the mouse keeps sliding down So we'll have to be careful with the mouse And what I want to do with this is I want to go to my main UI now And I want to put those two controls into my main UI. So we're going to have a local Driving control will give it a name. Let's let my fingers wake up

Let's just make sure we get that nice and cased and then we'll have a local connecting control Okay, and so one is on top of the other I've done that quite deliberately the connecting control is at the front What I want to do with that connecting control is just build a little piece of UI on it

So let's go to the connecting control. Let's make sure that this grid has a nice background of white Let's put a stack panel on here. I'm going to put it in the center and Let's put an image in here. So we'll say image image Source equals we don't have this image yet, but I'm going to throw in MS. Apex

Assets, we'll call it connecting dot PNG I don't want it to stretch and then underneath we'll have a little piece of text Let's say font size is 18 so you can see it. Let's put the text in the center. Let's put it Oh, no, no, no Put it in the center again, and I'm not going to put the text in this

I'm going to put the text in a resources file. So we'll just have a name for this an ID We'll call it text connecting so I don't hard code the text and That means I need some resource file to pull that value from so let's add some resources into the project Let's right mouse over here. Let's add a new folder. We'll call it resources and then on my desktop

Somewhere over here. I Have some bits and pieces. I've got a resource file. Let's drag that into that resources folder I'm going to do that. I've got some images. Let's drag that into the Assets folder Let's go back to Visual Studio and ideally the designer would show me something. Let's have a look

Okay, so it shows a phone connecting. It should show the text the designer doesn't work properly with resource files And I don't know why I wish it did, but it doesn't it doesn't do that, but we've got that in there And I was a little bit sneaky though while we were dragging and dropping those resources you probably noticed

That you thought I was being a bit sneaky. I didn't just drop one file I dropped three and In those file names we had device family iot and device family mobile and in my pictures I had three and You can probably guess straight away what this nomenclature is for what this device family stuff means

But let's just talk briefly about device families because they're kind of important to to this story and Essentially we've got thousands and thousands of different types of devices running windows and to make sense of that we group them up into families So there absolutely is a set of devices that we call the iot device family

It's the three or four small boards that run windows 10 Minnow board raspberry pi qualcomm there's another board called a shark's cove as well that runs windows 10 So there's four devices in that family, and then we have a mobile family its phones and small tablets There's quite a few devices in there, and then of course the PC family is enormous

There's thousands of different kinds of PCs running windows 10 they live in their own family The Xbox he or she gets his or her own family The surface hubs two devices in one family and lastly the hololens well of course the hololens should have its own family It's a it's a very cool thing it deserves a family of its own The way that this works is that you have the universal windows api's across all of that

But that might not be enough There's things that you want to do on a phone that don't make sense on an Xbox There's things that you want to do on an iot device that don't make sense on a desktop so we also have for each device family an extension

Sdk a set of extension api's specific to that device family But the nice thing about this is that if you use those extension api's it does not stop your code running on other kinds of Devices, so if you use the mobile extensions you can still run on an Xbox you can still run on a PC You can still run on a hololens

The only thing you have to do is you have to make a runtime check to say hey Is it okay for me to use these api's is it okay on this device and the platform will return back? Yes, or no if it says yes use the api's if it says no don't use the api's or Alternatively use the api's and crash. It's your choice. That's kind of what will happen at that point

So it's kind of the best of both worlds really in terms of what we've got as universal Plus extensions, and I'll just make it very clear Over 95 percent of our whole api surface here is in the universal platform Most things are in there. It's only little bits that we add on for these different device types

So let's pop back over to visual studio and We just made a connecting screen and driving screen So the gentleman asks, and I'm I'll answer your question But then I'm going to push all other questions to the end if that's okay the gentleman asks is the default the PC

Family and the answer is no the default is the universal windows platform And you don't get any extension added by default you'd have to go and choose it and you'll see that as we go along here So let's go back to our main UI And what we're going to do is we're going to write a little bit of code So let me just format this code a little bit. I'm going to override my on

navigating to So that we can write some code in this page, and I've written a class. It's in that library. We brought in it's called Sphero ball Represents the little ball that we've got down on the chair. I'll move him as we go along I just need to make this method async And we're going to say ball equals await

I wrote another class which finds the ball for me, so we're going to locate the first ball Attached to this device. We're not going to give it days. We'll give it up to 10 seconds to find the ball I'm going to assume that this works. It's not always a great assumption, but we're going to go with it and see if it works We're trying to find the first ball, and if we find it we could say this dot

connecting control dot visibility equals Collapse so we take that away, and then I need to pass the ball over to the control That's going to drive it. So we'll say this dot driving control dot Set ball and we'll pass it the ball

Now of course that method doesn't exist, so let's just get visual studio to create that method Let's see if we can get visual studio to edit that method in line, and we'll just say okay let's have a member variable here, or maybe we'll have a Let's have a property and then we can say this dot ball no no no no this dot ball

Equals ball and we get rid of this Okay, great. Let's see if we can run this on the PC I'm going to wake up the ball. Let's see if we can wake up the ball You have to get the ball a bit of a tap It's early for him yet But let's let him sit there and let's run this on the local machine and see where we get to and see if we've

Broken things already see where we are We're building. We're deploying Ideally we'll get a UI that says we are connecting to that ball and then ideally we'll connect to it and then ideally that UI will disappear we get a security check to use Bluetooth and

Ideally that will connect to that and the UI will go away, and this is our driving control We've reached step one you notice. I said ideally a lot in there I'm not overly confident about some of these things, but there we go We got that working quite nicely so we need a UI to let us drive the ball

Let's go over to the driving control. Which is currently blank now If I was to be doing this for a couple of hours or a morning what I tend to do is build this UI Sort of with you that isn't what we're going to do this morning because it takes me about 22 24 minutes something like that Mostly during that time you're just watching me dragging and dropping and changing margins, and it's a bit boring

And we haven't got time for it, so there is a new feature and in Visual Studio. It's a really exciting new feature we call it intelli design and what you do is you just think of the UI that you want and Then you just type

Make simple UI and it just makes you whatever you are you were thinking of it's it's patented its genius And it just so happens that it only does it if your UI looks like this That's what you get so we've got a little control for rotating the ball we've got a control for setting its speed and a control for changing its color and

What we've got also in that XAML is we've got handlers That we need to write on red on green on blue on Speed changed and on rotation change, so let's jump to our code behind with f7 in Visual Studio and We need to write those handlers again event handlers are not very exciting, so let me just add in some stubs for those handlers

So I realize very quickly even a developer as stupid as me Realize that on red on green could be delegated down to one function called on color and so let's say this dot ball Set color red green blue blue not clue

And then when the rotate rotation changes we could say this dot ball I have a method called change heading and we'll give it the new value from the UI and On speed changed we can say this dot ball Go forwards The speed on the screen goes from 0 to 10 the speed in my library goes from 0 to 1

So we just got to divide it down a little bit So we'll say e dot new value divided by 10 Okay, so ideally if I didn't mess that up We would be able to get hold of the ball I don't know where I can put the ball so that you can actually see it I'm going to put it down here. This will be

This will cause me trouble later on but never mind So now the thing is you can perhaps see it I can't see it and so if we got the ball we might be able to make the ball go green blue Blue we might be able to rotate the ball And we might be able to make it go somewhere to in the wrong way

It's going over there Okay, so we can drive the ball that all works when I see feel free to stay at the front. That's good So that's all nice one of the things that this application doesn't do right now very well is if we resize this window in You'll notice that the way I've set up the margins and stuff is not very clever this control becomes Too small this control gets too big

So it would be nice if we did something a little bit adaptive here And we do have adaptive techniques built into the XAML platform I just want to show you a little piece of that What I would usually do again is I would drop into our design tool blend And I would create visual states in blend is what I would do and in fact that is what I did And I took the XAML and I'm just going to paste the XAML into our into our XAML here to speed things up

So if we go back to that driving control Let's just go to the top here, and I've got a little snippet. I called it vis and Essentially what this is doing is creating some visual states Here's a simple one landscape. Well. We're kind of already got that covered

So we don't do anything in that case, but I want to just flag to you that I'm using a thing called a trigger we ship some triggers I think we ship one actually in the in the box in the framework and Triggers are just when should I change to another visual state? That's all it is a trigger, and you can write your own. There's already a library out there on GitHub

I think with about 10 or 15 in it. They're really easy to write I Wrote one called an aspect ratio trigger, and that's the aspect ratio of the window not the device The aspect ratio of the window, so I'm saying hey if the window is landscape You're fine carry on that's okay, but I'm saying here if the window is portrait

Change the margin on the rotaty thing and on the slider and Make the rotaty things span across the whole width of the screen and move the slider into the bottom row and make the slide a Horizontal and so what that net effect is if we run this back up

It's that we've got a little bit of something slightly adaptive going on. Let's just see if we can run that back up So ideally as we slide this thing in That's interesting My mouse seems to have packed in let's have a look at this No, no, everything's just wearing into gear as we slide this back in it adapts a little bit

You know like we do on the modern web It's not nothing to rocket science II but if you're going to span from six inch screens to 84 inch screens obviously this needs quite A bit of thought this is not the simplest thing in the world, but it's doable and and something That's in the platform you get the idea this being a universal windows application though

We should be able to run it on other kinds of devices I've got a Windows phone here a mobile device running Windows 10 So we should be able to take this and run it on that phone, so let's stop debugging The phone is an arm based device, so just as soon as the debugger comes back to me Let's see if we can stop debugging let's switch that to be and sorry let's switch that to be an arm based device and

Pick up the phone and deploy that down to the phone so start running that on the device of course you can't see my phone, so I'm just going to run the project my phone app and Say yes, and then just bring that down a little bit, so you can see what's going on on that phone Let me just grab the phone for you

Why is it running here maps? Let's come out of that. I probably just broken my debug session Don't run here maps right now. I don't care Okay, I don't think we broke it because I don't think it's deployed it yet, so we run this on the phone Let's see how that goes Are we still deploying yes, we are okay?

You'll notice as we deployed to devices And if you've done this work before you'll know this the first deployment always takes longer than the subsequent deployments There's more stuff to push the device so again. It's asking for my permission. Yes, that's fine notice It says connecting phone over bluetooth those are the different resources

We built in earlier on and it says let's do this and we should be able to use the phone now to change the color to be green or Red and we should be able to drive It's a little bit easier actually to drive the thing with the phone so we may be able to rotate it round Do a bit of driving wrong way Do a bit of driving Trust me. I will let you know if the ball doesn't move because I'll go oh, no

The ball isn't moving and we can drive that thing with the phone So what we've written so far runs on every Windows 10 PC in the world it runs on every Windows 10 phone in The world, but it would also run on surface hubs and Xboxes and hollow lenses if I had one of those things I don't have any of those with me the surface hub at 84 inches is a challenge to bring through London's tube system

I got stuck somewhere around Victoria with it if you want to go and find it's on the escalator in Victoria not really So what I did bring was a Raspberry Pi because you can put one of those in your pocket And we got the Raspberry Pi to running Windows 10 iot core down there, so let's run this on a Raspberry Pi So let's stop debugging

Raspberry Pi is also an ARM based processor, so we can stick with that and let me make sure I can see my Raspberry Pi Because if we can't see it. We can't do anything with it. It's called min win PC Which is the default out of the box? Looks like he is there and so I can switch my debug target here from device to remote machine

And I can type in min win PC. Just let you see that so Min win PC. I'm going to use the universal debugging protocol Which is new in Visual Studio 2015 update 1 and we're going to use that to debug across there We're going to select before we start debugging on it and the Raspberry Pi with Windows 10

It's not like a desktop It's more like an appliance You don't log in and run Explorer and task manager and excel and command prompts and that kind of thing You can connect a mouse and keyboard and a screen you'll notice on my Raspberry Pi I've got a little 5 inch LCD here Don't worry about seeing the detail of what's on this screen from the back. It doesn't matter. You'll see you'll see enough

I've also got an Bluetooth on my Raspberry Pi I've got Wi-Fi on my Raspberry Pi and I've got a small breadboard With some switches on which we'll talk about in a little while But as I say you don't kind of log in and sit at it really and What you do is you talk to it primarily through three ways

Number one you can talk to it through a PowerShell interface you can remote PowerShell into the device number two You can talk to it through a web interface You can open up a browser and do stuff on the device and number three. You can write an app your app Set it as the default app for the device and when the device boots It will be running your app and then you do whatever you want to do on that device

So let's start debugging down to the Raspberry Pi. Let's click remote machine and I'm just going to try and bring up the web interface while we're doing that. So let's go to HTTP min-win PC 8080 and We'll log in and so essentially here what you can do from this web console is you can shut down the device

Restart the device see details of its name change its name change its password change the date and time You can see what apps are on this device. So here's all the apps on my device You can remove them from here. You can start them running from here

You can set them as the default the app that boots the device Onto that if you're really mean and nasty you can kill running apps from here if you want to do that That's something that you can do and you can install apps from here You then have a sort of cheap and cheerful version of process monitor or task manager on here

So you can see what's running you have a cheap and cheerful version of performance monitor or task manager on here And hopefully I would see down here. The Visual Studio is hopefully I might be doing it already I'd like to see some IO going on here as Visual Studio sends stuff over to that Raspberry Pi and maybe that's it starting right there

You can see the green stuff coming in You can debug on here So you can go if you want to and debug the operating system itself or a process You can set up two different kinds of tracing You've got a cheap and cheerful version of device manager on here to show you all the devices you've got installed Set up your Bluetooth devices and hopefully for me you will see here's our sphero that we're talking to and

Then you can set up networking and update the operating system itself while I was talking the application did start running down on this device So it's here. You can probably even see that from the back. It's gone white. It's not black and this is not a touchscreen

So what we've now built It's completely useless But it's here Now if we were to plug in a mouse and keyboard this will work No problem with that But I thought what we do on the Raspberry Pi is not drive this with a mouse and keyboard and I've got some Switches on this breadboard down here. So what we'll do is we'll program those switches to drive the ball from the Raspberry Pi

These switches are general-purpose IO switches GPIO switches I've connected mine on the breadboard to some pins on the device if I remember rightly pins Four five six thirteen and nineteen. I've got five switches on here. So let's go back to Visual Studio and stop debugging

And I wrote a class to represent a switch being switched on and switched off and I called it GPIO switch so if we go into our project and add a Class we'll call it GPIO switch and then I've got a snippet for this class

so we'll just get rid of this and we'll get rid of this and We'll say GPIO switch So What I want to show you about this class GPIO switch you give it the pin number of the switch and you give it a function to run when somebody switches that switch and

Then what it does is it gets hold of the GPIO controller? Excuse me, it opens that pin it waits for the value to change on that pin and If it thinks the switch is being switched on It calls that function. So when somebody switches that switch on call this function

You might notice this code doesn't compile. So if we build this Errors The reason is that these types are not in the universal Windows platform. They're in the extensions for iot So we need to use the extensions for the iot. It's the first time we've gone beyond the universal platform

We've been in the universal platform up until now. So we need to bring in those extensions now I said before you can't just use the extensions. You need to first ask And it's easy for me to miss this out in a demo. So we're going to ask if we can use this Let's go back to our code. And if you remember we were in the driving control. We had a function called set ball somewhere

There it is. So we're going to ask I've got a little snippet that helps me with this because it's a bit of a wordy piece of code Windows Do you have? the low-level devices contract if

So we can use those api's if not don't use those api's so we're going to say do you have these things if so? if so This dot do some iot stuff Okay, let's generate that function Otherwise don't do it and then what we can do is go to our references over here and add a reference to

Universal Windows extensions, let's just expand these things out a little bit Scroll down and you will see in here if I can zoom it for you desktop extensions like the gentleman was asking at the front iot extensions mobile extensions and Team extensions our surface hub extensions, so I want the iot extensions

Let me just bring those guys in and then if we go back over to our and Gpio switch code We should see visual studio starts to realize that I can now use these types if I'm on the right kind of device So what do we need to do? Well, I need some kind of map between my pins and my functions

So let's have that map. Let's go back over to our driving control in the constructor here I'm going to drop in a couple of dictionaries Bear with me while I create variables for these

So what is this? They're just dictionaries a dictionary from a pin number to a function So pin 4 makes the ball go forward pin 5 makes the ball stop Pin 6 makes the ball go red and so on and so forth I've also got another dictionary of names

strings to functions So it's pretty simple stuff. Let's go back to our function that was do some iot specific stuff and Let's say let's build a little list. Let's say this dot list equals this dot numbered

That's the dictionary let's select from there for each entry. We'll select a new Gpio switch With the pin number and the function And we'll just turn that into a list to force it to evaluate and we'll put this into a member variable

To keep it around where did that member variable just go? Okay, that's fine So we're creating those switch instances that means if we run this back on the raspberry pi is our balls still awake Yeah, the balls still awake. I Don't know whether the pie and the ball are near enough to talk, but we will find out in a minute Let's have a look

Mm-hmm just deploying back down to the raspberry pi I think we've deployed. I think we're starting to run

working over there Okay, so I don't know which of my switches are which but ideally if we change these switches on the device

We should get a green ball a blue ball a red ball one switch made it go I know one switch made it go and one switch made it stop So we're now running that from the raspberry pi and like that you're keeping me honest by checking there Yeah, is he actually doing what he says he's doing I've paid the people at the front there. They're going to keep quiet

I'm so yeah, so we're controlling that from the Raspberry Pi I've also got on this breadboard a little rotating switch that we could use to rotate the device as well to be honest It's just more GPIO work. So I'm not going to paste that code in and run that right now It occurred to me when I look at this that if you were to take this raspberry pi and this breadboard and these

Switches and you kind of miniaturized it down and you put some serious effort into industrial design You might make something a little bit like this Which is probably far better suited for controlling a ball like that now the universal Windows platform has Apis for gamepad, so I thought well

Why don't we plug those api's in and see how that looks so if we stop debugging here? And I'm going to take the code back to the PC because my gamepad is plugged into my PC Let's go back to x86 And let's just add a little bit of functionality somewhere down here at the bottom of this file again I've got a little snippet for this because it's a little bit of code Let's throw in some Xbox functionality and bear with me while I just fix this

namespace Okay So what are we doing here? Well we get hold of the first gamepad and we go into an asynchronous loop Reading the gamepad and we say if it's the B button

Which is red then go red if it's the a button then we go green the blue yellow If it's the left shoulder trigger put the light on the ball And so on if it's the left thumb stick make the ball go forward if the left thumb stick is rotating Make the ball rotate, and we've got a namespace problem down at the bottom of the file

So we need to just make sure we call this function from somewhere so when we've got the ball Let's just jump back to that set ball function Let's make sure we call This and let's try that out. Let's see if we can run that on the local machine. There's the ball. There's a local machine

Let's see how that works Yes, yes, that's fine, okay, so Okay, let's switch it on that's probably good idea switch the Xbox controller on

So and what should happen then if that's on is that if I press the red button we should go red Green should go green Blue should go blue yellow should go yellow, and we should be able to pick this up and Send it somewhere come here

over there It's actually easier to drive from this than anything else we tried so far. I think I can switch stop stop There we go I think I can switch the light off with this as well make it go black and put its own little light on where you Can see which way it's pointing with that and make it stop So that works quite nice to be derived from the Xbox controller

And when I first did this I sort of found that standing here and saying I can make this go red I can make it go blue Was quite an empowering thing and I thought well well Why don't we get rid of this and just talk to it? And we have speech api's in the universal Windows platform, so we could put that in there and speak to the thing

so let's stop debugging here and Let's just add in another little snippet of code so somewhere down at the bottom of this file is probably best Let me add in speech recognition Again, I'm going to fix a couple of namespaces here, so we'll fix the speech recognizer and the speech synthesizer And let me show you what we're doing

So what we do is we create a speech recognizer and a speech synthesizer Do you remember that dictionary? I showed you of names to functions we tell the speech recognizer It's constrained To only look for those keys in that dictionary you can tell it you can feed it a whole speech grammar if you want to

It's quite a capable thing, but we're just saying listen for these words We compile up those constraints, and then we say Recognize those forever When you get a result Tell me what it is if it's in my dictionary

Let's do it and Then we also say it So down here, this is a little bit of a hacky piece of code, so don't look too carefully at this But basically it's using the synthesizer to synthesize that text to a stream and play it back Now if you want to use speech you've got to ask for the permission to use the microphone, so let's just go to the

Manifest over here and say we want to use the microphone and let's remember to call the function that starts listening for speech because otherwise it won't work, so let me just jump back to where we set up the ball and Where is that function I? Tell you what I'm going to do, and it's not cheating Speech and Xbox controller start to fight with each other for the control of the ball

So I'm going to comment out the Xbox stuff because they fight Because if the Xbox says stop and speech says go It gets a bit tricky. You would need a UI for that, so let's say start listening for speech Async we switched on the microphone. Let's try that and I bring the ball back for a second

Security check because we're using the microphone So ideally we would be able to say red You see how well that worked

red green green blue It's luggage isn't it blue You get the idea we can talk to the ball and the other thing I did by the way

Put the ball down there for a second the other thing I did I sneaked in while you weren't looking probably When we made our UI originally I am through onto that UI Somewhere down here This guy I sneaked into the UI an ink canvas ink canvas is the way in which we connect collect low latency

Digital ink on the platform. It's not It's not like on some devices where you have a sort of dumb stylus just laying down pixels It's real digital ink with pressure and direction and we fit curves to it and all those kinds of things So there is one of these living in the UI

So what we could do is write a little bit of code behind there, so if we just jump back to our code again Let's have a look and where we start listening for speech We have an ink canvas It has an event in it called strokes collected We could say on strokes collected

We handle that event and So I have one of these so we can get rid of this and we can just say strokes collected No on strokes collected bear with me while I fix up namespaces as usual in dotnet code So what's this doing? Well, what it's doing is it's saying okay when you get some strokes from the pen and I'm doing this in a really

Simple way. It's not really smart. It makes a recognizer container It tells it to recognize all the ink from the canvas You get back a list of list of results, so I try and flatten that into one array and Then we say well if we get any results

Does that intersect with our commands if so? Execute the command and get rid of the ink So again, ideally if we run this back up if I pop the pen out of my surface pro 3 And the ink canvas is in a weird place here I deliberately put it at the back because it I don't want it to obscure other things so I can't write here

But I should be it right what? Shush shush It's turning the ball to the right. I can't say the word. I'm gonna Put on the screen, but we could set

I'll try and bring that back up for you You get the idea I've got to be really careful now

We built something. Thank you. We built something. That's too intelligent. It's smarter than me at this point make it stop It's smarter than me. It's taking over okay, so we built some stuff there I want to just kind of give you another flavor just quickly and We haven't just been refactoring and building extension platforms and universal

platforms and those kinds of things we've also been growing the platform So I haven't gone out and counted I don't really know But I'm told that we've created around about two and a half thousand new functional areas for the UWP over where we were with Windows 8.1 and Windows Phone 8.1 I'm going to just pick out one of these and see if we can get a demo of that before we finish up

And it's this technology called all join. I'm interested in this It's an interesting bit of technology you see it mentioned in the iot space and if you haven't seen it before It's not a Microsoft technology It's overseen by a group called the all seen alliance who are part of the Linux Foundation. It's open source thing

What it's about is putting devices onto a network and discovering them and using them You can think of things. It's specifically targeted. I think at the home. It's about the local subnet and You can think of it in the same world as sort of DLNA or UPnP one of those things And I know that there are already light bulbs that support all join

I know that LG. I think is building all join into its televisions. It's that kind of technology As there's actually quite a bit to it as well So it deals with security it deals with how a device first joins a network if you go and buy a device How does it join the network in your house or your office? We're not going to do that here

We're just going to play with it at a sort of basic level And so what I thought we could do is we've got our Raspberry Pi controlling our ball we could turn that into an all join service and Advertise it on the network and then anything that speaks all join can talk across that network and control the ball We turn it into Sphero as a service is the idea

So let's give that a go. Let's wander back over to visual studio Let me drop to my desktop for a second the way this starts is that? You define yourself an interface, so I'm just going to open this up with notepad for a second And you see I've made an interface called Sphero You can rotate the ball send it forward make it stop switch the light on change the color

So that's simple enough Visual studio has a tool around this and let me just close some windows. It's called the all join explorer It's not built in you have to go to the visual studio gallery And then what you can do is you can go and add or remove interfaces from here now

I warn you sometimes this dialogue hangs my visual studio We'll see what happens There is a way around it, but sometimes it really hangs my visual studio Let's see if we can make it spin up the question is always how long do you give something like this? Let's just give it

Give it a few seconds I don't like to be too mean to it and say it's hung my machine if it's just thinking But I don't know what it's thinking about There's not much going on here, so What do you think do you think it's you think it's going to come back? Or do you think we've hung visual studio? No? Okay, and What I normally find is if I leave the network which is dangerous during a demonstration of a network technology and

it suddenly springs into life usually I Should say that the product team has seen this I've chatted to some developers about this They know this is going on and let's just see if we can do that And then I start to get the point where I think should I kill visual studio

Let's see let's see let's see aha okay So let's go and find that XML file. Which should be just there and get this tool to understand it Okay, great. Let's see if we can get ourselves back on the network that we were on

Okay, yeah Hopefully that worked and what that does that tools a bit freaky I'm just going to start building some code while we talk about it because it takes a couple of seconds to build so I'm Just going to put two arm, and we'll just build What that tool does is it takes that interface and it generates you a whole visual studio project With some C++ code in it most of this is boilerplate. It's kind of boring code. It's all generated straight from the interface

It gives you some custom win RT Types that you could reference from JavaScript dotnet or C++ To represent your interface if I show you what some of those look like let's have a look at

Where is it I? Sphero service dot H. So this is generated code. You'll see exactly what's gone on rotate forwards stop switch and Each function gets a generated return type which means you're going to generate quite a lot of code Which is why you end up with so much code over here, and you'll also notice here. There's a class called sphero producer

What this does is You give it one of those sphero services and it advertises it on the network for you That's going to be the primary thing we're going to use from here though the interface and that class So let's take a look at it. I think we probably compiled yeah, that's cool

So what I want to do is package that away and add a reference to it from my project So let's go to my project. Let's add a reference It's cool, and then we can use those types, so we need to implement I Sphero service, so let's add a class into our project Add a class and we'll call this sphero service

and We need to implement I Sphero service To be honest and this then is involving programming with some win RT types if you've looked at win RT You'll know that it has to be compatible with the type system of JavaScript dotnet and C++

So you can't have things like dotnet tasks because that doesn't make sense in JavaScript And it gets a bit annoying to have to work with it as a dotnet developer But there's extension methods that help you so I've made an implementation of this already It's not complicated and if we just make a constructor for this class that takes the sphero ball. Let's say sphero ball

Ball and let's put that into a member variable Just keep it I'm just going to throw in an implementation Sphero service and you'll notice that all it is is a Function that tells the ball to switch the light on to change the color to change the heading you've seen this stuff before really

We just need to make sure that an instance of this is advertised on the network So what we're going to do is go back to our driving control find our set ball function Which we've done quite a lot of work in in the past and we'll say this dot advertise Generate that function and very quickly. I'm just going to add an all join bus attachment

we'll call that time bus and Did we get that namespace and one of those generated types of spirit sphero producer? Namespaces

No, I know you're thinking it should be uppercase. I don't think it is What did I screw up a sphero producer com dot Talty dot sphero dot sphero producer

Is it me? Okay, we'll go with that don't know why and so we'll just say this dot bus is create a new one of those and then we'll say this dot producer create a new one of those give it the bus and Then we just give it the service that it's advertising which is our sphero service

wrapped around the ball and Then we'll say this dot producer Dot start the last thing we just need to remember. Oh firstly. We've got an uppercase ball Let's just do that last thing We need to remember is that if you want to use all join you've got to ask to use all join So we need to go to our manifest file over here, and we can say I want to use on the capabilities tab I

Want to use all join So let's just tick That okay, and let's see if we can deploy this back down to the Raspberry Pi Let's see how that goes and we're getting close to the end of the session So it kind of needs to work because we haven't got a whoa. What the heck is that?

What did we do we can screw something up someone we I Sphero service did Visual Studio generate me some type or something what have we done? Where's that coming from? No, it actually is lowercase. You'll see it's there in the interface. Just right right there. What is this?

That's okay okay, I Async operation has not got yes, you're right somebody said namespace missing you're absolutely right, but I'm looking at the wrong namespace Let's try that

Whoa tense let's see if we can compile this oh It's too much for me at this time in the morning Let's see we can build we may be able to deploy let's see down to the remote machine. Thank you for the assistance Oh come on. You can't find the device now really

We did leave the network didn't we? Was that a wise move? I don't think so Do you remember when I said this may not be the best idea I? Was right Let's see still got six minutes in the session. We might be able to get there. I've only got another 40 topics to cover We can see the pie

We may be able to deploy to the pie We may not It's doing something. It's better than doing nothing So there's a tool on github called, and I don't know if this is going to work based on what we just did with all Networks it's called the all join explorer it sniffs all join networks

So ideally if that pie runs that app and it advertises itself It should show up in this tool bear in mind this tool knows nothing about Spheros and and what we've written And what may or may not deploy to the device? Tell you what while it's doing that let me just talk about some of things

We'll come back to it if we in a second. It's deploying I'll finish the rest of the talk while that deploys So quickly what and what do you do with these things if? You've built one and you want to get it out there well There's three two things you can really do and you can side load the application onto machines And if you've looked at side loading in the past it was a massive world of pain. We've taken that away

It's now easy to side load these apps onto devices or you can put stuff into the store And if you want to put stuff into the store first off you need to register And we've made it so there is only one place that you need to go to So if you're a PC developer, an Xbox developer, a mobile developer, a PC developer, it's dev.windows.com

You register once you can if you want to submit one package For all devices or you can submit different packages for different devices It's up to you, but it's one place to do all of that work and where this stuff ends up is in one store so across desktop piece sorry desktop mobile and

Over time Xbox and hololens and surface hub will all be reaching into one store There's not a store for a phone and a store for an Xbox and all of that stuff that you might have seen in the past The other thing I'll just flag quickly while is that deploying what looks like it did cool And is we're also in the process of opening up the windows store for business

What is this about well fundamentally it allows an organization not just a business an organization? To set up their own area of the windows store Even if you don't allow your employees to go to the public windows store they can still go to your enterprise store It allows you to buy at volume

applications for your Organization and push them out to your employees or members and you can control the licensing so if you bought a hundred licenses for an application Your employees can't run 101 102 105 and also if you're a vendor It allows you to sell at volume your application into enterprises and have the windows store enforce that

Licensing it's not fully opened and just yet, but it's opening up at the moment at the moment it only supports free applications In coming weeks and months that'll change to support paid for applications as well I think this is a really really important thing I think it's a really cool thing that allows me to build something and sell it to some enterprise

Without ever going in the public store. I think it's quite a cool thing Let's go back. Let's see what's going on because it looks like we had some progress oh great No, you know how we had two devices here a couple of seconds ago now. We've got none Okay, well no let's try again. Let's not give up never give up

Okay, there's one Where's mine? One last try one last try Resto now you tell me Spin it up. We got just a couple of oh, it's showing up. It's showing up. It's showing up. Maybe even the balls gone to sleep

Put the ball back what? Is that running down there no I'm not convinced. What's going on I? Don't think this is going to be my My lucky day on this last demo

One last time one last time with feeling one last time go on you can do this You know it's there you can do this you talk to you you talk to where's the ball do you? deploy succeeded debug Started come on. What are you doing?

Uh-huh, yeah, you run that we're into the dying seconds. It's so tense. I can barely take it This is yeah, this is yeah, okay, so maybe it will have found our service. It's a bit risky this really, but let's try

Four interfaces we wrote one of them Sphero change the color Let's go for red. Let's go for no green. We don't like that pesky green Let's go for blue might go purple might not Hey look at that purple so essentially. Thank you

So essentially we've built sphero as a service We have that now if you come with an all join client on iOS or Android you could talk to that thing across A local network you could then take that and plug it into the cloud And I have another demo where we'll extend this to azure and control it from somebody's front room on the other side of the world

But you get the idea and I'm bang out of time. I just want to say that if you want more I'm around on the stand the Microsoft stand all day if you want to come and talk about Windows 10 come and chat I'd love to talk to you And I put my contact details back on one second if you want to catch me after the event for stuff relating to Windows

Developer dev.windows.com if you want to join our insider program for Windows Windows is rolling on and on and on with new Releases coming to insiders every day go to insider.windows.com Here's my contact details again, and just the last thing I'll just say and I work in a team here in the UK of what we call developer evangelists

And the chap that runs that team is at the back of the room over there Andrew if you want to give us a wave Andrews hiring at the moment so if anyone's interested in a job and might like to come up here and break various demos in front of People and have a chat to Andrew. He'll be around on our stand later in the day as well. Thank you very much Thank you for coming Hope you enjoyed it and come and chat on the stand

Catch me afterwards on mail or Twitter or whatever you want to do and enjoy the rest of your time at NDC Thank you very much