all right thank you guys forjoining us at this 12:30 slot, awesomely timed. but thank you for showing up, some of you guys brought lunch,that's good. my name is rajen kishna, i work at microsoft as a seniorproduct manager and with me i have. >> ken hilker, flexera software andalso senior product manager. and today we're gonna be talkingabout the desktop bridge, you might have known it asproject centennial sentinel before.
it's really this talk is a littlebit more deep dive into how do you bring your existingdesktop applications to the universal windows platform,using this technology. so, first of all, i like to doa little bit of a polling situation at the beginning, soapologies for that. but how many people have you seen at scott hanselman'sgeneral session, yesterday? okay, fair amount, not everyone, how many of you have done stuffwith the desktop bridge so far?
couple guys, okay perfect, soi think this is a good session for you then. the sort of goals ofthis session are for you to get a good end to end viewof what the desktop bridge means, what it can actually do foryou, how do you use it, and really focus on the differentstages that you can use it in. so we'll walk through those things. i want to set the scene a little bitin terms of what are we dealing with and why did microsoft sort ofinvest in this technology.
and why we did we actuallycome out with this? obviously, there's millionsof desktop solutions, you guys probably are in thedeveloping desktop solution within your enterprise or within your isv. and that is sort of the situation, where there's all this existinginvestment and you've heard us talk a lot about universal windowsplatform on windows 10. but there's a ton of stuff outthere currently that obviously, is very important and
in the case of line of businessapplications, critical sometimes. there are a couples of challenges interms of the user experience with desktop applications today. so one of things is and you probably have hit this eitheras a consumer or professionally, i hope not but finding the rightinstaller is often a challenge. you go to a website, you hope thatis actually the right website to get that product from, there's all thesedifferent websites that offer up the same installer for this piece ofsoftware that you're looking for.
and it's very hard for a consumer toreally get confidence in okay this is the right installer unless it'sdirectly linked off of your website. but if i would go to some otherwebsite that offer all these different applications,it's hard for me to judge whether or not that is good. so that kind of breaks the trustrelationship you guys wanna have with your users, in terms ofgetting them the right software that isn't infected with malware orspyware or those things. another big problem isobviously chain-installers,
getting how often you click next,next, finish. and then you end up with fivedifferent toolbars in your browser and all these different things on yourmachine that you didn't really want. that is sort of the challengenowadays as well, so that really impactsthat user experience. staying up-to-date isanother big challenge, you probably have faced this. if you've ever written an installer,you gotta write this auto update
mechanism, you gotta dothe patching, checking every day for updates, it's a verycomplex problem to solve. you have to take intoaccount a lot of things, which isn't really the core ofwhat you're trying to do, right. you're trying to develop this pieceof software to be helpful to users, to make them productive and there's all this infrastructurebehind it that you have to maintain. because you want to make sure thatthey are always on the latest and greatest version that theyget the bug fixes, etc., but
it's a hard thing to actually do. so for users, it's also annoying,i know that my wife, she never hits update on anything. so i always have to do it forher but it is good to get her updated andstay updated. and then lastly, obviously,we all write awesome software and it never gets uninstalled. but just in case, there is somesoftware that does get uninstalled, it almost never does that cleanly.
so if you take a piece of software,you hit install, it does some stuff onthe registry on the machine. you hit uninstall, that uninstaller then has a job to basically removeeverything out of the machine again. that never really happens 100%, sothere's always stuff left behind for users and they experience thatover time, their machine gets bogged down, they notice all thesethings happening to their machine. and they don't really know why,and this is one of the most common causes, there's all this residue ofold applications on that machine
that they wanna get rid of butthey can't really as a user. so from a different perspective,there's a couple of solution builder challenges and i try to comeup with a better word but, the us software developer,us distributors, etc. there's a couple of things inthere that actually are challenges from that end. one obviously i touched on itmaintaining installer technology, you guys have to writeall that stuff and maintain it doing updates etc andwe'll go into that.
the trustworthy distributionpart obviously it impacts users but it definitelyimpacts the people that are writing this software because they are,in fact, trying to get that software totheir users in a trustworthy way. providing auto-updates,we touched on that, again you have to buildall this infrastructure. monetization and licensing reallyis one of the things in terms of, how do you do that globally? think about, i mean,you offering your software up for
download if you're an isv, andthis obviously doesn't apply too much if you're runninginternal lov applications. if it does then good on you, but generally isvs they wanna sell theirsoftware, they go to their website, they have to build this paymentrelationship, they have to manage that, then they have a back end ofall this credit card data and all these things they need to secure,so that is really a tough problem. as well as licensing and making sure that those licenses areused well, in terms of piracy and
sort of people just copyingstuff all over the place. yeah they're reallyhard problems to solve. from a more technical side,dll hell, and i put it in quotes, i'm sure you all know what thatmeans, but, making sure that you're software on that machine isactually gonna work well and it doesn't conflict with any othersoftware that's on the machine. getting all thosepermutations right, it definitely takes a lot ofinvestment on the software development side to makesure that's all going well.
and then last thing, modernization. and you know for those of you thathave seen scott's session yesterday, he talked about all the differentways that we're trying to bring new features andnew things for you guys to offer. basically offer value to yourcustomers be it internal or external. that modernization,we needed something that you need to consider and maybe sometimesit is something you'll want to incorporate in your application butit's hard to do or
it's not on the exact platformthat you're writing it for. if you're writing a win formsapplication it doesn't necessarily get all the latest andgreatest features. but we know there's a lot of peoplethat buy this applications in rightfully so right. so, it was written a while ago,it was the right tool for the time, there's really no point. and scott said as well there'sno point in porting it just for the sake of porting it,you lose time and
then in the end you endup with the same thing. and that modernization step isreally what's holding a lot of people back from providingadditional value or effectiveness to their users. so i quickly just want to touch onthe universal windows platform and that's sort of the thing that you'veheard us at microsoft talk a lot about it. and i want to make sure that we'reright in the right context here. and it sort of touches a littlebit on some of those points that i
talked to you on the previous slide,like the modernization piece. there's all theseinnovation things going on, like windows hello, pen and ink. there's really cool stuff that youguys can use to make your solutions more secure, more effective. but it's hard to incorporate thatin this current ecosystem of your applications. it's good that we have that inthe universal windows platform but rewriting the application isn'tnecessarily always the problem or
always the solution. now obviously on top of that, youmight want to expand to all these other devices with your application. if you have an applicationexperience on pc today, you might wanna offer someexperience on phones or some experience on newdevices like hololens or surface hub within the enterprisethat are relevant. but you don't necessarily wannalose all that existing investment, you already did the work once,why would you have to do it all
over again just for the sake ofgoing to a different device? so with that context, i wannabriefly introduce you guys to the desktop bridge, we previouslyreferenced it as project centennial. from now on, you'll see desktop bridge assort of the way to reference it. the main reason is it got released, we don't wanna put it out there as aproject that is in beta or anything. this is something you can use today,you can use it, obviously, we're continuing to work on it, but thisis a technology that we are gonna be
supporting, and you guys canactually work on solutions with it. and the way this talk is structuredis really in two main segments and you'll see that sorta splitout across the demos and the talks as we go along. with that first portion we willbe focusing on deployment and distribution. a couple of those pointsthat we hit on earlier like the things that you needto do to make that easy. we're gonna go over how does atechnology help that and you'll see
the term modern deploymenttechnology a couple times. i'm gonna highlight thata little bit but that means but that's sort of the first step,right, making sure that you can use thatto alleviate some of those existing investments that you haveto do today, in terms of writing an installer maintainingthat auto updates, all those things. distribution, obviously, is another part and in some casesit make's more sense than others. but the windows store andthe windows store for
business are good mechanisms to getyour applications out there to many, many more users, and it takescare of a lot of other things. things like licensing,things like monetization. that is something that the store canhelp with from a both consumer side, as well as a business perspective. so we'll touch onthat in a little bit. and then, obviously, you've seenthe numbers in terms of how much reach we have with windows, sothat could be a compelling reason. and then the second portionreally is about the migration
of your solutions. so, really making sure that youcan take advantage of those new capabilities that we are bringing onwindows 10, and moving forward so you can actually go to otherdevices and new things. and that's sort of the waythat you get uwp apis and you get access to those thingsin your existing code solution. and you can actually graduallymigrate to that solution that goes across devices over time, instead of just having to rewriteyour application from day zero and
throwing away, basically,your old code. so diving a little bit into thedeployment and distribution part, the first step we'rereally gonna touch on is the conversion that we call it. it's a little bit ofan overloaded term, and i think ken is gonna go a littlebit more deeper into why that is, but it is really that step oftaking your existing installer or existing way of howyou do things and bringing that over to use thatmodern deployment technology.
things that you get, obviouslythe updates, the installation experience, and we'll show youa demo of how that actually looks. but after conversion, you are readyto distribute that application directly in the windows store, thewindows store for business as well. something that you can't really dowith desktop applications today until you do that, sort of,conversion first step. so modern deployment technology,i've touched on it a couple times, and it gives you this streamlineddeveloper experience. no more setup authoring,
you don't have to write all thesecomplex installers anymore. that is really something thatyou're gonna get with that deployment technology. now, obviously, this is allapplicable to windows 10, and especially to windows10 anniversary update. and i'm pretty sure not allof you are on windows 10, so this is definitely somethingthat you're gonna get over time. it's not a solution foryour problems tomorrow, but it's definitely something that youcan consider, and over time you can
adopt and, sort of, with yourwindows 10 user base, grow. and hopefully over time you canoffer that functionality to those windows 10 users. again, only trusted applicationsare able to install, so every one of thesethings is signed, you actually see up there,there's a publisher there. users can be sure that that thing issigned by you, as a developer, and you make sure that thatis a trusted installer. and it's optimized forupdates and downloads.
some of these thingsapply to the store, some of these things apply broader. but, for instance, if you distributeyour application to the store, the store will actuallyfetch the bits and pieces of your installer thatit needs for that specific case. so let's say your applicationsupports multiple languages, which in probably a lot of casesapplications do, the store will actually push down the languages andthe things that are required for that user in thatspecific moment in time.
it will not downloadthe whole thing and start the installation then,disregarding half of it you can actually just pushdown the bits that you need. in terms of update,it's the same thing. if just one dll changedin your update, and your entire application ishundreds of megabytes, it will actually push down that one dllchange, and not do an entire update that takes away a lot of bandwidth,and a lot of time to do that. so there's a couple of benefitsthere that also apply to side
loading, like the update mechanism,if you apply that patch, obviously it's not gonnajust download that bit. but that patching automaticallyhappens for you, so you don't have to take care of,how do i actually apply this update. from a user experience perspective, it also provides thisgreat user experience. so users can actuallyinstall applications, they no longer need in an elevation, they don't need administrator rightsto install these applications.
they don't get the user of accountcontrol prompt to click, yes, or enter their administratorinformation. this is really a thing thatis safe for users to do. and because of the way we set it up,and hopefully as the talk moves along, you'll see some ofthose bits and pieces. we wanna make sure that the usercan confidently install this application. if it's not right forthem, uninstall it, and nothing will be leftbehind on that machine.
and at lastly, obviously,it's ready for the enterprise. it uses the samepackaging format that universal windows platformapplications do, so it's .appx file. and this application package issupported by mdm solutions today, and you can do sideloading and all these things that youare used to in a business. you don't have to use our store ifyou don't want to or don't need to, so the package really gives you thatbenefit without you having to do all those public phasing thingsthat you might not want to do with
your line of business applications,for instance. and then jumping a little bit tothe sort of second piece of it, this is sort of an introductionof both of those things. once you are converted, and you are in this new world ofgetting that application package, that is really when you canstart moving forward and start modernizing and start addingthese things into your application. so that we split it up intosort of three phases of how you should approach this.
and the first phase isthe enhance phase we call it, and that is really adding uwp apisinto your existing code base. so you have your winforms application, and you wanna add push notifications,for instance, you can directly add thoseapis into your code without having to migrate over to a new appmodel or rewrite your code as is. and that's the first, kind of, less time consumingstep that you can then take. and the second phase,if my clicker works,
there you go, the second phaseis really this extension phase. that is when you add a uwpapp component, and again, we'll go over this in demos. but you add a uwp app component toyour package so you effectively have your existing winforms, or wpf,app and you have this uwp app, but because they are in the samepackage, they can actually communicate with one another,they can launch each other, etc. so they can work together while youhave a large piece of functionality still in your winforms application.
for instance, you can add a touchfriendly user interface, or an optimize your interface, you canstart using the new things that we're doing with pen and ink, whilestill having your functionality in the back end that youdidn't have to rewrite. and over time, that processcontinues in these two phases. and you move more and more codeover to the uwp app over time. and this is really that gradual path that we're enablingwith this technology. is that you can do this at yourown pace where it makes sense for
you, until at the end, obviously, you'll end up with this onlythe uwp app inside of that package. at which point,you can actually go forward and you can go to allthese other devices. up until that point,i do want to make that note, up until that point yourapplication runs still only on pcs, because it has thatdesktop component. now, once you gointo that extend and migrate phase,you may choose to split that out.
maybe on the phone you wannaoffer that uwp app experience because it has some functionalitythere that can be useful, but you cannot rely on thatdesktop component being there. that will only light upon pcs at that point. so that was a quick introduction. i'm actually gonna hand it overto ken to talk a little bit about the conversion deploymentdistribution part of it. >> [inaudible]>> i actually do, yes, sorry about that.
i'm not gonna hand it over yet. so, just quickly,like sort of visualizing what it is, we're gonna start withan existing desktop application. again, that can be anything,if you have an installer or no, if you don't have an installeryou can manually package it, it's an easy methodthat you can use. today, we're gonna do a demo withan actual installer and ken, obviously, is going to demo how youdo that with an install shield. and then, the immediate benefitsof converting that app,
like i mentioned,is all these things. and that's the step one weare gonna go through now. >> thank you. i'm kicking it. >> there it goes. >> thank you, and thank you forinviting us here today. it's been great working with you,the whole team, the developers out there. we've had a great relationship, and
it's been exciting to be a partof the solution and help. looking forward to bringing ourcustomers into this technology as well, so, start with that. but you're right, i do want to goafter the word conversion first. just to kind of bring that up,you mentioned that earlier. so when i think of the wordconversion i think of a, kind of, a one time process. i'm going from a to b,and that's the end. we look at
the way you build software asbeing a continuous process. many of you probably are ona continuous build cycle, you've got constant updates. you may have a daily build process,or even faster with many applications,and you're still going to besupporting multiple environments. you're out there with the windows10, the anniversary update, which is what we are focusingon here with this technology. we still need to supportyour applications,
either in your enterprise or customers on otheroperating systems. those were some of the challengesthat we were looking at and hearing from customers, some of thequestions that came up as the whole desktop bridge was being raised,that we wanted to go after it first. so one of the capabilities we'veadded to install shield in our latest release, is we'll starttesting your applications. all right, so you can take existingprojects, something you're all ready working on with installshieldtoday to build your installations.
and we'll look at that and compareit to see if it's gonna meet kind of the limitations and the capabilitiesthat come with the desktop bridge. and there's several differentscenarios we're looking at. the first column there is talkingabout if you're end goal is to get to a pure uwp app, we're going tolook at things a little different. well if we're primarily talkingtoday about the desktop bridge or even the store. cuz there's things thatthe desktop bridge can do, that uwp app package can do.
but there's policies toget into the windows store that may not match with those. so we do test those differently, look at the app from thosetwo different angles. we're not getting to it today, butthere's a related similar technology called windows server applicationsfor doing similar installations on theserver side and for windows nano. if you have questions about,that we can talk about that offline. all right.
so we're going through this helpingyou with some examples up here. we're looking at, let's seewhat i've got on the board. applications withmultiple shortcuts. again, if you're going into thestore, one of the store policies is one shortcut, one launchingentry point for the application. so if you had multipleshortcuts today in your msi, that would be a blocker toget into the window store. so we're looking for that kind of information orapplications that use com.
that's a current limitationin the desktop scenario. the app can internally use com, butit can't interface with external applications through a com ifyou're using the desktop bridge. so we're looking for that. we're proactively finding that, raising that to your attention soyou understand some of the limitations youmay run into in this. or you can start working withyour developers to address those limitations before you move forward.
so once we've done that, we'veaddressed any challenges you may have encountered, oryou may be green across the board. the next step is we wanna helpyou build that application. so, one project, build and design your installation once, wherewe're gonna get multiple outputs. we'll continue to build yourtraditional windows installer package, but we'll simultaneouslystart building the uwp app package in the .appx format. you get two outputs.
again, this is for that continuousbuild process cuz you still need to support this wide range of customersand multiple operating systems. so your app's gonna need to beout there in many different ways. with that you can thenuse that uwp app package. there's really twoscenarios there as well. you can use that to prepare forthe windows store and upload into the store, oryou can still continue. i can't even talk. continue to give that toyour customers directly.
same way you might hostan application today on your website as a download. you can do that withthe uwb app packages. so rather thandownloading a setup exe or install that msi, you can nowhave your application.appx that they can download, double clickto install on their devices. we're going to build all this foryou. now, some of the challenges,you brought up the concept of these bundles or suites so that thechained events, and yeah, sometimes
those do get abused for things likethe browser toolbars get asked to install antivirus tools we may ormay not want, you get that a lot. many developers do use thisintentionally to really help optimize the way theydesign their installations. so we talk about modular developmenta lot in the installation business. where if you have a component or arun time that's used across multiple applications, you may give it itsown installer and then bundle it or suite it together with each ofthe solutions that need it. so we see that this is a very commonpractice used by developers but as
brought up, that's really gonna be alimitation as you go into the store. you can only havea single file install. you can't have this bundleof different things that accomplishes yourlarger application. so we wanna help youflatten that out and we do that with twodifferent methods. the first one, just highlightingreal quick, is we've added an ability to merge multipleuwp app packages all into one. so whether you're building that uwpapp package with installshield,
with makeappx,with the desktop app converter, you can have all thesedifferent components, these different .appx files builtthrough any different tool. and at our build time we'll mergethose all together into one so that you're now compatible andfriendly to upload into the store. we've got thatlimitation of one appx. so you can still continue todevelop in a modular way, but build in a single file. the other way we'reapproaching that is
some people still wantthat bootstrapper. so the last slide,that's about getting into the store. here we're talking about,if you want to host it still, on your webpage. but you still havethat complex install. you still have that modulardevelopment you wanna use. install shield has a newer,a bootstrapper engine, we refer to as the suite engine. that you can bundle thesecomplex apps together.
so we can do that to bring inmultiple appx packages and compile them as a setup.exe. so you're still gonna havea setup.exe on your web page for customers to download. not in the store,setup.exes don't go in the store. on your web page, you can have thatsetup.exe single file download. and it can chain together allthe different components, runtimes, dependencies. pieces of your applicationthat you wanna bring together.
and we can do that also on demand. so it can be a stub file,just a small download for your customers initially. we'll look on their device,figure out they may already have the run time already installedor if it's a windows 7 device, then we'll download msi componentfor windows 10 anniversary update device,we'll download .appx components. so it's very dynamic,looks at the users device, downloads only what theyneed in the right formats.
so you can still buildthose custom boostrappers. and with that you can then regaincontrol of that user experience. when you double-clickthe .appx files, that's gonna be a standarduser experience. there's no option to customize lookand feel other than the logo and the product name. they're all gonna lookexactly the same. but if you want that, if you'remarketing team likes banners and display ads andinteract with the customers.
introduce the applicationduring installation, that's another opportunitywhere these bootstrappers, our suite engine canbe real powerful. so let me dive into a demoenvironment here, swap me over, i'm gonna wake this up. so i've got the latest version ofinstallshield here on the screen and it opens up here to thatvalidationless testing i was talking about earlier. in this case i'm greenacross the board for
the desktop platformswe were looking at. and this is the sameapplication that you're gonna see here in a minute from rashan's. the health clinic application. so we've tested it,we've looked for it. now, the reason some things areshowing up are the server scenario. nano in particular. nano doesn't have a desktop, so anything around using shortcutswon't work in that environment.
nano's also doesn't,part of keeping a small footprint, it doesnt supportthe wow 64 sub system. it's a pure 64-bit environment. so, when we see 32-bit files,we're going to flag that and bring it to your attention. so you're aware ofthat in that case. but really, in this case fordesktop use, we are totally green. and we've really made this simple. it's under the release settings.
where you define the wayinstallshield is gonna build your we can just say yes we wanna builda uwp app package and that's it. it's very simple. we can do more if we want to butat that point we are ready to build. so some things we can do,some extra steps in here would be, again if you were going afterthe server environment, we could enable thoseextensions here. you talked about some ofthe dependencies that if a store, if we wanted to get some thingsdynamically from the store, some.
let me give you an example there. so if you requirethe visual c runtimes, there's something called a frameworkpackage where we can download those straight fromthe windows store directly. so we can establish that, call thatout in the package manifest so it knows what it needs andwill grab it at install time. in that same concept,we talked about merging. if this is my primary appx package,my uwp app package but if i had others that iwanted to merge together,
i'd be able to browse for those andbring them in at this time. the one thing you also raisedearlier was the need to digitally sign installations. so in the windows installer world,you should. that's the best practice. we've always recommended it,but it's not required. once you go into uwp app packages, it is a requirement thateverything is digitally signed. so make sure you've brought that in,if you haven't yet.
you can do that here, throughinstallshield, we'll sign it for you as we build. or if you already have signingprocess built into your build engine, that's fine, too. as long as it gets signed beforeyou deliver to customers. so, from there,let's go ahead and build this. it runs real fast. and this is now building botha windows installer installation and a uwp app package.
we get both, one build process. you can do that here fromide like i'm doing, or we have a stand alone build engineyou can run on your build server and just tie it in toyour build process. so this will run as a partof your standard processes. all right, there we go, andit links me straight out there. to do this, the side-loading has tobe enabled on the end user device. and in the enterprise environment, that's something you can easilycontrol with a group policy.
so make sure that's been turned on. at that point,the application launches. this is that standardexperience i was describing, that all uwp app packages thatgo through this manual install, that will look exactly the same. what we see is that doesnot include a next button. you get the install button,that's it. so there's no custom of thatinstall, there's no banners or commercials or advertisements.
there's no custom actions in there. you can't turn features on or off. you get the whole thingall at once every time. you got that progress bar andthat is it. and it merely givesyou a launch button. so that app opens right up. and nice on this,let me open here on the menu. we can pin these tothe start screen. and then again,launch the application.
now, you talked also aboutthat clean user experience for the uninstall. and that's also beenmade very simple. no longer having to dig into thecontrol panel, find the application. the end users, they have thissoftware installed this way. you can simply right-click,uninstall the app and it instantly disappears,pulled out immediately. no external wizards,no dialogues, it's just gone. so nice and simple.
now let me close that. the other example we talked aboutwas the bootstrapper scenario, so let me switch there for a minute. and this is what we callthe install shield suite projects. and in here we can addmultiple packages. so i have added twodifferent app exes. i've got just a standard run time,then my app needed, and the health check. but you could add several otherthings in here if you call other
msis, it can call packages,it can call what do we have in here? if you're doing anythingwith server applications we can bring web deploy apps. we can call outrun powershell scripts, we can do dism commands to kindainstall windows roles and features. so, if it's, again, web app we can install iis as partof the bootstrapper as we've got a lot of power through this engineto really customize that experience. with those in place, let me get
that expanded back out,this one's pretty straight forward. i'm just gonna go ahead and run it. and now we're in the scenario whereyou're in control of the wizard where you can expose this, you can customize the look andfeel of the bootstrapper. and you can tie that into licenseagreements or whatever you want to display to your customer forthat more traditional experience. and it's doing the complexingsbehind the scenes. we're installingmultiple components,
it's doing things to the machine,it can run scripts, it can meet your complex applications, your complexneeds, if you need to go there. so all that's available. so just a quick recap we've talkedabout testing your applications, making sure they'recompatible with the needs. having that information up front soyou can interact with your developers,address that early in the process. we have looked at buildingboth of these simultaneously, have that msi for your windows 7,windows 8 user base.
having the uwp app package foryour window's 10 customers. and then a couple different ways of kind of flattening outyour installation. being able to handle thesecomplex modular apps. you can bring it all into a singleapp x to bring it into the store. or you can leverage these bootstrappers to handle like more complex installation if you'regoing to deliver straight to your customers through your website. with that, i'll turn it backover to you, i appreciate it.
>> all right, thank you, ken. a couple things i wantto highlight there is, you've seen sort ofthe initial experience. and it's great to have partners toflexera to have this experience. if you use installshield before, you can continue to use thatin your environment today. one of the cool things, i think, is in installsheild is that firstcompatibility sort of check. there are a couple things thatyou need to be aware of and
i'll show you where you canfind those things, but there are a couple things that you needto be aware of in terms of support. and this really makes ita developer focus technology. this is really a way where ifyou do the conversion step it is very likely that you will have tomake some small code changes to make sure that you fit in this new sortof run-time deployment model. now granted thosechanges won't be huge. but it's great to have tools thatwill actually go through those things and show you, okay, this issome of the stuff that you need
to address before moving forward. and diving a little bit intohow does that work, right. so in terms of the plural modelas mentioned it uses that modern deployment stack. it has extensions for things you want to call outnative windows functionality. let's say you wanna have a startuptask in your application, where every time the user logs on,you want some code to run. we have extensionsin that framework so
you can actually callthose things out. and windows willmanage that lifecycle. the cool thing about thoseis it is managed by windows. so you no longer have tocreate registry entries or all these fancy things on themachine to make sure that happens. windows will manage that atinstallation, it will register with windows, and at installation it willactually remove that registration. so again, it will leavea clean sort of machine there. and then, like i said, solvingthat dll hell and registry bloat.
there's a couple things that wedo in the deployment system, and that's sort of why you need to makesure that you are able to make some changes to the code if necessary. there is some redirectionof the file system and the registry going on to make surethat we can actually capture all those changes and keep it clean. taking the registry as an example, there's a registry.dat file thatgets deployed with your application. the desktop app converter,
or the other tooling that you'regoing to use to create that package. that is actually going tocapture all those changes you make to the registry,it's going to put that in the file. so as soon as your applicationtries to read from the registry, the file andthe actual registry get merged. so your application is none thewiser, like the registry is there, all the things that itexpects is there, but as soon as you start writing to theregistry it writes only to the file. so the actual registry onthe machine keeps clean.
if you uninstall the applicationthe registry file gets wiped and everything is clean on that machine. so there's a couplethings there that we do. app data i'm gonna show you shortly,that folder gets moved as well. but to your applicationit's transparent, you will actually getthe right folder location. and then obviously the same codeif you run this conversion step or the initial step of that process,that same code will continue to run. so if you're using things likeinstall showed, you can still output
that existing msi file and have thatnew windows 10 deployment mechanism all at the same time while servicingthe right users with the right tool. so at this point,once you have the conversion, you have that modern installation. you can actually be activating viatiles, like ken actually showed you. you can be activated via filetypes and uri protocols and things like you would expect forit to happen. uri protocols actually a new cool feature that you can thenuse in your application.
you can just have a url and haveit pop inside of your application instead of just a web url. and your applicationhas this app identity. so the package comeswith an app identity. an app identity youcan really view it as sort of a unique name of yourapplication, system-wide. >> [inaudible]>> what, [laugh]. i was confused there,someone else started talking. so the app identityreally gives you a way to
access all the differentuwp apis that exist. for example, if you wantto do push identifications, like i said earlier,you need that app identity. that api expects there to bean app identity for it to work. once you do the conversion process,you actually have that. so let me touch quicklyon distribution. and then we can sort of move intothe actual code demos on how this works in visual studio to moveyour application forward. and i wanna make sure that ihighlight the fact that obviously in
the store you can distributeyour application at this point. if you want to do this,obviously it's our job as microsoft, to make sure thatusers get the trusted, good experience inthe store all the time. technically any desktop applicationcan be converted over or moved over into thisapp package format. but not necessarily allthe applications or all the .exes that are outthere in the world. we want to be able to servethose to users in the store.
i'm sure you're gettingwhat i'm alluding at. so we do have a process for you to let us know if youwanna go to the store. we follow up with you, we make sure have a chat and we sortof move you through that process. so that is a link thatyou can actually, that you can actually follow. and again, you'll have this deck soyou'll have those links. whoops, quickly highlightinga couple things and making sure you
guys are, you know, aware ofthis stuff that we're doing. actually, a couple weeks ago, welaunched a first set of applications that are available in the store. so if you go to the windows storetoday, you will find things like this movie edit pro softwarefrom magix software. and this really is a rich fullfeature windows application. if magix were to decideto move this over to uwp, it will probably bea multiyear process. and i'm sure you havethose applications
in your organizations today. these huge applications that reallyfunction well and do the job. but you might want tosimply the distribution or you want to distribute itthrough the windows store for business this really givesyou that opportunity. again, evernote is another example,if my clicker will work evernote is another examplethat is in the store today. and their desktop applicationactually can be pulled down from the store.
it gives them that sort offlexibility in terms of installation. and it simplifies things for them. and they actuallyintegrated live tiles and pushing the notifications inthe application, as well. so, they did that sortof modernization step of their existing software. so, moving on to how doyou actually do that. so, at this pointwe have this thing.
we want to enhance itwith these uwp apis to have new functionalityin our application. and i'm gonna show you the healthclinic application, the wpf app. and i'm gonna show you how youactually add new apis into that. so let me switch over tothis cable really quick. all right, so i have this one. so this is the healthclinic solution and you may have seen it yesterday. scott showed you what it basicallylooks like, it's a solution that has
a portable class library witha core logic of the application. and then it has thisdesktop project, so one of the interesting thingsthat we did here is we added the functionality in hereto do push notifications. so if i scroll down, you willactually see that i'm calling the push notificationchannel manager. this is probably not an apiyou've seen in .net and winforms, because it doesn't exist in .net andwinforms. this is really one of the uwp apisthat you're able to bring in.
so the way that this works isyou actually add a reference, to sort of the uwp api surface. and i'll point you to thedocumentation where this actually is, it lives in program files,windows kits, etc, a long complex path. but you see that windows,that winmd file at the end, that is really the metadatafile that you can reference and start adding these uwp apis. there's modularversions of it as well,
if you just need smaller files,but this is generally the one that you want to sort ofadd those apis in there. as soon as you do,these things light up, and you can actually startcalling these apis. and because we're going to packagethat application up into this application packagethat has app identity, this api will actuallysuccessfully execute. you could definitely startadding that windows, winmd file to your existingdesktop project and try to run it.
with a lot of uwp apisthat works but the ones that require packageidentity or app identity, that you really need thatpackaging step to happen. another example that we have putin this solution is actually putting in life tiles. so if i go in here and scroll down a little bit,you will actually see then, once i load the data from the serverside, i get a list of appointments. you've seen that in an applicationjust a minute ago but i wanna
make sure that my next appointmentis always in the live tile. so if i glance on the live tileas sort of the person behind that application, i don't always haveto have that application open, get it refreshing, etc. i can use that live tile to feed menew information that's relevant to me at that time without havingto go into that application. and again,you see these examples and it's sort of this notion of allthe uwp apis that you could use. you can actually startadding them into here, so
building this applicationactually gives me a build output. and basically,two things need to happen in here, you will need to add,appxmanifest file. and that is, we need a manifestfile that's descriptive of what is this applicationpackage about? what is the executable namethat i need to launch, etc., so i open up that manifest file,you can see that i have a couple things in here, so againlike i said i have this identity, and this identity is unique.
so in this case, i actuallyregistered this application with the store, the store gave mea package identity that’s unique across the store, so i can dothings like push notifications. in here,i have the targetdevicefamily, which is windows.desktop,again like i mentioned, at this stage your applicationjust runs as it did before. so it's just gonna runon windows desktop and then i declare this capabilitycalled runfulltrust. and that is reallythe capability that we
require in this manifest tomake sure that the system knows you have this desktopapplication that's going to run. uwp apps in general they're wellisolated, they don't really get a lot of things that theycan do on the system but this is a desktop application likeyou're used to doing it today. we didn't wanna restrict thatexperience for you so you would have to do a lot of code changes tomake this work in the first place. but so this declares in the systemthat this is an application that requires all thesefunctionalities on the system.
and then in here, you can see thatthe executable name is set up to myhealth.client.desktop.exe, which is just a plain applicationthat was the wpf app. so actually running through this,you will see that i can i'll end up with an application packageif i were to package this project. and that is sort of this experience,you've seen that. but if you wanna do development,then you're actively working on this application, you needto make some changes. you don't really wanna do thatconversion, or that building step,
or that installationstep every time. so what you can actually do is youcan take the build output that you have here. so i have this debug folder andbecause it manifests this here and all the things that i need forthis application is here. i can actually go into powershelland load this up a little bit and execute this command,so add-appxpackage. i give it the registerflag which basically says, register the applicationwith this manifest.
so again,i'm not packaging it up anything, i don't have thisinstallation experience. i'm just registering thisapplication and once i execute that, it will actually registerthat app with windows. so right now, i registered the app, and i can find it here,which is healthclinic.biz. i can actually pin the tile,everything, launch it, it will launch. the cool thing now though is that,every time i build this application,
i make changes to it, it is stillregistered in that location. so i can just continuously build andexecute and run the app without having to do thatinstallation experience every time. this is really a developerproductivity thing that we have in the system. this works with anyuwp app by the way, if you've ever done universalwindows platform app development you don't have to build anddeploy every time. you could use this registrationto really register that folder
where everything resides. but as you can see here, i canactually see that the live tile has updated with the nextappointment that is there. and that is really thatcapability that gives me this access to all these newuwp apis that are in this system. all right, i'll close this up. so moving back to these slides, you've seen that sortof enhanced phase, how do i add uwp apis tothe existing code base.
you've seen i didn't reallyadd any new components, it was still my wpf app. just added new apis in there but what if you wanna takethat one step further? and this is really that sort ofextend phase that we talked about is, i wanna get more accessto these uwp api services. things that i obviously can'tdo in the previous step is anything ui related. if i wanna have a modernxaml touch friendly ui.
if i wanna use know the new bindingmechanisms as a developer that we have there or i wanna offer this really easyinking platform to my users. that's really not something i"mgonna get because it requires this application ui model that theuniversal windows platform offers. so for those specific cases,you can have this extend phase and basically package up a uwp app withyour existing desktop application. and you have this communicationflow that can go back and forth between them.
and you can see thatuwp app inside of it, that runs in the app container,as we call it. that is the thing i alluded topreviously is that it is restricted on what it can do on a machine. and if you wanna have access tothings like the photo library or the camera or the bluetooth devices you need toregister those capabilities with it. so users are aware of what thatapplication actually does but that runs in the appcontainer context.
it can call out tothe full trust process, sort of desktop process thatwe have in the same package. so again, the current code, itjust stays in the desktop process, the uwp app it goes intothe app container process, but they can activate one another. so if you do have your desktopprocess as the leading process in that case. and you wanna call intothe app container process, the uwp app portion of it,it can actually activate that thing.
other way around, same thing works,so if you have your uwp app and you wanna call the functionalitythat is in your desktop process, the activation cango that way as well. now there's a communication channel,it is using app services. if you've never heard about appservices it is a thing that we have in uwp, that is basically a communicationchannel between applications. so your app can register an appservice and then that app service then, silently is registeredon the machine by windows.
and it can be called by all thosedifferent applications, you can even expose these app services toother applications if you want. let's say, you have a loginscenario in your enterprise, you could create this app servicethat handles that functionality. and all these different applicationscould call into this one app service, so you don't have to rewrite thatfunctionality every time. in this case, how that worksis the app service is between in the app container process andthe desktop process.
so if you wannna pass somefunctionality to the desktop processing, okay, fetch me thisdata, or put this thing on the system you could pass thatmessage over to the desktop process, it will actually execute and run anddo all the things it needs to. and it can pass informationback saying, okay, this was successful or here'sthe data that you requested, so let's jump into a demo ofhow that actually looks. let me close this up, sohere i have a slightly different application andthat was the wrong button.
so in here,i have a different project, it has three,a different solution i mean, it has three projects inside of it,so it has a background task. this is one of the thingswhere you would need to do this sort of extensionbecause background tasks are something you candefine in the uwp app world. think, you know, every 15 minutes, i wanna execute this type offunctionality that sort of a thing. i have the desktop app, which isa simple desktop application, and
i'll walk you through a codein it in just a second. and i have the uwp app, that isactually the thing that is going to launch initially, so that is my mainentry point into the application. again, it doesn't have to be,it could be the other way around. in this case, my uwp app is leading,so to speak, and it can actually call intothe desktop application. so opening up the background task, i'm just gonna quickly show you whatit does is, this it the standard way of defining a background task inthe universal windows platform.
not gonna go through all these apisbut basically what it does is it has a function that says showtoast,so this can actually pop up a notification,a local notification, on a schedule. so this background task, i wouldregister it with the system and on a schedule it will give methese notifications saying, hey, your next appointment iscoming up or things like that. that is a local service that'sactually gonna run as a background task, then, if my mouse would work. all right, there we go, so
in the desktop application whatactually is happening in here. and as you can see if i zoom in, this thing is actually doingthings in the registry. obviously, this is not something, we don't have registry apis in theuniversal windows app platform, and for a good reason likei explained earlier. you wanna use the alternatives thatwe have, we have a way for you to do local application data, you canroam that data all over the place. there's alternatives that you canuse that don't really affect that
system in a permanent way. but in this case, i have thisexisting application that writes some things to the registry, andi wanna reuse that functionality. i'm not necessarily ready torewrite that functionality to use new apis or to do different things, but i do wanna modernize myuser interface in this case. so in this case,my desktop application, it just does creatingof a registry key, if it doesn't exist my app isa very simple application.
i can set my availability status inthis app so i can say i'm available or i'm busy and actually storesthat information into the registry. if you go doesn you willactually see here that i did register that app service. like i said this is a thing that isregistered in the application as a communication channel betweenmy ewp app and my desktop app. so this is the service registrationthat i do, i open the connection. this thing won't remainopen the entire time, so as soon as i make a callto that app service,
it will actually start up andit will actually. and i execute whateverfunctionality is gonna need to be executed as you can see it usesa thing called a value set. which is basically justa key value pair but this is a structure that is usedto pass messages back and forth. now, this is limited in termsof what it can pass along in one message. so you will have to chunk up data ifyou want to send more data over back and forth but this is ininstructure we are going to use.
in this case, i'm gonna add acurrent status as an initial status. i'm gonna add thatas a value set and pass that along tomy uwp application. again, my uwp applicationis a user interface. so, at launch, i want toknow what my status is, but that status is in the registry. so, i'm immediately askingthe desktop application, pull that information from the registry,return my current status so i can actually use itin the user interface.
and obviously, there's a method to close thatservice as well if i need to. now, moving intothe uwp app portion. going into the app.xaml.cs, which is the basic entrypoint of this application. you can see i also doregistration of the app service. again, here i have a methodthat says request received, so if i jump over to there. you will see i just fetched a thing,if it contains a key current status,
i fetched a current status, and i actually put that intothe user interface. and in the main page,what i do is, i have, let me show this animal first, so in the main page what this lookslike, get the design here a second. very simple page,i have a status drop down here, that just shows memy current status. i can change it, and sort of pass that message back tothe desktop application portion.
again, this is defaultexample that we have in here, nothing really fancy. there's a color animationhere to show you guys. cool animations,because who doesn't love animations? but then in the code is wherethe important stuff happens. first of all, i'm registeringthe background task remember i do have that background taskthat does the time trigger. so every 15 minutes i'm gonna get anotification saying what the current status is.
and then in here, if i skip overto that you will actually see that i am using this api tolaunch the fulltrustprocess. again, like i explained, the udopapp starts up, but i wanna get the status.so i wanna make surethat the fulltrustprocess launches. it can actually execute,it registers the app service. i send the message back andi get the data back. so this is an api you can use andyou need a, what we call extension sdk tothe universal window's platform. so if you go into references, addreference, and you go to universal
window's platform extensions,you will actually see that there's a number of extensionsdks here as well call them. so there's the desktop extensions. there's the iot extensions,the mobile extensions, etc. and these extensions reallyare the specific apis that we make available forthe specific devices. again, the universal windowsplatform it is universal. but on desktop, you may havea couple of apis that you don't have on mobile forinstance like this launcher.
same thing on iot, you will probably have a lot ofthings to interface with devices over dose buses, that don't reallyapply to any of these other devices. so make sure you are referencingthe desktop extensions if you want to runthis full launcher apn. and then lastly if i actually changethis selection in the combobox i am going to first ofall create a value set. that value set i'm gonna addthat value for status update. and if the connection actuallyexists on the machine i
am going to send that message. now, that message hasthe opportunity to immediately return a response. and that response is whati'm gonna use to, for instance in this case,set up a live tile. and that live tile will actuallyshow me the status as well. again, simple scenario, butyou kind of get the gist of how things flow back andforth between these applications. so again, executing this thing, iclick the build output that i have.
i register that with the system. so i do add-appxpackag -register. i put in this andthe appxmanifest, hit enter. it registers the applicationwith the system. i go down here where inow have my desktop app. step four, again, i don't have alive tile for this or a tile image. but i could put that in there. if i launch it, it will actuallycreate the registry key for me again, important to knowbecause this is now running
in the context of the app package. this is not writing tothe actual registry and writes to that data file. so i keep the system clean and i don't actually mess upanything in the registry. you see the fancy animation,by the way? no applause necessary. but so i can change thisto do not disturb and actually see that the live tile willupdate with that status in there.
and because this information isstored in the registry, next time i open the application, it will againask for that in the desktop process. get that back to uwpm. so this is sort of how that flow,back and forth, works with the app service. all right, sojumping back to the slides. so at this point you really havethe basic core components of how you would take this forward. and a lot of the next phases isjust gonna be iteration over this.
over time moving your codeto the uwp app portion. making sure you don'tcall those apis anymore, that you don't need to callin sort of a desktop world. in this case, you would move overthat api to use the local settings. apis et cetera. you can add moreapis if you want to. you can add in more app services,or background tasks, or triggers. there's some cool functionality thatwe have in the universal windows platform that is now all accessibleto you as an application.
because you can use that either,directly in your existing code, or in the uwp app portion of it, so youcan really benefit of both worlds. while you, obviously continuouslymigrate to your ui to xaml and to the universal windows platformif you do plan on exposing that functionalityon other devices. this clicker is funny. so like i said, migration over time,moving everything in there and you will end up with this stagewhere you would just have the uwp app insideof the app package.
so you could actuallydistribute that thing. so, getting started,i wanna highlight a couple things, because obviously,this has been pretty quickly and i have a lot of things thathave been pre- staged. i wanna make sure you guys havethe right information to get started on how to get startedon how to use this. so, first of all, obviously if you want to use installshield, if you're using it today. go to the website, you know,have the support for
outputting those uwppackages directly. if you want to get any informationabout the desktop bridge and you want to get started,you actually go to this page. again, i will havelinks in the deck and i'll point you to a placewhere i get more information. but this is sort of the landingpage where you will find all the new informationthat we have. there's a quick, a little over aminute video there if you wanna show other people,this is sort of the gist of it.
that's a quick video that you canshow, and if you scroll down, you will actually have some morein-depth information in here. i'll make sure that this talkactually comes on this site as well and there's a way foryou to provide feedback. either getting help on the forms orgiving us feedback about features that you need, things that aren'tin a product today necessarily, or things that you wouldlike to see in the future. you can actually give usfeedback on user voice, we're actively monitoring sortof what happens on user voice
to see how we can better serviceyou guys with this product. i wanna quickly show youthe page that you can use to let us know that you are readyto submit to the windows store. so if you do want to do that, this is sort of the pagethat you do that with. there's a quick form that we askyou to fill in to sort of highlight what your application is about and what you wanna do jumpinginto the documentation, there's a couple of interestingthings i want to call out.
so first of all, this is the maindocumentation page that you get. in here, you will have this, prepareyour desktop app for a conversion. and this is really, it sort ofcorresponds with the list that install shield has, thatthe checks they do automatically. but this the list where you reallyhave to monitor, okay, is my application in a good state rightnow to do the actual conversion. again, like i said, you will haveto make some changes necessary. in this case, first example, ifyour application targets a previous version of .net,you will have to up that to 4.6.1 to
make sure that you are compatiblewith using the desktop bridge. so there's a couple things in here,couple apis. obviously, things like you know, ifyou're using the hklm registry hive, the local machine, you canobviously totally use that it will just go into your file,your registry file. other applications don't havethat view to your registry file. so if you wanna make system widechanges, you can write to hklm, but no other applications isgoing to see those changes. so make sure you're awareof that fact and you,
sort of plan according tohow you would change that. so there's a couple of thingsin here that will guide you through that. actually moving forward, startinga conversion process, you will see here the different options thatyou would have to do that conversion process we have a tool calledthe desktop app converter. it is actually in the windows storeitself, so you can use that thing from the store toconvert your app to go to the store. it's very meta, but there's otheroptions to do that obviously.
so, if you want to domanual conversion, if you just have an application thatis a simple xe file with maybe some configuration files you might nothave this complex installer today. you're gonna actually doa manual packaging, and it's a very easy process. you create the manifest,you run a mac, makeappx command, and we'll actually,i'll put that package for you. and then, obviously, third partyinstallers, so again, install shield is one of the options, butwe do have other partners.
wicks by fire giant and events installer by they actuallysupport this today as well. so if you're usingany of these tools, you can continue to use that sort ofwork flow to go and move forward. two more things i wanna call out. the converted desktop appextensions, like i mentioned, there's a couple thingsin the sort of uwp app world that don't existnecessarily that you might want. one of the things is startup tasks,so if you want to,
like i mentioned, maybe you, everytime you run the application when the user logs on you puta icon in the system tray. we actually have an application inthe store right now that does that, ear trumpet. i'm not sure if you heard of it, it's a very cool volume monitoringtool for windows but it does but an icon in the systemtray every time i log on. you can use these extensions toreally get that functionality while its managed by windows, so ifi uninstall it, this things will no
longer exist, but nothing ismy registry, for instance. again, this is start up tasks,as one example. app execution alias is anothergood example, if you want to... go into the run window or in the cmd and you want to startyour application with some alias, this is actually a registrationthat you can do. previously, you would have toregister your path into the global path variable that's in window andall these complex things and the path variable wouldend up being this big.
that no longer is necessary, you can use this app extension tobasically declare that registration. so definitely checkout this site and these are things that obviouslynow apply to the desktop bridge. but over time, we're looking to bring these thingsto the universal windows platform, so more applicationscan actually use this. and then lastly, i wanna give you a quick sortof glimpse of what is to come.
if you are using vs15 in the previewversion, not 2015 15, great naming. if you're using, we'll see v nexttoday you can actually install an extension that will give youdebug experience out of the box with visual studio usingthe desktop bridge applications. right now, you've seen ihave to go into powershell, i have to register application. it gets registered with windows buti can't really hit f5 because i need to hit the tile toactivate the application. if i wanna debug,i can attach the debugger today, but
it's sort of this manual process. so what this visual studioextension actually does, is it gives you a projectto add to your solution so you can add this desktop to udwppackaging project solution. and if you just put that asthe startup project, it will launch the application package for you,and attach a debugger directly. so you can actually start debuggingright from visual studio, so look for that in the nextversion of visual studio and how that sort of works.
but that is a cool thing of how to,again, improve the developerworkflow there, all right. so in summary,the desktop bridge, again, you start with your existinginstaller or your files. what you do is youconcert that solution using the desktop app convertermanually or installer technology, you'd get this uwp app packagewith a manifest inside of it. from then on you test thefunctionality corresponds to what you expected so no changes or anychanges that you might need to make,
you actually catch up front. you can update that thing,you can distribute, and that is sort of the cyclethat you're then in. and then you can,from there on, extend and enhance that functionality withuniversal windows platform apis. to go to other devices as well. so next steps,these are couple links down there, make sure you let us knowif you are using this. like what do you think about it,i'll be here for a few minutes but
i'll be down at the boothas well in building b. and can sure he'll join meright after the session to sort of talk to you about the thingsthat we did, that we have there. there are couple related sessionsi wanna quickly call loud for it if you're interested in thiswhole sort of notion of bringing your applications tothe universal once that platform. i'm not gonna go throughthis entire list, but there are related sessionsthat we have here today. tomorrow there's somethings about the story,
if you're interested in that story. and on friday, we have some sessionson, you know deployment, kyle is actually gonna present there, on howyou distribute these applications. in an enterprise using eitherthe windows store for business or side loading, so if you're interested in thatstory definitely check that out. there's a couple of theater sessionsdown in the windows booth in building b. so those are 20 minute sessionswhere you can sort of quickly get up
to speed up of things. and again, like i said,you can come down to us or come down to the showcase, thatlittle box there is where we are. so it's in the developer area,it's not in the windows platform and devices area, so make sure youare aware of where that is. and if you actually hit this url,you can fill out a short form and we'll send you all the links withthe resources to all the things that we talked about as well. so you have one handy email with allthe information that is required.
>> over at booth 2250 as well,if you'd like to come out, we've got someconsultants out there. we've got some of our tech peoplethere who're happy to answer your questions as well, yep. >> and with that, i want tothank you for your attention. please fill out this eval, make sure that you let usknow how useful this was. if you want either one of ourcontact information, it's up here. but i wanna thank you foryour time and
enjoy the rest of the conference. >> [applause]>> thank you.
0 comments:
Post a Comment