The first step is to register at http://www.madewithmarmalade.com/blackberry. Then create your BlackBerry 10 application using the Marmalade SDK and submit it within 30 days in “Draft” to BlackBerry World. Don’t worry, it doesn’t have to be 100% ready for this first step!

The first 300 qualifying vendors will receive a free BlackBerry Dev Alpha testing device on loan. Once apps are completed, submitted for final review, and approved, you’ll receive your free Marmalade Indie License (value of $499 USD) and you’ll get to keep your testing device to create more apps!

Our Marmalade License offer last year was extremely popular with over 1,000 apps created! Be sure to register quickly to secure your free Marmalade Indie License and be one of the first 300 to get a free BlackBerry Dev Alpha device.

If you already received a BlackBerry Dev Alpha device, you won’t qualify for an additional one. However, you are still eligible for the free license. Previous recipients of a free Marmalade License through a BlackBerry offer are not eligible to enter this promotion

For those that don’t know about Marmalade, it’s a powerful cross-platform SDK for the creation of richer apps and games on BlackBerry, iOS, Android and other platforms.

Marmalade makes it easier than ever to create BlackBerry 10 apps. Why not try developing your app with the new Marmalade RAD tool, which you’ll get for free when you sign up? Marmalade Quick is a fast, flexible and open RAD programming environment for the creation of 2D games and apps. It’s based upon best-in-class open source components including Cocos2d-x/Box2D, and the entire engine is made available in source code.

www.madewithmarmalade.com/BlackBerry

This article will aim to explain how to build a native app from the command line, using the tools bundled in the BlackBerry 10 Native SDK and your favourite text editor.

Set up your environment

The Native SDK includes a script called bbndk-env.sh (or .bat on Windows) in the root folder that initialises the environment variables that the other tools depend on. I will refer to the install location of the Native SDK as $NDK_DIR.

Mac: source $NDK_DIR/bbndk-env.sh
Win: $NDK_DIR/bbndk-env.bat

So what does this script set?

The most important environment variables are:

QNX_TARGET: This directory contains all the configuration files and libraries for the BlackBerry 10 device, the target that we want our app to run on.  You can see all the libraries which can be linked against in $QNX_TARGET/armle-v7/lib and $QNX_TARGET/armle-v7/usr/lib.

QNX_HOST: This directory contains the tools and configuration files for our host system, ie Windows, Mac or Linux. It includes a compiler, linker and assembler for cross compiling to various architectures, as well as command line tools for packaging, signing and deploying your application.

Building for the ARM architecture

You may have noticed the use of armle-v7 in the above directory structure. This refers to the processor architecture on BlackBerry 10: ARM Little Endian Version 7. To build binaries that run on BlackBerry 10 you need to compile for this architecture.

Start by creating a folder to hold our app’s files, call it GoodbyeIDE. From now on I will refer to this as $PROJECT_DIR. Inside this folder create a file called main.c with the following content:

#include <stdio.h>
int main()
{
  fprintf(stdout, "Goodbye IDE!\n");
  return 0;
}

Now lets compile it. Change to $PROJECT_DIR and execute:

qcc -Vgcc_ntoarmv7le main.c -o main

Lets explain this command in a bit more detail. qcc stands for QNX C Compiler. BlackBerry 10 is built on top of QNX and uses many of its build tools.

qcc is essentially a wrapper for gcc  (GNU Compiler Collection). The -V switch tells qcc which version of gcc to use, in this case its the ntoarmv7le version which stands for QNX Neutrino ARM Version 7 Little Endian (a bit of a mouthful).

To build for the BlackBerry 10 simulator you need to use the gcc version for the x86 architecture.

qcc -Vgcc_ntox86 main.c -o main

To view a full list of the available gcc versions run:

qcc -V

The main.c -o main part of the command just specifies the input C filename and output binary filename.

OK, so now we should have a binary (called main) that will run on a BlackBerry 10 device. This binary won’t run on your host operating system since it’s not compiled for the same architecture. If you have a working gcc you can compile it by doing:

gcc main.c -o main2
./main2

When you execute main2 you should see “Goodbye IDE”.

Create the BAR descriptor XML

BlackBerry 10 apps are packaged as BAR (BlackBerry Application aRchive) files. To create a BAR file we need a descriptor file called bar-descriptor.xml. This file includes information about the app such as name, version, required permissions and a list of assets.

Create the bar-descriptor.xml file with the following content:

<qnx>
  <id>com.example.GoodbyeIDE</id>
  <versionNumber>1</versionNumber>
  <name>Goodbye IDE</name>
  <asset path="main" entry="true">main</asset>
</qnx>

From our point of view the most important line in bar-descriptor.xml is this one:

<asset path="main" entry="true">main</asset>

This specifies that the BAR contains a file called main which is the entry point for the app.

A full list of BAR application descriptor parameters is available here.

Packaging and deploying your app

Now that we have a binary and an application descriptor we are ready to create a BAR file.

A BAR file is essentially a zip file which contains all your app’s assets and the meta information from bar-descriptor.xml. In fact, if you rename a .bar file to .zip you will be able to extract it to see all the files in that app.

To create a BAR file run the following command:

blackberry-nativepackager -package GoodbyeIDE.bar bar-descriptor.xml -devMode -debugToken ~/Library/Research\ In\ Motion/debugtoken1.bar

Note that the -devMode and -debugToken flags are only required if you are deploying to a physical device. This is a handy feature that allows you to deploy your app without signing it, as long as your debug token is installed on the device.

To do this you’ll need to register with RIM to sign applications and create a debug token.

So now you have a BAR file called GoodbyeIDE.bar you can deploy it to the device using the following command:

blackberry-deploy -installApp 169.254.0.1 -password pass GoodbyeIDE.bar

169.254.0.1 is the IP of your target and pass is the device password.

If you take a look at your application icons, you should see a new one called Goodbye IDE (as specified in the <name> tag in bar-descriptor.xml).

If you tap on the icon your app should run! But…nothing happened, right?

Viewing log files over SSH

Actually the app did run, it’s just that all it did was print “Goodbye IDE!” to the stdout. The stdout on BlackBerry 10 is directed into a log file. We can view this log file by SSHing onto the device. Here’s how:

First we have to tell the device that we want to create a secure connection to it:

blackberry-connect 169.254.0.1 -password pass

Now open an SSH client (such as putty) and run:

ssh devuser@169.254.0.1

You should now be connected via SSH. Feel free to poke around! Apps are installed in /accounts/1000/appdata. Each app is given its own sandbox folder with a unique name based on its id (which we specified in bar-descriptor.xml).

Example sandbox folder name: com.example.GoodbyeIDE.testDev__GoodbyeIDEcf9b848

The log file can be found in the logs directory under the sandbox folder name. To view the file just run:

cat log

The log file is re-created each time the app is run. To test that the app is working delete the log file, tap on the app icon and run the above command again.

Summary

That’s it for now. The next article will focus on making your life easier by using Makefiles, the Qt build system and creating a more logical project folder structure.

Coding and deploying for the devices with 10.1 OS

Even if your older 10.0 Z10 version of the app runs “fine” on the newer 10.1 devices (Q10 and upcoming Z10 update) running the 10.1 OS version, you should try to use the latest 10.1 SDK. Why? Starting with the 10.1 SDK, you get access to some new features which will enhance your app’s experience on the Q10 devices significantly. This particular blog post here is a great source of information when you are converting your Z10 app for the upcoming Q10 devices. In terms of the UI elements that you can leverage as a developer, among others, you now have access to certain components like the auto hiding ActionBar, customizable/freeform and sticky TitleBar – these elements will allow you to maximize your screen real estate (for the smaller screen Q10 devices) and provide more room for actual content for the users.

Key shortcuts and listeners are some of the other slick new features; they make common tasks much easier for your users. The Q10 devices are definitely designed for the power users who love the physical keyboard and who value productivity greatly. You want to show them as much useful content as possible (even in the smaller screen) and require as few user input as possible to get to the primary features and content.

What about my current applications for the Z10 devices?

If there are any updates or bug fixes necessary for your currently public Z10 versions of the app (made using 10.0 SDK), you definitely don’t want to keep your users waiting. Until the in-market Z10 devices receive the 10.1 updates, you should continue posting updates and bug fixes as necessary. Going forward, the new 10.1 features that you will be using for Q10 devices (which you definitely should be) and upcoming Z10 updates; if they are mainly on the QML asset files, you can just continue to maintain just one BAR file. All the 10.1 specific QML code; those asset files can be placed in the folder called 720×720. For devices running lower 10.1 OS, that folder will just be ignored and only the QML files in the root folder would be considered. You can check out the github sample apps here to look at the code for projects like these. If you are using any new 10.1 C/C++ API then your application would need the latest 10.1.X.X SDK to compile against to bypass all the compile errors (the corresponding BAR file would also be a different one, since it would need the minimum 10.1 platform to run against).

Project Explorer View

The QML code under the 720×720 folder. It is using some new 10.1 specific features (e.g. customizable TitleBar).
If the same BAR file is run on the 10.0 devices, this code won’t be executed (the folder will be ignored).
Note: This is a modified sample code shown here just for demonstration

The QML file under the root assets folder; this will run by default. Note that there is no 10.1 specific code here

Note that you can install all the different SDK versions through the IDE update options and install the different OS versions. Re-iterating what is mentioned on the release notes:

• If you are developing using a BlackBerry 10 Dev Alpha device, you need to download the 10.0.10.263 target from the update site.
• If you are developing using the BlackBerry Z10 smartphone, you need to download a target from the update site that matches the device version that’s provided by your wireless service provider. You can verify the device version by opening the Settings app, tapping About, selecting OS in the Category drop-down list, and checking the version that’s listed in the OS Version field.
• For more information about developing apps that work on different versions of the BlackBerry 10 Native SDK, see Appropriate version of the BlackBerry Native SDK in the BlackBerry Support Community Forums.

How do I specify restrictions to BlackBerry World and BAR files?

When you are submitting the signed BAR files through your vendor portal account, you can choose the minimum OS version and the devices accordingly. These settings control whether or not your app will show up on the users’ BlackBerry World app (depending on the devices and the OS version they are currently running on).

Note that there is also a specific value that can be set through the bar-descriptor.xml file, which dictates the minimum required platform OS version required to install and run the app. This in turn gets reflected on the final signed BAR produced (MANIFEST.MF file). Do not modify this default value set unless you are absolutely certain which device OS versions you want to prevent the app from being installed (even if they are discovered through the BlackBerry World app). This value is checked by the OS itself when the app is installed and run using the BlackBerry World app. However, this is not something that the BlackBerry World looks at (currently) to filter what apps the user can see to download. This means, if you are playing around with this value, there could be instances where the user can see or buy the app through the BlackBerry World app but not be able to install it! The vendor portal filtering only gives you granularity between 10.0.0, 10.0.10 and 10.1.0 for now but if you are modifying the bar-descriptor.xml value for this, you can end up being really specific (10.0.9.X, 10.0.10.X, 10.1.X.X) which could prevent your users from installing the app (even if they are being able to see it or buy it).

The bar-descriptor.xml editor from the QNX Momentics IDE

Viewing the resulting signed BAR file through the IDE (MANIFST.MF file)

Viewing the resulting signed BAR file through the IDE (MANIFST.MF file)

Managing code base

Since there are newer API/libraries with 10.1 SDK, you might already be thinking about how to manage your code base better. Well, there are a few different options to choose from:

1. If you are already using a version control system like Github, just use the branching and merging technique for your code base
   • Create a new branch from your latest 10.0.X.X code version. Add all the new 10.1 features here and continue to use this one for devices running 10.1 (Q10 devices for now and soon to be Z10 as well)
2. If your 10.1 changes (e.g. using some of the newer UI elements and features) are mainly on the QML assets, you can make use of the static asset selector which is new with 10.1. Basically, your IDE will be pointing to the same project (code base) but based on which device you are targetting your app, it will select the respective .qml files
   • As mentioned before, the Z10 devices running lower than 10.1 OS, will just ignore the folders such as the 720×720
3. If you are using 10.1 specific API in your C++ code (only), you can use the NDK versioning macros to detect the OS versions. This forum post here talks about this in details

To Sum Up

• For devices running 10.1 OS, definitely use 10.1 SDK to compile and deploy your app; make use of all the useful features which will make the Q10 experience of your app significantly better
  • As soon as 10.1 OS is picked up by the Z10 devices, these app releases will be shown through BlackBerry World as well (provided you set the vendor portal filtering accordingly)
  • There is more than one way to manage your code base; you have to decide which one is best for you
• For posting updates and bug fixes to the 10.0 Z10 versions of your app, continue to use the respective 10.0 SDK to compile and deploy the app
• Sanity check: Don’t forget to test and try out the application on the OS versions that your users are expected to run the app

We hope at least some of this was helpful to you. If we have missed any particular cases, do bring them to our attention and we will try to advise accordingly. Hope to see all of your apps for the Q10 devices soon!

With the successful launch of BlackBerry 10, we now turn our attention to letting developers know what to expect from the BlackBerry 10 SDK when it comes to the BlackBerry Q10. Up until the BlackBerry 10 launch event, details on this device had been much like those of the majestic Yeti. But fear not, all details on the device have now been revealed and we’re ready for you to start testing apps on the device.

I’m very happy to announce that we now have updated versions of the BlackBerry 10 SDKs available for download. The main purpose of these SDK updates is to ensure that the development runtimes have proper support for the physical keyboard and screen size and to provide simulators so that developers can start testing their applications on the 720×720 screen resolution.

The details of the SDK additions are posted on the online roadmaps for each of the runtimes. The focus of these SDK updates is not on net new functionality, but instead around updates needed to support the 1:1 form factor, and screen resolution, allowing you to easily build a single application for both the full touch and physical keyboard devices. We’ll also be performing demonstrations, sessions and labs at BlackBerry JAM Europe to show you how to provide a single application for both the BlackBerry Z10 and BlackBerry Q10 devices with very little effort. In fact, in most cases your app will simply work right out of the box, but you can also easily make Q10 specific tweaks to your application using our built in framework additions.

This release brings with it an updated Q10 Simulator, but no SDK OS update for the BlackBerry Dev Alpha testing devices. The SDK update is specifically targeted at providing testing support using the BlackBerry Q10 simulator and BlackBerry Dev Alpha C testing devices (which are currently only available in the hands-on lab sessions at BlackBerry JAM Europe).

There’s updated SDK downloads for Native and AIR, as well as on-device updates for the Android and BlackBerry WebWorks runtimes. So grab the latest Simulators and SDK downloads to start testing your application for the BlackBerry Q10!

With the BlackBerry 10 launch event just around the corner, we’re also making an update available for the BlackBerry 10 Dev Alpha A and B testing devices. That’s right – on January 30th we’ll be providing an updated version of the BlackBerry 10 SDK and OS for the BlackBerry 10 Dev Alpha A and B testing devices. This SDK and OS upgrade will be delivered in the same manner as the previous target OS version, as an available target OS update in the Momentics IDE and as an OS upgrade for your BlackBerry 10 Dev Alpha testing device. Please check out the details from the previous blog post on how to download the latest target OS from within Momentics, and how to upgrade your BlackBerry 10 Dev Alpha OS.

Just like the previous target OS update, this one brings simply a newer version of the BlackBerry 10 SDK OS but with a slight twist. This January 30th update will also include the BlackBerry Hub, phone, and BlackBerry Maps applications. Adding these three new applications will go further to help developers test their end-to-end integration with core BlackBerry 10 applications.

So get ready for the launch event next week, and also prepare your development environment and test devices for an update.

Everyone loves a good webinar. OK, perhaps that’s an overstatement. Nevertheless, we hear loud and clear that our developer community loves them. The series of webinars we have run throughout the summer in conjunction with each successive SDK release have been extremely successful. So why stop now? Tomorrow – Tuesday, December 18th – we are bringing you two webinars that will cover all the latest information related to gold release Native and HTML5 SDKs for BlackBerry 10. The launch event date is coming up fast, so head on over to the registration pages and mark your calendars.

BlackBerry 10 Native SDK

We will take a quick look at what we have achieved so far with our native SDK. We will then look at the latest and greatest API and tooling features that have arrived in this most recent beta as well as the beta that preceded it. This includes things like advertising, SMS and invocation framework enhancements. Also, for the first time you will get a quick preview of the cards that are available to invoke and how you can invoke them. We will also cover some of the important IDE enhancements that have arrived, including the update manager, a brand new spanking project wizard, and the latest and greatest features that have been added to the Microsoft Visual Studio Plugin.

REGISTRATION:
http://www.blackberrydeveloperevents.com/events/webcast/registration/register.html?scoid=1079239157

BlackBerry 10 WebWorks SDK

We’ll take a look at the latest gold release as well as the most recent beta that preceded it. Starting with a quick overview of BlackBerry WebWorks, we will move to a summary of all of the latest features. We will then dive deeper into some of the more interesting features with a live look at code and functioning samples.

REGISTRATION:
http://www.blackberrydeveloperevents.com/events/webcast/registration/register.html?scoid=1079318388

I’m still pretty new to RIM, and still learning all the new tools we have to offer. So there I was in Cascades and C++ training when something caught my ear. It went something like this: “Blah blah blah C++ blah blah posix blah blah QML blah blah JavaScript…” Wait! Back up; did you say “JavaScript?!”

Turns out, the native Cascades framework doesn’t just support JavaScript; it’s baked in. The implications hit me fast and my head started racing with ideas. From that moment on, I quietly raced into my own little world of coding and exploring. Here’s what I found:

You can create a fully native BlackBerry 10 UI using QML and JavaScript

QML looks sort of like HTML and JSON had a baby. Check this out:

import bb.cascades 1.0
Page {
       Container {
              Label {
                     id: hello
                     text: "Hello World!"
                     horizontalAlignment: HorizontalAlignment.center
              }
              Button {
                     text: "Welcome!"
                     onTouch: {
                           // this is some JavaScript!
hello.text = "Thank you!";
                     }
              }
       }
}

You can even “subclass” and customize native controls within QML and JavaScript. Even better, the native IDE has a live UI preview and a properties inspector. Both cut the learning curve down to where even a noob native developer like me can get in and do some serious damage in a short time.

You can build many native apps purely in JavaScript

BlackBerry 10’s native Cascades framework exposes its goodness to C++ and JavaScript. It’s like having a browser engine without all the fuss; you’re connected directly to the metal. This means web developers can explore the wilds of native development in BlackBerry 10 without having to stray too far from our comfort zone.

You can expose other C++ code to the JavaScript layer

This means that if you run into something that really needs some seriously optimized C++ code to get it running, you can still have the convenience of your application logic being in JavaScript. It’s not an all or nothing scenario. What a great ice breaker to have with native development folks; working on the same project in peace and harmony (flowers, moonbeams and unicorns are optional).

The web is still in there; it’s just in a UI control

Even the most die-hard native developers recognize that some things (like, say, content) are well suited for HTML and such. That’s why most native libraries out there provide a web view of some sort. BlackBerry 10 is no exception. In fact, I’ve met web developers who are using a hybrid approach: writing the UI for their app in QML, application in JavaScript, contents and other goodies inside a web view inside their app; all baked into a single native BlackBerry 10 app. Sounds crazy, but the results are pretty cool.

So why would you want to do this? What about the web… versus native debate?

The deep truth is, native apps will always be more suited to many high performance and demanding applications. While HTML5 gets more awesome every day, sometimes you may have the urge to push beyond what is offered in the browser engine (or ignore it entirely). There’s nothing wrong with having these thoughts, and now that you have a slick outlet for them in BlackBerry 10, there’s no reason not to go exploring.

Ready to get going? Here are some resources to help you on your journey:

The Cascades SDK page: https://developer.blackberry.com/cascades/

Some samples on GitHub, with lots of JavaScript: https://github.com/blackberry/Cascades-Samples

You can ask me more on Twitter too – @balmer

Today is the launch of the Gold version of the BlackBerry 10 SDK for Adobe AIR. Thank you to everyone that has been helping us test it so far! For a full list of API updates and fixes, please head over to the release notes. Below are some of the benefits of using the gold release of the BlackBerry 10 SDK for Adobe AIR.

BlackBerry UI / Same components as native

The BlackBerry 10 SDK for Adobe AIR has been rebuilt from the ground up to allow developers to create applications that adhere to the BlackBerry UI branding guidelines. Basically all of the components you would get if you were a native developer, you also get in the BlackBerry 10 SDK for Adobe AIR.

Performance

Developing Adobe AIR applications that perform well on mobile is a challenge, and is also one of the main reasons why so many Flash developers shy away from mobile development. The BlackBerry 10 SDK for Adobe AIR was built specifically for BlackBerry 10 and mobile development. If you use the components of the SDK, you can be assured that they are the best performing components for BlackBerry 10.

Multi-screen development

With the BlackBerry 10 SDK for Adobe AIR, developers can use the Container API to organize the application’s UI controls. By using a layout, a Container manages the positioning and size of any UI component that it contains. This allows developers to target multiple aspect ratios and orientations easily without having to specify set dimensions for their application.

Native capabilities

The BlackBerry 10 SDK for Adobe AIR has native capabilities baked right in. You can easily take advantage of things such as invocation, sensors, push, notifications, payment and more.

Port your AIR apps

Re-compile your existing BlackBerry PlayBook AIR applications to BlackBerry 10. If you’re already using the fuse component set that debuted with the BlackBerry PlayBook SDK for Adobe AIR, the port should be quick and easy. You can get more details from this blog post.

For more details on what’s coming after Gold for the BlackBerry 10 SDK for Adobe AIR, please visit our Adobe AIR roadmap.

Augmented Reality is a way to enhance what you see around you with the use of your mobile phone’s camera, sensors, and location services. If done right, applications of this technology can take the experience of the consumer to an entirely new level. Implementing this technology can be exciting and challenging at the same time. For those seeking a mature solution, we are extremely delighted about the recent announcement on the BlackBerry® 10 support for the Wikitude SDK.

Following up with that announcement, we are pleased to announce our next webcast on Augmented Reality (AR) Development for BlackBerry 10. Join us to learn how to make use of the Wikitude SDK to create cool AR apps and games for the BlackBerry 10. Get a deeper insight into the concepts of creating AR content using HTML5/JavaScript/CSS and integration into BlackBerry10 Cascades™ applications. Hear directly from Wolfgang Damm, Lead Software Architect from Wikitude Team that created the “Best Augmented Reality Browser 2012“.

Registration is open now! Please signup to reserve your spot for the webcast on November 20th, 2012 at 11:00am EST

http://www.blackberrydeveloperevents.com/events/webcast/registration/register.html?scoid=1075028770

Get up to speed on the features of Wikitude SDK for BlackBerry 10 before the webcast:

http://www.wikitude.com/developer/sdk/wikitude-sdk-blackberry-10

Speaking of porting, don’t forget our 36 hour The BlackBerry Got Game Port-a-Thon  starts tomorrow! Check out this post for details and how you can get some awesome rewards for porting apps to BlackBerry® 10. – Ed.

The BlackBerry® 10 SDK for Adobe® AIR® has been created to make it easier for you to create Adobe AIR applications on multiple screen sizes while keeping mobile performance in mind. If you’re a developer that has one or more of the 6000+ Adobe AIR applications on the BlackBerry® PlayBook™ tablet, this article will help point you in the right direction for getting your BlackBerry PlayBook tablet application updated for BlackBerry 10. This blog post will cover:

• Getting started
• User interface guidelines
• Support for multiple screen sizes
• Fuse UI
• Layouts
• Application icon size
• Samples
• Help

Getting Started

The first thing you’re going to want to do is download and install the latest versions of the BlackBerry 10 Beta SDK for Adobe AIR 3.0 from this location. This link also provides steps on how to download and install the latest version of the BlackBerry 10 Dev Alpha Simulator, which you’ll also need if you haven’t attended a BlackBerry Jam event and got yourself a Dev Alpha unit. To get your development environment set up, you can follow one of the many guides located here. If you are porting content that was originally created using Adobe® Flash® Professional, there is a guide you can follow here.

User interface guidelines

The user experience for BlackBerry 10 has changed significantly from the experience on the BlackBerry PlayBook tablet. Creating a cinematic experience, having fluid workflows, and emphasizing high performance are just some of the key principles that BlackBerry 10 applications should follow. The BlackBerry 10 UI Guidelines cover these principles and specify design, interaction, and style guidelines for your app.

Support for multiple screen sizes

Your BlackBerry 10 application should support the different screen sizes so that it looks consistent across devices. You specify the splash screen in the BAR application descriptor file and you can add them for each supported screen resolution. The BlackBerry 10 OS chooses the correct icon and splash screen to use based on the device that the application is running on.

Currently, the BlackBerry 10 OS supports the following screen sizes:

To support multiple screens in your BlackBerry 10 application, modify the bar-descriptor file.

<splashScreens>
   <image>splash-1024x600.jpg</image>
   <image>splash-600x1024.jpg</image>
   <image>splash-1280x768.jpg</image>
   <image>splash-768x1280.jpg</image>  
</splashScreens>

Fuse UI

In BlackBerry Tablet OS SDK for Adobe AIR 2.0, the qnx.fuse.ui API was introduced as a replacement for the qnx.ui API used in version 1.0. While the qnx.ui was deprecated, it remained available to applications for the BlackBerry PlayBook OS.

In the BlackBerry 10 SDK for Adobe AIR, the qnx.ui API has been removed, and you must update up your application to use the qnx.fuse.ui API.

In order to use the qnx.fuse.ui API in your application, you must add the QNXSkins AIR Native Extension to your application. For more information, see Adobe AIR native extensions.

Layouts

In BlackBerry Tablet OS SDK for Adobe AIR 2.0, the container methodology (highlighted in qnx.ui.core) was deprecated in favor of using layouts to organize your UI components.

In the BlackBerry 10 SDK for Adobe AIR, the container concept has been removed, and you must update your application to use the layout method.

You can use the Container class to organize your application’s UI controls. By using a layout, a Container manages the positioning and size of any UI component that it contains. Any controls that are added to a container are known as children. A container can also contain other containers, called sub-containers.

Below a container is created and a rowLayout is assigned to it:

//Create container
container = new Container();
container.scrollDirection = ScrollDirection.VERTICAL;
container.height = stage.stageHeight;
container.width = stage.stageWidth;
//Create layout
var row:RowLayout = new RowLayout();
container.layout = row;
row.spacing = 5;
row.padding = 5;

Application icon size

When creating new application icons, make sure that your application icon is the appropriate size for the application platform.

Samples

There are some BlackBerry 10 Adobe AIR samples that you can download the source for that will help you get started. You can find a description and the download location here. If you’re new, I recommend starting with the “Starship Settings” application and then moving on to the “Weather guesser” application for some more advanced layout techniques.

Help

If you need help, here is a list of resources that you can reference:

The Adobe AIR Development BlackBerry Support Community Forum
BlackBerry 10 SDK for Adobe AIR API Reference (beta)
The BlackBerry SDK for Adobe AIR Documentation
The Adobe AIR Development BlackBerry Resource Center

If all else fails, you can tweet me @dustinmalik or tweet @BlackBerryDev.