TapDoctor for iPhone

TapDoctor for Android
https://market.android.com/details?id=air.com.jonas.TapDoctor

TapDoctor for Blackberry Playbook
https://appworld.blackberry.com/webstore/content/55119



TapDoctor is a puzzle game that combines observation, reflection and speed.
Have fun!

This is version 1.
To be continued…

Use :

Bench.output = output;
 
Bench.push(test1, "This is the 1st test with 5 iterations", 5);
Bench.push(test2, "This is the 2nd test with 5 iterations", 5);
 
Bench.run();
 
private function test1():void {
	// here what I want to bench
}
 
private function test2():void {
	// here what I want to bench
}
 
private function output(result : String) : void {
	//see https://github.com/jonasmonnier/Mobilo/blob/master/src/com/mobilo/bench/BenchView.as
}

I took the loops from grant skinner to make my first test.

Loop test class on Github

private function forIncrement() : void {
	for (var i : uint = 0; i < loops; i++) {
		var a : uint = i;
	}
}
 
private function forDecrement() : void {
	for (var i : uint = loops; i > 0; i--) {
		var a : uint = i - 1;
	}
}
 
private function whileIncrement() : void {
	var i : uint = 0;
	while (i < loops) {
		var a : uint = i;
		i++;
	}
}
 
private function whileDecrement() : void {
	var i : uint = loops;
	while (--i) {
		var a : uint = i;
	}
}
 
private function doWhileIncrement() : void {
	var i : uint = 0;
	do {
		var a : uint = i;
	} while (++i < loops);
}
 
private function doWhileDecrement() : void {
	var i : uint = loops - 1;
	do {
		var a : uint = i;
	} while (i--);
}
 
private function forIn() : void {
	for (var b:* in vec) {
		var a : uint = b;
	}
}
 
private function forEachIn() : void {
	for each (var b:Boolean in vec) {
		var a : uint = loops;
	}
}
 
private function forEachInUntyped() : void {
	for each (var b:* in vec) {
		var a : uint = loops;
	}
}
 
private function forEachInPosttyped() : void {
	for each (var b:* in vec) {
		var c : Boolean = b as Boolean;
		var a : uint = loops;
	}
}
 
private function vecForEach() : void {
	vec.forEach(vecForEachF);
}
 
// helper functions:
private function vecForEachF(item : Boolean, index : int, vec : Vector.<Boolean>) : void {
	var a : uint = index;
}

I test 1 million loops 5 times with a 1 second delay between each test.
Some results are a bit surprising…

Note that Garbage Collection is not forced ​​with Flash Player in this version.

More info in an upcoming post…

Nobody to point out my spelling mistakes ?
Hope it is understandable

So I wrote 3 static classes : Tick, Timeout, Interval class to bypass the problem. (With a big thx to @seraf_NSS for test, debug and enhancements)

To be simple Tick is a global ENTER_FRAME available from anywhere (including non-DisplayObject).
Then Timeout and Interval subscribes to when necessary.

To be optimized for mobile, all listeners are stored in vectors and no events are dispatched.

Tick use :

// create a tick
Tick.create(onTick);
 
// remove a tick
Tick.remove(onTick);
 
public function onTick():void {
	trace("tick");
}

Tick class
Tick demo class

Timeout use :

 
// create a timeout with a 300 ms delay
var id1:int = Timeout.create(onTimeout1, 300, 10);
 
// create a timeout with a 300 ms delay and 1 optionnal argument
var id2:int = Timeout.create(onTimeout2, 300, "hello");
 
// clear a timeout
Timeout.clear(id1);
 
public function onTimeout1():void {
	trace("onTimeout1");
}
 
public function onTimeout2(message:String):void {
	trace("onTimeout2", message);
}

Timout class
Timout demo class

Interval use :

 
// create a interval with a 300 ms delay repeated 10 times 
var id1:int = Interval.create(onInterval1, 300);
 
// create a timeout with a 300 ms delay repeated until we stop + 1 optionnal argument
var id2:int = Interval.create(onInterval2, 300, 0, "hello");
 
// clear an interval
Interval.clear(id1);
 
public function onInterval1():void {
	trace("onInterval1");
}
 
public function onInterval2(message:String):void {
	trace("onInterval2", message);
}

Interval class
Interval demo class

I am interested in your feedback on these classes and this article. Please point out my spelling mistakes, I think I’m better in Actionscript than in English…

A few tests later, I isolated the problem: The setTimout() method does not work properly (?) in AIR 2.7 for IOS.


I solved the problem by coding a small static class to manage multiple timeout using an unique enterFrame event.

Thx to Seraf for bug fix and clear(id) method

Use :

Timeout.create(myMethod, 300, "optional param");

Below are screenshots of the setTimeout() VS my Timeout.execute() test on my iPhone 3GS.

Below the test for FP 10.1.
Note that my class performs better or equal to the setTimeout() method (Win7 – FF4 – FP 11).

Test class source
Timeout class source

…

Use :

ErrorHandler.getIntance().init(this);

A reasonable adjustment in production :

ErrorHandler.getIntance().activeWithPlayerMode = ErrorHandler.MODE_DEBUG;

With flash player 10.1 an UncaughtErrorEvent object is dispatched when an uncaught error occurs.
Here is a small class for displaying errors within the application based on selected parameters …
Sources on Github

Use :

var error:ErrorHandler = new ErrorHandler(this);

Demo :

Picture Html5 full support in a few years. Let’s now picture Flash Player X, implemented with Adobe’s innovations, video, sound, 3D, performance, and anything that you can’t possibly imagine. Here you have the basic advantage of a plugin, a technology not depending on browsers and their updates, not depending on the current web actors’ inertia.

The non-support of Flash by Apple is a blow, but keep in mind that iPhone’s market share is declining. IPad is a great device, but unlike the iPhone (which has long walked solo on the market), it will soon face a fierce competition from manufacturers (HP Slate, Toshiba, Dell…) developing tablets offering full-flash support.

More & more  mobile devices will come with Android built on, and Google supports Adobe. The Open Screen Project should allow Flash to be available on other OS.

It’s true that Flash is still not fully supported on Mobiles, but as things stand today, mobile web is not THE Web.

So I would appreciate people keeping in mind the reality of Web Development with real clients/users. Html5 will be a great evolution of html, but it’s still in development and far to be ready.

Fyi, I’m a Flash Developer and I’m booked up for months.

Thx @Nounie.

• Our target is scaled, so the bigger the the screen is (or the smaller our target is) the more our UI is pixelized.
• The DisplayObjects above our target will be included in our full-screen.

With Flash Player 10,  hardware acceleration is possible using direct or gpu mode, but it’s not available for AIR and depends on hardware…
Working with full-screen mode

The overlay can be managed during the application conception, but it can quickly become complicated and even impossible with a component that can be placed anywhere in an application…

So I wrote a small class to simplify it (flash/flex).

Example :

Sources

How does it works :

Simple :

var fullscreen:FullScreen = new FullScreen(target);
fullscreen.mode = FullScreen.RESIZE_HARDWARE;
fullscreen.toggleFulScreen();

In resize mode our target must be resizable (Simple component invalidation) :

public class MyComp extends Sprite
{
	private var _width:Number;
	private var _height:Number;
 
	public function MyComp()
	{
 
	}
	public override function set width(value:Number):void {
		_width = value;
		_invalidate();
	}
	public override function get width():Number {
		return _width;
	}
 
	public override function set height(value:Number):void {
		_height = value;
		_invalidate();
	}
	public override function get height():Number {
		return _height;
	}
}

The 4 modes :

FullScreen.RESIZE
Resize the target to screen size and place it at the highest depth in the display list.

• Benefits :
  Keep a clean UI.
  Resize your target as you want.
• Drawback :
  Worst for ressources.
  Do not use with video without gpu or direct mode.

FullScreen.RESIZE_HARDWARE
Resize the target at screen size and place it at the highest depth in the display list.
Try hardware acceleration using fullScreenSourceRect on the full stage.

• Benefits :
  Keep a clean UI.
  Resize your target as you want.
  Use fewer resources than FullScreen.RESIZE.
• Drawback :
  Use more resources than FullScreen.SCALE.

FullScreen.SCALE
Scale with fullScreenSourceRect (try hardware acceleration).

• Benefits :
  Best for ressources.
  No need to resize target.
• Drawback :
  UI pixelisation
  Potential overlays problems.

FullScreen.SCALE_ABOVE
Scale with fullScreenSourceRect (try hardware acceleration).
Place target on highest depth.

• Benefits :
  Best for ressources
  Avoid overlay
  No need to resize target
• Drawback :
  UI pixelisation

Links :

Flash fullscreen best practices

Sources

I will soon release a 0.2 version. All ideas are welcome.
Feel free to point out to me the mistakes

For example, this code calls three times my draw method :

1
2
3

myComps.width = 100;
myComps.height = 100;
myComps.color = 0xFF0000;

Mmmm ? Stupid ?

The solution is to wait for the next enterFrame event to update the display.
The UIComponent that is the base of Flash components offers all the methods to do this, but the last thing I want is to use them.

Here’s how to set up a simple invalidation:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package
{
	import flash.display.Sprite;
	import flash.events.Event;
 
	public class InvalidateSprite extends Sprite 
	{
		private var _width:Number = 150;
		private var _height:Number = 100;
		private var _color:Number = 0xCCCCCC;
 
		public function InvalidateSprite(){
			_invalidate();
		}
 
		public override function set width(value:Number):void {
			_width = value;
			_invalidate();
		}
 
		public override function set height(value:Number):void {
			_height = value;
			_invalidate();
		}
 
		public function set color(value:Number):void {
			_color = value;
			_invalidate();
		}
 
		private function _draw():void {
			graphics.clear();
			graphics.beginFill(_color, 1);
			graphics.drawRect(0, 0, _width, _height);
		}
 
		private function _invalidate():void {
			if(!hasEventListener(Event.ENTER_FRAME))
				addEventListener(Event.ENTER_FRAME, _invalidateCallback);
		}
 
		private function _invalidateCallback(e:Event):void {
			removeEventListener(Event.ENTER_FRAME, _invalidateCallback);
			_draw();
		}
	}
}