Over the last year, our mantra has been “you ask, we act”. We announced two new initiatives last week: Built for BlackBerry® and the $10K Developer Commitment. We’ve put a lot of thought and work into both programs – with two ultimate goals in mind; a chance for you to build a successful business on BlackBerry® 10 and a great app experience for our users. BlackBerry® WebWorks™ and our BlackBerry 10 Native SDK are designed to help achieve both these goals.

You asked (and rightly so): “What about apps built in AIR?” Well, apps built in Adobe® AIR® are awesome – we see them every day on the BlackBerry® PlayBook™ tablet. Josh even wrote a post about amazingly fast games built in Adobe Flash.

Well – you asked, and we’re doing. Starting today – apps built using AIR tooling (BlackBerry 10 SDK for Adobe AIR, NME, Flash Builder) are eligible for both the Built for BlackBerry and the $10K Developer Commitment programs.

We’ve said it before – quality matters. Can’t wait to see what you build.

BlackBerry Jam Americas – Sept 25-27, San Jose CA

BlackBerry® Jam Americas 2012 is a showcase for the bold, new direction BlackBerry is heading with the upcoming BlackBerry® 10 platform. The event attracts developers and industry leaders who understand the power of BlackBerry and want to build their success with the platform. Whether you’re a Native, Web, or Android™ developer, don’t miss this opportunity to explore the powerful, game-changing BlackBerry 10 platform.

Join us, September 25-27 in San Jose, California. Register Now and use promo code DJAA45 to register for only $299.00

Beta 2 of the BlackBerry® 10 SDK for Adobe® AIR® now has support for participating in the BlackBerry 10 Invoke Framework. You can find all of the APIs in the QNXDevice.ane and they are all documented.

Invoking a Application

By leveraging the Invoke API, you can invoke virtually any other application on the BlackBerry® smartphone through some simple API call, where you’ll set a parameter for the app you want to invoke and then pass in any parameters that application is expecting. A typical example would be that your application can invoke the BlackBerry® Maps application when it comes across an address. InvokeManager.invoke() will invoke an application.

When the application has been successfully invoked, an InvokeEvent.INVOKE_TARGET event will be dispatched. If there was an error invoking the target, an ErrorEvent.ERROR event will be dispatched. Please refer to the following Knowledge Base article for details on some known issues which will be addressed in an upcoming patch.

Invoking a Viewer

InvokeManager.invokeViewer() will invoke a viewer. A Viewer class is returned and is used to communicate with the viewer.

Let’s say you have an image viewer application and you want to invoke it from the main application you’re working on. In the main application, you want to pass the image file that the imager viewer app will open when invoked.

Below is a sample of how you can invoke a viewer and wait for it to be created. This example assumes that you have created the viewerRequest object with the correct data for your viewer.

var viewer:Viewer = InvokeManager.invokeManager.invokeViewer( viewerRequest );
viewer.addEventListener( ViewerEvent.VIEWER_CREATED, viewerCreated );

private function viewerCreated( event:ViewerEvent ):void
{
   //viewer is created and ready to communicate with.
}

Making your Application an Invoke Handler

If you are developing an application that can be invoked by another application, you will want to add a listener for the invoke event at the very start of your application. These should be the first lines of your application.
Once you have received the invoke event, you can check the startup mode and get the data that you were invoked with.
Below is a sample of how you would accomplish this:

InvokeManager.invokeManager.addEventListener(InvokeEvent.INVOKE, onInvoked );
private function onInvoked( event:InvokeEvent ):void
{
    if( InvokeManager.invokeManager.startupMode == InvokeStartupMode.INVOKE )
    {
        var invokeRequest:InvokeRequest = InvokeManager.invokeManager.startupRequest;
    }
    else if( InvokeManager.invokeManager.startupMode == InvokeStartupMode.VIEWER )
    {
        var viewerRequest:InvokeViewerRequest = InvokeManager.invokeManager.startupViewerRequest;
    }
}

Query a list of targets

You can also query a list of targets or viewers on the device by calling the InvokeManager.queryTargets() method. At some point in the future, this will make a pop-up list in your application that will allow users to select items from the list. For now, it returns the results and it is up to you to use those values in your invoke() and invokeViewer() calls.

InvokeEvent

No matter how your application is started, you will receive an InvokeEvent dispatched by the InvokeManager. In order to determine how your app was started, you can check the InvokeManager.startupMode in your InvokeEvent handler. So, your application would look something like the following, assuming that your application can be launched as a target and a viewer:

package
{
    import qnx.events.InvokeEvent;
    import qnx.invoke.*;

    public class Main extends Sprite
    {

        public function Main()
        {
            //NOTE: THIS MUST BE THE FIRST THING SET IN YOUR APPLICATION CONSTRUCTOR
            InvokeManager.invokeManager.addEventListener(InvokeEvent.INVOKE, onInvoke );
        }

        private function onInvoke( event:InvokeEvent ):void
        {
            if( InvokeManager.invokeManager.startupMode == InvokeStartupMode.INVOKE )
            {
                //invoked as an application/target.
                var data:InvokeRequest = InvokeManager.invokeManager.startupRequest;
            }
            else if( InvokeManager.invokeManager.startupMode == InvokeStartupMode.VIEWER )
            {
                //invoked as a viewer
                var data:InvokeViewerRequest = InvokeManager.invokeManager.startupViewerRequest;
            }
            else
            {
                //launched by the pressing on the icon on the home screen.
            }
        }
    }
}

Closing a Viewer

There are two different ways a viewer can be closed:

1. From the application
2. From the viewer

When an application wishes to close a viewer that it has created, it can simply call the Viewer.dispose() method. This will cause the viewer to be removed immediately.

A viewer can request to be closed by the application and should never actually attempt to close itself directly. Viewers can call the InvokeManager.requestViewerClose() method. This will send a message to the application requesting that it be closed. The Viewer instance in the application will dispatch a ViewerEvent.VIEWER_CLOSE_REQUEST event. When application receives this event, it should call the dispose() method on the viewer to close it. The reason this doesn’t happen automatically is so that applications can transition viewers out before removing them. We may make this a bit more automated in the future, and we’ll let you know when this happens.

Viewer message relay

Viewers can send data to applications using the InvokeManager.viewerSendMessage() method. The Viewer instance will then dispatch ViewerEvent.VIEWER_MESSAGE events with the message and data properties set to what was passed into the viewerSendMessage(). Here is an example of how you would use this:

Viewer code

InvokeManager.invokeManager.viewerSendMessage( "select", {name:"Fred"});

App Code

__currentViewer = InvokeManager.invokeManager.invokeViewer(viewerRequest);
__currentViewer.addEventListener( ViewerEvent.VIEWER_MESSAGE, onMessage );

private function onMessage( e:ViewerEvent ):void
{
    trace( e.message, e.data ); //outputs "select Fred";
}

In keeping with our goal of delivering fresh content frequently through the summer, we are pleased to announce the release of a new version of the BlackBerry® 10 WebWorks™ SDK. And this one is a doozy. It really provides a platform to build on for making high quality, integrated BlackBerry® 10 applications using web technologies. It also provides the groundwork for future updates throughout the summer and fall, filling out the API set to support a wide-range of use cases.

Now, where to start…

Invoke

You will be seeing a lot about the Invoke framework when it comes to BlackBerry 10 application development. Invoke provides the mechanisms for interacting with other applications and services on the device, both system and third-party. And it works both ways: you can invoke another application to access some functionality; you can register to be a target for invocation based on a pre-defined or custom “Action”, and for specific types of data. This one deserves its own blog post, so stay tuned as one will arrive in the not too distant future. Needless to say, you will want to get intimate with this API, as it is one of the cornerstones of the BlackBerry application value proposition of deep integration with the system and third-parties. Please refer to the following Knowledge Base article for details on some known issues which will be addressed in an upcoming patch.

File and File Transfer

In previous versions of BlackBerry WebWorks for BlackBerry® OS and BlackBerry® PlayBook™ tablet, there was a blackberry.io.file API to allow for management of files on the device. With the latest version of the WebKit engine, we now have support for the HTML5 File specification, so this is your route to file system access on BlackBerry 10. This is in keeping with our general strategy of alignment with the open web and standards.

One thing to be aware of with the File API is that, by default, it will act exactly like in a typical browser environment in that the application will only have access to a local sandbox area (enforced by browsers for security reasons). Since application development is different from a browser-based environment, we have provided an API (blackberry.io.sandbox = false;) that will allow you to create an un-sandboxed file system that will be at the root of the device file system.

Also in blackberry.io are a couple of properties that direct you to points of interest on the filesystem, such as the Shared folder, and the home folder of the application which are useful in an un-sandboxed environment. Device permissions for read/write etc. are enforced, as well as perimeters in a BlackBerry® Balance™ environment (i.e the blackberry.io.sharedFolder property will point to the correct Shared folder in the perimeter that the application was installed into.). Whitelisting is enforced on domains when it comes to the sandboxing logic, so security is preserved.

One of the key things we were missing for BlackBerry OS and BlackBerry PlayBook OS was the ability to work with remote files. Being able to upload and download files is a natural extension of the filesystem API, and with BlackBerry 10 you can now create an app to upload to the interwebs as many pictures of your food as you like. Check out the blackberry.io.filetransfer API. Your filesystem just got more powerful.

blackberry.io.filetransfer.download(
        "http://myfiles.org/mypdf.pdf",
        blackberry.io.sharedFolder + "/downloads/mypdf.pdf",
        function (result) {
              alert("Download successful");
        },
        function (result) {
              alert("Download failed");
       } );

Push

Everyone likes being pushed around! OK, maybe not. But you definitely like knowing the latest as soon as it happens. This is one of the hallmarks of the BlackBerry solution: getting relevant information right away, without having to ask for it. This is Push. And in keeping with every BlackBerry WebWorks platform to date, you can integrate your application with Push-enabled services using the blackberry.push API. The APIs are more streamlined in BlackBerry 10, especially in that it abstracts away the differences between BlackBerry Enterprise Server and BlackBerry Internet Service push, so you no longer need to worry about that. Watch this space for a dedicated article on the Push APIs coming soon.

Context Menu

One of the UI cornerstones for BlackBerry 10 is the context menu. When the user of your application long-presses on an element in your page, the context menu will slide in from the right and present standard actions for the given context. So when the user long-presses on an image, you will get actions such as “Save Image”. At this stage, the context menu will be populated with system defined actions. In future updates to BlackBerry WebWorks we will provide APIs that will allow you to customize the menu with your own secret sauce.

Swipe Down Event

A small event, but oh so powerful. The swipedown event will be triggered when the user swipes down from the top bezel into the application content. What most people will use this for is to render a menu that comes in from the top of the screen, as you will find with many applications on the BlackBerry PlayBook tablet. Often this menu will be used for application settings and options. You can also find a very useful sample of how to make this happen in our open source GitHub repo at https://github.com/blackberry/WebWorks-Samples/tree/master/swipemenu

Multiple, Localizable Splash Screens and Application Icons

With this release, you are now able to specify multiple icons and splash screens for your application. This is to cover different screen resolutions in the future, and for when the device orientation changes. Make sure you have a splash screen for both landscape and portrait orientation. Further, you can also specify splash screens and icons for different languages. When the device language is changed, the system will use the appropriate icon or splash screen. This is accomplished through a folder in your application called /locales. And all you need to specify in your config.xml is the main version of the images, and the system will take care of the rest. See our documentation for more details.

Ripple

A Ripple update is being polished off as we speak and will be delivered very soon. We have updated Ripple to improve the configuration by removing the requirement to manage the build and deploy services yourself. Now Ripple will start and stop the service for you. Further, we have emulation for the invocation framework as well as the swipedown event. Cordova emulation also got a lot of love with most of the API set now emulated, thanks to a big helping hand from the Cordova group themselves (shout out to @filmaj and @mwbrooks). We’ll update you as soon as it is released to the site.

Open Source

As I have indicated in the past, we are hard at work on the upcoming releases already. Check out our GitHub repos to see the latest goings-ons, and shenanigans, and such-and-suchs.

For BlackBerry WebWorks SDK work, check out:
https://github.com/blackberry/BB10-Webworks-Packager
https://github.com/blackberry/BB10-Webworks-Framework
https://github.com/blackberry-webworks/BB10-Webworks-API

Ripple? Check out:
https://github.com/blackberry/Ripple-UI

API reference:
https://github.com/blackberry/WebWorks-API-Docs

Getting started

We are really looking forward to see what you will build with these new updates. Click here to download the new SDK and get started!

Have fun with this release!

image from Indian Creek Web Design

I’ve spent many hours talking to members of our developer community both online and in person at our conferences and meet-ups, and I know you’re excited by these tools. Last week, I attended my first BlackBerry® 10 Jam in Toronto and I was blown away by the energy of the developers in attendance.

What to expect in this first Beta

The BlackBerry 10 SDKs don’t jump to awesomeness in their first iteration; it’s an evolution to greatness. In this first Beta we’ve provided the foundational building blocks and a great start for developers to see where we’re heading. The SDKs allow you to create the BlackBerry 10 user experience with core controls and a great application framework to build the necessities of your application around networking, storage and other foundational pieces. It’s not like we’re starting from scratch; all the functionality provided in the SDKs for the BlackBerry® PlayBook™ tablet is also available.

We’ve also made sure that the core UI controls in the Adobe® AIR® runtime have been re-skinned to provide the BlackBerry 10 look and feel along with updating bbUI.js for WebWorks developers to provide the same BlackBerry 10 experience as you find in Cascades™.

Did you just say “first Beta” – and what does it mean to evolve?

We’ll be providing a series of Beta releases on the road to the gold BlackBerry 10 SDK. I want to make sure I set expectations with the community on how we’re approaching the beta cycle. As we evolve each of the SDKs, it means that on top of adding functionality we may need to make changes to functionality released in a previous beta. We are making sure that we examine all the possible angles before we make changes that could affect your application’s code during the Beta and are trying to minimize these changes as much as possible. However, there are times when we’ll have to make changes to ensure that we have solid footings for moving forward with follow up releases. As we move closer to gold, our goal is to make sure that changes in the SDK do not affect compatibility with your code.

What about PIM, BBM, Share and Invocation Framework APIs?

RIM has a strong heritage in delivering fantastic deep integration into the core BlackBerry experience and providing a differentiating factor for your application on the platform, and this will continue with BlackBerry 10. As we evolve the BlackBerry 10 SDKs, these deep integration APIs will be made available, but they aren’t quite ready for 3rd party consumption yet.

These APIs are still seeing refactoring as we move through all the use cases of our core applications. We want to ensure that both our core apps are using the same APIs as 3rd party developers and that the APIs see minimal changes after they are made available in a Beta.

I won’t list all of the APIs that are coming, but I’ll list the hot topics where I usually get inquiries:

• BBM™
• PIM (Contacts, Calendar, Tasks, Notes)
• Messages/Email
• NFC
• Share/Invoke Framework
  • Adding your menu item to an existing app
  • Invoking and being invoked by another app
• String pattern registry
• Geocoding & reverse geocoding
• Bluetooth®

All these and more will be coming in follow-up Beta releases, so make sure you grab the SDKs and start building the core of your application to ensure that you’re ready to integrate these features as soon as they’re available!