Pro Windows 8 Development with HTML5 and JavaScript
- Createanappthatisdynamic,adaptive,andresponsive
- Effectivelyusetheextensiveasynchronousprogrammingsupportthatruns
- Adaptyourapplayouttothecapabilitiesandconfigurationofthedevice
- Prepareanappandgothroughtheprocessforpublishingitonthe youcanbuildonyourexistingknowledgeofJavaScript,HTML,andCSStocreate
For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
and Contents at a Glance links to access them.
Contents at a Glance
About the Author ..............................................................................................................xxiv
n
n
n
n
n
About the Technical Reviewers .........................................................................................xxv
Part I
Getting Started .............................................................................................................1
Chapter 3: Y n
n
n
n
n
n Acknowledgments ............................................................................................................
Chapter 2: Getting Started ..................................................................................................11
Chapter 4: Completing the App ...........................................................................................53 Part II
Core Development ....................................................................................................79
Chapter 5: The Single-Page Model .....................................................................................81
Chapter 6: Creating an Adaptive Layout ...........................................................................107
Chapter 7: Commands & Navigation .................................................................................135
n
Chapter 8: View Models & Data Binding ...........................................................................161
n
Chapter 9: Using Promises ................................................................................................193 Part III
n
UI Development ......................................................................................................229
n
Chapter 10: Creating the UI Controls Example Framework .............................................231
n
Chapter 11: Using the ToggleSwitch, Rating and Tooltip Controls ..................................259
n
Chapter 12: Using the Time/Date Pickers & Flyouts ........................................................281
n
Chapter 13: Using Menus & Dialogs .................................................................................303
n
Chapter 14: Using the FlipView Control ............................................................................325
n
Chapter 15: Using the ListView Control ............................................................................351
Chapter 16: Using Semantic Zoom ...................................................................................381
Chapter 17: Using Pointers & Gestures .............................................................................405
n
n
n
Chapter 18: Using Animations & Utilities .........................................................................437 Part IV
n
Platform Integration ..............................................................................................467
Chapter 19: Understanding the App Lifecycle ..................................................................
n
n
n CONTENTS AT A GLANCE n
Chapter 29: Working with Sensors ...................................................................................
Part V n
Index ..................................................................................................................................
Chapter 33: Publishing to the Windows Store ..................................................................
n
Chapter 32: Selling Upgrades ...........................................................................................
n
Chapter 31: Windows Store Integration ...........................................................................
n
Chapter 30: Creating an App to Publish ...........................................................................
nn
Chapter 28: Using Toast and the System Launcher .........................................................
n
Chapter 20: Working with Settings & App Data ...............................................................
n
Chapter 27: Working with App Tiles .................................................................................
n
Chapter 26: The AutoPlay, Protocol Activation and Print Contracts ................................
n
Chapter 25: The Sharing Contract ....................................................................................
n
Chapter 24: The File Activation & Picker Contracts ........................................................
n
Chapter 23: Integrating File Services ...............................................................................
n
Chapter 22: Working with Files .........................................................................................
n
Chapter 21: The Search Contract ......................................................................................
nSelling Apps ............................................................................................................801
P a r t 1
n n n
Getting Started
I begin this book by setting the scene for the content and style, putting Windows 8 development in context and showing you how easily you can build on existing knowledge of web app development to create a simple Windows 8 app. n n n
Putting Windows 8 in Context
Windows 8 represents Microsoft’s desire to break out of the traditional desktop computing market and make an impact in the mobile world, which has been dominated by Android devices and, of course, Apple products.
Microsoft’s plan is to offer the user consistency across devices, allowing the same apps to operate on the user’s data irrespective of which device, or which kind of device, the user has at hand. This is attractive to many users and it leverages Microsoft’s greatest asset—the leading position in the desktop computing market—to drive sales, acceptance, and credibility in the tablet and smart-phone markets.
The traditional Windows desktop isn’t a good model for consistency across different types of devices, and attempts to add touch support and rework the interface for smaller screens have not ended well. Trying to extend the old Windows model to small devices is part of the reason Microsoft’s previous forays into the mobile world have fared so badly.
And that’s where Windows apps come in. Rather than perpetuate its existing application model, Microsoft has decided to create a new one. Windows Store applications, more commonly known as apps, are available on every device that can run Windows 8 and its derivatives (Windows Phone 8, Windows RT, etc.). More important, Windows apps run as well on large-screen desktop machines with a mouse and keyboard as they do on a moderately sized touch-screen tablet. Windows Store apps are a big departure from regular Windows desktop apps: they fill the screen, don’t have title bars and buttons, and have a completely different look and feel.
Another big departure for Microsoft is that you can use web technologies to create apps, which is the reason I have written this book and, most likely, the reason you are reading it. By embracing HTML, CSS, and JavaScript, Microsoft has embraced a completely new community of developers, who can take their knowledge of web app development and apply it to Windows app development.
Note Microsoft uses the term Windows Store App, which I find awkward and I can’t bring myself to use it n throughout this book. Instead, I’ll refer to Windows apps and, often, just plain apps. I’ll leave you to mentally insert the official Microsoft names as you see fit.
Putting App Development in Context
Windows apps are at the heart of Microsoft’s effort to present a consistent user experience across a range of different device types, including traditional desktop PCs, tablets, and smart phones. Windows apps offer n PUTTING WINDOWS 8 IN CONTEXT
fast and fluid user interactions, support touch and keyboard/mouse input, and integrate tightly into Microsoft’s cloud services, allowing users to replicate their data everywhere they work and on every device they use.
Apps are very different from traditional Windows desktop applications. Windows 8 apps fill the screen by default, are chromeless (which means there is no surrounding window, title bar, or buttons), and can’t be resized or overlapped the way desktop apps can. Users don’t close apps and there are no Close or Exit buttons. Only one app is displayed at a time, so there is no need for windows or title bars.
Key dialogs that require input from the user, such as file pickers, are also full screen and are like mini- apps in their own right. In fact, they look and feel a lot like apps you might see on an iPhone, iPad, or Android device—which is, of course, no accident. With Windows 8, Microsoft aims to gain some of the lucrative smart-phone and tablet market and hopes to leverage its dominance in the desktop world by making apps available across a wide range of platforms, including regular PCs.
Apps benefit from a range of integration services, known as contracts, which make it easy to create apps that are tightly integrated into the Windows platform and can share data with other apps. If you have just installed Windows 8 and have been wondering what some of the icons on Charm Bar are for, then wonder no more. Apps use contracts to provide services to the user through the Charm Bar. It may seem like an awkward tool when you are new to Windows, but it becomes second nature pretty quickly.
Developing Windows Apps with JavaScript and HTML
One of the biggest departures for Microsoft with Windows 8 has been making JavaScript and HTML first- class citizens for app development. This is a big deal for two reasons: the first is that Microsoft has invested heavily in the .NET platform over the years and has been reluctant to open up Windows development for tools and languages that are not part of the .NET family, such as C#. That has changed completely with Windows 8.
The second reason is that Microsoft has stuck to the standards. The JavaScript and HTML that you have used to write web apps is the same JavaScript and HTML that you use to write Windows apps. There are still new libraries and techniques to learn—hence this book—but if you have developed a web app, then you already have a big chunk of the knowledge and experience you will need for app development. I demonstrate this in Chapter 3, where I show you how to create your first app using little more than regular JavaScript and HTML. This web-driven theme runs deep: apps written in JavaScript/HTML are executed using Internet Explorer 10 (although this isn’t evident to the user, who won’t be able to tell which technology family you have used to create your app). You don’t get to change which browser is used to execute your app, but after a while, you won’t really want to—IE10 turns out to be pretty good and has some good support for the new HTML5 and CSS3 features. (There are some Microsoft-specific extensions, but they occur when the W3C standard is still being developed or where the feature is very app-specific.)
Developing Apps with Visual Studio
Unlike with regular web development, you can’t choose your own development tools when writing apps using JavaScript and HTML: you must use Visual Studio 2012, which is the same tool required for development targeting any Microsoft platform. So, the bad news is that you have to learn a new development environment, but the good news is that Visual Studio is excellent and Microsoft has taken the time to make the JavaScript and HTML support as good as any of the tools and editors I use for regular web development. I have to admit, though, that I already had a soft spot for Visual Studio from my time writing C# apps and services, and you may find that the learning curve is steep as you grapple with a new set of tools and a new kind of application development. This isn’t a book about Visual Studio, but in Chapter 2 I give you a quick tour of the essential features to help get you started. n PUTTING WINDOWS 8 IN CONTEXT Publishing Windows Apps
Most Windows apps are sold through the Windows Store. The exception is apps written for the enterprise, which can be installed like traditional desktop apps (although this is available only in the Windows 8 versions targeted at corporations). The Windows Store is much like any other app store—users can search for apps, see rankings of successful apps, and get updates for their apps. And, like any other app store, the Windows Store operates by taking a cut from your app sales. I’ll explain how you use the Windows Store as a developer in Part IV of this book, but it will be helpful if you bear in mind that publishing via the Windows Store is the ultimate goal of app development.
What Is in This Book?
In this book, I show you how to use your knowledge of web app technologies and techniques and apply them to create rich, fluid, and dynamic Windows apps. I start by showing you these web technologies can be used to create a simple app using the same approach that you would encounter in regular web app deployment and then show you the different techniques, libraries, and features available to take advantage of Windows 8 and the app environment.
Who Is This Book For?
You are an experienced web developer who already knows the basics of JavaScript, HTML, and CSS and who wants to develop apps for Windows 8. You want to build on your web experience to create apps that go beyond the browser and take advantage of the Windows platform features in a way that regular web apps can’t offer.
What Do I Need to Know Before I Read This Book?
You need to know how to write a simple web app, using HTML, CSS, and JavaScript. You need to understand HTML elements and attributes, CSS styles, and JavaScript concepts such as functions and events. You don’t have to be an expert in any of these technologies, but you do need some experience. I don’t provide an introduction to web development in this book, and you will struggle to follow the examples if you are new to the world of web technologies.
Windows app development uses HTML5 and CSS3, but it isn’t critical if you are up to speed with the latest drafts of the HTML5 specifications. The new features in HTML5 and CSS3 are largely evolutionary, and a good understanding of HTML4 will give you enough of a foundation to figure out what you don’t know.
Tip The HTML5-related features I use most often in this book are actually the new CSS3 layout features, which n make it easy to create fluid interfaces. You can use the new elements and APIs, but for the most part you don’t need to, and some key features are exposed more conveniently through the app-specific APIs.
What If I Don’t Have That Experience?
You may still get some benefit from this book, but you will find it very hard going and you’ll have to figure out a lot of the basic techniques required for app development on your own. I have written a couple of n PUTTING WINDOWS 8 IN CONTEXT
other books you might find useful. If you are new to HTML, read The Definitive Guide to HTML5. This explains everything you need to create regular web content and basic web apps. I explain how to use HTML markup and CSS3 (including the new HTML5 elements) and how to use the DOM API and the HTML5 APIs (including a JavaScript primer if you are new to the language). If you want to learn more about practical web app development, then read Pro jQuery. jQuery is a very popular JavaScript library that simplifies web app development. I don’t use jQuery in this book, but you will improve your understanding of all aspects of web development by learning how to use jQuery effectively (and since you can use jQuery for Windows app development, the time you spend will stand you in good stead later). For more advanced topics, read Pro JavaScript for Web Apps, in which I describe the development tricks and techniques I use in my own web development projects. All three of these books are published by Apress.
What Don’t I Need to Know?
You don’t need to have any experience in Windows desktop development or other Microsoft technologies (such as C#, XAML, or the .NET framework). Developing apps with web technologies builds on what you already use for web app development, and while there is a lot to learn, you don’t have to worry about other programming languages or markups.
But Don’t I Have to Know C# for the Advanced Features? No, honestly. Microsoft has done a pretty good job of putting JavaScript on a par with C# and the other
NET languages and making HTML a good alternative to XAML (which is the way user interfaces are defined in most .NET apps). When you get deep into app development, you will become aware that you are using libraries of JavaScript objects that are shared with the .NET languages. This is evident only because some of the object and property names are a bit odd—in all other respects you won’t even know that other languages are supported.
I have been writing Windows apps in both HTML/JavaScript and XAML/C# for a while and I have yet to find any feature available to .NET programmers that is unavailable to web technology programmers. HTML and JavaScript are first-class technologies in the world of app development.
What Tools and Technologies Do I Need?
You need two things for app development: a PC running Windows 8 and Visual Studio 2012. If you get serious about app development, you’ll need to buy a copy of Windows 8, but if you are just curious, you can get a 90-day trial from Microsoft—I’ll explain how later in Chapter 2.
Visual Studio 2012 is Microsoft’s development environment. The good news is that Microsoft makes a basic version of Visual Studio, available free of charge, and that’s the version I’ll be using throughout this book. It has the catchy name of Visual Studio 2012 Express for Windows 8 and I’ll tell you how to get it later in this chapter.
Paid versions of Visual Studio are available, and you can use any of the different Visual Studio editions with this book. Microsoft tends to charge for features such as enterprise integration, version control, and test management, and while they are all useful features, none of them are essential for app development and I don’t rely on them in any way. n PUTTING WINDOWS 8 IN CONTEXT
What Is the Structure of This Book?
In this chapter, I introduce you to Visual Studio and show you how to create a simple project. I give you a quick tour of the key parts of the Visual Studio interface, explain what each of the files in a Windows app development project looks like, and show you how to run and test an app using the app simulator tool, which is included with Visual Studio.
In Chapter 3, I show you how to build your first app. I focus on using basic HTML, CSS, and JavaScript features to demonstrate how much of your existing web app development knowledge can be applied directly to Windows app development. You’ll be pleasantly surprised by just how much you can do. Of course, you didn’t buy a Pro-level book for the basics, and most of the rest of the book shows you the different techniques and features that transform a basic app into one that provides a first-class app experience. In the sections that follow, I briefly describe what you will learn in the other parts of the book.
Part II: Core Development There are some core features that almost all apps benefit from using. In this part of the book, I explain
these fundamentals techniques, showing you how to let the user navigate through your app’s content, how to adapt your app layout to the capabilities and configuration of the device it is running on, and how to make best use of the extensive asynchronous programming support that runs through pretty much all of the Windows app development libraries. By the time you finish this part of the book, you’ll know how to create an app that is dynamic, adaptive, and responsive.
Part III: UI Development You can create the UI for a app, known as the layout, using the standard HTML elements, such as button
and input, but you also have access to the WinJS UI library, which contains the interface controls that give Windows apps their distinctive look and feel. In this part of the book, I take you on a tour of the controls, explain when they should be used and how they are applied to regular HTML elements, and give you many, many examples so you can see them in operation. By the time you have finished this part of the book, you will know how to apply the distinctive Windows look and feel to create pretty, pretty apps.
Part IV: Platform Integration Once you have your application structure and layout in place, you can start to integrate your app into the
features and services that Windows provides. This includes making your app part of the file and data search process, working with the file system, telling Windows that your app supports different types of file and protocol, printing, and sharing data between apps. I cover all of these topics in this part of the book and also show you how to create different kinds of notifications for your apps, including low-key live tiles and more intrusive toast notifications. By the time you finish this part of the book, you will know how to make your app a first-class Windows citizen that is fully integrated into the wider platform and your user’s workflow.
Part V: Selling Apps In the final part of this book, I show you how to prepare an app and go through the process for publishing
it in the Windows Store. By the end of this part of the book, you will have seen the complete life of a Windows app, from an initial basic implementation through to advanced features and, finally, its release to the world. n PUTTING WINDOWS 8 IN CONTEXT Are There Lots of Examples in This Book?
There are loads of examples in this book and I demonstrate every key feature you’ll need to create first-rate apps. In some cases, I go back and combine different features to show you how they work together, the benefits of these combinations, and on occasion, the problems that can arise. There are so many examples in this book that I had trouble fitting all of the code into the chapters. To help fit everything in, I list JavaScript code and HTML markup in two ways. The first time I introduce a new file, I show you the complete contents. You can see an example of this in Listing 1-1, which is code taken from Chapter 6.
Listing 1-1. A complete listing of a new file
(function () { "use strict"; WinJS.Namespace.define("ViewModel.State", { appBarElement: null, navBarContainerElement: null, navBarControlElement: null }); WinJS.Namespace.define("ViewModel.UserData", { }); })();
When I make a change to a file, I tend to show only the part that is being changed, similar to Listing 1-2. The code in bold shows the changes I have made that are relevant to the technique or feature I am demonstrating.
Listing 1-2. A partial listing of a modified file ...
WinJS.Namespace.define("ViewModel.UserData", {
word: null, wordLength: { get: function() { return this.word ? this.word.length : null; }
} }); ...
What If I Want to Follow the Examples Myself?
You can download the complete code for every example in this book from Apress.com. The code is organized by chapter and each project shows the completed state of each app, so you can see what the finished result looks like and follow along if you wish. You can use the code in your own projects or create new apps using the examples as templates. n
Image Attribution
I use a number of image files in the examples throughout this book. Thanks go to the following people for kind permission to use their photographs: Horia Varlan, David Short, Geishaboy500, Tanaka Juuyoh, Mervi Eskelinen, Fancy Speed Queen, Alan “craigie3000” Craigie, notsogood, and melalouise. n n n
Getting Started
Before you can start developing an app, you need to get Windows 8 and the development tools up and running.
In this chapter, I’ll take you through the process of getting set up with the right software and take you through the process of creating a Visual Studio project for a Windows 8 app, giving you a tour of the files it contains and the tools that Visual Studio provides to work with then.
Getting Set Up
You don’t need an especially high-end PC for app development—anything that meets the minimum Windows 8 spec will do. As ever in development, a faster machine makes development a little more pleasant, but you don’t need anything overwhelmingly powerful.
Tip If you are buying a PC for Windows 8 app development, I suggest spending most of your money on getting n the biggest screen you can find. No screen is too big when it comes to writing apps—the sweet spot for me is to be able to edit a JavaScript file, an HTML file, and a CSS file side by side and still have enough room for the rest of the Visual Studio interface (which I’ll show you shortly). Your next priority should be memory. The least important component is the CPU: today’s CPUs are all supremely capable, and even the cheaper models are more than able to cope with Visual Studio for app development.
You can get a free 90-day trial of Windows 8 if you want to see what app development is like before committing yourself. You can get the Windows 8 evaluation copy here: evalcenter. You’ll find what you need by clicking on the Release link in the Windows and Platform Development section.
You are required to create a Microsoft account to get the evaluation, but you’ll need one of those anyway to get set up as a developer. Microsoft accounts are free to create and there are instructions to follow if you don’t already have an account. n GETTING STARTED Tip Microsoft offers some pretty good discounts if you are upgrading from an earlier version of Windows. You n may also be able to get a cheap copy if you are a student or if you work for a company that has a deal with
Microsoft. Very few people need to pay full retail price for Windows, and it is always worth asking around to see if
you are covered by one of Microsoft’s myriad schemes.Getting Visual Studio Ready
You will also need a copy of Visual Studio 2012. As I mentioned in the previous chapter, Microsoft makes an edition of Visual Studio completely free. It doesn’t have all of the testing and integration features that some of the paid-for versions contain, but you don’t need those to create apps. In all other respects, the free version of Visual Studio is fully featured and does everything you will need. Don’t worry if you have a different version of Visual Studio 2012. You won’t need all the features in your edition, but all the instructions and examples in this book will work without any problems or modification.
You can download the Visual Studio installer from products/express. There are several different flavors available, each of which can be used to develop a specific kind of application. For app development, you will need Visual Studio Express 2012 for Windows 8.
The names of the flavors are confusingly similar, so be sure to download the right one.
Install Visual Studio as you would any other app. Although the software is free to use, you will need to activate it, which requires the Microsoft account you created earlier. After you have gone through the process, you’ll end up with an activation code for Visual Studio. You will also need a developer license, which is free as well. When you first start Visual Studio 2012, you will be prompted to obtain a license—it takes only a second and, once again, it requires the Microsoft account you created earlier.
Optional Equipment
A Windows 8 PC and Visual Studio are all you need to write apps, but some app features are more readily understood if you have a device with orientation sensors. As you’ll learn in Part 2 of this book, responding to the way the user has oriented the device is an important Windows 8 feature, and while you can simulate the effect using Visual Studio, there is no substitute for a real device. Equally, a device with a touch screen will let you develop and test touch-screen interactions—another key app feature. This is something else you can simulate, but simulation is no substitute for the real thing.
Tip I use a Dell Latitude Duo, which is an odd hybrid between a tablet and a laptop. You can pick them up
n cheaply secondhand, and they have a decent touch screen and an orientation sensor (although the driver for this hasto be hunted down from the sensor manufacturer, rather than from Dell). I wouldn’t suggest coding on the Duo,
which is a little too slow for comfort and lacks RAM, but it makes a pretty decent test machine and I wouldn’t be
without it.Getting Started
Once you have installed Windows 8 and Visual Studio, you are ready to start. In this section, I’ll show you how to create a Visual Studio project for an app and give you a quick tour of the tools and features you will use. If you have used another integrated development tool, you will recognize many of the key Visual Studio features. n GETTING STARTED Creating the Visual Studio Project
New Project link on the Visual Studio Start page To create a new app project, you can either click on the New Project from the File menu.
(which is displayed when you first start Visual Studio 2012) or select
Note Actually, it is the FILE menu, because Microsoft has decided to display the menus in Visual Studio in n capital letters, even though this gives the impression that your development tool is shouting at you. I will just refer to the menus in regular case.
New Project dialog windows, as shown in Figure 2-1. Visual Studio includes templates You will see the to get you started on different kinds of projects, and these are displayed on the left side of the dialog. The set of available templates differs based on the Visual Studio edition you are using. The figure shows the templates available for Visual Studio Express 2012 for Windows, which supports four programming languages for creating apps. For each language there are templates that are prepopulated to some extent, for creating different projects.
Figure 2-1. The Visual Studio New Project dialog window
I understand why Microsoft includes these templates, but they are pretty useless. It can be a bit alarming for new programmers to be faced with an empty project and a blinking cursor, but the code they put into these templates isn’t very good and is rarely the kind of thing you will want for anything but the simplest and most trivial projects. n GETTING STARTED Tip Visual Studio supports colored themes. The default for most Visual Studio editions is the dark theme, which n
is predominantly black and doesn’t show up well in screen shots. I have switched to the light theme, which is why
theNew Project dialog in the figure looks different from what you can see on your screen. I changed the theme by selecting Options from the Tools menu and changing the Color Theme setting in the Environment section.
Blank App template in the Templates > JavaScript section. The Blank Template creates Navigate to the an almost empty project with just the files that are required to let you run an app without generating any errors. This is the template I will use throughout the book, and when I say I created a new project, this will always be the template I have used.
NoteFlash in the name field. This is the name of the first app you will create in Chapter 3. I Enter am not going to do any serious development at this point, but by the end of the chapter you’ll understand what the moving parts in a Windows 8 app project are and then you can see how they are used in Chapter 3.
Browse button to select a location for your project. It doesn’t matter where you save the Next, click the
OK button to create the project. Visual Studio files, as long as you can find them again later. Finally, click the will grind away for a moment as it generates the files and configures the content, and then you’ll see the initial view of the project, as shown in Figure 2-2.
Figure 2-2. The initial Visual Studio view for a new project n GETTING STARTED
In the sections that follow, I’ll show you the most important Visual Studio features that you’ll use in app development. Some of this will be a little obvious, but stick with me, because Visual Studio offers a tightly integrated development environment and it is useful to know how the parts all work together.
Running the Project
The best place to start with a new project is to run it and see how it looks. You have three choices when it comes to running your apps during development. The first is to run the app on the same PC you are using to write the code, the local machine. The second is to run the app in a simulator that is included with Visual Studio. The final option is to run the app on another device.
Of the three options, the simulator is most useful. The problem with running the app on the device you are working on is that Windows 8 apps are full-screen and they cover Visual Studio and the rest of the desktop. You can toggle between your app and the desktop, but it is a clumsy process, especially when you are trying to debug some kind of problem or error.
Running the app on another device can be very useful. You’ll need to download and install the Remote Tools for Visual Studio 2012 on the device, which you can get from Microsoft at com/en-gb/windows/apps/br229516. I find the ability to run an app remotely to be useful when I want to test how a feature or problem relates to a hardware capability that my development machine doesn’t have—a touch screen, for example. I don’t use it for regular development because it takes a few seconds for Visual Studio to package up and transmit the app to the remote device, and this becomes tiresome after a while.
Tip You can’t just copy an app onto another device as you would with a traditional Windows desktop application.
n Microsoft is very keen on the use of the Windows Store to deploy apps, and until you are ready to publish, the easiest way to test on a device is with the remote tools.This leaves the third option: the Visual Studio simulator. This is how I test my apps during development, and I recommend you do the same. The simulator is a reasonably faithful re-creation of a real Windows 8 device, and you can use it to simulate some important device characteristics, including device orientation, GPS locations, touch-and-gesture input, and different screen sizes and resolutions. It isn’t perfect, however, and there are some app features that you can’t properly test in the simulator. I’ll point out these features in the appropriate chapters so you will know to use one of the other ways to run the app.
You select the way you want to run your app using the Visual Studio menu bar. By default Visual Studio will run a new project on the local machine, but you can change this by clicking on the arrow next to the button shown in Figure 2-3. The text displayed by this button reflects the choice you have made, so it might not match the figure exactly—but you can’t miss the button, because it has a large green arrow next to it. (The arrow you need to click to change the setting is the small down arrow to the right of the button text—not the green one). n GETTING STARTED Figure 2-3. Selecting the way Visual Studio will run the app
Pick the Simulator option from the drop-down menu, as highlighted in the figure. Once you have made your choice, click on the green arrow or the button text to start the app. Visual Studio will launch the simulator, install your app, and start running it. The Blank App Visual Studio template you used to create the project really does generate just the basic structure of an app, so there isn’t a lot to see at the moment— just a black screen with small text in the top left corner that says Content goes here. Ignore the app for the moment and look at the buttons on the right edge of the simulator window, which I have shown in Figure 2-4. You can also start the app by selecting Start Debugging from the Visual Studio Debug menu—the effect is the same. I’ll come back to the Visual Studio debugger later in this chapter.
Note When I tell you to start the app, I mean that you should select the Start Debugging menu item or click n the button on the toolbar so the debugger is used. There are a couple of features that need to be tested without the
debugger, but I’ll make this clear when you get to them. In all other cases, you should make sure the debugger is
running.Figure 2-4. The Visual Studio simulator n GETTING STARTED
I have shown the buttons enlarged alongside the simulator. These buttons allow you to use the simulator to interact with the app in different ways and to change the orientation of the simulated device. The simulator buttons are grouped in sections of related functionality. The first group changes the input method, allowing you to use a mouse to simulate touch input. You’ll see how these buttons work in
Chapter 17, when I show you how to deal with touch gestures. The second group allows you to simulate rotating the device clockwise and counterclockwise. I use these buttons in Chapter 6 to show you how to create layouts that adapt when the device orientation changes.
The sole button in the third group changes the screen resolution and pixel density, which I also explore in Chapter 6. There is only one button in the fourth group as well and it is used to simulate GPS data. You’ll see how this is used in Chapter 29, when I show you how to create apps that are location aware. The final button group lets you take screenshots of whatever is shown by the simulator. I don’t use these buttons in this book.
tiPS for USinG the SimUlator The simulator works by creating a second desktop session on your development machine and displaying it in a window. This is a neat trick, but it has some side effects that it are worth knowing about. Some can be useful and others are worth being aware of if you have any problems. First, when you start an app using Visual Studio, the app package is installed and executed on the local machine and displayed in the simulator. This means that you can navigate to the Start screen of the simulator or real Start screen on the local machine and start the app without Visual Studio if you wish. If you have problems running an app—which will happen from time to time—you usually can fix things by going to the Start screen, locating the app you are developing, and uninstalling it (right-click on the app’s tile and select Uninstall). Second, some app features that provide integration with Windows features are easiest to test from the desktop, such as file activation, which I describe in Chapter 24. Because the Visual Studio simulator is running a regular Windows session, all of the applications you have set up to run automatically are started when you first activate the desktop in the simulator. I find that this causes some problems, especially with applications that expect to have sole access to a storage location or that manage hardware. The most annoying example for me is the software that let me remap the buttons on my mouse—when I switch to the desktop in the simulator, a second instance of this software is started automatically and it renders my mouse unusable until I kill one of the processes (a job made more complex by the lack of a working mouse). These are not usually terminal problems, but if you start seeing odd issues when you are using the simulator, remember that it runs a full Windows session, with all the good and bad this entails. Finally, the way the simulator creates and displays the Windows session means that it doesn’t work if you are connected to a VPN when the simulator is started. You can activate the VPN after the simulator has started and everything will be OK.
Controlling App Execution
Once you have started the app, the Visual Studio interface changes to give you options to control its execution. A row of buttons appears on the toolbar, as shown in Figure 2-5. n GETTING STARTED Figure 2-5. Buttons to control the execution of the app in Visual Studio
These buttons pause, stop, and restart the app. If you have made any changes to the project, the Restart button will ensure that the app is updated before execution is started. The fourth button (whose icon is a lightning strike with two arrows forming a circle) is the Reload button. This button quickly reloads any changed files without completely stopping and restarting the app. This feature is useful during development, and I find it most useful when I am fine-tuning CSS layouts, for example. Reloading isn’t possible if you add or remove files from the project or make changes that require the app to be reinstalled (such as changing the manifest, which I’ll introduce shortly)—in these situations, Visual Studio will prompt you to perform a reload instead.
Tip The buttons are complemented by items on the Visual Studio Debug menu that perform the same functions. n I tend to use the toolbar buttons, but there is no difference between them.
Exploring the Project
The Solution Explorer is at the top right of the Visual Studio window by default, although you can move it or even detach it entirely. In Visual Studio parlance, a solution is a wrapper around one or more projects. All of the example apps in this book are contained in single projects and, for the most part, solutions are a holdover from development practices that predate Windows 8 apps.
The Solution Explorer provides you with access to all of the files that are in the project. Most of the entries the Solution Explorer shows are folders and files that Visual Studio generated when you created the project, and others are references to files your app relies on. You can see all of the files in more detail in Figure 2-6, and I’ll explain what each of them does and their initial contents in the sections that follow. n GETTING STARTED Figure 2-6. The Solution Explorer, showing the files Visual Studio generates for the Blank App template
To edit a file in your project, simply double-click on its entry in the Solution Explorer window. You can also search for files by name in the Solution Explorer using the search bar just below the row of icons—this can be useful in large and complex projects. (The icons themselves allow you to navigate and configure the Solution Explorer).
Tip Below the Solution Explorer window is the Properties window. This window is important in other n kinds of development projects, but it doesn’t have any value at all for JavaScript app development, and you can safely close it to make more room for the Solution Explorer window, which is useful for large and complex projects. You can reopen any window you have closed through the View menu (some less-used windows are available through the Other Windows menu item).
Exploring the Project References
The first entries shown in the Solution Explorer are the project references. There are six reference files, and you can see the fully expanded References item shown in the Solution Explorer in Figure 2-7. n Figure 2-7. The project references shown in the Solution Explorer
The references consist of JavaScript and CSS files. This is an important point because it demonstrates how the support for web technologies in Windows 8 apps runs very deep—so much so that apps written with JavaScript and HTML are executed using Internet Explorer 10. The user isn’t aware that the browser is being used to run the app, but it is the engine that executes your app.