Controlling A Basic Arduino Circuit Using An iPod & Titanium Mobile from Boydlee Pollentine on Vimeo.

This second video is the same concept but using a piezo element to play some basic music...it's pretty straight forward basic beginner stuff but if anyone wants the source code I'm happy to post it.

Appcelerator Titanium Keyboard & Arduino w/ Piezo Element from Boydlee Pollentine on Vimeo.

There are three main reasons for using this kind of pattern;

1. It stops you polluting the global scope. It does this by creating one (ideally) global object that all the functionality for your app is added to, 
2. It helps you avoid naming collisions or excessive variable prefixing (ie creating stacks of vars that look like item1, item1_1, __item1, etc),
3. Memory management - by putting everything into the same global object namespace, you avoid multiple Ti.include() statements, which are essentially including files over and over again unnecessarily. This is particularly prevelant when you start opening multiple window objects and have all your Ti.include() calls at the top; this rapidly leads to memory starvation and your app crashing.

Let's create a basic example application that reads in a couple of RSS feeds and shows them on two separate views, which have 2 separate JS files, and use the same context.

Create a new project in Ti Studio, call it whatever you want (I've called mine NamespaceMethod). Delete the pre-set code out of the app.js file, and then create two new files called feed1.js and feed2.js respectively, and add these to your Resources folder.

Now let's create the TableView for feed1.js...

...and feed2.js and save both of those files:

Run your app in the simulator now and you'll (hopefully) see a screen that looks like this:

Now let's fill those two TableViews with some data from 2 separate remote RSS feeds. We're going to define the feed URL's in app.js, then create a new javascript module file called api.js which is going to handle calling and returning our JSON data. Note here that you will probably want to structure your app a bit differently to this, but this example is more about showing you how to keep everything in that single namespace context.

Edit your app.js file by adding the following couple of lines to it, right after the RSSAPP declaration at the top. Note that I've used YQL to automatically do the XML Feed -> JSON conversion for us.

Now create the api.js file and save it to your Resources directory. Type or paste in the following code. This simple module just accepts a URL and creates a HTTPRequest and passes back the JSON-formatted response data via the 'success' function, or throws any errors back via the 'error' function.

Now we can call our "grabFeed" method from within the api.js file from anywhere in our app that utilizes the RSSAPP namespace. Let's populate the table1 object first - open up feed1.js and enter in the following code, just before the final line where you are adding the table1 object to the window. It should look like this:

Run your app in the simulator again and you should see that the first tableView (top of screen) is populated with RSS data from http://boydlee.com/feed.html.

As we're on mobile devices and we want to avoid using too much bandwidth (not to mention HTTPRequest collisions) we're going to populate the second table only when the first table has finished its data request/population. Add the following function call to feed1.js directly after the line "RSSAPP.table1.setData(rows);"

And now let's update feed2.js so it looks like the following:

Finally, run the app in your simulator. You should see table1 populated by data from http://boydlee.com/feed.html, via YQL, and when it has finished you'll see the data from the Appcelerator Developer Blog feed populate table2.

So what have we learnt from this sample? Firstly, you can see we no longer need to import the same file a hundred times - both the feed1.js and feed2.js files can access the webservice functions from api.js without multiple inclusions. This means less redundant code and less memory usage.

You also now have a convenient global structure - properties and objects added to the RSSAPP namespace can be accessed from within any part of your app at any time.

App-wide data can be instantiated once, and used over and over again. You can see this happening from the properties we created to hold the feed URL's - these were defined in the namespace from within app.js, and then accessed and passed around throughout our files.

Functions can now be defined as belonging to our namespace, meaning they can be executed from anywhere. You can see this happening when we call the loadFeed2Data function - it is declared within feed2.js but we're calling it directly from feed1.js, essentially removing the need for firing off multiple events or doing unnecessary Ti.include()'s.

Because all your windows and views exist in the same namespace they can be immediately instantiated - giving you faster app performance.

You can download the sample project here, and please comment if there's any mistakes in it (I wrote this fairly quickly!).

Entries will close on the 28th of December, 2011 at Midnight CST (6am on 29th December GMT if you live in the UK, Ireland or Western Europe).

Note that I am pretty busy so I can't always respond straight away but I will try to get back to everyone as quickly as I can.

Here's a bit of a blurb:

Appcelerator Titanium Mobile allows developers to realize their potential to develop full native iPhone and Android applications by using free Titanium Studio tools without the need to know Objective-C or Java. This practical hands-on cookbook shows you exactly how to leverage the Titanium API to its full advantage and become confident in developing mobile applications in no time at all.

Appcelerator Titanium Smartphone App Development Cookbook offers a set of practical and clear recipes with a step-by-step approach for building native applications for both the iPhone and Android platforms using your existing knowledge of JavaScript.

This cookbook takes a pragmatic approach to using your JavaScript knowledge to create applications for the iPhone and Android platforms, from putting together basic UIs to handling events and implementation of third party services such Twitter, Facebook and Push notifications. This book shows you how to utilize both remote and local datasources using XML, JSON and the SQLite database system. The topics covered will guide you to use popular Titanium Studio tools effectively and help you leverage all the advanced mobile features such as Geolocation, Accelerometer, animation and more. Finally, you’ll learn how to register developer accounts and how to publish your very own apps to the Android and Apple marketplaces.

If you prefer to buy from a regular retailer, such as Amazon, here's those links below:

Amazon UK: http://www.amazon.co.uk/Appcelerator-Titanium-Smartphone-Development-Cookbook/dp/1849513961

Amazon US: http://www.amazon.com/Appcelerator-Titanium-Smartphone-Development-Cookbook/dp/1849513961

Waterstones: http://www.waterstones.com/waterstonesweb/products/boydlee+pollentine/appcelerator+titanium+smartphone+app+development+cookbook/8847564/

Book Repository: http://www.bookdepository.co.uk/Appcelerator-Titanium-Smartphone-App-Development-Cookbook/9781849513968?gbase=true&utm_medium=Google&utm_campaign=Base&utm_source=UK&utm_content=Appcelerator-Titanium-Smartphone-App-Development-Cookbook

Sprint: http://www.sprintbooks.co.uk/scripts/browse.asp?ref=250657

I will be putting up a page on my website where you can list any omissions, questions or mistakes (there's always a couple!), and I'll do my best to answer your questions and provide updates and revisions.

Thanks everyone for your support,

Boydlee

I needed to extend the size of a VirtualBox Hard Disk (VDI file) in order to install some new software on it - being a tightwad I'd only given the drive 25GB initially and needed at least another 10gb.

To do it, open Terminal on your Mac and navigate to wherever the VDI file for your VirtualBox machine is located, and then type in the following and hit enter:

VBoxManage modifyhd NAME_OF_YOUR_HARD_DISK.vdi --resize NEW_SIZE

Where the name of your hard drive and new size are valid values, such as the example below. Note the size parameter is in MB, so 40,000MB = 40 gigabytes (approx). Make sure you also escape any filenames with spaces in them - even easier is to start typing the first word of the filename in terminal and press "Tab" - this will fill out the rest of the filename for you.

VBoxManage modifyhd Windows\ XP\ Hard\ Disk.vdi --resize 40960

Once you have done that, start your VirtualBox machine and once it loads, go into Control Panel -> System & Security -> Administrative Tools -> Create and Format Hard Disk Partitions. You will see a section called "Unformatted Disk Space" usually next to Disk 0 (which would be your C:\). You can then right-click on the C:\ and extend the partition size utilizing the new, extra drive space you just created.

Titanium Mobile: Build an Image Uploader

This is a fairly straight forward, single page article and I hope you enjoy it.

I'm not going to give away the actual questions here (nor can I remember them anyway), but the following list should provide you with a good starting point for what topics to study. It goes without saying that you should understand Javascript properly before even attempting the exam.

1. Basic UI, Layout and Objects 
   • • you should understand the basics of creating controls and their proper namespaces (e.g. how do you create a Ti.UI.createImageView and add an image to it?)
   • • you should understand the basics of JSS
   • • you should know how event handlers work properly and how to attach listeners to your controls
   • • you should know how to layout your apps using absolute positions and vertical/flow positioning
   • • make sure you understand device orientations (portrait, landscape and the events fired when orientating)
2. Code structure and modularity
   • • you should know how to create modularized code and how to attach event handlers to your modules
   • • know how and when to use Application Properties and when not to
   • • you should know how to do device checks using Ti.Platform
   • • from what I saw on the exam there wasn't a great deal about particular framework patterns such as Tweetanium or CommonJS - though that may change in the future as these patterns increasingly become the recommended way of developing your apps
   • • understand your tiapp.xml files inside-out
   • • know how to at least include a pre-built module into your app and how to use it
3. SQlite and local database and filesystem calls
   • • you should know how to save and read in files using the Filesystem
   • • know how to create a Sqlite database and how to attach an existing one
   • • you should know basic SQL syntax as there will be questions that involving performing database queries
   • • you should definitely know how to perform a SQL 'select' query and parse the results
4. XML HTTP Requests & JSON
   • • you should most certainly know how to make a HTTPRequest (XMLHTTPRequest) and parse the response contents
   • • you should most certainly understand how to read, parse and iterate over JSON objects
   • • you should most certainly understand how to read, parse and iterate over XML objects
   • • know how to upload a file to a server and understand content types
5. Camera, Photos, Audio, Video and other media
   
   • • you should know how to call the camera and parse the resulting media contents
   • • you should know how to call the photo gallery and parse the resulting media contents, and understand media types
   • • you should know how to do implement video, audio and sound player objects
6. Maps and Location services
   
   • • you should most certainly know how to create a Mapview, understand how to set regions, add annotations, etc 
   • • know and understand geo-encoding - both reverse and forward geo-encoding
   • • understand the differences in creating mapviews between iOS and Android
7. WebViews
   
   • this is the section I remember doing worst in, because it happens to be the section I do the least work on day to day, so...
   • • understand webviews, including setting remote and local HTML content
   • • understand passing around events between your webviews and your app
   • • have a rudimentary understanding of the canvas object
8. Social API's and Contacts
   • • you should most certainly know how to integrate Facebook and make Graph API calls using the Titanium FB objects
   • • you should know how to read in from the local contacts storage on your device
   • • have a decent understanding of oAuth
9. Titanium Studio and device packaging and distribution
   • • you should most certainly understand Ti Studio - how to create a project, how to run on device, any limitations of the simulator, etc...
   • • wouldn't hurt to properly understand provisioning profiles and certificates and how to build your app directly from XCode

That's all I can think of for now, I think if you can understand all of the points listed above you should be totally fine with the exam. Good luck!

http://www.titaniumdevelopment.com.au/blog/2011/10/19/this-week-in-titanium-mobile-development-17-oct-2011/

I have recently given an interview with Learning Titanium about Titanium Mobile development and my upcoming book.

You can read the full interview between myself and Sharry from LearningTitanium.com here: http://www.learningtitanium.com/featured-apps-and-developers/boydlee-pollentine.html