I decided the move to the new building was a great excuse to have a bit of fun with the movers. The prank came to me without much effort at all and within a few seconds I had the idea, all that was left was the execution (I’m being vague on purpose, be patient please!). My cubicle neighbor and comrade in shenanigans Rob Williams thought he could rig up an Arduino with an accelerometer and speaker together with a battery pack to keep the juice flowing for long enough to leave everything un-disturbed for a few hours. This was an awesome idea, though a bit out of my league I know Rob is a wiz with that kind of stuff, but then I thought to myself “Hey, we work for BlackBerry!” I grabbed a Dev Alpha B out of my desk, and started thieving code from GitHub programming, in less than five minutes I had a finished app that would serve as the entertainment for myself, some colleagues, and hopefully anyone reading this for a few weeks (the move was delayed a bit).

Without further delay, I present to you, my first ever YouTube video: “Kitties locked in a box”

Let me know what you think! Send me a message on Twitter with your feedback and any tips for pulling of the prank – garettBeuk

Part 2 should be posted in the upcoming week…

Up to this release, the BlackBerry 10 SDK was supported using a pre-release version of the Titanium SDK which added a both few extra steps and downloads in order to start testing/building your application for BlackBerry. Now the BlackBerry 10 SDK is officially supported in the public version of the Titanium SDK 3.1.1 and can be installed just like any of the other supported platform SDKs.

For those of you familiar with Appcelerator and the Titanium platform, this release brings the BlackBerry 10 SDK to about 90% coverage of the core Titanium APIs, including supporting the Alloy framework. This is a great time to start taking your existing applications and testing to see how great they look, feel and run on the BlackBerry 10 platform. The way Titanium builds for BlackBerry is using the Cascades framework, meaning you will receive native, intuitive applications with solid and fluent user experience out of the box. With just a few keystrokes you can have your existing application compiled and tested on a BlackBerry 10 device or simulator, then just a few more steps to get it signed and uploaded to BlackBerry World.

On the other hand, if you have heard of Appcelerator but are not really sure what they offer, allow me to break it down very simply: Appcelerator’s Titanium IDE allows you to create full featured cross-platform applications using JavaScript. Titanium also recently added support for a new UI framework dubbed “Alloy” which allows developers to define all application UI using a mixture of XML and CSS. “JavaScript” and “XML” may make Titanium sound like it creates web applications, however the applications are actually bundled with a JavaScript engine that interprets the code and displays it in the native UI of the platform for which the application was compiled. The result is an application that can be created very quickly to support multiple platforms (ex BlackBerry 10, iOS, Android) but with the performance, look and feel of a native application.

Existing Titanium developers can get the 3.1.1 SDK update which includes the BlackBerry 10 SDK using the Titanium SDK’s built-in update mechanism. Anyone that needs to download the full IDE can grab it from here.

For more details on all that 3.1.1 has to offer please check out this Appcelerator blog post.

Do you have an application built using BlackBerry Java that makes use of the Payment Service APIs? You’ll be happy to know that Cascades support the exact same digital goods types meaning you can provide the same monetization model in BlackBerry 10; you can even use the same digital goods already in your vendor portal. This means less time planning how to monetize your app and less time creating and managing digital goods giving you more time and freedom to develop the rest of the app or letting you finish a few days earlier.

BlackBerry World Client

In BlackBerry OS 7 and lower the Payment Service was included as a separate library which was heavily dependent on the version of BlackBerry World that was installed on the device. This meant that your application would need to query what version of BlackBerry World was installed and, if not at the version required by the library, prompt the user to upgrade the client to a newer version.

In BlackBerry 10 the Payment Service libraries are integrated directly into the OS and the tight coupling with the BlackBerry World client has been removed; meaning you only need to worry about developing.

Vendor Portal

As mentioned above the same digital goods used for BlackBerry OS 7 app releases can be used against any device/OS including BlackBerry 10. To make use of the existing digital goods you simply need to create a new BlackBerry 10 release that references the SKUs of the existing goods. If you are creating a new app altogether then you only need to create the digital goods in the same manner done for your Java apps:

http://docs.blackberry.com/en/developers/deliverables/47831/1278466.jsp

If your BlackBerry Java application has a good user base then I would recommend the above approach, it will allow existing users to download your new BlackBerry 10 version as soon as they upgrade, being visible right in the “My World” section of their BlackBerry World client app when they start up their new BlackBerry 10 device. You will, however, want to upload separate metadata for each platform you are targeting (screenshots, descriptions, keywords etc):

http://devblog.blackberry.com/2012/11/blackberry-app-world-success/

Environment Setup:

Both BlackBerry OS 7 and 10 require an additional library to be added to the project, the difference is that in BlackBerry 7 you need to download and add the library (JAR) to your project, whereas in BlackBerry 10 you only need to reference the library that is integrated with the SDK and OS meaning less work for you and a library that stays updated as you change SDK versions.

Java:

Add the JAR to your project

http://docs.blackberry.com/en/developers/deliverables/40131/Add_Payment_Service_library_to_build_path_1316204_11.jsp

Cascades:

Add the LIB reference to your .PRO file

https://developer.blackberry.com/cascades/documentation/device_platform/paymentservice/selling.html#pat1339516868668

Initializing the Payment Engine/Manager:

The “brains” of the payment service, where all calls are initiated, stems from one object which needs to be instantiated before any further calls can be made. Below are code snippets that show how this instantiation occurs in BlackBerry OS 7 in Java followed by BlackBerry OS 10 using Cascades APIs:

Java:

A prerequisite to using the payment service is to verify that the version of BlackBerry World client on the device is at a sufficient level and, if not, prompting for the update to be installed prior to making any payment calls.

try {
 PaymentEngine.isAppWorldInstalledAndAtCorrectVersion();
} catch (AppWorldUpdateRequired e) {
 PaymentEngine.upDateAppWorld();
 System.exit(0);
}
PaymentEngine engine = PaymentEngine.getInstance();

Cascades:

The payment service in Cascades requires information on which window group the app is using so the payment prompts can be properly drawn overtop.

bb::platform::PaymentManager *m_paymentManager = new PaymentManager();
 bb::cascades::Application::instance()->mainWindow()->groupId();
m_paymentManager->setWindowGroupId(windowGroupId);

The PaymentManager lets you define properties that will be displayed to the user in all purchase requests, specifically the application name and the URL of a custom icon if desired.

m_paymentManager->setApplicationName("The Awesome Store");
m_paymentManager->setApplicationIconUrl(QUrl("http:///mycompany.com/100x100.png"));

Test Mode:

Not available in BBOS

Cascades:

PaymentManager::setConnectionMode(PaymentConnectionMode::Test);

Initiating a Purchase

Java:

PurchaseArgumentsBuilder arguments = new PurchaseArgumentsBuilder()
     .withDigitalGoodId( "1234" )
     .withDigitalGoodName( "My Product" )
     .withDigitalGoodSku( "Ab34t2eC" )
     .withPurchasingAppIcon( bitmapIconImageVariable ); 
     .withPurchasingAppName( "My Application" ); 
     .withMetadada( "Extra info for consumable goods" );
 try 
 {
     PurchaseResult result = engine.purchase(arguments.build());
 }
 …

Cascades:

const PurchaseReply *reply = m_paymentManager->requestPurchase("1234", "Ab34t2eC", "My Product", "Extra info for consumable goods");
connect(reply, SIGNAL(finished()), SLOT(handlePurchase()));

Restoring Past Purchases

Java:

try
 {
     ExistingPurchasesResult result = engine.getExistingPurchases(false/true);
     Purchase[] resultPurchases = result.getPurchases();
 }
 catch (PaymentException e)
 { 
 }

Cascades:

const ExistingPurchasesReply *reply = paymentManager->requestExistingPurchases(false/true);
connect(reply, SIGNAL(finished()), SLOT(handleExistingPurchases()));

If you happen to be new to C++ and would still like to monetize your Cascades application then you will be happy to know that our Payment Services developers have created a nice sample which takes the bulk of the payment calls needed and exposes then through to QML, allowing you to make payment calls without writing a single line of C++ yourself, just copy the important parts from the sample into your own application. This sample can be gitted from here:

https://github.com/blackberry/Cascades-Samples/tree/master/paymentservice

Of course there are a few more calls available through the Payment Service in both Java and Cascades, but the above set provides a solid baseline for the main functions developers using the Payment Service should be aware of. If there is anything else you would like to know about the Payment Service, or have trouble porting the pieces from Java to Cascades, there are a few great options for support:

1)      Support forums:
http://supportforums.blackberry.com/t5/Payment-Service/bd-p/pay_serv

2)      BlackBerry Developer Twitter account: @BlackBerryDev

3)      Garett B (Developer Relations Payment Service Expert): @garettBeuk

Happy porting!

http://blackberry.webtrends.com

This provides a great option for devs that need analytics for only BlackBerry applications (the dashboard was sandboxed to display only BlackBerry provided data) however with the mobile ecosystem bursting at the seams we want to ensure that when moving forward to BlackBerry 10 developers have as much flexibility as possible. “Flexibility” meaning choice of analytics providers as well as the ability to use one dashboard to display data from across multiple platforms; knowing that many BlackBerry 10 developers may also be developing for other platforms in tandem and may have strong preference to a specific provider makes flexibility all the more important. This shift in end goals of an Analytics service for developers also shifts the approach when presenting a solution to the community. The approach that was decided on fits in with the general model of BlackBerry 10 openness: rather than create an Analytics service specific to BlackBerry 10 we will focus on partnering with existing Analytics services to help them add support for BlackBerry 10 to their offerings.

The partnering approach offers tons of key benefits: Developers can continue using the analytics provider they choose. Any updates made to the SDK at the service level will be immediately available to all users. Analytics from multiple platforms can be visible under a single dashboard. Familiar API calls. There are many more benefits as well, and all while still keeping the application integration as smooth and easy as possible. At BlackBerry Jam I actually added Flurry Analytics to a Cascades application in well under 2 minutes.

As you can read from the above synopsis, moving from BlackBerry 7 to BlackBerry 10 there has been an entire shift in how Analytics will be provided. At present there are already options for Cascades, Native and WebWorks/HTML5 developers:

100% free industry leading service. Support for C/Native and Cascades application from one SDK.

Fully open sourced client and server offerings as well as a hosted solution. Support for Cascades and WebWorks/HTML5.

Localytics is the most recent service to join the list; now officially supporting for WebWorks/HTML5 and Cascades applications on BlackBerry 10. This service provides near real-time Analytics data.

And we are making it as easy as possible for Analytics providers to bring over their services for BlackBerry 10 by creating a porting guide for both Native and HTML5 solutions. The guide is set to cover all the common information typical analytics frameworks would need to know such as determine the Time Zone, unique identifiers and lifecycle of the BlackBerry 10 devices. This porting guide should be published in the near future will be available from the Analytics Services page:

https://developer.blackberry.com/develop/platform_services/platform_analytics.html

Just prior to BlackBerry Jam Americas, I was speaking with Adam Stanley about analytics services for our BlackBerry 10 HTML5 developers. Adam had been looking into Localytics and found that they have an analytics service written entirely in HTML5; BlackBerry has an entire development approach based on HTML5, so he decided to try his hand at plugging it in to a WebWorks application on his BlackBerry Z10. Without much delay he found that almost the entire service worked as-is out of the box (web standards are a thing of beauty!).

After the above discovery Adam quickly fired off an email to the Localytics folks to see about getting some official documentation posted for BlackBerry 10. Normally using this approach, without having an “in”, it takes time; with Localytics we were put in touch with their VP of Strategy and Business Development, Brian Suthoff, right away, and were on a call with him within a few days. Localytics was excited to know just how easy it was to use their service with BlackBerry 10.SDK Dev Lead Randy Dailey jumped right to working on SDK tweaks to further support BlackBerry 10 and official documentation.

Today, just a couple of weeks from our first engagement with Localytics, I am happy to say that Localytics is now officially supported on BlackBerry 10. All you WebWorks developers can go ahead and add a few simple lines of JavaScript to your existing applications and start tracking usage of your application. But wait, there’s more! If you use Cascades and want to use Localytics then you’ll be happy to know that there is also a QML interface for the service making it available to you as well! Check the Localytics blog for the official announcement:

http://www.localytics.com/blog/2013/localytics-releases-blackberry-10-sdk/

I have already created my first Cascades application using Localytics; the entire process was a breeze. From account creation, to getting the files and docs needed to start, to the point where I had analytics actually displaying in my dashboard was all of about 30 minutes.

The service plans begin completely free for developers and indie publishers and scale up from there depending on your needs.

Ready to get started? If you’ve read this far then of course you are! Chad Tetreault has gone ahead and written the first WebWorks sample application with Localytics implemented, you can get it right now: 
https://github.com/blackberry/BB10-WebWorks-Samples/tree/master/Localytics

For more info check out the main Localytics site and the following resources for more information:

• 
  http://www.localytics.com
  
• 
  http://www.localytics.com/docs/blackberry-10-integration/
  
• 
  http://developer.blackberry.com/html5/
  
• 
  http://developer.blackberry.com/cascades/
  

1. Register to receive push messages with the device
2. Register with the BlackBerry Push Service in the cloud to allow push messages for the app to begin being delivered
3. Register with your server side app so it knows there’s a new subscriber
4. Be ready to receive push messages at any time
5. Process pushes in a quick and efficient manner

The server-side portion of consumer push is identical between all BlackBerry smartphone versions, meaning you can use your current server-side app and push service credentials.

By włodi from London, UK (The Big Red Button Uploaded by Yarl) [CC-BY-SA-2.0 (http://creativecommons.org/licenses/by-sa/2.0)%5D, via Wikimedia Commons

BlackBerry 7

In BlackBerry 7 Java, there were two main ways to set up your application to receive push messages – open a port and begin listening indefinitely or register your port and application details with the device. The former basically required that your application begin a background process when the app was first installed, as well as every time the device started up. When the push arrived on the port opened by the app, the data could then be processed however required by the app, followed by the app once again listening on the open port for the next message. This method also required the app to perform “manual” registration, an HTTP POST, with the BlackBerry Push Service to allow devices to begin receiving push messages for your app.

https://github.com/blackberry/JDE-Samples/tree/master/com/rim/samples/device/httppushdemo
(this sample shows Enterprise Push which is similar to the pre-5.0 Push API method through BIS)

The latter approach was introduced in BlackBerry 5 where new APIs were introduced that removed the need to keep an app thread running at all times. Instead, the app would register itself with the device by passing it the assigned port and push app ID, allowing the device to listen for push messages on behalf of the app and launch to pass the push message to be processed. This method provided a simple way to allow the app to perform the registration with the BlackBerry Push Service.

http://www.blackberry.com/developers/docs/7.0.0api/net/rim/blackberry/api/push/package-frame.html

BlackBerry 10

The approach used in BlackBerry 10 is most similar to the last approach mentioned for BlackBerry 7 and is arguably the simplest way to handle push messages yet. One simplification is that developers no longer need to worry about application ports, as the on-device service will now handle port selection directly with the BlackBerry Push Service. Another is that rather than needing to deal with reading network streams to receive the push payload, it is not delivered directly to the app fully available in the data portion of an invocation.

Application flow

The first thing your app will need is an entry in the bar-descriptor.xml file that registers the app to receive invocations from the device push notification service. Below is an example entry. The only thing you need to change is the invoke-target id value to a string unique to your app:

              <invoke-target id="com.unique.string.for.your.app">	
      <type>APPLICATION</type>
      <filter>
         <action>bb.action.PUSH</action>
         <mime-type>application/vnd.push</mime-type>
      </filter>
    </invoke-target>

The second thing to add to the bar-descriptor is the permission for consumer push (this can also be added through the GUI editor in the IDE):

<permission system=”true”>_sys_use_consumer_push</permission>

After the above entries exist, we are ready to start programming. Using the various Push APIs, the following flow needs to occur in the device app:

Create a Session

Frequency: Every time your app launches

This is where your app registers itself to receive push messages. Once your app passes the on-device service, it’s provided a push app ID as well as the invoke-target ID you specified in the bar-descriptor file. This basically tells the service, “If a push comes in with this push app ID, invoke my app using this invoke-target ID”.

PushService* m_pushService; //Member variable creation in header file

//In this case BLACKBERRY_INVOKE_TARGET_ID would be “com.unique.string.for.your.app” from above

m_pushService = new PushService(BLACKBERRY_PUSH_APPLICATION_ID, BLACKBERRY_INVOKE_TARGET_ID);
m_pushService->createSession();

Create a Channel

Frequency: Once for the lifetime of the app

After the session has been established on the device, the app then needs to register itself with the BlackBerry Push Service. This operation is referred to as “creating a channel”. The creation of a channel tells the BlackBerry Push Service, “If a push message arrives with this app ID and is addressed to my device, please let it through”. Without this step, pushes will never be delivered to the device.

m_pushService->createChannel(QUrl(BLACKBERRY_PUSH_URL));

Another important part of this step is that when the channel is created, it should return a “token” which currently is simply the value of the device PIN. This can be sent to your server once retrieved to let it know that a new device has subscribed.

Register to Launch

Frequency: Once for the lifetime of the app

Following the channel creation, your last step is to call the “register to launch” function. Unlike BlackBerry 7, BlackBerry 10 apps do not run all the time. When a push arrives however, the application can be launched into the tiled state to perform processing on the push it’s not already running. In order to be launched when a push arrives, the app must call the “register to launch” function. Otherwise if this function is not called and the application is closed, the push data will be lost.

m_pushService->registerToLaunch();

Once the above steps are completed, your app is ready to start receiving push messages. As push uses invocation, you can handle the messages in about the same way you would for a standard invocation of your app:

https://developer.blackberry.com/cascades/documentation/device_platform/

invocation/receiving_invocation.html

The one difference is that you need to use the PushPayload class to retrieve the push payload from the InvokeRequest’s data:

https://developer.blackberry.com/cascades/documentation/device_comm/push/

cs_receiving_a_push_message.html

Ready to get porting your BlackBerry Java push app over to BlackBerry 10? Here’s a great resource that walks through the entire service including lots of code snippets:

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

Need a sample to test your current push credentials? Check our GitHub repositories:

https://github.com/blackberry/Cascades-Samples


https://github.com/blackberry/Cascades-Community-Samples

Never used Push before? Check out this overview of the service:

https://developer.blackberry.com/services/push/?CPID=PUSHAPI00

If you still have questions toss a post in the Push Development forums or send me a tweet:

http://supportforums.blackberry.com/t5/BlackBerry-Push-Development/bd-p/Applications_using_Push_Technology

@garettBeuk

For anyone new to analytics let me explain why I am so excited and why you should be as well. Analytics gives you the ability to know who is using your application as well as how they are using it. Sounds easy enough right? The Flurry SDK integrates with your application and allows it to log “events” when they occur. A simple example would be logging an event where a button is clicked. That data is recorded and then sent up to the dashboard where patterns start to emerge on how many people are clicking that button, how they got to it, and what users do after it gets pressed.

Analytics helps by telling you two very important pieces of information:

Who is using your application?

The Flurry Analytics service will report the following information about the user/user’s device by default:

• Locale set on the device
• Time Zone
• Approximate location
• Device name (ex “BlackBerry Z10”)
• Device OS version
• Carrier

And can also be configured by you to report:

• The version of the app being used
• The user’s geolocation (with permission from the user)
• The user’s gender (if supplied by the user)
• The user’s age (if supplied by the user)
• The user ID (if used by your application)

This will let you know where your application is being used, as well as provide you an idea for the type of people that are using it. This in turn gives you the ability to tailor content to various regions and locales based on demand, as well as determine which device models you may want to focus on in the future.

How are people using your application?

Of course after you know who is using your application you will definitely want to know how they are using it. Flurry lets you log events that occur within your application, letting you map out every step the user takes. This is helpful so you can see trends for where they may be getting stuck, areas for improvement, and features that are being used more than expected and can be prioritized for enhancement in future releases. This information is invaluable for making informed decision on where to take the direction of your application.

From the aspect of monetization, knowing user patterns can help you understand what will make your application and possibly digital goods for sale, more attractive/valuable to the end user. Events would also allow you to track the success of promotions within your application. If you happen to sell a limited edition digital good, or offer to unlock the premium features of the app at a reduced price, you have the ability to track the success of the promotion with a relatively short turnaround.

The idea of tracking everything your users do may sound like a scary concept, however all data is made anonymous by the service meaning there is no way of tracking specific actions back to one device/user. Keeping the data anonymous keeps users from compromising their privacy while still maintaining the integrity of the data.

If you’re ready to add some analytics to your application then getting started is easy. Simply go over to the Flurry home page and create an account. Then create an application to get the analytics SDK for BlackBerry 10.

I’ve also whipped up a sample app that you can take a look at to get a feel for the APIs that can be downloaded from the Community Samples Repo on GitHub.

JAM68 – Flurry Mobile Analytics on BlackBerry 10!!

If you’re lucky enough to be at BlackBerry Jam Americas this week, you can attend JAM68 where Anthony Watkins and Rich Brett from Flurry will be presenting with me on how to integrate the Analytics SDK into your BlackBerry applications. For those unable to make it, the recording should be posted a few days following the session and you can always send me a message on Twitter with your questions/comments: @garettBeuk

For more information you can also refer to our Analytics page on the forums:

http://developer.blackberry.com/devzone/develop/platform_services/platform_analytics.html


http://supportforums.blackberry.com/t5/BlackBerry-Analytics-Service/bd-p/analytics_serv

Learn the tips and tricks around optimizing your payment services code to provide the best user experience possible while at the same time maximizing your potential revenue. See how other apps that have earned the coveted Built for BlackBerry designation have implemented payment services as we deconstruct the models used by real apps in BlackBerry World today.

In the ever growing world of app choices, choosing an appropriate monetization strategy is as important as a solid execution in determining the success of your application; in JAM05 we will discuss both.

Whether you need to bus, train, fly, run, scooter, bike and/or pogo to get to this year’s BlackBerry Jam Americas, we hope to see you there. If you are without one or more of the aforementioned means of travel, fear not.  The sessions will be recorded for playback at a later time!  However, if you choose that option, you will miss out on Larry and my sparkling personalities and live stage theatrics, as well as the Q&A, but we’re always reachable via Twitter at @lmcdunna and @garettBeuk for questions and feedback.

With these questions in mind, I set out to create a few fairly simplistic samples to demonstrate a few potential answers to the above questions.

Sample 1: Simple Push Server Sample

What does it do? This app is written in Cascades, meaning that you effectively have a server-side app capable of sending pushes running right on your BlackBerry 10 device. No need to jump to your computer whenever you want to send a push to your client-side application – simply launch this app and push away!

Features

1) Push a message to a single recipient (specify the device PIN)
2) Retrieve all active and subscribed users (these are all persistently stored via QSettings)
3) Push to all known active subscribed users (pulled from QSettings)
4) Formats the push payload in a specific format that is expected in Sample 2 which includes 3 properties: priority of the push, a title for the message, a body for the message

Sample 2: Simple Push Client Sample

What does it do? This sample is the second half to Sample 1 – it receives push messages, expecting them in the format sent from Sample 1, and handles them differently based on the priority level set. The app also works with the application lifecycle, notifications engine and application cover to provide a fairly comprehensive implementation of push.

Features

1) Receive and display push data
2) Store push data messages (stored via QSettings)
3) Integration with the cover of the application (seen when the application is minimized). The last received push message gets displayed along with a custom header graphic and a timestamp providing details to the user without the app needing to be opened.

4) Integration with the system notifications engine at 3 different levels depending on the priority of push message received:
a. Low: Set the splat on the application icon
b. Medium: Execute a Notification that will alert the user based on the system settings
c. High: Display a NotificationDialog that will contain the details of the push message
5) Work with the application lifecycle when a push arrives to close the application when a push arrives and the user’s attention is not immediately required, and the application is not in use:
a. Low and Medium: Close the application after handling the push message
b. High: Keep the application open; user engagement is expected

Note that best practices state that if the application is launched via a push invocation and does not need to remain open, then it should exit once the message is processed.

Both sample applications can be modified to work with your own push service account by just changing a few variables. Once that is completed, you will have a fully functioning client and server-side push implementation. In the client, the PushManager code handles the push messages received by the device while the CoverManager code handles all updates to the minimized application cover.

Ready to get started? The samples are hosted here:

SimplePushClient:

https://github.com/blackberry/Cascades-Community-Samples/tree/master/SimplePushClient

SimplePushServer:

https://github.com/blackberry/Cascades-Community-Samples/tree/master/SimplePushServer

For any further support, please send a message out to @BlackBerryDev or @garettbeukeboom, and for more involved questions, post a message to the BlackBerry Push Development forum board.

As many of you may be aware, there are essentially two main models for distributing applications through BlackBerry World: paid and free. With paid applications, the gap between a user seeing an application in BlackBerry World and actually purchasing that application can be a bit of a problem, especially for newer applications.

Free applications can spread quickly but don’t generate revenue when downloaded. So how do you get your applications into the hands of the masses without worrying about this gap and still make money? It’s not a trick question – the answer lies with a hybrid of the two models discussed above by use of the Payment Services SDK.

Enter the freemium (free + premium) business model. The freemium model uses the approach of providing free products/services with paid premium upgrades. Using this model, you would be able to provide a version of your application for free, allowing anyone to test your application without paying a cent, and then offer premium items for purchase using the APIs available in the Payment Services SDK to enhance the user experience. Of course, there are many options for how this could be achieved; the best way to proceed may be to use an example and evaluate a few strategies.

The simplest application to use this model that comes to mind would be a game. With a game, you can allow users have a feel for the gameplay, use the controls and get absorbed into the plot by distributing it for free. One great example where the freemium model is being used today is in the games created by the BlackBerry World vendor Ebscer, in particular Xploding Boxes. I will be using this example to draw parallels to a few concepts discussed in the remainder of this blog post.

To monetize, here are a few options which leverage the Payment Service SDK:

Upgrade

• The idea with the upgrade would be to provide a base or lite version of the application for free and provide the means for the user to pay to unlock the full version. In this scenario, you could present the user with an “Upgrade” button which, when clicked, uses the Payment Services SDK to purchase a Digital Good from BlackBerry World. Once this Digital Good is purchased, the full version of the application can be unlocked for the user.

Unlock Levels

• An alternate approach could be to create the application with 10 (to pick an arbitrary number) levels, but only allow the first 5 to be playable for free. The remaining 5 could be purchased in order to become playable and complete the game. For this you could use a single Digital Good to unlock all 5 levels, sell them individually or in bundles.

In the example of Xploding boxes, the first 25 levels are completely free to play when the application is first installed. As you work your way through the game and have exploded the first 25 levels worth of boxes you then have the option to complete an in-app payment to unlock all 360 levels! The first 25 levels do a great job of getting the player hooked with simple, fun and mind-bending puzzle gameplay, so once those are completed, the nominal fee to unlock an extra 335 levels is more than worth it.

Unlock Features

• Suppose the user would like to customize their game character, or access items for use in the game which will help them complete the game more easily. Why not offer the ability to purchase premium features such as clothing to customize character appearances or a charm to speed up character movements? These features could be as simple as a change to a variable value in the game, but could mean increasing the chances of returns and adoptions of your once-free application.

There are many more options to monetize your applications using the Payment Services SDK; the above three are just some ways this could be done. There is also no restriction to choosing one singular approach; you could use multiple approaches in the same application. As well, you can always release updated versions of your applications with new features and new options to enhance the application through paid premium upgrades.

A few minor suggestions when choosing to use the freemium business model: Make the application addictive/engaging and usable on its own without the user needing to purchase premium features. When selling premium features ensure that the end user receives a good return on their investment by making the features add good value to the application. Finally, premium features should be just that – “premium” – so it is important that they meet or exceed the caliber that users have come to expect from the rest of your application. Going back to the example of Xploding Boxes, all three of these criteria are met: the game is very fun and addictive, the extra 335 levels is a great return providing hours (if not days) of more fun, and as the additional levels extend the existing gameplay model, the user knows exactly what they are getting before making the purchase.

The Payment Service SDK is already supported in current BlackBerry smartphones (OS <=7.1) as well as the BlackBerry PlayBook OS and BlackBerry 10, so no matter what development approach you use (BlackBerry Java, WebWorks HTML5, Native, Cascades Framework, Adobe AIR, Android) there are APIs to support in-app purchases of Digital Goods.  The only thing left to do is implement the freemium model to your existing* or upcoming applications! Oh, and if you would like to have a good example of how this is done, then I would highly recommend giving Xploding Boxes a try on your BlackBerry PlayBook tablet as well as BlackBerrysmartphones (OS <=7.1 and BlackBerry 10) – it is free, after all.

Ready to get started? Here are some resources to help:

Cascades Framework
Native SDK
HTML5 WebWorks
Adobe AIR
Runtime for Android Apps
Java (BlackBerry OS <= 7.1)

BlackBerry World applications cannot change between paid and free models