Graphics on the Go

Graphics on the Go

Gil Irizarry

Conoa

About Me

• Launched VC News Daily app on iOS and Android. Over 1200 downloads so far.

• Owner and lead engineer at Conoa, a graphics and mobile software firm

• gil@conoa.com

• http://www.slideshare.net/conoagil/

About Me

• All examples and sample code in this presentation can be found at:

– http://conoa.com/hidden/example.zip

Why?

• There are nearly 2 million mobile apps available today. (http://www.pureoxygenmobile.com/how-many-apps-in-each-app-store/ )

• 1.5 years ago, there were 15K new mobile apps released each week. (http://www.nytimes.com/2011/12/12/technology/one-million-apps-and-counting.html )

• For many, interacting with software means interacting with mobile devices (or at least devices that run mobile software).

What we will do

• We will learn how to build lightweight mobile apps quickly, using open source tools.

• The apps will be cross-platform.

• However, we must actually pick a platform on which to build and test the apps.

• For this presentation, we will work in Android since the tools are free and easily available. We will do this on Windows.

What we will do

• (Mostly) everything presented today in the Android environment will apply to iOS, or has an equivalent in that environment.

• So, let’s get started…

Assumptions

• Setting up a development environment is covered in the Making Mobile Apps Quickly workshop.

• For this workshop, we assume that a development environment is in place.

PhoneGap

• PhoneGap allows HTML pages to be built as mobile apps.

• HTML pages can include JavaScript and JavaScript libraries, such as jQuery.

• HTML pages can also include HTML5 elements.

Canvas

• HTML5 includes a new <canvas> element.

• Canvas allows the rendering of 2D graphics via some low-level primitives.

• It does not include a scene graph API, so you must store rendering information yourself for redrawing a scene.

Canvas

• Canvas supports:– Basic shapes– Images– Transparency– Compositing– Transforms– Basic animation

Graphics Example 1 – Simple Canvas

• Select the Graphics Example 1 project in the Package Explorer in Eclipse.

• Select Run from the top menu bar

• Once the emulator starts and is finished installing the app, you should see something like this:

Graphics Example 1 - Create a Canvas

Graphics Example 1 – Simple Canvas

• This example creates a canvas, gets its drawing context, and draws into it.

• It follows a pattern that will soon be familiar: most of the action is happening in JavaScript.

• One problem with this example is that the canvas is a fixed size. Let’s fix that with Example 2.

Graphics Example 2 - Better Canvas

Graphics Example 2 – Better Canvas

• Example 2 queries the size of the window, then adds a canvas to fit the window. In this way, we can make a canvas that would fit any device.

• Notice that the position of the text is based on the size of the canvas, which is now based on the size of the device window. The text will be centered on any device the app is run, courtesy of a small amount of JavaScript.

• Let’s see what else we can draw.

Graphics Example 3 - More Drawing

Graphics Example 3 – More Drawing

• This example gives a sense of what can be drawn.

• Canvas uses a drawing system similar to Adobe PostScript or Mac OS QuickDraw. This is not surprising considering that Apple developed the initial implementation of canvas before it became a (nascent) standard.

• Obtain the graphics context of the canvas for issuing drawing commands

Canvas Drawing

• beginPath() … fill() or stroke () paradigm

• moveTo() / lineTo() for paths

• arc() for full or partial circles

• bezierTo() for complex curves

• fillText() / strokeText() for text

Canvas Drawing

• drawImage()

• colors, either by name or hex values

• gradients, linear or radial, and patterns

• stroke styles, including stipple patterns and line end caps

• push and pop transformations and state

Canvas Coordinate System

• (0, 0) is in the upper left corner of the canvas.

• Increasing y is “down” from the screen’s perspective. Increasing x is to the right.

(0, 0)

(0, height)

(width, 0)

Let’s make a pattern

• Find an image from the internet and save it to GraphicsExample3/assets/www

• Change this code:– context.fillStyle=gradient;– context.beginPath();– context.arc(55,155,40,0,2*Math.PI);– context.fill();

• To this code:

Let’s make a pattern– var img = new Image();– img.src = 'clouds.jpg'; // use your image name here– img.onload = function (e) {

• var pattern = context.createPattern(img, 'repeat'); • context.fillStyle=pattern;• context.beginPath();• context.arc(55,155,40,0,2*Math.PI);• context.fill();

– };

• Shapes that you fill will become masks for the underlying pattern.

Graphics Example 4 – Touch

• Everything so far has been static.

• JavaScript has an event system. We saw one in the previous example: onload

• Let’s use other events to add some interactivity.

Graphics Example 4 - Touch

Touch Events

• HTML5 canvas adds new events for devices:– ontouchstart– ontouchmove– ontouchend

• Note that events come back as arrays. Why?

• Because HTML5 supports multi-touch. We can have multiple simultaneous move events.

Touch Events

• Important to remember that event coordinates triggered by the canvas are relative to the full window.

• Events need to be converted to the canvas coordinate system in order to be relevant to the canvas.

• Look at function windowToCanvas (canvas, x, y) in Graphics Example 4 source code (found in assets/www folder).

Previewing

• Examples 1 through 3 work equally well as a PhoneGap-powered mobile app and as a web page. If you haven’t already done so, trying running assets/www/index.html in a browser.

• However, by incorporating touch events, we must run Example 4 and other examples incorporating touch in the mobile emulator.

Graphics Example 5 - Touch

Images

• In addition to stroked shapes, we can draw images.

• Images can be sourced locally or over the network.

• Note how images are loaded:– image.src = filename;– image.onload = function(e) {– };

• If you reference an image before it is loaded, you run the risk that you are trying to use an image before it is available.

Images

• Images can be scaled and transformed.

• Canvas supports compositing and alpha.

• Canvas also support shadows.

• The example uses an RGBA color value to render semi-transparent text and have it composited over the image. The text is given a drop shadow.

Images over the network

• To access images over the network (or any data at all), remember that network access must be enabled. On Android, network access is not the default. It must be enabled in the AndroidManifest.xml file:

• <uses-permission android:name="android.permission.INTERNET" />

Saving and restoring state

• save() pushes the current context onto a stack.

• In addition to the current transformation, attributes are also pushed.

• In the current example, because the text was given a shadow, the shadow applies to the paint object. If we want only the text to have a shadow, we could put the text rendering code inside a save() / restore() block.

Graphics Example 6 – Paint and Menus

• Since we can render images into the canvas, we can use a set of images and canvases to create menus.

• We could also draw into the canvases to render the menu options dynamically.

Graphics Example 6 – Paint and Menus

Graphics Example 6 – Paint and Menus

• Example 6 allows the color and size of the paint brush.

• Separate canvases are used for the icon images, and touch event handlers are attached to the canvases. How else could we accomplish this?

• The image selector and scale checkbox are standard HTML controls that trigger JavaScript events. We could make <div> elements with <img> elements containing the icons, and put event handlers on the images.

Animation

• Although we’ve added some interactivity, the examples so far have been a little static.

• Let’s add some animation.

Graphics Example 7 – Simple Animation

Animation

• self.setInterval () is used to have the page be called again.

• Note that the screen is not cleared and that we are adding to the canvas on each call.

• Instead, let’s clear the canvas each frame. We can transform the previous example into a simple clock app.

Graphics Example 8 – Simple Clock

Animation

• This example queries the time from the JavaScript Date() object and draws the hands accordingly.

• The canvas is cleared each frame and redrawn.

• If you haven’t already, try running the Graphics Example 8 in a browser (by running assets/www/index.html)

• There is something consistently missing in both the emulator and the browser. What is it?

Animation

• The answer is flicker. The same canvas is cleared and redrawn each frame, yet there is no flicker.

• This is because the canvas is inherently double-buffered.

• You could implement your own double buffering scheme because HTML5 allows drawing to off-screen drawables. You could draw off-screen, then swap the off-screen memory to the on-screen canvas. However, HTML5 canvas does this more efficiently.

Save and Restore

• Remember save() and restore()?

• Let’s use them to change the clock face so the text is oriented around the face, much like text on a path in some applications.

• Do this by using translate and rotate to change the coordinate system of the fillText() call.

• If you can’t figure out how to do this, look at the commented out code.

Graphics Example 8 – Simple Clock

Let’s Do Things the Right Way

• We have been cutting some corners, so let’s do things the right way.

• PhoneGap should load the JavaScript when it is ready, otherwise you potentially have the problem similar to when you reference an image before it is loaded.

• Set a device ready event:– document.addEventListener("deviceready", fnName, false);– fnName is the name of the event handler

Let’s Do Things the Right Way

• Setting the device ready event requires that the device get set in the config.xml file. This file is not in a default Eclipse project, so it needs to be added manually. It goes in the /res/xml folder.

• <feature name="Device">• <param name="android-package"

value="org.apache.cordova.Device" />• </feature>

Let’s Do Things the Right Way

• Look at the clock app. Also, try running it in a browser and look at it there.

• If you look closely enough, you’ll see a stutter on the second hand. This is because setInterval() is a general suggestion to the canvas on when to redraw and not a hard commitment.

• There is a better way: requestAnimationFrame()

Let’s Do Things the Right Way

• requestAnimationFrame() is designed to deliver 60 FPS and is made for games or animation.

• However, there is a problem. Many browsers don’t implement it!

• Remember that HTML5 is still not a standard!

Let’s Do Things the Right Way

• webkitRequestAnimationFrame() for Chrome, mozRequestAnimationFrame() for Firefox.

• Search for ‘robust polyfill code’ to find ways to deal with this.

• http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating

Let’s Do Things the Right Way

• Unfortunately, Android and iOS do not support requestAnimationFrame(), at least at the versions we’ve been supporting in these examples.

• In this case, the polyfill code reverts back to setInterval() or setTimeout().

• Another solution is to support only later versions of the OS.

Let’s Do Things the Right Way

• http://caniuse.com/requestanimationframe

Let’s Do Things the Right Way

• Let’s stop the main Android activity from showing up before the HTML loads.

• <application android:theme="@android:style/Theme.NoTitleBar" >

Graphics Example 9 – Bouncing Balls

Playing Sound

• In the latest example, a sound is played when a ball bounces.

• To enable this, remember to set the correct permissions in both AndroidManifest.xml and config.xml.

• Create a PhoneGap media object. This requires the use of cordova.js in addition to cordova.jar.

Playing Sound

• If you listen closely, you hear that the sounds are not exactly in sync with the bounces.

• This is an inherent problem with PhoneGap’s Media class.

• To alleviate, use an uncompressed sound file.

• Also, there is the Low Latency Audio Plugin for PhoneGap.

Sprites

• HTML5 does not support sprites natively but, now that we know how to do animation and draw images, we can simulate them.

• drawImage() allows a subset of an image to be drawn.

• Every so many frames, we can draw a different part of a larger image. The larger image can be made up of different sprite images.

Graphics Example 10 – Bouncing Balls

What about 3D?

• An emerging standard for 3D graphics in a web page.

• However, it is not supported by iOS or Android browser and has no support within PhoneGap.

Thank You!