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!

For both South Africa and India, the new pricing tiers reflect adjustments for updated foreign exchange rates, competitive benchmarking, consumer friendly price points, and taxes, where applicable.

The price change is completely automatic and will not impact the availability of your content items to customers. You are not required to take any action.

Should you like to adjust the price tier for your content items in a given country you can freely do so within the BlackBerry World vendor portal at any time.

Please note that if you make any changes to the pricing of your content items there will be a delay of up to 24 hours until the prices appear.

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.

If you could promote your application on a rapidly growing social network with 60+ million active users – 70% of which use it daily – with just a few lines of code, would you do it? I think the more appropriate question is, why haven’t you done it yet?

Meet the BlackBerry® Messenger Social Platform (BBM™ SP), which you can use to enable your application to go viral with very little effort. Approximately 2% of applications in the BlackBerry App World™ storefront have connected to the BBM SP; however, that group accounts for over 20% of all downloads! Spending just half an hour to add this to your application can really pay off. With minimal development effort, Foursquare was able to integrate their application with the BBM SP, resulting in a doubling of downloads in a single day. Nobex Radio saw a 52% increase in downloads after they added support for the BBM SP.

Continue reading for a high level overview of what can be done using the BBM SP APIs. Today we’ll cover the “What” of the BBM SP. Future articles in this series will provide more technical “How To” for both Native and BlackBerry® WebWorks™ developers. The features discussed in this article exist both on BlackBerry® 10 and BlackBerry® OS 5 through 7.

Registration

Registration is the first step in connecting to the BBM Social Platform, which involves an application registering itself with the RIM®-hosted BBM infrastructure. Keep in mind that like most features on a BlackBerry device, the user can approve or deny this connection, allowing them to regulate which applications they allow to use the BBM SP. The application is also informed during this process whether or not the connection was a success. If it did fail, the application is given the reason why. Possible reasons include lack of network coverage, registration blocked by the user, or BBM Client not configured. Once this step is complete, the more interesting APIs of the BBM SP are available to your application.

Invite to Download

The invite to download feature allows users of your application to invite their BBM contacts to download your application from BlackBerry App World. The recipient receives the invitation through a BBM Chat session, which includes a message provided by the application and user sending the invitation. The chat session also contains buttons for the user to accept or decline the invitation. If they accept the invitation, BlackBerry App World is opened to show your application. This feature is ideal for multi-user applications or games, allowing the user to easily invite their contacts to participate.

Note that for this to work between BlackBerry 10 and BlackBerry OS 5-7 users, the SKU in BlackBerry App World for the two releases of the application (BAR and COD) must be the same.

Profile Integration

Updating personal message from BBMQtProfile Sample

BBM SP allows for both read and write access to the user’s BBM profile. This allows your application access to their profile message, status text, availability and avatar image. The screenshot above shows the confirmation prompt that appears when an application attempts to update a user’s personal message.

View from my contact’s device

Profile updates are visible from the devices of my contacts. They can see a list of recent updates made to my profile and provide yet another opportunity for viral growth. If an update to my personal message was made from an application other than the BBM Client, a tag is shown under the update stating the name of the application that performed the update. Note the “from BBM SDK Demo” tag beside the red arrow. Users can click on that tag to download the application from BlackBerry App World. This requires the sender to have installed the application from BlackBerry App World, so that tag won’t take you to BlackBerry App World if you side loaded your application for testing.

Profile Boxes

Profile Boxes provide yet another way for an application to promote itself to a user’s BBM contacts. They appear within the Apps area of a user’s profile and are ideal for sharing what a user is doing within an application. Every application that is connected to BBM SP appears in the list. Applications can create profile box items that appear under their application header. You can supply a custom image and string, which is used to create the profile box item. The user’s contacts can also use this to download the application from BlackBerry App World.

Contacts

An application can retrieve a list of BBM Contacts who have the same application installed. This list can be used as selection criteria for connecting to create a multi-user experience. Events are also fired for changes to this contact list, allowing your application to keep track of both the addition and deletion of contacts in the contact list itself and/or changes to individual contacts. An application could pick up on changes to individual contacts to trigger some event. For example, if someone gets a new high score, a game may broadcast it to the user’s BBM contacts by changing their BBM personal message. An application could listen for this update and use it to trigger an in-game challenge to beat their friend’s new high score.

You could also use this to trigger in game connections. A user could enter a game and indicate they want to play against their friends. The game could update the user’s BBM status to something like, “Mark wants to play Slingshot 5000 with someone.” By listening to BBM status updates, my contacts who are also in game could be prompted to join for some head-to-head action.

Wrapping It Up

This list covers the core BlackBerry Messenger Social Profile features that will be available for your application to use upon the launch of BlackBerry 10. The SDKs and APIs are available to use now — start today so you can be ready for launch. If you have an existing application that targets BlackBerry OS 5-7, you can roll out these features right away.

Keep an eye here on the blog for follow-up articles that’ll provide some technical information on how to code these features into your application. We also have further information available on the BBM SP website. Also, watch this blog for additional blog posts in the BBM series that cover how to use these features in a Cascades™ application and BlackBerry WebWorks application, as well as how to invoke BBM using the invocation framework.

C2 Development has opened up their application Kaxi for beta testing exclusively on BlackBerry® 10 Dev Alpha devices. Kaxi is a location-based app that simplifies the process of finding taxi companies local to the UK and USA. All you need is a GPS signal and a working network connection (Wi-Fi®/3G/4G). The app will then list local taxi companies nearest your location.

Sign up for the beta to gain access to the latest release before it reaches the BlackBerry App World™ storefront. Accepted beta requests will be given access to the Kaxi beta Portal which may be used to submit feedback and bug reports. The latest downloads will also be available via this portal.

Kaxi is currently only available for BlackBerry 10.

You know, working in the Developer Relations team at Research In Motion® (RIM®), you get to get to play around with some fun stuff. Recently, Near Field Communication (NFC) has been exercising my brain cells. Some of you may be familiar with the NFC-related articles and code samples that I’ve co-authored with my co-conspirator, Martin Woolley (@mdwrim), which you can find listed in our NFC Article and Code index.

Now, whenever you mention NFC in a conversation, people invariably think of payments. Using NFC to make secure payments is perhaps the most obvious use case. However, when I think of NFC I tend to think of workflows as well. “Workflows,” you say? What do you mean?

OK, let’s think about it anecdotally. How many times have you had the challenge of transcribing some data from an external source to your handset whilst holding a bag and trying to hold a conversation at the same time? How many times have you tried to share information on your handset with someone else and had to struggle with inputting email addresses whilst doing three other things at the same time? These use cases are examples of Workflows, or Business Processes, that stumble on the point of having to accommodate more “human” interaction than is really necessary. NFC can be used to help streamline simple workflows that involve human interactions on mobile devices and ultimately help achieve efficiencies.

So, having thought about this and how to demonstrate a simple but realistic use case (whilst also having some fun), we came up with the concept of the “Fun Run”.

Suppose you’re taking part in a charity “Fun Run” – not quite a marathon but something shorter for fun. The race organizers have developed a simple mobile application to allow you to register for the event and have placed NFC Tags in the starting and finishing areas. As you start you tap on one of the tags, your race timer is started as well as notifying the organizers that you have begun. When you pass the finish line, simply tap on one of the tags in the Finish area to stop your timer and notify the organizers of your finishing time!

In between the start and finish, there may be Way Points with NFC Reader devices that can be used to register intermediate times as the runner passes these points. Tap the handset to the NFC Reader and receive confirmation that the timing data has been transferred successfully.

OK, maybe it’s not 100% realistic, but as an example it is sufficient to demonstrate how a workflow process that involves having to record start and finish times and tracking progress can be made more efficient using NFC. The key learning point is to understand how integrating NFC technology into your application can be used to achieve efficiencies in similar processes.

The Applications

Let’s take a look at how we implemented this simple example using BlackBerry® 10 and BlackBerry® 7 NFC capable devices. There are really three use cases:

1. Tap your handset against an NFC tag at the start of the race to start your race timer.
2. Tap your handset against NFC readers at intermediate waypoints during the race to transfer your current race timer data to an application that manages the reader.
3. Tap your handset against an NFC tag at the end of the race to stop your race timer.

Acting on External Tag Events

To implement the first and last use case, we decided to provide two NFC tags that had specific NDEF messages as their content. There would be one tag that would start the timer at the start of the race and one tag that would stop the timer at the end of the race.

Specifically the data in the two tags is:

1. Tag used to start the timer:

NDEF TNF = External ( integer value 4 )
Type = “my.rim.com:myrecordtype”
Payload = “start”

2. Tag used to stop the timer:

NDEF TNF = External ( integer value 4 )
Type = “my.rim.com:myrecordtype”
Payload = “stop”

Why use this data? Well, firstly we choose an NDEF TNF (Type Name Format) for the NDEF Message because it allows us to define custom tag content that won’t clash with standard tag message types such as Smart Poster (“Sp”) or URL (“U”) or Text (“T”). We want to make sure that when one of these tags is presented, our application, and our application alone, is launched to process the tag.

Secondly, we choose a “Type” of “my.rim.com:myrecordtype“. Within the context of an External TNF record the Type can be arbitrary, but in order to prevent clashes with other organizations’ custom tag formats, we use the DNS naming scheme to set the namespace of the tag as “my.rim.com” to establish it as a RIM NDEF message. We further qualify it with a specific sub-type of “myrecordtype” since an organization may define a whole family of custom tag formats for its own use.

So, these settings ensure that these tags will only make sense to our application and not overlap with tags form elsewhere. The “Payload” of the two tags differs in that one has the string “start” and the other has the string “stop” to mark them as ones to be used to start and stop the timers respectively.

In the case of BlackBerry 10, our application registered with the Invocation Framework through the stanza in its “bar-descriptor.xml” file as shown in Figure 1. The “uris” attribute of the “<property … />” tag has been set to the value “ndef://4/my.rim.com/myrecordtype” which a URI format specification of the two tags just described above.

...
<invoke-target id="com.example.NfcRaceTimeWay">
    <type>APPLICATION</type>
    <filter>
        <action>bb.action.OPEN</action>
        <mime-type>application/vnd.rim.nfc.ndef</mime-type>
        <property var="uris" value="ndef://4/my.rim.com/myrecordtype"/>
    </filter>
</invoke-target>
...

Figure 1 Registering for tag types in BlackBerry 10

When a “start” or “stop” tag is presented to the handset, then our application is launched if it’s not already running, and the tag contents are handled as shown in Figure 2 — where the payload of “start” or “stop” is extracted once we’ve verified that it’s of the correct type.

...
void NfcListener::receivedInvokeRequest(const bb::system::InvokeRequest& request) {

    QByteArray data = request.data();
    QtMobilitySubset::QNdefMessage ndefMessage = QtMobilitySubset::QNdefMessage::fromByteArray(data);

    handleNdefRequest(ndefMessage);
}

void NfcListener::handleNdefRequest(const QtMobilitySubset::QNdefMessage ndefMessage) {

    QList::const_iterator ndefRecord;

    for ( ndefRecord = ndefMessage.begin(); ndefRecord != ndefMessage.end(); ndefRecord++) {
        if (ndefRecord->typeNameFormat() == QtMobilitySubset::QNdefRecord::ExternalRtd) {
            if (QString(ndefRecord->type()).compare("my.rim.com:myrecordtype") == 0 ) {
                emit raceTagDetected(QString(ndefRecord->payload()));
            }
        }
    }
}
...

Figure 2 Handling a Start or Stop tag in BlackBerry 10

In the case of BlackBerry 7, registration is achieved in Java® by registering a listener for the specific NDEF message type as shown in Figure 3.

...
    nfcManager = ReaderWriterManager.getInstance();
    nfcManager.addNDEFMessageListener(listener, NDEFRecord.TNF_EXTERNAL, "my.rim.com:myrecordtype", true);
...

Figure 3 Registering for tag types in BlackBerry 7

A similar behaviour is achieved for BlackBerry 7 through the implementation of the “onNDEFMessageDetected()” method of the “NDEFMessageListener” interface as shown in Figure 4.

...
    public void onNDEFMessageDetected(NDEFMessage msg) {
        NDEFRecord[] records = msg.getRecords();
        int numRecords = records.length;
        if(numRecords > 0) {
            byte[] payloadBytes = records[0].getPayload();
            try {
                String ascii_payload = new String(payloadBytes,"US-ASCII");
                Utilities.log("XXXX payload="+ascii_payload);
                if (ascii_payload.equals("start")) {
                    startTimer();
                }
                if (ascii_payload.equals("stop")) {
                    stopTimer();
                }
            } catch(UnsupportedEncodingException e) {
                Utilities.log("XXXX "+e.getClass().getName()+":"+e.getMessage());
            }
        }

    }

...

Figure 4 Handling a Start or Stop tag in BlackBerry 7

So, what we’ve achieved here is the ability to use an external NFC tag to trigger a process in our application. In this case it’s simply the starting and stopping of a timer, but it could be extended quite easily to, say, call a web service and integrate the event into a larger workflow process.

What does this look like in practice? Well, here’s a short video of the BlackBerry 10 application in action:

[ YouTube link for mobile viewing ]

Virtual Tag Emulation

Let’s get back to the original use cases. To implement the second one, we decided to have the BlackBerry handset emulate a virtual tag and allow the contents of the virtual tag to be read by an external NFC reader.
What format of tag should be emulated by the handset? This is what we chose:

1. Virtual tag emulated by the application

NDEF TNF = External ( integer value 4 )
Type = “my.rim.com:myrecordtype”
Payload = “hh:mm:ss”

a. That is the time displayed on the handset in:
Hours (hh)
Minutes (mm)
Seconds (ss)

The type of the virtual tag is exactly the same as for the “start” and “stop” physical tags for the very same reasons, except that the payload is a representation of the current race timer value (“hh:mm:ss”) as displayed by the application.

...
void NfcListener::startTagEmulation(const QString &tagData) {
    nfc_ndef_record_t *ndefRecord = makeCustomRecord(QString("my.rim.com"), QString("myrecordtype"), tagData);
    if (_emulateNdefMessage) {
        CHECK(nfc_delete_ndef_message(_emulateNdefMessage, true));
        _emulateNdefMessage = 0;
    }
    CHECK(nfc_create_ndef_message(&_emulateNdefMessage));
    CHECK(nfc_add_ndef_record(_emulateNdefMessage, ndefRecord));
    CHECK(nfc_start_ndef_tag_emulation(_emulateNdefMessage));
...

Figure 5 BlackBerry 10 – starting virtual tag emulation

As shown in Figure 5, starting tag emulation in BlackBerry 10 is quite simple. It just involves calling “nfc_start_ndef_tag_emulation()”. In addition we can use BPS (BlackBerry Platform Services) to determine when a read on the virtual tag has been successful, as shown here in Figure 6:

...
void NfcListener::handleNfcEvent(bps_event_t *event) {
    uint16_t code = bps_event_get_code(event);
    if (NFC_VIRTUAL_TAG_SELECTION_EVENT == code) {
        emit tagEmulationSelectEvent();
    } else if (NFC_VIRTUAL_TAG_LEFT_EVENT == code) {
        emit tagEmulationLeftEvent();
    } else if (NFC_VIRTUAL_TAG_READ_EVENT == code) {
        emit tagEmulationReadEvent();
    }
}
...

Figure 6 BlackBerry 10 – stopping virtual tag emulation

So, what we’ve achieved here is the ability to transmit live information from an application in the BlackBerry handset in real time to an external application via an NFC reader. The external application simply displays the time displayed by the BlackBerry application, but it could easily be extended to integrate with some larger workflow process.

Take a look at the video here for a demonstration of this on BlackBerry 10:

[ YouTube link for mobile viewing ]

If you’re interested, the virtual tag emulation functionality was tested using an NFC Reader attached to a PC controlled by a Python application using the “PyScard” (Python for Smart Cards) library available from SourceForge.net. (Python and Ruby are my favorite programming languages!)

The two versions of our NFC-enabled “Fun Run” applications are available with full source code from our GitHub repositories here:

https://github.com/blackberry/Cascades-Community-Samples/tree/master/NfcRaceTimeWay
https://github.com/blackberry/Samples-for-Java/tree/master/NFC/NfcRaceTime7

Just in closing, it’s worth making one or two comments about the relative ease of developing applications to the same set of end user specifications in BlackBerry 10 Cascades™ versus BlackBerry 7 Java. I’ve been developing code in C/C++ for more years than I care to remember and for a shorter time in Java (but still since the language first saw the light of day), so I feel I’m qualified to make comparisons. I’ll be honest: I’ve found it much easier to develop applications using C/C++ and Cascades. The user interface elements are particularly easy to use, and I’ve found it possible to get a user interface up and running in Cascades much faster than I would have done in Java. It’s much easier to modify and extend since Cascades elements map directly to Qt/Cascades C++ classes and the SIGNAL() / SLOT() model makes it so easy to connect events to handlers.

I’m definitely sold on Cascades, Qt and C/C++!

First and foremost, there are two kinds of invocations – unbound and bound. An unbound invocation is performed when an app does not specify a specific target app that should get invoked, and hence relies on the invocation framework to select the best target. For example, if there are three apps that can open .DOC files, the framework chooses the best one based on its own target selection logic. So, for unbound invocations, the framework provides automatic brokering to find the best-fit targets and also performs target selection to choose the best among the best. This is very powerful because the client application does not need to know any target applications at all, and yet it can discover and invoke them via the invocation framework.

On the other hand, a bound invocation is performed when the target app is specified by the client application while sending an invocation request. For example, a client app may request that Docs to Go® should be invoked for opening a .doc file. In this case, the invocation framework does not provide any brokering (or target selection) and blindly invokes the specified target app with the request parameters. Extra care must be taken when performing a bound invocation because an app may be sending a request to a target that the target does not understand at all. One thing is clear — bound invocation assumes that the client knows the target well.

There are really two ways you can know a target. First, you might have had a conversation with the author of the target app and have an agreement on the invocation request parameters. In return, they have made you aware of their target ID that you can use to perform a bound invocation. Second, you can query the invocation framework with an invocation request to get a list of best-fit targets and programmatically parse their attributes (capabilities) including their target IDs and invoke one programmatically. Note that querying is another way to discover apps without knowing them and is even more powerful and flexible than unbound invocations. As long as you have a valid target ID, you can perform a bound invocation with the appropriate parameters.

So far so good, but how does the invocation framework know about all the target apps? It does because each target app is required to register with the framework if they wish to be considered by the framework. While registering with the framework, targets must specify a target id which alone makes them candidates for bound invocation. However if a target wants to make itself available for unbound invocations or invocation queries, it must define one or more invoke filters. Each filter is a combination of the following attributes.

• Actions (e.g. bb.action.OPEN) that describes the action it can perform
• MIME types (e.g. application/pdf) describing the content type it can perform the action on
• URIs (e.g. http://, file://) specifying the protocols it can handle to retrieve the data
• EXTs describing the file extensions it can handle if the URI scheme is file://

Note that at least one action and one MIME type is mandatory for each filter definition, and if the URI is file://, at least one EXT must be specified. Filters are what really allow the invocation framework to broker between clients and potential targets as well as target selection that lead to successful invocations.

Well, that’s a 30,000 feet overview of the invocation framework but as a developer I know your hands are itching for some real code. The good news is I have that covered — I have already uploaded a few sample applications on Github that you may find very (very) useful.

• InvokeClient – An application that demos different ways to invoke and to query for targets
• InvokeTarget1 – A dummy target app that can be used with InvokeClient
• InvokeTarget2 – A second dummy target app that can also be used with InvokeClient

Samples are great, but so are documentations (if we read them) for a solid understanding. Please refer to our App Integration development guide for a comprehensive guide with code snippets for both invoke clients and targets.

I am more excited than ever before to introduce the invocation framework as part of the BlackBerry 10 Native SDK beta 2 and have no doubt that this will help most app developers out there to provide a deeply integrated user experience. Invocation is one of the core aspects of the BlackBerry 10 experience and come launch, it is going to be hard to find an app that does not invoke or get invoked. I will keep everyone posted on new features as we add them to this framework but more importantly, I am all ears to your feedbacks at shaque[at]rim[dot]com, @BlackBerryDev and @shadidhaque.

When digital media company PineLake Communications® wanted to learn more about BlackBerry® 10 development, it developed a simple application on the Android™ platform and ported it to the BlackBerry® PlayBook™ tablet and BlackBerry 10 Dev Alpha device. The company quickly learned that porting the app was not only a simple and straightforward process, but also that the visibility of their application on the BlackBerry PlayBook tablet was far superior to any other platform. After enjoying measurable early success with their Cubifice® app, the company is looking forward to the official launch of the game on the BlackBerry 10 platform.

PineLake’s Creative Director, Bill Larocque, Cubifice lead developer, Dave Wagler and Associate Account Director, Liana Buenaventura Brown talked about the ease of porting the application, why it is important to develop for the BlackBerry platform and the importance of sharing the app with other BlackBerry 10 Dev Alpha device developers.

Describe your experience porting your application to the BlackBerry 10 Dev Alpha device.

Dave: The porting process only took us one hour. The application was built using the OpenGL framework, which has a lot of existing support. Once I read the documentation about how to convert the application, it was extremely easy to install the BlackBerry tools into Eclipse™. After a couple of clicks, we came up with the BlackBerry 10 application. It took a very small amount of increased labor to build on the BlackBerry PlayBook tablet and BlackBerry 10 versions, and the rewards have certainly been worth it.

Bill: We couldn’t believe how quick, easy and powerful the porting process was. That last hour of work was the most productive time that we spent on the entire project and it allowed us to work with a real live device. I would recommend that all Android developers try it because it is so straightforward and has already proven to be successful for us.

Why was it important for you to develop this application on the BlackBerry platform?

Bill: The BlackBerry user community is very engaged, and there is far greater visibility of your application on the BlackBerry App World™ storefront than on other platforms. BlackBerry App World has a clear layout and does not suffer from the over-saturation that you find somewhere like Google Play, where your app quickly feels lost in a huge sea of similar applications. With this application, not only do we have 25 times more downloads on BlackBerry App World than on Google Play, but we’ve also been able to maintain that high number and visibility. This visibility translates into a far better return on investment once the app becomes monetized because we will have to spend far less on marketing the application to users.

Why is developing for the BlackBerry 10 Dev Alpha device such a good opportunity?

Bill: It’s important to be able to put an application on an actual device, put it in other peoples’ hands and have them test it. Having access to the BlackBerry 10 Dev Alpha device means that we can avoid going through launch issues and beta testing. We also have the ability to submit this application to BlackBerry App World and allow other developers to download it on their BlackBerry 10 Dev Alpha devices. Developers are keen to download each other’s apps and outdo each other, leading to healthy competition and better overall apps.

Liana: We feel confident that we are well ahead of the curve for the launch of the BlackBerry 10 smartphones. Developing the application on the BlackBerry 10 Dev Alpha device ahead of time helps us ensure that we’ve covered all of our bases and gives us the utmost confidence that we’ll be able to deliver a great experience to the public. We now have the opportunity to fine-tune the experience with the help of every BlackBerry developer who downloads it onto their device, and that’s a huge plus.

If you want to write your own Cascades™ app using OpenGL ES, you can’t miss our webcast on Building Compelling 3D Apps using Cascades and OpenGL ES, which will take place on July 31, 2012 at 11am EST.

This fourth Cascades webcast will focus on how to combine Cascades and OpenGL ES to create compelling 3D apps. The techniques discussed were first presented at BlackBerry® 10 Jam in Orlando by discussing the creation of GoodCitizenCascades, a Cascades version of the NDK sample app Good Citizen (the original version of this sample app will be posted to the Cascades-Community-Samples repository on GitHub soon). The sample app featured best practices for how to properly structure the OpenGL code and link it in with Cascades, how to leverage Actions and the use of NavigatorPanes for multiple panels, and how to process touch events and use them to control a 3D scene rendered in OpenGL using Qt objects and JavaScript®. In the webcast, we will also expand on the original content with more Cascades tips and tricks based on new Cascades features coming in the next BlackBerry 10 beta release, and demonstrate at least one additional sample app demonstrating some of the integration techniques not covered before.

Registration is now open, so get signed up and reserve your seat today!

Miss the first three webcasts? No problem!

If you would like to attend the fourth webcast but missed the first three, don’t worry — they are available on-demand from the Cascades microsite. Feel free to watch these webcasts, follow along with the sample applications demonstration, and code at the same time. You’ll be able to get caught up on all the information needed to take full advantage of the fourth webcast session.

On the topic of videos: if you are unable to attend this fourth session, rest assured that it too will be posted to the Cascades microsite shortly following its presentation, so keep watch of the site for updates.

I am eagerly looking forward to the upcoming webcasts and interacting with you all again!

Last month, we looked at how to internationalize your BlackBerry® Java® application. In this post, we will look at how to internationalize your BlackBerry® WebWorks™ application. There are a few options for accomplishing this – let’s take a look.

Using JavaScript and storing all the texts locally

One common way to internationalize your web application is to remove all strings from your code and have them all in an object with key-value pairs. All the code exists locally and nothings get stored on the server side.

This looks something like:

var strings = {
	"en" : {
		"BUTTON_CANCEL" : "Cancel",
		"BUTTON_SAVE" : "Save"
	},
	nl: {
		"BUTTON_CANCEL" : "Annuleer",
		"BUTTON_SAVE" : "Opslaan"
	}
}

Now let’s assume you keep the chosen language somewhere in a variable called language. You can then access the right string for the user language, like with the cancel button text for example:

Strings[language].BUTTON_CANCEL

That will give you either ‘Cancel’ or ‘Annuleer’ depending on whether the language variable contains ‘en’ or ‘nl’.

Using JavaScript and storing all the texts on a remote server

Another way of internationalizing your application in BlackBerry WebWorks platform is to use the server side code. Unfortunately, JavaScript does not have the concept of a resource file, and strings that will be generated by JavaScript must be defined in the code.

The easiest approach to deal with this issue is to define your JavaScript strings dynamically in server-side code (Java/JSP, ASPX, PHP, etc.). The following example defines some string resources in a JavaScript script block at the top of a JSP page:

Assuming the currentLocale object is set to English (US), the resulting block should look like this:

When currentLocale is set to German (Germany) it should change to this:

There are a couple things to keep in mind with this approach. First, any strings that are embedded in the files, whether JSP/ASPX/PHP/etc. or JavaScript .js files, must be externalized, i.e. the strings should be moved into the string resource block as demonstrated above, and replaced in the code with their variable names. Second, the JavaScript string resource block should be defined before any other embedded blocks or .js file includes that make use of these externalized strings. For example, the resource block should be defined before the following function is called:

Using JavaScript Object Notation (JSON)

Finally, another way to add multi-language support to your BlackBerry WebWorks application is to use JSON objects. Here is a sample which illustrates the use of JSON objects and changes the text dynamically based on the user’s language selection:

<html>
<body>
<h2>Internationalization Sample in WebWorks</h2>
<h3>Select a language:</h3>
<p>

<select id="languagechoice" onChange="displayGreeting()" >
  <option value="1">English</option>
  <option value="2">French</option>
  <option value="3">Spanish</option>
  <option value="4">German</option>
</select>

<br/> 
<br/>
<br/>

 <span id="greetings"></span> <br/>
</p>

<script type="text/javascript">

function displayGreeting(){

 var lang = document.getElementById("languagechoice");
 var lang_value = lang.options[lang.selectedIndex].value; 

 var JSONObject_en = {"hello":"Hello, Welcome to Internalization of WebWorks Applications in English!"};
 var JSONObject_fr = {"hello":"Hello, Welcome to Internalization of WebWorks Applications in French!"};
 var JSONObject_es = {"hello":"Hello, Welcome to Internalization of WebWorks Applications in Spanish!"};
 var JSONObject_de = {"hello":"Hello, Welcome to Internalization of WebWorks Applications in German!"};

 if(lang_value == 1){
   document.getElementById("greetings").innerHTML=JSONObject_en.hello 
 }
 else if (lang_value == 2 ){
   document.getElementById("greetings").innerHTML=JSONObject_fr.hello
 }
 else if (lang_value == 3 ){
   document.getElementById("greetings").innerHTML=JSONObject_es.hello
 }
 else{
   document.getElementById("greetings").innerHTML=JSONObject_de   .hello
 }
}

</script>

</body>
</html>