Looking to get started using Native extension? Here’s a quick primer with links to more resources. What the heck are AIR Native Extensions?
Optimizing Performance for the Flash Platform is filled with tips to make faster, more efficient Flash Player and AIR applications for desktop, mobile, and TV devices.
The chapter called Optimizing network interaction has some tips worth reviewing:
- Use smart seeking. Smart seeking improves performance when a user seeks to a new destination in a streaming video. Use Netstream.inBufferSeek. (Adobe Flash Media Server 3.5.3 or greater required)
- Divide your app into multiple SWF files. Multiple smaller SWF files means your content loads faster, especially on mobile devices with limited access to the network.
- Provide event handlers and error messages for IO errors. Because network access can be less reliable on a mobile device, be sure to catch every IO error and keep the user informed.
- Use Flash Remoting and AMF for optimized client-server data communication. As a binary format, Action Message Format (AMF) reduces the size of the data, improving the speed of transmission. Flash Remoting gateways, such as ZendAMF, FluorineFX, WebORB, and BlazeDS, know how to handle the AMF format on behalf of the server side.
- Cache assets locally after loading them. Avoid unnecessary loads from the network by saving files to the local file system, by using SharedObjects, or by saving data to a local database.
For more details on these tips, and other topics such as conserving memory and improving rendering performance, visit Optimizing Performance for the Flash Platform.
Jackie Levy, Content and Community Lead
Looking for ways to build incredibly speedy Flash or AIR applications for mobile devices? If so, look no further than Optimizing Performance for the Flash Platform. Released last year, this guide is brimming with valuable tidbits, provided in part by Adobe’s own Thibault Imbert. It offers tips for optimizing performance on mobile devices, desktops and TVs, ranging from basic ActionScript best practices to sophisticated graphics rendering techniques.
Here are a couple of simple ActionScript optimizations from the Miscellaneous optimizations section of the ActionScript 3.0 performance chapter.
Avoid evaluating statements in loops
Another optimization can be achieved by not evaluating a statement inside a loop. The following code iterates over an array, but is not optimized because the array length is evaluated for each iteration:
for (var i:int = 0; i< myArray.length; i++)
It is better to store the value and reuse it:
var lng:int = myArray.length;
for (var i:int = 0; i< lng; i++)
Use reverse order for
while loop in reverse order is faster than a forward loop:
var i:int = myArray.length;
while (--i > -1)
These tips provide a few ways to optimize ActionScript, showing how a single line of code can affect performance and memory. Many other ActionScript optimizations are possible. For more information,
Optimizing Performance for the Adobe Flash Platform contains a treasure trove of tips on less obvious performance enhancements. For example, chapter 3, “Minimizing CPU usage”, highlights the following CPU management features:
- Pause and resume SWF files based on screen exposure: This is an automatic feature in Flash Player since version 10.1. Flash Player minimizes processing when SWF content goes off-screen.
- Instance management: This feature introduced the
hasPriority HTML parameter. By default, Flash Player doesn’t start SWF content that is not visible. You can override this behavior in most cases by using the
- Sleep mode: On mobile devices, Flash Player and AIR detect when the device backlight goes into sleep mode. When this event occurs, rendering of SWF content stops, and frame rates drop to 4fps. Because the frame rate stays above zero, all open data connections can remain open.
- Freezing and unfreezing objects: You can use
ADDED_TO_STAGE events to keep objects that are no longer in the display list from consuming unnecessary CPU cycles.
- Activate and deactivate events: By using events to detect when your application is activated or deactivated, you can reset the frame rate, freeze or unfreeze objects, or perform other CPU optimizations.
- Mouse interactions: Detecting mouse interaction on many objects simultaneously can be CPU-intensive. You can reduce that overhead by disabling mouse interactions on objects that do not respond to mouse events.
- Timers versus
ENTER_FRAME events: To execute code at specific intervals you can choose between a timer or
ENTER_FRAME events. The optimal choice for your situation depends on a number of factors, such as whether your application uses animation.
- Tweening syndrome: Minimize the use of tweens, especially for content intended for low-performance mobile devices.
Visit the Optimization Guide to find out more about these topics and many others, including memory management, efficient use of the ActionScript language, rendering, networking, and database access.
Problems building and debugging the Starling example on Adobe Developer Connection? This blog posting might help.
There are tons of awesome code snippets and examples in the ActionScript Reference and ActionScript Developer guide. Learn about the enhancements we’re working to make it easier to find examples: http://e-musings.tumblr.com/post/11670105969/looking-for-actionscript-examples-try-this
Here’s a little tidbit about developing native extensions for Adobe AIR for Android devices using the native extension Java API.
The main point: The call that your extension’s ActionScript side makes to
ExtensionContext.createExtensionContext() must return before the native side of the extension can call methods of the instance of your class that extends the FREContext class.
Let’s break that down.
The AIR runtime instantiates your FREExtension instance the first time the ActionScript side of your extension calls
The sequence of calls to your Java implementation of the FREExtension class is:
- FREExtension implementation class constructor
In createContext(), you return an instance of your class that extends the FREContext class.
But be careful. The FREContext object can only be considered fully constructed once the
ExtensionContext.createExtensionContext() ActionScript method has returned.
Therefore, do not call any methods of your FREContext instance until after the
ExtensionContext.createExtensionContext() ActionScript method has returned.
For example, you might be tempted to call your FREContext instance’s
getActivity() method in its constructor. Don’t do it. You’ll get an
IllegalStateException if you do.
- Provide an initialization method that the ActionScript side can call after
- In the initialization method, call your FREContext instance’s
The Gyroscope and Vibration examples do exactly that. See them at http://www.adobe.com/devnet/air/native-extensions-for-air.html.
Detailed documentation about creating extensions is at Developing native extensions for Adobe AIR.
To use a native extension in your AIR application, see Using native extensions in AIR applications.
The Flash Player 11/AIR 3.0 (Serrano) release fulfills a long-standing developer request by introducing a native ActionScript JSON API. With this API, you can import and export objects using JSON encoding. Native JSON functionality correlates closely with the ECMA-262 (5.1 Edition) specification for JSON. Because of this, its syntax is somewhat different from the third-party as3corelib JSON library. You can find out more about these differences in community member Todd Anderson’s blog posting at the Infrared5 company blog.
The API itself consists of a top-level class named JSON. This class provides two methods:
stringify() for encoding, and
parse() for decoding JSON strings. The JSON feature also supports
toJSON() member functions in any class. Visit the official documentation at these locations:
ActionScript 3.0 Reference
ActionScript 3.0 Developer’s Guide
With the announcement of AIR 3 and its new native extension feature, detailed documentation about using Native Extensions for Adobe AIR is available now at:
Developing native extensions for Adobe AIR
– Overview and conceptual information
– How to use the C and Java native extension APIs, plus reference pages
– How to package your native extension using ADT
– Details on the Extension Descriptor file
– Information on using Android shared libraries, and using resources on Android and iOS
If you are using a native extension in your AIR application, see:
Using native extensions in AIR applications
For lots of examples and tutorials, see this Adobe Developer Connection page:
Todd Anderson just posted “iBattery”, a great example of a native extension for Adobe AIR on his blog.
His iBattery extension allows an AIR application to get the status of the battery of an iOS device — from ActionScript. Todd also gives a nice tutorial highlighting some of the details that go into creating a native extension.
You can see more examples of native extensions at the Adobe Developer Connection page http://www.adobe.com/devnet/air/native-extensions-for-air.html