File Browser Air Native Extension for Adobe AIR developers

Do you want to browse the sdcard from your Air mobile project? and let the user to pick one or some files to use inside your app? well, you don’t have to build the whole interface inside Air, instead, you can use this cool extension to easily open a file browser dialog window and browse through files and folders in your sdcard and touch to pick the files you want.

• Easily call and open a browser dialog
• select multiple files
• search files and folders
• preview icon for popular files
• get full path to selected files

Below is a usage sample code: you may also check out the sample FLashDevelop project below. (to run the sample project, you should copy the .ane into the lib folder and of course set the path to Flex and Android locations from bat/SetupSDK.bat)

don’t forget to include the necessary permissions in the android manifest file application.xml

Regards,
MyFlashLab Team

Android Loading dialog native extension for Adobe AIR developers

With android loading dialog extension you can easily create loading dialogs and control them from your Air project.

• you can create the dialog and decide if it is cancelable by device back button or not
• you can optionally create a BitmapData in your project and send to the extension to show on the dialog
• you can create classic or progressive dialogs
• you can set the position of the dialog on your screen
• custom title and message

Please check out the sample FLashDevelop project below. (to run the sample project, you should copy the .ane into the lib folder and of course set the path to Flex and Android locations from bat/SetupSDK.bat)

The following example shows how you can create a classic loading dialog window

The folloiwng example shows how to create a progressive loading dialog and how to update its value

don’t forget to include the necessary activity in the android manifest file application.xml

Regards,
MyFlashLab Team

Android like menu Air Native Extension for Adobe AIR developers

Using AS3 and Air for developing mobile apps is very cool but I’m sure you always wanted to be able to build an android like menu in your projects to avoid writing many lines of code to create your own menu! now with this extension, you can create a native extension which looks and works similar to how menus work in android.

• modify colors
• insert as many buttons as you like
• custom icon and label
• custom arrangment
• modify animation effect

Below is a usage sample code: you may also check out the sample FLashDevelop project below. (to run the sample project, you should copy the .ane into the lib folder and of course set the path to Flex and Android locations from bat/SetupSDK.bat)

don’t forget to include the necessary permissions in the android manifest file application.xml

Regards,
MyFlashLab Team

PDF Reader Extension for Adobe AIR developers

Opening pdf files, something useful but impossible for an AIR app developer. Now it’s easy and possible

If you have ever wanted to be able to open pdf files from your Air app, this extension can do the job easily for you!

To run the sample project, you should copy the .ane into the lib folder and of course set the path to Flex and Android locations from bat/SetupSDK.bat

don’t forget to include the necessary activity in the android manifest file application.xml

Regards,
MyFlashLab Team

Google speech API Extension for Adobe AIR developers

The Google speech recognition tech on Android is very cool and enables developers to build many different apps but air developers couldn’t use this library as it was written in native java! but now, you can use this light Air extension, only 79kb, and simply convert text strings into sound objects to play in your air app and also convert voice messages into text words or sentences!

Did you ever liked to develop an AIR app that uses voice commands or wished to create a beautiful AIR dictionary or something like that? Google Speech API Extension now makes things easy for you

• different languages supported (all of the languages that Google Speech API supports)
• Text to speech
• Speech to text
• say something, Extension lists anything that understood from your voice. handy when creating voice commands

using the extension is very straight forward. below are two sample codes to get you going: you may also check out the sample FLashDevelop project below. (to run the sample project, you should copy the .ane into the lib folder and of course set the path to Flex and Android locations from bat/SetupSDK.bat)

The folloiwng example shows how you can run the extension and enable the mic

The folloiwng example shows how you can send a string to the extension and get the voice file to play back

don’t forget to include the necessary permissions and activities in the android manifest file application.xml

Regards,
MyFlashLab Team

rateApp Extension for Adobe AIR developers

Have created the best app or game ever but don’t know how to convince users to rate you?
rateApp Extension helps you on this. you as an AS3 programmer let your users know to rate you after a period of time or after a specific times of launches…

• set after how many days show rating dialog box
• set after how many launches show dialog box
• set all of the rating parameters and texts
• it’s all dynamic and so flexible

Working with this extension is as easy as the following. Happy coding

Run Demo App to Test rateApp Extension!

Or by checking the “Air App Properties” window:

You should also make sure the path to the Flex SDK is set to your computer. Open “bat/SetupSDK.bat” in your text editor and make sure the following paths are correct! Mine looks like below:

 
When working with any extension, considering that each extension does a specific set of functions on device, there might be some manifest permission that must be configured correctly. The manifest permissions for this extension look like below:

I hope you enjoy the rateApp extension

Regards,
MyFlashLab Team

PART 1) Introduction to In-app Billing for Adobe Air

If you were an Android Developer or better to say a Java Developer you absolutely knew what is Google Play In-app Billing because you were completely familiar with Java Documentation Reference. It was a must for you! But most of our audiences here are Air Developers who really want to work with Android and Java! And I know that you are not a Java Developer and don’t expect you to know about In-app Billing or other Google Play services
I myself as an Air Developer even hate to get close to Java Documentation Reference because I’ve really got into the habit of searching in Flash Documentation Reference. You know! I’ve grown up out there

Ok let’s see what new we are offering you:

In-app Billing enables Java Developers, to easily use Google Play In-app Billing in their Projects. You as an Air Developer, can also easily use Google Play In-app Billing Service and will be able to interact with the Google Play purchase flow and payments system indirectly, by means of IPC communication with the Play Store app installed on the device using our In-app Billing Adobe Air Extension. We used In-app Billing Version 2 API in our Adobe Air Extension for it supports both unmanaged and managed products, as well as supports subscriptions, where In-app Billing Version 3 does not yet offer support for subscriptions.

So let’s clarify some important features of In-app Billing and find out more about it:

In-app Billing Version we used supports three different product types to give you flexibility in how you monetize your app. In all cases, you define your products using the Google Play Developer Console, including product type, SKU, price, description, and so on.
• Managed per user account — Items that can be purchased only once per user account on Google Play. When a user purchases an item that uses the “managed per user account” product type, Google Play permanently stores the transaction information for each item on a per-user basis. This enables you to later query Google Play to restore the state of the items a specific user has purchased. If a user attempts to purchase a managed item that has already been purchased, Google Play prevents the user from purchasing the item again and displays an “Item already purchased” error.

  The “managed” product type is useful if you are selling items such as game levels or application features. These items are not transient and usually need to be restored whenever a user reinstalls your application, wipes the data on their device, or installs your application on a new device.

• Unmanaged — Items that do not have their transaction information stored on Google Play. This means that you cannot later query Google Play to retrieve transaction information for those items. For “unmanaged” purchases, you are responsible for managing the transaction information. Also, Google Play does not attempt to prevent the user from purchasing an item multiple times if it uses the “unmanaged” product type. It’s up to you to control how many times an unmanaged item can be purchased.

  The “unmanaged” product type is useful if you are selling consumable items, such as fuel or magic spells. These items are consumed within your application and are usually purchased multiple times.

• Subscriptions — Items that are sold with a developer-specified, recurring billing interval. When a user purchases a subscription, Google Play and its payment processor automatically bill the user’s account at the specified interval and price, charging the amount to the original payment method. Once the user purchases a subscription, Google Play continues billing the account indefinitely, without requiring approval or action from the user. The user can cancel the subscription at any time
  Subscriptions can only be sold using the “managed per user account” purchase type. As with in-app products, once the user has purchased an in-app product there is no refund window. Users desiring refunds must contact the developer directly.

PART 2) What you should do before getting started

Before getting your hands dirty with coding, you need to perform a few administrative tasks, including setting up and maintaining your product list on the Google Play Developer Console, registering test accounts, and handling refunds when necessary.

To start, you should make sure you have a Google Play publisher account where you can upload your app and create a product list. Of course you need to have a Google Checkout merchant account if you want to collect the money, right?
You can register as a Google Play developer and set up a publisher account at the Google Play Developer Console. You can register for Google Checkout merchant account at the Google Checkout site.

You do not need to register for any new accounts to support In-app Billing if you have already these important accounts.

PART 3) Uploading your apk to Google

In the Google Play Developer Console which provides a product list for each of your published applications you can sell items using Google Play’s in-app billing feature.
You can access your application’s product list by clicking the In-App Products link in applications listed in your developer account. Be careful! The In-App Products link appears only if you have a Google Checkout merchant account and the application’s manifest includes the com.android.vending.BILLING permission.
Application manifest is actually an XML file which is contained in Sample Project Download file and it includes some important information of your apk like permissions.

So you should add the billing permission in the manifest:

You must also add the following service to your manifest:

And also the following receiver should be added to your manifest:

Open the .xml file in the sample project you have downloaded and you will see them. You need to apply these modifications in your app manifest file for the extension to work properly.

So before you upload your apk remember to include your application’s manifest the permission (com.android.vending.BILLING). Otherwise you will not be able to add new items to the list.

You will see that it is as easy as abc to upload your apk in the Google Play Developer Console so I refuse to explain it in details. The importance of this part was including permission in the application’s manifest.

Ok after uploading “APK” (you still have not implemented the extension in your project, that’s ok, we’ll get to that later! you just need to upload your apk so that you can add products for it) and finishing the “Store Listing” and “Pricing and Distribution” panels, please keep in mind that you should come to “Service & APIs” panel. You don’t need to publish your apk yet.
In this panel there is a License Key or let’s say Public Key which is very important and you should save it in a secure & safe text file. You need Public Key to use it later in our In-app Billing Extension.

The Google Play Developer Console provides a Public Key for each app. The key for the app is available for copy/paste in License Key for this Application field, as shown in the following figure.

You must enter the following information for each item in a product list after you click on the Continue Button in the above figure:
• In-app Product ID

A product ID must start with a lowercase letter or a number, and must be composed using only lowercase letters (a-z), numbers (0-9), underlines (_), and dots (.). The product ID “android.test” is reserved, as are all product IDs that start with “android.test.”

• Product Type

The product type can be Managed per user account, Unmanaged, or Subscription. You can never change an item’s product type after you set it. In this Extension we are dealing with Managed and Subscription because Unmanaged type is no longer in use in In-app Billing Version 3.

• Publishing State

An item’s publishing state can be Published or Unpublished . To be visible to a user during checkout, an item’s publishing state must be set to Published and the item’s application must be published on Google Play.

Note: This is not true for test accounts. An item is visible to a test account if the application is not published and the item is published.

You can provide localized titles and descriptions for your in-app products using the Add Translations button. If you want Google Play to translate your title and description for you, based on the title and description in the default language, just click the languages that you want to offer. If you want to provide custom translations in specific languages, you can also do that. By default, an in-app product inherits its default language from the parent application.

• Title

The title is a short descriptor for the item. Every item must have a title. The title is visible to users during checkout. For optimum appearance, titles should be no longer than 25 characters; however, titles can be up to 55 characters in length.

• Description

The description is a long descriptor for the item. The description is visible to users during checkout. Descriptions can be up to 80 characters in length.

• Price

You must provide a default price in your home currency. You can also provide prices in other currencies, but you can do this only if a currency’s corresponding country is listed as a target country for your application. You can specify target countries on the Edit Application page in the Google Play developer console.

PART 4) How In-app Billing for Adobe Air Extension works!

Congratulation! You are now able to use In-app Billing service with all you have learnt till now.
Well also thank you very much that you have tolerated us till this part. We appreciate your patience.
Ok, let’s see how In-app Billing Adobe Extension really works. Our Extension is very easy to work with. You should just read this final part and follow our step by step Tutorial

1 – Well the first thing is to import the needed AS3 Classes to your project:

2 – Next step is to make a Variable of the extenstion:

3 – Then we make a Button named “initialize” and give it a Listener:

Well in the above snippet when the Button “initialize” is clicked if (_ex && _ex.isInitialized) happens. This command checks to print “you have already initialized the extension!” if this extension is initialized before. But if it is not initialized yet it initializes the extension:
_ex = new Google(onInitSuccess, onInitFailed, “M32iL+ykKpVz2/BS/mxI8OZITZfMh/AqfnQAB”, true);
Now, let’s see what we have in this line as inputs:
1- If the extension initialization is successful the first function is called: function onInitSuccess()
2- If by any reasons the extension initialization is not successful the second function is called: function onInitFailed()
3- The third parameter if you remember is the Public Key you have saved before: “M32iL+ykKpVz2/BS/mxI8OZITZfMh/AqfnQAB”
4- The last parameter is called Debug Mode which is set to true (You as the Air Developer should set it to true so that you can debug. It enables you to work with fake purchase buttons in your App ).
Please remember to set this parameter to false when you want to release your app in Google Play.

to work with the in-app billing service, you should add some listeners in function onInitSuccess()

4 – Next we make another Button named “is initialized?”:

When it is clicked we actually have called the Getter “_ex.isInitialized”. This Getter returns true/false so we put it in C.log() to find out whether it is initialized or not.

5 – Now another Button we make named “do a fake purchase for debugging reasons!”. You can guess what it is for by its name:

In this snippet we call the method “requestPurchase” and give it two parameters as its inputs.
The first parameter is FAKE_PURCHASE which is a Public Static Constent ( FAKE_PURCHASE, FAKE_REFUND, FAKE_UNAVAILABLE & FAKE_CANCEL ) of Google Class.
This parameter should be replaced by Item ID for a real purchase.
The second one is “developerPayload”. Hey Air Developer! Don’t worry for this is nothing but a string as raw data which is sent to Google Play when the “requestPurchase” is called. Then Google Play returns it. It is optional and can be replaced as an empty string or null. It totally depends on your application.

6 – Another Button we make is “check if subscription is supported?”:

Before asking your app users to subscribe for a service in your app, it’s wise to check whether this subscription is supported in their environment or not! This environment depends on several things like:
• In which country the user is living?
• What mobile device does the person own?
• What is the person’s mobile device IP?
and several other things…

Ok, in order to check whether the subscription is supported or not, call the method “checkSubscriptionSupport”:
_ex.checkSubscriptionSupport(onSubscriptionIsSupported, onSubscriptionIsNotSupported);
In this line there are two functions as inputs:
The first function “onSubscriptionIsSupported” is called if the subscription is supported.
The second function “onSubscriptionIsNotSupported” is called if the subscription is not supported.

7 – Now we make another Button named “do a fake refund behavior?”:

This enables you to test what happens when a refunding happens on a user’s device!
Let’s talk more about the Refund before we go to explain this part.

As an example imagine that I have bought something from your app I am using but I did not like it and want to get back my money from you.
Google Play does not allow me to directly request YOU for refund.
So what should I do is to email you, give you the Order ID and ask you to refund my money.
Then you go to your Google Wallet and “can refund” my Order ID…

We made this time consuming process very easy for you in this Extension:
Well the above snippet is for a fake refund but When you really refund my money from your marchant account, the app throws a notification which tells me as the buyer that my money is refunded. Then the money is automatically refunded to my account. so in the app, you need to know that it has been refunded, so that you can stop the service from working, right? you should check the getPurchaseInfo() method.

There are other behaviors and Buttons. These work as just the fake behavior. Just consider the button name and what is given to “requestPurchase” method when calling:

8 – There is another Button named “get list of made transactions!”. You can guess what it is for by its name:

In this snippet the method “getPurchaseInfo()” returns an Array containing all the transactions that a user has had with your app.

Transactions help users not to buy a product more than once! Imagine a user who has bought an in-app product from his mobile device logged in with his gmail account. If he logs in to another device with his gmail he does not need to buy that app again because Google Play has known his gmail account and the transactions in relation with that gmail account.
You the Air Developer can use the information of transactions like name, order ID and the time of the purchased item.

9 – Ok all you got learnt till here was about testing. Now it is the time to really work with some real money:

REAL $1 PURCHASE! Button

This snippet works as the fake purchase I told you above. It works with requsetPurchase method but instead of Google.FAKE_PURCHASE you should enter a real Item ID here: “test01″

REAL $1.20 monthly subscription! Button

This snippet works as the fake purchase I told you above. You should enter a real Item ID here: “test03″

Request a refund from app owner! Button

to make sure the refund email request is sent to you, please open “refund.php” and replace “define(“SENDTO”, “your@email.com”);” with your own email address.

I hope you enjoy our little In-app Billing Extension.

Regards,
MyFlashLab Team

This Optimization we are offering is Unique

Heh, once again I should say Hello to all Air Developers in the Globe and how are you today?
This time we are talking on how to optimize scrolling in Air Apps in the most Optimizing way you haven’t seen before.
You’ve probably noticed a rough, slow, lazy and low performance when scrolling with a large amount of content in your Mobile Air Projects. Well this is natural to your device CPU for it can not handle the heavy operation caused by heavy and large amount of content!
You as an experienced Air Developer absolutely know all of the issues related to Scrolling in Mobile Air Projects since the AS3 has stepped into the world of APP Development. You are sure that AS3 is amazing! Even it became more marvelous with introducing the Starling Framework with which you are familiar I am sure. It actually simplifies your development on all major mobile platforms out there with all its nice and unique features! We all know these features which help us for a better performance in Mobile AS3 APPs like Scrolling Performance Optimization.

But the more amazing and marvelous aspect of AS3 and Starling Framework is in our hands now. I mean the Ultimate Optimization we have developed for Scrolling in Mobile Air Projects. If you watched our video clip Demo you would know what we are going to talk about.

Did you see how soft, smooth and flexible was the scrolling in the Video Clip? There was a huge content in the scrolling though!
Got surprised or not? Have you seen such a Scrolling Optimization before?

We are going to let you know how we did it. We did show you this, but more surprisingly we intend to make you Feel it in your own mobile air projects. We want to make you Feel this smoothness with your own finger tips.

Ok we told you this is unique but actually it’s nothing special we did. There are just some simple but delicate tricks we used to gain a high level of performance in our scrolling optimization.

So please stay with us in this tutorial:

1 – Firstly, if you have downloaded our Scroller import these AS3 Classes in your project:

Note: The “MyStarlingSprite” & “MySprite” are “Sprite” class of Starling Framework. But we extend them to be used more easily. You can use them too if you want.

OK – Before we go to next step we set some variables of which the most important is named “_body”:

As you see this variable is actually a ClippedSprite Variable ( ClippedSprite is an Extension of Starling Framework. You can search to read more about it if it’s necessary ).

Then you should initialize and addChild the variable “_body” wherever you want in your project:

2 – Secondly, we set a mySprite variable and some properties from which we can make our texture:

You can even make your own texture if you don’t want to use mySprite.

Ok, now based on the dimension of the screen in different devices we define “ITEM_WIDTH” and “ITEM_SPACE” so that we can specify “_numRows”:

• ITEM_WIDTH:

The width if every item

• ITEM_SPACE:

The vertical space between each item

• _numRows:

The number of the rows or actually columns. It depends on different screen devices.

3 – Thirdly, we should do some preparations to initialize our list just after providing the previous information:

“listHolder” should be addChilded to the “_body”.

Ok you see that We’ve set a list holder using MyStarlingSprite() and made a default background using touchTexture().
touchTexture() is a function which uses the previous information we have provided in step 2 ( a few lines above ) as our texture properties.

This is actually one of those tricks we have used: You know there is a heavy content we suppose to scroll! For example 500 different items as you can see in sample project file. So we made a default texture just once and we call it whenever we want!
You know or don’t know but it’s worthy to alarm you that if you make a texture for many and many times it decreases the performance; on the other hand, you can use a texture for many and many times you want without decreasing the performance.

Now, we initialize our list:

This list is fully an abstract class that arranges your items.
new Sprite() is that Sprite of Starling Framework.

As you can see in line 2 of this snippet our list have a property named “holder” that should be equal to “listHolder” that we defined a few lines above.
Another property is named “itemsHolder” which is actually a new Sprite(). ( itemsHolder contains our those 500 different items )

There are some other properties here that I’m sure you can guess what these are for! Of curse these are optional in this tutorial. You can use your own properties.

Then considering _body we call the localToGlobal method and give it a new point. We also initialize a Rectangle class to _body.clipRect and give it the width and height of a place where our _body is addChilded to:

These two lines are actually the settings that are needed for ClippedSprite.

4 – The forth step is to initialize our scrollbar:

Well our scrollbar have a Listener addEventListener which listens to this Event ScrollEvent.TOUCH_TWEEN_UPDATE. So when the scrollbar is Tweening, the function onScrollerUpdate() is called.
There is no need to talk about the rest of this snippet here. You can refer to the our Scroller Documentation you have downloaded.

But let me tell you what is _scroll.holdArea = 10;?
Imagine you want to click on an item in the scrollbar. If you don’t define this property, as you touch the screen the scrollbar starts to scroll and you can not click that item. So you should set this item to 10 pixels or whatever you like to make the scrollbar not to move away when the probable movement is lower than 10 pixels. In this way the scrollbar knows that when the movement is more than 10 pixels then it is the time of scrolling.
Are we clear enough?

onScrollerUpdate() calls an important function in case of our optimization that we tell you later in the last step.

5 – We make two other textures, a texture for mouseOut and another one for mouseOver:

We make two textures and put them in “outT” and “outT” variables.

Well we have 500 different items in our sample project file but we should not make 1000 textures ( 500 for mouseOut and 500 for mouseOver ).
We just make these two textures once in the project and we can use them anytime we want so that it helps to gain a better optimization. This is another trick we used in our optimization!

6 – Now we want to put our items in our list we made in previous steps, so we need to call the function addItems() :

Here you can see a For Loop
var i:int;
for (i = 0; i < 500; i++)
which you could write it this way:
for (var i:int; i < 500; i++)
But you as an Air App Developer should try not to force the mobile device RAM do extra operations. So do it like we did. It really affects the performance.

You know it is true that the app itself does Garbage Collect but you as an expert developer should work in such a way in that there won’t be any needs for the app to do Garbage Collect!

And please keep this line in mind _numItems = _list.items.length;. There is a same story behind which I tell you later in the next step.

We avoid to explain the rest of these lines in this snippet for our main goal in this Tutorial is learning how to gain a higher optimization ( Full documentation regarding our Scrollbar is available in main file you have downloaded ).

But let me tell you for what we have called _list.itemArrange();:
As we add the items in step 6 we should call this method to arrange the items based on the features we have defined in step 2.

Ok in order to align itemHolder to center we divide _list.holder.width by 2 and then we subtract it by _list.itemsHolder.width by 2. We do the same order for for the height.

The line 18 does the same operation as line 19 but again in order to gain a better performance we did our division in this way.

6 – The final step is to call the function optimizeScrolling(). So let’s see what and how the function optimizeScrolling() really does:

Ok do you remember _numItems = _list.items.length;?
We make a For Loop considering the _numItems. But we don’t use _list.items.length because it decrease the performance if you put it instead of _numItems in this For Loop.
You know what I’m talking about man! You as an Air App Developer should observe all of these little tricks in order to gain a better optimization for any App you develop.

Well the Pivotal Trick we have used to gain a better optimization in our scrollbar is here!
Our scrollbar does not show all of the so called 500 different items at once. It only shows the part of the content which can be seen in the device screen

Yes, as you can see here is an if else statement that tells the scrollbar to make the items visible if and only if they are within the device screen dimensions. Otherwise the item visibility is set to false ( item.visible = false; ).

I hope that you enjoy this Tutorial and can create awesome Air Apps with Ultimate Optimization. If you do so, do send us a link, we’d love to see what you have created using these tricks.

Regards,
MyFlashLab Team