Start learning with our library of video tutorials taught by experts. Get started
Viewers: in countries Watching now:
This course surveys the core principles and techniques essential to building web sites for mobile devices. Author Joe Marini introduces the mobile context, sheds light on its unique coding requirements, and discusses interface design techniques that enhance existing sites for mobile viewing. The course shows how to approach designing for mobile form factors such as smaller screens and finger-based interaction, along with how to incorporate CSS3 and HTML5 capabilities, such as geolocation, local storage, and media queries.
And the nice thing about this is that as long as your code it right and do client-side feature detection like we talked about earlier, the unsupported features simply don't show up on platforms that don't support them. So, the first one we are going to look at is how to measure performance of your mobile web site. Now measuring performance is an important subject just in and of itself, but up until recently, there was no real good integrated way to do this in the browser. That's changed because there is now a built-in interface for measuring performance, but it's currently only implemented by Internet Explorer 9 on both desktop and mobile.
The way that you use this is on the window.performance object, and the window. performance object stores performance information that is automatically recorded by the browser in the background and then made available to scripts that want to examine the information and then make use of it, either display it, or report it back to the server, or whatever. When the page finishes loading you can write script that looks at the data in the performance object to see how long each stage of the process of requesting the page from the server and loading it into the browser so the user can see it took, and we are going to look at code that does that.
There are two properties on the window performance object that help you to do this. The first one is navigation, and the navigation object describes the type of navigation, whether it was navigation or reload or such, and the number of redirect accounts that it took to get the page from the server to the browser. The timing object contains a lot of fields that measure various navigation time points. So let's take a look at some of those. This is a partial table of some of the time points that IE measures when the page-loading process is going on.
So right at the top there, navigationStart, that's the first time point that will get measure. That's the time at which the page-navigation process begins. By measuring that time point, you can then look at other time points to see how much time elapsed between when the navigation first started and something that you're interested in happened. So for example, by subtracting off the requestStart time, which is down here and that's what measures the time when the document was first requested, actually requested from the host server.
By measuring that time point and subtracting it off from the navigationStart, you can see how much time elapsed between when the navigation began and when the document was actually requested from the server. If we take a look at some more of the properties, you can see that there's more property that have to do with the page itself and the DOM. So for example, you can see that there is a property for domLoading. There is a property for domInteractive. So domLoading measures the time point at which the DOM of the page began to actually load in the window, and domInteractive indicated the time points at which the document was able to process user events-- in other words, the time point at which the user was able to start interacting with the document.
You can also see the domComplete time point, which is when the DOM was completely initialized for the loaded document. Then finally, there is event such as loadEventStart and loadEventEnd, which indicate the time points for when the onload event for the document was started and completed. So for example, by subtracting loadEventEnd off of navigationStart, you can see how long the entire page-loading process took. So let's take a look at how to use some code to see various performance data about our web page. So here I am in the code.
This is my performance_start.html file, which is in the example folder. And I've got my snippet file as well. And let's scroll down to the Mobile Performance Measuring section. So what I am going to do is copy this function here, calcPerfNumbers, and I will copy that and put it in here. We'll get back to that in a second. I am also going to copy the init function and the window.onload statement, and we'll paste those in.
So when the window loads, it's going to call the init function, and all init is going to do is call setTimeout on calcPerfNumbers, with a delay of about half a second. So after about a half a second within the time completing of the window.onload event handler, this function here will get called. And you can see that I am using feature detection to see if the window.performance object exists. And if it exists, I'll be able to go and calculate various time points. And if it doesn't exist, I am just going to show an error messages here that says, "Hey, you know this does not support the performance object." But if it does, then I am going to measure some various time points.
And then down here in the document you can see that I've got various spans where I am going to substitute in the time points that I am measuring. So here's one for requeststart, this is the onLoad time, this is when DOM Complete was, and this entire page load time right here. So let's go back up to our code. So the way that I calculate various time points is, for example, by taking the time point that I am interested in and subtracting off the navigationStart event.
So by taking requestStart and subtracting navigationStart, I can see how many milliseconds it took from the time that navigation started until the time that the page actually got requests from the browser and so on so forth. Here I am subtracting loadEventStart from loadEventEnd, which will tell me how long the Windows onLoad event handler took to execute. Then I am going to measure the entire page loading time by subtracting navigationStart from the loadEventEnd, and that will give me the entire time of the page-loading process.
So let's go ahead and save this. And now I am going to go copy this to my server. So I'll copy this over here, and we'll put it in. So here in the Windows Phone emulator you can see I have already got it running, but because it didn't have any code in there, there are no values. So now that I've copied the file in, I am just going to refresh it. And you can see that after about half a second of the page loading, we're getting various pieces of performance data.
So it took about 448 milliseconds, or about a half a second, from the time that the emulator issued a request to the local host server until the page began to load. You can see that the whole onLoad event handler took 1 millisecond to execute. It was about 700 milliseconds from the time that the navigation started until the DOM was complete, and the entire page loading time from start to finish took 760 milliseconds, So less than 1 second. so that should give you some idea of how you can use the new performance timing event object inside Internet Explorer to measure how well your web site applications perform, at least for now in IE, until other web browsers begin to implement the same interface.
There are currently no FAQs about Mobile Web Design & Development Fundamentals.
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.
Click on text in the transcript to jump to that spot in the video. As the video plays, the relevant spot in the transcript will be highlighted.