Ready, Set, Read

I have read through Chapter 4 of the O'Reilly Flex 2 e-book. Thus far, the book has given a thorough introduction into Flex, how its used, and the different components that combine together to create flex applications. Chapter 1 gave a a broad overview of Flex, its integration with Flash (flex apps compile into .swf binaries), and its ability to load content at runtime.

Chapter 2 provided a broad overview of the Flex framework, how to compile flex applications using the SDK and Flex Builder, and setting up cross-domain policies on the server- addressing the security issues that occur with cross-site scripting.

Chapter 3 gave a functional overview of MXML, Flex's markup language (somewhat a mix between HTML and XML) to create user interfaces, including basic tags, containers (to be used later for dynamic content loading), event handling, and data binding.

Chapter 4 gave an overview of ActionScript as it relates to Flex. Essentially, Flex is Actionscript, as is MXML. ActionScript is a full-fleged Object Oriented language, with syntax similar to Java, utilizing packages, visibility modifiers, variable declarations, static variables, constants, and methods and its reliance on class declaration, object instantiation, the importance of scope, and the management of synchronous error handling (try-catches). Key differences with ActionScript is that it does not allow overloading, the way it utilizes getters and setters, the way it handles arrays (more similar to PHP than Java in that they are not strongly typed), its emphasis on event dispatching and listener functionality, and lastly, its inherent integration with XML.

Below is a screen shot of an interface I have developed to test a simple ActionScript:

Flex 2

This weekend, I have managed to obtain an e-book of the O'Reilly Programming Flex 2 to serve as a reference and building block for creating Flex applications in Adobe Air.

I have also managed to obtain a copy of Adobe Flex Builder 3 to use to code in Flex. I hope to have a working model by tomorrow of a simple calculation script in Air, which I can hopefully extrapolate to rewrite the Credit Union game written in GWBasic.

Open the File

I have made a bit more progress with the text editor. I have a browse button in the application to open an existing text file for editing. I have the dialog open up, and limit the user to only open *.txt documents, then have the application open a file stream and read its contents. For binary data, this is done using

var stream = new air.FileStream();
stream.open( file, air.FileMode.READ );
stream.readBytes( header, 0, 0 );
stream.close();


However I need to read flat ASCII files, not binary files, and this is handled differently in javascript and AIR. I am still searching for a good reference book that outlines the AIRAliases script as well as the AIR document object model (DOM).

Save File As Prompt

I have a basic model working that allows me to write to a and save the file to the document with a specified name "note.txt" (using the AIR air.File.desktopDirectory.resolvePath()).

This functionality is a start, but it is too limited. I want to be able to save a file to a user-specified location, using a user specified name. I am still in search of a good reference for some built-in AIR DOM and methods.

I have come a cross the method browseForOpen(), which I can use later to open an existing note. Unfortunately, my guess of browseForSave() to save a file is not working...

I will continue searching for a more thorough AIR reference online.

Working with the File System

After completing my image resizing and database applications, I am working on creating a simple AIR application that manipulates/creates a file on the local machine. The application will allow a user to browse for an existing file, make edits to the file, and save it to specified directory (essentially a simplified text editor, similar to notepad). I have begun work on the application, with the basic GUI set up and the basic logic working, but I will need to figure out what AIR file methods are available to both read and write from files/filestreams, as well as how to allow the user to browse his system's file system.

I may end up building on this application to use the AIR default menus.

SQLite + AJAX

After playing with the AIR SQLite Admin (mentioned in the previous post), I created a simple database using the following SQL:

CREATE TABLE contact (
id INTEGER primary key autoincrement,
fname TEXT,
lname TEXT,
email TEXT
);

I also downloaded this large collection of samples for AIR 3 Beta

I began playing with the CRUD example, which is a simplified version of what I wanted to complete for my project. In the example, a simpler database is used, using only two columns (id and name). I wanted to make my own contact management system, so after about an hour's work, I had a fully working example, using four fields (id, first name, last name, and email). This project helped me better learn how to connect to the SQLite DB from AIR, as well as furthered my understanding of basic AJAX, particularly how to use the javascript methods createElement, and appendChild. The adaptation of the CRUD example provided proved to be a bit more difficult, as it was a bit oversimplified, and adding database columns requires a great deal of modification to the example. Below is a screen shot of my project using the more robust database.


After completing the SQLite/AJAX example, I went on to work on the image scaler. Originally, the scaler used a fixed scale ration (25%). I modified the example to use user input to scale the image appropriately, as well as return a success message on completion. The application appears as the following:

For my next project, I hope to use a Map API such as GoogleMaps or Yahoo Maps Beta

I also will be sure to post more blog updates as I do these projects- I have a tendency to play with AIR for 20 minutes at a time, and not post what I have learned until I have completed the projects. Instead, I will keep my blog up to date as to my progress.

Nifty Air Functions

So after reading through the AIR Ajax Tutorial, I decided to play around a bit with AIR and its asynchronis abilities. I created a small application that simply tells the user the status of the network connection by checking an RSS feed from macromedia's site. Below are two screen shots of the small application (note the highlighted sections):
And when the network connection is disabled....

I've also started to play with SQLite and AIR. After some struggle to determine how to execute queries from AIR, and looking at this tutorial, I ended up looking elsewhere for a simple way to manipulate data in the SQLite database. I found an Air-based SQLite Admin Application and have been familiarizing myself with SQLite syntax, which is not too different from any other SQL langauge. I plan on writing my next small application to modify and update data in a local SQLite database. Thus far I have a small table created called 'Contacts,' and I plan on using this table for my test application.

Until then, I will continue poking around different AIR tutorials and web blogs to see what other things are possible.

On my Way

I've begun the tutorial Introducing Adobe AIR for Ajax developers to look into how to incorporate AJAX and dynamic content into Adobe Air.

I've also begun poking through the code of the Credit Union Management Game and looked into the logic. The code is a little archaic, very much unlike traditional languages I am used to, but I think that I should be able to figure out some of the logic by simply poking around and looking up GWBasic syntax. Thankfully, the code is well commented, so that may make things a bit easier.

I hope to finish the AJAX tutorial this weekend and include some screen shots.

Development Begins

After reading the first chapter of the O'Reilly Adobe Integrated Runtime (AIR) for Javascript Developers, I have a greater understanding of the advantages of using AIR for application development, particularly as opposed to using a standard internet browser. While the book goes into detail the specific advantages over traditional browser-based web applications, the main advantages are outlined below:

• AIR was specifically designed for applications, unlike browsers, originally designed to serve simple HTML pages
• Better control flow of applications. (ie no Back Button that can cause state loss, or control flow exceptions)
• Integration with the Desktop, including greater interaction between web applications and desktop applications
• The ability to utilize the application when an internet connection is unavailable
• No need for platform-specific code, particularly with Javascript, AJAX, and CSS
• No need for application developers to have to learn new languages

I've set up my development environment as outlined in the text. I've created a simple test application, utilizing a basic HTML and xml document. The book's example experiences errors with the latest versions of the runtime and SDK versions of AIR. Below are some screen shots experienced, and the process used to troubleshoot the problem.

This appears to be a problem with the XML descriptor file. I changed the runtime version from "http://ns.adobe.com/air/application/1.0.M4" to "http://ns.adobe.com/air/application/1.0.M6".

This solved the first problem, but then the ADL began to complain about other tags in the XML file, which led me to believe that the XML notation must have changed with the newest version of Air. I found this tutorial, and began basing my XML descriptor file on the given example.

After correcting the XML, the ADL stopped generating errors. The application would run, but for some reason the GUI would not load, and the application would simply hang with the following prompt "init function called" is a return statement from the HTML file, so we know that the application is running, but for whatever reason, the AIR GUI is not loading.


Unfortunately, the AIR/AJAX tutorial does not go into detail in how to utilize the ADL and ADT binaries to test/build the application.

After some tweaking and trouble shooting, I realized why my GUI for my application was not coming up... it helps to set the visibility of the application to true in the XML descriptor file.
<visible>true </visible>
And Voila:

I have successfully created my first HTML AIR application, with only a few bumps and dents along the way!

Starting Development

I've begun researching how to get started with developing applications for AIR. It appears that almost all application development can be done with the Adobe CS3 suite, which I have already installed on my system. I am interested in pursuing Flex and how to incorporate it into AIR apps. An important download to get started with development in AIR is the Adobe AIR SDK.

I plan on following this tutorial on how to incorporate AJAX into Adobe AIR. The tutorial gives a good foundation on how to get started.

I have also been looking for Adobe AIR books on Amazon.com and plan on going to some local bookstores to see if I can pick up a good book to reference and give me some potential projects for my directed study.

Installing Air

Installing Air is relatively straight forward; all one must due is download the executable and run it; I did not have any dependency problems and the installation ran seamlessly. I then used the Adobe Air Showcase to download an application to test my installation. I had to sign up to become a member of the Adobe community (which was free) to download any of the showcase applications. I decided to try FinetuneDesktop as my first Air application, so I downloaded the .air file to my desktop and ran the application. The install ran successfully and placed an icon on my desktop.

The application is extremely light weight, accounting for no more than 8% of my processing power when idle, and taking only 66mb of memory usage. The primary framework of the application appears to be Adobe Flash, and Flex. I will continue to test additional applications utilizing different frameworks as backends.

First Post

Welcome to my MIST 5990 Directed Study Blog. From this blog, I will log over the course of the spring 2008 semester my work with rich internet applications, particularly with Adobe Air (Adobe Integrate Runtime). Adobe AIR is an cross operating system run time environment/framework built primarily to allow for Flash, Flex, Ajax, and HTML applications that can be deployed as desktop applications. It has great potential to allow for rich user-interaction, real-time data acquisition and manipulation, and lightweight powerful applications. Competing concepts include Microsoft Silverlight, JavaFX, and Mozilla's XUL. The official web site for Adobe Air can be found here. From the site, one can download Beta executable versions of the application as well as some showcase applications to demonstrate what Adobe Air can do for free.



I hope to post to this blog at least three days a week, keeping it up to date with my progress with Adobe Air. Check back soon for updates and summaries of what I am currently working on.