Of course this would be made possible by the Accelerometer built into the Android device. With it I can get controls and user interactions based on how the user interacts with the device itself not just screen controls.

If you are starting with this post I recommend actually starting with a previous post introducing AIR for Android Development. There is a ANT file there that you will want to have.

Memory, Power, and Performance Considerations
When first making this test app I felt that with as small as it is that I wouldn’t have to worry about performance concerns. Running the app it was choppy and the refresh rate was terrible.

At the time I was updating the position of the “ball” on every accelerometer update event. So I changed the ball move to be on the enter frame event. BAM! Immediately the app was running smooth. Quick lesson number 1.

Next thing that I did was to cache the ball bitmap. Since I don’t rotate the ball and don’t mess with the balls alpha channel the ball is a perfect candidate for bitmap caching. There was a small visual improvement on this change but the lions share was on the enter frame change.

Like Geolocation the accelerometer has the setRequestedUpdateInterval method. I recommend playing with this interval and finding what makes sense for your application. Too often and you’re killing battery and performance. To infrequent and your updates may not do what you want. Again, play with this interval and see what works for you.

Accelerometer App
The app itself is really simple. Make sure to check out the section that I enable accelerometer support and see how I made sure to check that the device supports the accelerometer before using it. The function that I used to actually move the ball isn’t anything special and just meant to make the movement seem natural. You’ll definitely want to make your own function for your application.

Application Descriptor File
For accelerometer suppor you don’t have to do anything special to the application descriptor file. I just wanted to make sure to share it so you didn’t think I did anything funny.

Good luck! And look out for Wooden Ball in a Cup!

I’m going to talk about some Air for Android APIs that many Flash developers my not be used to seeing.

Today: Geolocation.

If you are starting with this post I recommend actually starting with a previous post introducing AIR for Android Development. There is a ANT file there that you will want to have.

Memory, Power, and Performance Considerations
Unlike previous Air and Flex development Air for Android development is unique in the fact that you must be conscientious about battery life and depletion. As such, with Geolocation services you don’t want to keep tasking the GPS subsystems continuously as they are power hogs. When looking at the code look at a specific method:

This method sets the timer for a moment to get the user’s current location. If you set this value low you will get quicker access to the current user’s locations however the battery will run down that much faster. There isn’t a hard and fast rule to follow, just get the location whenever is truly necessary.

Also you should remember that many devices can have their GPS muted. When the GPS is muted you shouldn’t even look for the GPS values, saving power and computation cycles.

The code I am showing checks for when the GPS status changes and then adds and removes listeners appropriately when the GPS systems are on or off.

The Geo App
The app itself is really simple, it displays your current GPS location. The entire example is written in pure AS3 but could also easily work in Flex.

Application Descriptor File
If you copied and pasted the previous code and hit run then you would have probably noticed that the Geolocation doesn’t work. The reason is that you need to specify that this application has access to the Geolocation hardware. You do that in the Application Descriptor file (Geo-app.xml).

The links you need to make sure to have available are as follows…

The full Application Descriptor file is:

With all this you will have an application that works that will pull the latitude, longitude, heading (from North), speed, and horizontal/vertical accuracy.

Adding in @includeExample is super simple if you’ve been actively testing your component. There are a few things you may need to do to enable the examples inclusion but the process should only take a few moments to set up.

I have an open ASDoc Jira Bug around this topic. The issue is that I want to see the example working in the asdoc but the current asdoc tool doesn’t actually make the SWFs and the embed information. It is partially there and commented out. I would like to see this completed.
Link To Jira Bug – vote for it

To include your examples is simple.

First, your need to duplicate your src directory. On the base directory add in a folder called examples. This is where your examples will go – in the same structure as your library classes.

Second, you need to write your example. For my example I am building an example for my AutocompleteList.

The example:

Thirdly, you need to specify that there is an example in the class level asdoc. All you need to do is give the name of the example file. Since the examples files are mirrored against the original classes the asdoc tool knows the folder structure to find the example.

- Optional – Adjust your compiler arguments. If for whatever reason your examples aren’t part of your project or live somewhere else you may need to add some arguments to your compiler. Specifically the -examples-path. By default the asdoc tool looks for the examples folder, but if you put the examples in a different folder just specify it as such:

Your folder is titled “myexamples” in the base directory, the compiler:

Or if your folder is at c:/myexamples, the compiler:

The rest of the structure is matched for you.

And now your example is included with your asdocs page.

Related Posts:
Intellisense – Making your components work with the Flash Builder IDE
Building ASDocs with ANT

I am going to veer away from my normal discussions on technology to focus on some points on communication and processes that you can easily add to your every day discussions to improve the quality of your communication. Starting with going over some common misconceptions that people have with communication.

1. Just because I said it, means it got across
This is the first and most important miscommunication. We believe our communication is sound, especially since we said it and the communication method makes sense to us, and that the receiver has understood the message. The issue is that this isn’t programming and we aren’t just talking 1s and 0s. So there are infinitely more reasons why the packet may not have been received.

When communicating you need to remember the communication model.

=== Context ===
The context refers to the environment of the message or external details to the message that provides relevance or information to the message itself.

So if you are talking to your client and he says “did you get that thing done?” you know what that “thing” is. If you aren’t 100% sure what that “thing” is, ask them to define the context of the message.

“What are we talking about?”
“The contract.”
“Oh yes, I got the contract done”.

Often we assume that whatever is the most important thing going through our own heads is also the most important thing going through everyone else’s heads that we are working around. Make sure to stop and define the context as much as possible.

Instead try:
“When it comes to the contract we were discussing yesterday…”

=== Sender ===
The sender in this communication environment is you – the originator of the message.

=== Receiver ===
The receiver in this communication environment is the client – the intended recipient of the message.

=== Message ===
The message is actually not the words you are trying to have heard, instead it is the thought that you are trying to get across. That is another important point to remember, you aren’t trying to get the “words” across, but instead the idea. If you focus on the words then you will be locked into the same actual message, yet if you focus on the idea then you will have many more words and forms of communications that will be open to you to get the idea across.

=== Response ===
The response is the information you receive from the receiver. This response can take place in many different forms – we will discuss verbal and nonverbal. A verbal response could be as simple as “uh huh”, or as complex as a question or conversational additive. A nonverbal response may be a simple head nod or actually taking action that displays that the message was received.

At this point the roles of sender and receiver switch as you need to be able to accept the message in the response.

=== Interference ===
Interference is often the attribute of the communication model that most people – developers included – forget completely. If you are talking on a phone with bad reception or at a loud bar interference is obvious, yet there are many more forms of interference that happen in every communication interaction that are not as obvious.

• - As a programmer my mind often has a component or some set of code running through it.
• - As a male my mind often is thinking of sex. Yup, I said it.
• - As a person that watches South Park, Futurama, and Family Guy there are often words that will be used that will spark a reference to some joke. Some joke that I will replay in my head the second your words trigger it.

That means that at any time that you are trying to communicate with me there are three other things going on in my head at all times. This internal interference is something else that you the sender need to be aware of when communicating and try to overcome.

=== Channel (not visualized) ===
The final element to communication – that I didn’t visualize – is the channel that the message transfers on. This can be as simple as the air that the message travels on and the words that are used, the phone line, or the video chat that you are using with or without wifi… unless you are an iPhone user.

If the channel is getting in the way of good communication, fix it.

No individual part of the communication model is more or less important than the other and all must be considered equally when communicating.

2. Higher Quantity == Higher Quality
Obviously just because I talk more doesn’t mean that I get my point across any better.

Instead, work on switching up how you get your point across. Each time you make a point, try to come up with different and distinct ways to illustrate your point. I’ll touch on this a bit more later, but with more distinct ways that the message is sent across, the higher the likelihood that the meaning will be communicated.

3. The meaning is in the words
This is the final point of miscommunication. The meaning of the message is something that is interpreted based on the words and the persons history and background to the words that were used. As such there is no way for you – the sender – to transmit the meaning using words alone. Instead, be aware that the meaning of your message will be changed when it reaches the receiver. It is our job as good communicators to get the meaning of the message communicated as completely as possible.

Ways to improve your communication
First let me say that communication takes practice and effort. Good communication is a skill that does not come naturally though we do communicate naturally. As such you need to remember that will every skill you need to practice, prune, and work to improve your own communication on a daily basis.

Let’s look at some great communication techniques that you can add into your daily communication with clients and coworkers that will help improve your communication skills and no one will realize that you are actually practicing to be a better communicator.

=== Ask for context ===
I touched on this earlier but I am serious as a heart attack. Ask for the context and be sure to understand what the context is before responding. If the client asks you for that “thing”, ask what the thing is. If someone starts talking to you “mid-conversation” ask for context. It’s really simple and will force the sender to communicate their thoughts a bit clearer. This is a good way to improve the level of communication in a conversation on the whole.

Without context you may put your foot in your mouth in a way that only gets worked out in bad sitcoms. Be sure of the context before you respond.

=== Pete and Repeat===
Repetition is beneficial for more than computers and modern pop stars that can’t produce original work. Repetition is the key to making sure that your point or instructions were clearly communicated and the message’s meaning made it full circle. By asking for the recipient to reiterate what you just told them you can be sure that what they heard is what you meant.

Remember! We aren’t looking for a word for word repetitive memory dump. Since we already know that the meaning isn’t in the words we know that these words are meaningless. We are wanting to hear the recipient’s interpretation of your meaning and make sure that the two messages are congruent. You will be shocked to find out how often the messages actually don’t match and you will have to clarify your message to make sure that the two match. Keep this circle going till you are content that the recipient understands the message.

Now that you are a learned communicator though doesn’t mean that your communication is perfect either – so you should also practice repeating the meaning so that you are sure that you received the message properly. After receiving instructions or a questions I other will say “So what you are saying is…” or “So what you are asking is…”. This very simple start allows for a reinterpretation of the meaning and gives the original sender the ability to clarify is the message wasn’t correctly received.

This back and forth interaction is so important to everyday communication, not just when contracts and clients are on the line. If you are talking to someone and all they are doing is smiling and nodding be very afraid what information actually got across. This time of reinterpretation also helps allow for the time it takes for the meaning of the message to take hold in the recipient. If you’ve noticed how people always come up with questions a few minutes after you’ve communicated your message, this is because the meaning hasn’t really sunk in yet, and when it does they need come up with meaningful questions. This clarification time gives them the recipient the ability to really soak in the message and apply meaningful thought to the subject. This will ultimately save you from interruptions and future clarifying questions after the initial communication.

=== Less is More ===
Earlier we discussed how many people believe that more communication equals better communication. We know this isn’t true. Often times less communication provides clarity of meaning. Keep your communication simple, clear out the side stories and tangents. Think of the meaning you are trying to get across and stick to that one thought. The more tangents and superfluous details you add into your communication the more convoluted your communication becomes.

=== Variety is the spice of life ===
My final hint to better communication is to add variety to your communication. By just speaking your meaning, the retention rate is on average 10% after only a few hours. By showing visuals alone, 35%. By speaking and showing visuals, 65%.

This tells you that the more ways that you can communicate your message the better.

If someone doesn’t understand the first time you communicate with them, don’t repeat word for word what you said earlier. This is not going to help communication at all. Instead switch it up and change your tactic. The person you are communicating with may be a visual learner rather than an auditory learner or vice versa. By switching up your communication style you have a greater ability to communicate your meaning then by sticking to one form of communication only.

I know this seems simple but I don’t know how many meetings I sit in where people try to talk to me explaining and reiterating their ideas over and over again where a picture will solve everything. Usually this is the point that I pop out of my chair and start drawing on the board and the meaning becomes clear for everyone in the meeting. It’s okay to change it up and try new techniques in meetings with clients and coworkers. No one is going to be upset when they leave a meeting with a full understanding of what is going on.

They will only leave upset when they wasted their time and no meaning was fully communicated.

This also can apply to complex computer systems when talking to non-geek clients. Rather than trying to explain to the client exactly how a system works, reorient the example to something they are familiar with. This may sound like you are “dumbing down” the subject but what you are actually doing is just improving the entirety of the conversation’s communication quality.

Too often developers and designers like to prove how smart they are by overtalking their audience, however all they are really doing is making themselves look like horrible communicators and therefore less intelligent, not more.

If you can’t communicate your ideas and meaning then what was the point?

This information is in the AIR_Android_ReleaseNotes_xxxx.pdf. What I am posting here is just meant to shift to the surface some very valuable information.

I know that there are many people out there that manually merge the AIR SDK onto the Flex SDK – myself included. I knew there had to be a better way to do it but “if it ain’t broke, don’t fix it” right?

Well I’m tired of spending those tedious minutes going through folders and copying over files. Yes, if you are in windows this is just a drag and drop operation but not for a mac. We need to get into terminal to do this.

1. In terminal, “cd” to the root folder of the Flex SDK

2. Place the AIR25_mac_sdk_XXXXXXX.tbz2 file in your root folder

3. Run the following command:

If there is a file permissions problem you may need to add a “sudo chop” to the front of that command, as such:

FYI. The “sudo chop” was supposed to be a joke.

HTH

Once you have your project set up (Flash Professional or Flash Builder) and all the required downloads from the earlier post we still need to do some setup before we can start running the emulator and releasing to your Android device.

This is where that ANT file will really help your development. What we need to be able to do is startup the Android SDK and AVD Manager, download some packages, and set up some virtual devices. Only once this is done can we create emulators of different types and start installing.

Before going down the next steps make sure to set up your build.properties. Once you have all your paths set correctly we’ll be ready to move forward. What you don’t realize is you already have a working development environment, now let’s see how to use our environment.

Information on how to use the command line for all your commands is in the Android Development Guide. I’ve just made it a bit easier by providing a preconfigured ANT file.

Starting up the Android SDK and AVD Manager
The next few steps all take place in the provided Android SDK and AVD Manager. To startup the manager is very simple, with ant execute the start_up_manager target.

With this command properly called the java app should start right up and you should see this.

On the first startup you won’t have any listed virtual devices. We’ll need to add those in.

Select and Download Packages
Before we can create a virtual device you need to go get some packages for your device to run on.

Go to Available Packages and select the packages you want to download. Depending on the amount of packages you select you may be here a long time – I just did them all because I am crazy like that. I’d recommend getting a drink right about now.

Once all the packages you’ve selected are downloaded the waiting is over, we can get moving now.

My Installed Packages.

You can go through your finder/browser and see the downloaded packages in your platforms folder.

Setup Your Android Virtual Devices
With your packages downloaded we can now create our virtual devices on the Virtual Devices window.

Now you can go to New… and create a new Virtual Device.

Select your target platform.

The final thing that you need to do is to add abilities to your new virtual device by adding hardware specifications.

Once you have your virtual device set up we can run it as an emulator. You can set up as many of these as you like so don’t hold back.

With your platforms downloaded you can also set up your AVDs through the ANT file by calling the following command.

1	$ ant -buildfile build.xml create_virtual_device

Startup the Emulator
Once you have some virtual devices set up you can just click on Start… and startup the emulator, ready for installing and testing.

You can also do this through the ANT file by calling the following command.

1	$ ant -buildfile build.xml start_emulator

Install the AIR Runtime on the Emulator or Android Device
These next parts require going either through the ANT file or command line. For the ANT file installing the AIR Runtime on the emulator is extremely simple. With your Emulator started up just call the following ant command.

And for an Android Device just call:

The provided scripts expects that there will only be one emulator and/or one device connected at a time.

Install your Application on the Emulator or Android Device
Installing an Application on the emulator or Android Device is extremely simple – just as simple as installing the Runtime. With your Emulator started up just call the following ant command.

And for an Android Device just call:

The provided scripts expects that there will only be one emulator and/or one device connected at a time. The ANT script currently recompiles and builds the application and then deploys it to the target device.

DONE!
Once you have done all of this you will have a working development environment up and going. Good luck in your Adventures with Android.

If you are starting with this post I recommend actually starting with a previous post introducing AIR for Android Development. There is a ANT file there that you will want to have.

FYI: All these steps are also available in Developing AIR Apps for Android PDF provided by Adobe.

Unlike Flash Professional we won’t be able to create an .apk file from our IDE. We can debug from the Flash Builder IDE, as shown by Renaun. That being said, that is where my ANT build file is even more helpful as it can package your application into a .apk file quickly for you.

Let’s set up this project.

Step 1: Startup
Create a new Flash Builder Project. File > New > Flex Project.

Step 2: Project Settings

Make sure the application type is Adobe AIR and that you are using the SDK that you created with the AIR 2.5 SDK.

Then click next twice or until you get to this screen.

Change your main application file to “[Your Application Name].as”. By default it will try to create an MXML file, but as we are trying to make an AS3 project we need to change the file extension to being “.as”.

It’s also good practice to change your application ID to be something a bit more unique – I always just add in reverse domain extension to it.

Click Finish

Step 3: Program
You should now have an application that looks like this:

You can keep programming your application to whatever you want. As I just want a quick application that shows Hello World so that we can continue, my application is going to be very simple.

My Application:

Step 4: Setup your descriptor file
First thing you should do is make sure that your application descriptor namespace includes “2.5″:

If you are using the right SDK, this shouldn’t be an issue.

We only need to change a few attributes in the application descriptor file to get things going. Any other changes that we need to make will be more specific for your application.

In the “initialWindow” tag find “visible”. Make sure it is set to true.

Now find “supportedProfiles”, set this to mobileDevice.

Now go to the “content” tag and change it to “[Your Application Name].swf”. Flash Builder typically switches this name out for us, and I could do it in my ANT file. But I can be lazy at times and would prefer just to set this value. Especially since this application descriptor belongs to the one specific application.

Step 5: Package your application
Your application is now ready to be changed to a .apk file for release. This is also when I will diverge from the Adobe PDF. See, I don’t like command line. So I created that nifty little ANT file to do everything I need. Now go get that ANT file and add it into your project and make any changes necessary to the build.properties as described previously in the last post.

With the settings changed to your specific computer we are good to go. You can either run an ANT file from command line or from your IDE.

From the IDE:

Here I right-clicked on the build folder and went to Run As.

Or from your command line you can run the ant file. Just “change directory” to your project holding the build.xml. Here you can type in one of two commands.

Both mean the same thing as the build target is the default target in ANT and the build.xml is the default file. If you wanted to run a different target you could.

To run get_devices

1	[Hello World Directory] $ ant -buildfile build.xml get_devices

To run start_up_manager

1	[Hello World Directory] $ ant -buildfile build.xml start_up_manager

After you run the build target you are good to go. The ANT file will spit out your .apk file in a release folder. That’s it, you are ready to get away from the Actionscript and into the Android release process.

If you are starting with this post I recommend actually starting with a previous post introducing AIR for Android Development. There is a ANT file there that you will want to have.

FYI: All these steps are also available in Developing AIR Apps for Android PDF provided by Adobe.

Step 1: Add Extension
Go to Help > Manage Extensions… and install the AIR for Android Extension for Flash CS5. (Yes, CS5 is required).

Step 2: Restart
Restart Flash CS5

Step 3: Create Project
Create a new AIR for Android project.

Step 4: Save
Save the the document.

Step 5: Write your App
Do whatever you want. Here I’m going to add text that says “Hello World”.

Step 6: AIR for Android Settings
Now we do the Android specific steps. Go to File > AIR for Android Settings.

With the settings:
Output File: Hello.apk
App name: Hello
App ID: Hello
Aspect ratio: Portrait

Step 7: Set up the Deployment…

On the Deployment tab, make the following settings:

• Certificate: Point to a valid AIR code-signing certificate. You can click the Create button to create a new certificate. (Android apps deployed via the Android Marketplace must have certificates that are valid for 25 years.) Enter the certificate password in the Password field.
• Android deployment type: Release
• After Publish: Select both options
• Enter the path to the ADB tool in the tools subdirectory of the Android SDK.
• Close the Android settings dialog by clicking OK.

Step 8: Update the AIR Descriptor file.

• Open the application descriptor (located in the directory where you saved the .fla file).
• Change the tag to and make sure that it contains a value of the form: number.number.number
  For example: 0.1.0
• Save the file.

Step 9: Publish
Now just go to File > Publish and you can export your .apk file. We’ll still need to install the runtime and the application on the emulator and/or device, but for now we have our .apk file ready to be installed.

This September I’m proud to present again for 360|Flex and the conference goers in DC. I’ll be covering a hands on and best practices to developing with the Android Device using Adobe AIR.

I’m hoping many of you come out and check out this hands on. I’ll be going over environmental setup, development, best practices with development, and tips and tricks to debugging and final releases. After you leave this hands on you should be popping out Android applications just as fast as you can dream them up.

Go checkout and register for 360|Flex DC now! There are tons of A-List presenters and fun activities to be had.

The tricky part isn’t writing the application. That part is easy and we know that part. The tricky part is building the .apk package and testing the application on an emulator or other valid device.

So that is what I am going to write about, the tricky parts.

• - Managing the Android Development Environment
• - Building the Hello World Application in Flash Professional
• - Building the Hello World Application in Flash Builder

Once you read through these posts you’ll have an up and going Air for Android development environment and an initial application to kick you off.

Starting these posts off I will add a few disclosers:

1. 1. I am not a fan of command line.
2. 2. I am not a fan of messing with the paths in my computer.

I am not a fan of command line
I just don’t like memorizing a ton of commands or having to go back and reference a ton of commands and paths. One small path issue and BAM nothing works and you have to read through a ton of mixed code to see where your problem is. Not fun.

I am not a fan of messing with the paths in my computer
Seems like every programming language I get into requires a bunch of path changes and if I move computers now nothing works till I set it up. Not fun. I also fear screwing up my computer.

In case you like setting up paths or want to know how there is a guide provided by Adobe called Developing AIR Apps for Android in the prerelease site. That PDF includes a section Setting the path environment variable. Follow that guide.

Solution
I like using ANT. I can set up all my paths in ANT and ANT works directly into your continuous integration environment. So if I move computers I can just set up my properties I’ll be good to go. Finally the amount of commands to memorize goes WAY down or you can just look into the ANT build file and see the available possible commands.

Expert tip!
You can always view the available targets in an ANT file in the command line by running the following command.

1	ant -buildfile build.xml -projecthelp

Want to know what else is pretty slick? I’ve set up the ANT file for you. I’m thinking of making a nice GUI in AIR to help you out, but for now an ANT file will have to help.

Getting Started
The things you’ll need to get started with Air for Android.

1. - Download the Android SDK
2. - Sign up for the Air for Android Prerelease program
3. - Download Air 2.5 from the prerelease site (if you don’t already have access to the prerelease site, you’ll have to wait for your email after you sign up for it)
4. - Download the prerelease Runtimes (emulator and device)
5. - Download the Flex 4 SDK
6. - Combine the Flex 4 SDK with the Air 2.5 SDK

Creating a Project
AIR for Android currently works best with either a Pure AS3 project (no Flex) in either Flash Builder or Flash Professional. If you are building with Flash Professional, there is an extension that Adobe has provided for you to help speed up the .apk build process. If you go through Flash Builder you’ll have to make this file. Again, with the ANT file I am providing either is a very simple path, so choose the development environment that you prefer.

• - Creating a Flash Builder Project
• - Creating a Flash Professional Project

Setting Up Your ANT File
Once you have your projected set up you will be ready to add in the ANT build information. The ANT file that I will use for the rest of these posts is really easy to set up, just drop it (and base.properties) into your application in the root level.

This ANT file provides you the ability to install the device and emulator runtimes, install your application and test it on a device or runtime, set up a device, run the emulator and even run the Android Management device. Again, yes you can do all these things in the command line… but do you want to?

Then you need to create a build.properties text file. This is the file that you will put your own environment’s paths. So if you share this build file, everyone can have their own properties and the main build.xml is the same and unchanged.

build.properties

You’ll probably notice that I put my Android SDK in the same folder as my Flex SDK. This isn’t necessary, I just thought it’d be nice that all the information for my development environment would be in one location.

In upcoming posts we’ll go through how to use the ANT file and manage your development environment.

Good luck in your Adventures with Android.

Don’t miss this, this is the link for the ant files!

If you previously downloaded this ANT file please redownload it. I’ve added quite a few additions to it that should make your development much easier.

From here checkout how to manage your Android SDK environment, how to create a Flash Builder Android Project, or how to create a Flash Professional Android Project.