The Cascades Framework uses a modular approach to store, access, and display data in your apps.

There is a good chance you will need your app to interact with external data – the raw data for your app. The format of the external data can vary depending upon your needs and Cascades provides classes that help you manage three common data formats: XML, JSON, and SQL.

First, let’s look at a table comparing BBOS and BlackBerry 10 Data Storage:

USER File system

BlackBerry 10 introduces a file system (recall on BBOS there was no file system). So, what to know about the file system? Firstly, the working directory is where your app is started – it is also called current directory and the sandbox ($sandbox/app). Access to files and folders in the working directory is controlled through Unix-style groups and permissions. Key point: never hardcode absolute file paths – all should be relative to your sandbox.

Please review the following file system diagram:

And visit this page :

https://developer.blackberry.com/cascades/documentation/device_platform/filesystem/index.html

For more information on the file system.

Secondly, let’s look at working with XML, JSON, and SQL. The following provides some code snippets for all three along with links to more information.

XML

The following is a code snippet on how to load XML using a GroupDataModel

// Create the data model, specifying sorting keys of "firstName" and "lastName" 
GroupDataModel *model = new GroupDataModel(QStringList() << "firstName"
                                           << "lastName"); 

// Create an XmlDataAccess object and load the .xml file. The QDir::currentPath() 
// function returns the current working directory for the app. 
XmlDataAccess xda; 
QVariant list = xda.load(QDir::currentPath() + 
                         "/app/native/assets/employees.xml", 
                         "/employees/employee");

For more on XML data, please click “Working with XML”

http://developer.blackberry.com/cascades/documentation/device_platform/data_access/working_with_xml.html

JSON

The following is a code snippet on how to create a JSON Data Access Object and load the JSON file

// Create a JsonDataAccess object and load the .json file. The  
// QDir::currentPath() function returns the current working  
// directory for the app. 
JsonDataAccess jda; 
QVariant list = jda.load(QDir::currentPath() + 
                         "/app/native/assets/employees.json");

For more on JSON, please click “Working with JSON data”

http://developer.blackberry.com/cascades/documentation/device_platform/data_access/working_with_json.html

SQL

The following is a code snippet on how to create SQL

 // Create an SqlDataAccess object 
    SqlDataAccess sda(home.absoluteFilePath("mySQLFile.db")); 

    // Create a table called Employee in the database file 
    sda.execute("CREATE TABLE Employee( firstName VARCHAR(50), 
                 lastName VARCHAR(50), salary INT);"); 

    // Insert employee records into the table 
    sda.execute("INSERT INTO Employee (firstName, lastName, salary) 
                 VALUES ("Mike", "Smith", 42000);"); 
    sda.execute("INSERT INTO Employee (firstName, lastName, salary) 
                 VALUES ("Joe", "Brown", 55000);");

For more on SQL data, please click “Working with SQL”

http://developer.blackberry.com/cascades/documentation/device_platform/data_access/working_with_sql.html

In conclusion, the data files that you work with in your apps are stored in the file system on the device. Different file system locations have different permissions; in some areas, you can create new files to store your app data, while in others, you can only load data from existing files. If you want to access your data files using the method that works best for you, you need to understand where your data files are located in the file system. Please follow this link “File system access for app” for more information.

Data files that you package with your app (when you compile the app) are located in the assets folder in the file system. Your app has read-only access to this folder, which means that you can load data from files in this location, but you can’t save new data in these files. When you create new data files dynamically while your app is running, they are stored in the data folder. Your app has full read-write access to this folder, so you can load and save data using files in this location.

Now on to Part 9!!

The Cascades framework is a rich and powerful modern UI framework build on top of the Qt application framework. The UI can be developed in C/C++ or Qt Modeling Language (QML) or both.

Lets take a look at a sample HelloWorld application in both frameworks:

HelloWorld side-by-side. A label in both Java and Cascades

// MAIN: the setup
public static void main(String[] args)    
{
      HelloApp app = new HelloApp();
      app.enterEventDispatcher();

}

	// MAIN: the setup
Q_DECL_EXPORT int main
(int argc, char **argv)
{
   Application app(argc, argv);
   new HelloWorld(&app);
   return Application::exec();
}

// HELLO WORLD CLASS

public class HelloApp extends
   UiApplication {
public HelloApp () {
 HScreen scr = new HScreen();
  pushScreen( scr );
      }

	// HELLO WORLD CLASS

HelloWorld::HelloWorld 
(bb::cascades::Application *app)
: QObject(app)
{
    QmlDocument *qml = 
QmlDocument::create("asset:///main.qml")
.parent(this);

    // create root object for the UI
    AbstractPane *root = 
qml->createRootObject();
    app->setScene(root);
}

// SCREEN CLASS: THE UI

public class HScreen 
extends MainScreen {

  private LabelField lbl;
  public HScreen()
  {
    lbl = new   LabelField( "Welcome!" );

    add( lbl );

  }}	// QML Page : THE UI

Page {
    Container {
        layout: DockLayout {}
        Label {
            text: qsTr("Hello World")
}}}

Both frameworks start with the main application and the HelloWorld class. In the case of Java a screen gets pushed on the screen stack. In the case of Cascades a QML document gets associated with root UI object.

In Java, a Screen Class gets created by extending MainScreen and adding a LabelField to it. In Cascades a Page gets declared and a Label is placed inside a container as shown on the screen.

When embarking on porting any application that include the User Interface. It’s important to review the UI guidelines for both platforms.

The BlackBerry Java UI guidelines can be found at:
https://developer.blackberry.com/design/bb7/

The BlackBerry 10 UI guidelines can be found at:
https://developer.blackberry.com/design/bb10/

A note on Java UI

The BlackBerry Java Development Environment (JDE) or the Eclipse Plugin is used to develop applications for BlackBerry OS 7.1 or lower.

There are two main supported frameworks for creating user interfaces in Java:

• MIDP UI APIs
• BlackBerry UI APIs

For compliance, the MIDP APIs are included for porting apps from MIDP devices. The BlackBerry UI APIs target specifically BlackBerry development and are the main focus of this article.

Rendering in Java And Cascades UI Frameworks

In Java UI rendering is done in “widgets” using the paint() functions. Normally, a list of such “widgets” will represent your entire UI. The system will go through the entire set of “widgets” and ask them to draw themselves by calling the “paint()” method. The consequences of this implementation are as follows:

In Cascades, rendering is done differently. Unlike in Java where the application is part of the rendering loop a Cascades application only manages the UI tree. The Cascades Rendering engine (which executes on a separate thread) takes care of drawing the UI. The consequences of this implementation are as follows:

For more information on the topic please see this blog post.

(http://devblog.blackberry.com/2012/09/cascades-custom-ui/)

Navigation:

Single Screen

Normally a single screen Java application would extend from MainScreen as in the HelloWorld sample provided. Similarly in Cascades a Page would get created with individual components added to it.

Screen	Page

Stack of Screens

In traditional Java applications flow is maintained by adding and removing screens to/from the stack, which is owned by the main application. The equivalent to this on BlackBerry 10 is the Navigation pane where individual pages can be pushed and popped from a stack. For more information on Cascades Navigation Pane please see: http://developer.blackberry.com/cascades/reference/bb__cascades__navigationpane.html

Tabs and Filtering content

In Java applications Tabs are used to display filtered content and are achieved with the PaneManagerModel. This can be achieved in Cascades using Segmented Control.

Cascades tabs allow the apps to change the flow of the application. In BlackBerry Java, this effect was achieved through the use of custom components.

PaneManagerModel, Pane, HorizontalTabTitleView, PaneView, PaneManagerView	SegmentedControl http://developer.blackberry.com/cascades /reference/bb__cascades__segmentedcontrol.html
Custom Component implementing custom Toolbarhttp://docs.blackberry.com/en/developers/ deliverables/17965/Toolbars_6_0_1137042_11.jsp	Tabbed Panehttp://developer.blackberry.com/cascades /reference/bb__cascades__tabbedpane.html

Layout

Java:

http://btsc.webapps.blackberry.com/btsc/fetch/2000/348583/800332/800505/800508/How_To_-_Create_tabbed_view_screens.html?nodeid=1357482&vernum=0

Cascades:

http://developer.blackberry.com/cascades/reference/user_interface_layouts.html

The following tables illustrate layout mapping of the most frequently used layouts.

In BlackBerry Java, the most common approach is to use combination of HorizontalFieldManager and VerticalFieldManager. This can be achieved in Cascades using the DockLayout.

FlowFieldManager	Stack Layout default behavior

Combination of Horizontal and Vertical Field Managers	Dock Layout

AbsoluteLayout

Menus:

The Java Menus documentation can be referenced at:

http://developer.blackberry.com/java/documentation/menu_items_1970228_11.html

The Cascades Menus can be reference at:

http://developer.blackberry.com/cascades/documentation/ui/navigation/menus.html

The most common way of interacting with content in BlackBerry Java was through the BlackBerry Menu (the hardware key). On BlackBerry 10, Cascades applications would use an action in the action menu to get the equivalent functionality.

BlackBerry Key Menu vs. BlackBerry 10 Action Menu

Menu (Screenshot)	ActionSet

Application “Settings” Menu. [BlackBerry 10 Only]

A swipe-down menu is accessible on BlackBerry 10 for infrequently used actions such as settings, getting customer information, managing accounts or downloads etc…

N/A	Menu class and ActionItem object

Context Menu

Context menu is a common BlackBerry specific method of acting upon an item in a specific context. This can be achieved on both platforms as illustrated below.

Context Menu	contextActions

Custom Menu

In certain cases you might want to create a completely custom menu that makes sense for your application. This is possible in BlackBerry 10 using the MenuManager API.

Override keyDown and then create a custom component to display on the screen.	MenuManager

Active Home Screen Elements

In BlackBerry Java, apps would normally change the icons and the icon descriptions to keep track of the application state. For more information on the APIs please see:

http://www.blackberry.com/developers/docs/7.1.0api/

In BlackBerry 10, apps would use Active Frames to update the status of an application. For more information of Active Frames please see:

http://developer.blackberry.com/cascades/documentation/ui/active_frames/index.html

Active Home Screen App Elements

Active Icons	Active Frames

Notifications

To learn more about BlackBerry 7 notifications please see:

https://developer.blackberry.com/java/documentation/message_list_1984778_11.html

To learn more about BlackBerry 10 hub notifications please see:

https://developer.blackberry.com/cascades/documentation/device_comm/notifications/index.html

MessageList	Hub Notifications

Popup Dialogs

DialogFieldManager and PopupManager	NotificationDialog

Custom Controls

In BlackBerry Java, custom controls are challenging to implement and often involve overriding the paint() method of native components. For more information and samples please see:

https://developer.blackberry.com/java/documentation/
advanced_ui_components_and_managers_1970227_11.html

In Cascades, custom controls are created by combining existing components and modifying their behavior. For more information on how to create a custom control in Cascades, please see:

http://developer.blackberry.com/cascades/documentation/
dev/integrating_cpp_qml/custom_control_tutorial.html

Sample Use of Custom Components	Custom Control

Dialog Boxes, Prompts, Toasts

The BlackBerry Java platform supports Dialogs of different format (information, status, inquiry). For information on dialog boxes please see:

http://developer.blackberry.com/java/documentation/dialog_boxes_1970203_11.html

Cascades supports dialog boxes, prompts and toasts. For more information on how to implement them please see:

http://developer.blackberry.com/cascades/documentation/ui/dialogs_toasts/index.html

Dialog Class	Dialog, SystemDialog, SystemListDialog … Below is an example of a custom dialog box.

Lists

For reference of List implementations in Java please see:

http://developer.blackberry.com/java/documentation/lists_and_tables_1970216_11.html

For list implementation in Cascades please see:

http://developer.blackberry.com/cascades/documentation/ui/lists/

Active Home Screen App Elements

SimpleList, RichList, TableView	ListView

Text

For reference on how to handle text in Cascades please see:

http://developer.blackberry.com/cascades/documentation/ui/text/index.html

Label

Labelhttp://developer.blackberry.com/java/ documentation/text_field_label_1984828_11.html	Label

Text Field

LabelField, RitchTextField, BasicEditField, PasswordEditField, EmailAddressEditField, KeywordFilterField, AutoTextEditField	TextField with TextFieldInputMode Of type: Default, Text, EmailAddress, Password, Chat, Url, PhoneNumber, NumbersAndPunctuation,NumericPassword, Pin

Text Area

RitchTextField and ActiveRitchTextField	TextArea with TextAreaInputMode of type: Default, Text, Chat, EmailAddress

Web Content

WebView

BrowserField http://www.blackberry.com/developers/ docs/7.1.0api/net/rim/device/api/ browser/field2/BrowserField.html BrowserField BrowserField browserField = new BrowserField(); screen.add( browserField ); browserField.requestContent ( "http://blackberry.com" );	WebView http://developer.blackberry.com/ cascades/reference/bb__cascades __webview.html WebView { id: webView url: " http://blackberry.com " }

http://giphy.com/gifs/TznYiZCFXeLle

Multimedia on BlackBerry 7 was based on the multimedia JSR (135). There were a lot of limitations regarding supported formats, how many sounds could be played at the same time, and even what worked on which device.

In BlackBerry 10, there are a wide range of supported codecs, containers, and protocols.

For video, we recommend an MP4 containing H.264 video at 720p and AAC audio. For audio, it depends a lot on your use case. In addition to mainstays such as MP3 and AAC, we support things like FLAC and Ogg Vorbis.

To actually play your multimedia, you should be looking at the MediaPlayer class. That will handle audio or video. You can also easily play the built in system sounds with the SystemSound class.

• Tutorial: Playing Audio or Video
• Tutorial: Playing SystemSounds in an app

Recording audio is through the AudioRecorder class. You can record a few different formats, including AAC (.mp4) and PCM (.wav).

• Recording Audio

This is all pretty straightforward and should be pretty easy to adjust to if you are used to the Java way of doing things. There are a few key differences that you might not be expecting though.

The first is the NowPlayingConnection. If you are building any sort of media player type application: use it. What it does is let the user control the volume and playback of your app from in another app, using the volume keys on the side. You can also provide a bit of data like a thumbnail image and the current song playing. No user is going to want to have to go back into your application just to change the volume, and it’s really easy to implement.

• Working with NowPlayingConnection

Secondly, unlike in BlackBerry 7, in BlackBerry 10 you can enable echo cancellation in order to do VoIP. There is no convenient Qt API to do this, but you can use QSA and open a connection to the “voice” PCM audio interface.

• BlackBerry 10 VoIP

The other big difference is that you can’t just feed bytes directly into the media player. You need to have an actual file to play, or be using one the streaming protocols supported. Of course, there is nothing stopping you from dropping down to OpenAL/ALUT and doing whatever you need if that’s your style. You also have QSA available as mentioned before, as well as mm-renderer (which is what MediaPlayer is using), but that is all beyond the scope of this article.

That said, we wanted to put our money where our mouth is so Alec Saunders sat down with Frédéric Boulanger, CEO & Co-Founder of Macadamian, to find out what their reasons are to port to BlackBerry 10. Watch what happened below.

[ YouTube link for mobile viewing ]

If you’re interested in using Macadamian to port to BlackBerry 10, make sure you visit them here.

Have you ported your app to BlackBerry 10? We want to know your story! Let us know in the comments!

Guest post from Roberto S. – Ed.

In Part 2 of this series, we would like to introduce BlackBerry Java developers to what has changed with respect to application lifecycle in BlackBerry 10, and what you should be aware of when you port this aspect of your application to Cascades.

All BlackBerry 10 applications have a similar lifecycle that includes three possible states: running in the foreground, running in the background, and stopped.

• An app running in the foreground is visible and is taking up the entire screen.
• An app running in the background is either displayed as a thumbnail, such as when a user swipes up from the bottom of the screen to display a list of running apps, or is invisible but has the run_when_backgrounded permission to run in the background.
• An app that is stopped is not visible and doesn’t have permission to run in the background.
• An app that is pooled (the app is paused and ready to be opened in the foreground)

Developers porting their apps from BlackBerry OS will need to take this into account and make the following changes to their apps:

1. Unlike in BlackBerry OS, apps do not have an extra entry point available to them for starting up a background thread at startup, or for modifying theirs icons. Homescreen Icons are not modifiable in BlackBerry 10 so any such logic is not portable as is. However, the active frames feature allows developers to customize their frames when minimized. Therefore, this may allow some of the icon logic to be applied to the cover instead on a BlackBerry 10 version of the app. For more information about Active covers, go to https://developer.blackberry.com/cascades/documentation/ui/active_frames/index.html .
2. Background services capabilities are currently not available to third party developers. They will be available in a future release of BlackBerry 10. Developers relying on background services to poll servers for updates or execute code when they are not running will have to implement an alternative approach for the time being. The alternative currently recommended is to use push to launch your apps when new data is available. With Push, your server side application can poll for new data on behalf of the client application and deliver any new data in a push message which can be processed even if the client application is closed. Check out this recent blog post on push for more information: http://devblog.blackberry.com/2013/01/push-samples/ .
3. To handle the life cycle changes that occur in your app, there are several signals made available to Cascades apps that an app developer can intercept and process accordingly. For more details on application lifecycle and the various signals available, go to https://developer.blackberry.com/cascades/documentation/dev/fundamentals/index.html and https://developer.blackberry.com/cascades/reference/bb__application.html for more information. The developer must take their state into consideration and reduce app activity accordingly:
   • When your app enters the thumbnail state, it should stop any extraneous processing and use only the resources it needs to update the cover or maintain critical functionality like maintain a server connection or check a remote server for updates. Your app should stop other threads that aren’t required when running in the background. Examples of what to stop are rendering, multimedia playback, audio playback, etc.
   • The invisible signal is emitted when the app (and its thumbnail) is no longer visible. This state might occur if the device backlight is off or if another app has been brought to the foreground. When your app is in this state and doesn’t have the run_when_backgrounded permission, it is considered stopped and won’t receive any processing time. If your app does have the run_when_backgrounded permission, your app should stop any rendering operations (for example, updating the UI) and any other unnecessary operations. Your app should only listen for events that it needs to respond to, and process these events when they occur.
   • It is very important for applications to reduce processing as much as possible while thumbnailed or invisible. It will conserve CPU usage and also save on battery life. This is an important criterion that is taken into consideration when applications are evaluated during the BlackBerry World approval process.
4. When a user closes your app, your app usually needs to perform some final cleanup operations, whether it be saving the user’s data, shutting down your threads in a particular way, or manually closing the app database or network connections. Cascades provides developers with a choice of automatic or manual exit mechanisms that they can take advantage depending on their cleanup needs.
5. BlackBerry OS developers should be aware of the fact that C++ does not have automatic garbage collection like Java does. However, Qt does provide some built-in mechanisms that provide limited object cleanup. Please refer to the API references for QObject and other QtCore classes like QSharedPointer for additional information on how to manage pointers and automatically delete objects after use. For more information about object ownership in C++ and QML and what that entails, go to https://developer.blackberry.com/cascades/documentation/dev/fundamentals/index.html
6. The new pooled state is designed to take advantage of the extra memory added to BlackBerry 10 devices. The system sends a signal to the app to prepare to be pooled. The app is expected to reset its UI t o a point that matches startup conditions and signal back that the operation is completed. If the app fails to do this, the app will be terminated.
7. Another limitation to be aware of is that currently only eight apps can run at the same time on BlackBerry 10. As a best practice, developers should ensure that any apps launched in the background to process push events should exit as soon as possible if user interaction is not required or if they launch a notification to alert the user to launch the app later. This will prevent push interactions from bumping up the number of running apps for more than a short period of time.

Please stay tuned for series Part 3 – UI Overview.

Qt developers often ask the following questions: Is there a porting guide to help me port my Qt apps to BlackBerry 10? What about porting Qt Quick to BlackBerry 10? How do I configure Qt Creator for BlackBerry 10?

The good news has arrived: you now have a porting guide covering the most commonly-encountered use cases. This guide provides the necessary information to developers of native mobile apps who fall in one of the following categories:

• Developers who have Qt apps written in C/C++/ QML/JavaScript and intend to have their apps running on the BlackBerry 10 platform;
• Developers who want to write new Qt C++, QML and/or JavaScript code for the BlackBerry 10 platform;
• And finally, developers who want to take advantage of the Cascades UI framework and change their existing UI to the Cascades framework.

BlackBerry supports developers in all of the above described scenarios, and so this guide provides developers with best practices for each category. It also explains why a particular practice is considered the best one.

Please check the full Qt porting guide at:

http://developer.blackberry.com/native/documentation/bb10/porting_qt_apps.html

Related Posts:

YouTube: BlackBerry Jam Session (JAM12): Porting Qt Applications to BlackBerry 10
Porting Qt Applications to BlackBerry 10 is Easier than Ever!
Writing Qt apps for the BlackBerry 10 platform
YouTube: QtDD12 – How Qt Helped RIM Build BlackBerry 10
YouTube: QtDD12 – Developing with Qt for the BlackBerry 10

Two weeks ago it was just an idea, but today it is a reality. The most popular mobile payment solution in Uruguay took advantage of the BlackBerry Developer relation’s team support to port the entire solution to BlackBerry 10 – in just 3 days. How did that happen? Easy: they arrived to the BlackBerry Innovation Center in Buenos Aires on Monday with no BlackBerry app and left on Thursday with it already submitted to BlackBerry World. Simple.

Seriously, how did that happen?

I’ll let them tell you what, how and why…

Paganza is a revolutionary application for paying family bills. The app allows scanning the barcode of the invoice and making payments through a bank account. The service was recently launched in Uruguay and within weeks was already leading the ranking of finance applications in the iPhone and Android stores.

The last week of last December, Paganza was invited to the BlackBerry Innovation Center in Buenos Aires with the aim of having its application available on the new platform before January 30th. While those were complicated dates and the term was very short, we decided to accept the challenge. The result was that in single a week we managed to migrate the application and today we have the first version of Paganza available in BlackBerry World.

Development was carried out with the native BlackBerry 10 SDK, which allowed us to easily access existing C++ libraries without compromising performance. At the same time the user interface was developed with Cascades, which gave us access to an extensive library of controls and a rapid iteration of logic in JavaScript. The application uses a C++ library of recognition of bar codes developed in-house with the support of the National Agency for research and innovation of the Uruguay (ANII). This library, unlike those used to read barcodes of books, allows to read longer bar codes such as those present in utility bills, in a very heterogeneous universe of cameras, like the ones we have in Latin America.

The company’s plan is to consolidate a case of success in Uruguay to then expand to countries in Latin America, making agreements with banks in the region, where the payment of invoices is a headache and cell phones are growing exponentially.

Marcelo Lanfranconi
marcelo@mail.paganza.com
CTO – Paganza

This is another success story of a startup company investing a really small amount of time and money to bring their solution to BlackBerry 10. Additionally, this is another success story of the commitment of our developer relations team and how the one-on-one support makes a huge difference. Come and join us!

Do you want to know more about the BlackBerry Innovation Center and how you can leverage it? Ping me on Twitter – @bryantafel

With all the excitement around BlackBerry 10 launch, one key request from our developer community is how to bring your existing BlackBerry Java applications to BlackBerry 10. As always, we at RIM developer relations constantly strive to break any barriers for developers.

Starting today, we will be publishing a series of blog posts specifically designed to help port your existing BlackBerry Java application to BlackBerry 10. As you may already be aware, BlackBerry Java is no longer supported on BlackBerry 10. Our goal here is to provide you all the info needed to quickly migrate your app functionality.

The BlackBerry 10 Native SDK enables you to develop applications in C/C++ and provides an open-source friendly environment for porting POSIX compliant code. It comes with the Cascades framework allowing you to build visually rich applications. The key focus of this development guide is specifically on BlackBerry 10 Cascades development. For more information on BlackBerry Native Development, please refer to http://developer.blackberry.com/native/

What is Cascades?

BlackBerry Cascades is built using the Qt framework, which allows Cascades to leverage the Qt object model, event model and threading model. BlackBerry Cascades enables you to develop your UI in C++, Qt Modeling Language (QML), or both. Qt Modeling Language (QML) is a declarative language that’s based on JavaScript and is included as part of Qt. You can use QML to describe the structure and behavior of a set of UI controls. BlackBerry Cascades uses a modified version of QML to let you create UIs for your apps.

One fundamental importance when looking to develop your BlackBerry Cascades application is deciding when to use QML or C++. You can use both of these languages in your application, but as a general rule of thumb you should use QML for your UI development and C++ for your business logic. Please refer to the below link more information on BlackBerry Cascades development and to download Native SDK and BlackBerry 10 Simulator. https://developer.blackberry.com/cascades/

API Feature Parity

One of the main challenges while migrating app functionality from BlackBerry Java to Cascades is finding the correct mapping of APIs. To simplify this process, below is an API Feature Parity table that covers the most common BlackBerry Java APIs and their corresponding equivalent API in Cascades.

As you can see from the above table image, most of the common Java APIs have a direct mapping in Cascades making it easy for you to port your existing BlackBerry Java application to BlackBerry 10.

Please stay tuned for series Part 2 – Application Life Cycle.

What’s Buffer? Well, the name speaks for itself – it’s a service that allows you to send your status updates to a buffer in order to post them to multiple social networks at once and stagger these posts throughout the day. This way, you won’t flood your followers/social media friends with tons of posts all at once. More importantly, you can choose the time of day that you want the posts to be published, in order to have the best visibility in terms of audience.

You can even keep track of the number of retweets, likes and clicks that your posts get. Smart, right?

After they launched the service more than a year ago, they built an app for iOS and Android that quickly became successful.

A few weeks ago, I contacted them again to inform them about my new adventure here at RIM and to ask them about the possibility of porting Buffer to BlackBerry 10. They are not a big company, so they need to prioritize tasks and were very busy at the time. One option was to port their Android app to BlackBerry 10 and then to plan the development of a native Cascades version later.

I am happy to announce that as of last week, Buffer was made available for download from BlackBerry World.

Do you think that 24 hours after publication, and given that BlackBerry 10 devices are not commercially available yet, we could impact their service? Well, apparently, YES!

Here is what Leo says:

“Converting Buffer to the new BlackBerry 10 platform couldn’t have been any easier. It took us less than one day to do so and it was running super smoothly immediately. Seeing hundreds of downloads within days and great reviews too was an incredibly overwhelming response from our userbase.”
“Being part of the new BlackBerry 10 platform is super exciting for us. What few people know is that BlackBerry users are the second largest mobile traffic for Buffer, even before Android. So being able to provide a slick app in such a hassle free way made our life extremely easy. And, a large part of our userbase is a lot happier and more productive. Happy Buffering from BlackBerry! “

Impressive, right? I really recommend giving Buffer a try – the BlackBerry 10 app in conjunction with their browser extensions is a killer social media weapon!

Let’s talk about one of the best parts of the Port-A-Thons; the rewards. Here’s an update on the reward process that highlights how and when things will happen.

Updated Timelines

For the All Aboard, Community, Android and Last Chance Port-A-Thon’s, we’re extending the deadline to get your app approved.

You will now have up to February 18, 2013 to get your apps approved. This fits nicely with the deadline to apply for the $10k Developer Commitment.

Please note: The Got Game Port-A-Thon is now closed.

Rewards Process

Rewards are distributed to vendors only after all the apps have been put “up for sale”. By default, apps are automatically put “up for sale” when approved.  If you chose otherwise, please take a moment to put them “up for sale” and ensure you take this step to receive your rewards.

Cash Rewards are distributed by our program partner Milestone. You will receive an email to confirm payment information from rimredemption@milestoneintegrated.com . If you live in a country serviced by PayPal, you will need to confirm your PayPal Account. If you live in a country not serviced by PayPal, you will need to provide wire payment details. After this information is provided you will receive your payment in 4-6 weeks. We are working hard to have the money transferred as quickly as possible.

Device rewards are distributed by Touchstone. You will receive an email to confirm shipping information from BlackBerryPlayBookOffer@tmgideas.com. After confirming your shipping details, the device(s) will be shipped as quickly as possible. Note that RIM pays all shipping costs and duties. If you are required to pay these fees, please contact BlackBerryPlayBookOffer@tmgideas.com with the details and you will be reimbursed.

Trip rewards are distributed by HRG. You will receive an email from A Thousand Words Marketing and HRG.

My apps are approved, when do I see reward emails?

To mirror the extension of the submission deadlines, the reward emails will extend as follows. We take a snapshot of approved apps at the end of day each Friday. Information is then provided to Touchstone (for cash), Milestone (for devices) and HRG/Thousand Words Marketing (for Trips) who then send out the reward emails on Tuesdays.

If you notice your apps are approved, please wait until the following Tuesday to get your reward emails.

What happens if you are not able to attend BlackBerry Jam?

Given the new deadline extensions, we realize that trip winners may have some logistical challenges getting to Amsterdam for the BlackBerry Jam Europe 2013.  For those that are unable to attend BlackBerry Jam Europe 2013, we will extend the trip offer to BlackBerry Live in Orlando on May 14-16, 2013 under the same conditions. Please note that the trips are non-transferrable.

When are the draws happening for Community Port-A-Thon?

The Community Port-A-Thon draw for Trips and devices will be held on February 18, giving participants additional time to get their apps approved and become eligible for the draw.

As the draw happens after BlackBerry Jam Europe, the trip will be for BlackBerry Live in Orlando on May 14-16, 2013. To make this even more exciting, we’re adding $500 USD spending money for the trip winners.

The draws for the All Aboard and Got Game Port-A-Thons have been drawn and winners have been notified.

Last Chance Port-A-Thon

If you participated in the Last Chance Port-A-Thon last weekend, expect to be notified of your eligibility by Friday, January 25. This email will inform you of the apps that were submitted during the Port-A-Thon and your eligibility for rewards. Please note that those apps must be “Up for Sale” on or before February 18, 2013 to be eligible to receive an award.

Thanks for all your apps!