In many ways, this release is rather uneventful since we had achieved most of what we set out to do from an SDK perspective for BlackBerry® 10 in the last release. But as they say, “no news is good news” and the reason for this release is primarily performance enhancements – we delivered all the key APIs you need in earlier releases.

Our main focus at this time is to stabilize the Native SDK and make sure to get rid of those nagging bugs and issues that can make the lives of our developers difficult. We also want to avoid feature creep and churn, especially with our BlackBerry 10 launch not that far away. That being said, there are still a few key features that I would like to talk about in this release.

At the core Native layer, we introduced a few new APIs and fixed a whole bunch of bugs. There are too many fixes to list, and you should refer to our release notes if you need a comprehensive overview. However, I thought I should point out a couple of important ones.

We added functions to support a Proxy auto config (PAC) and URL exclusion list to the BPS netstatus API. We also fixed the netstatus availability API, and added a last known location request to the BPS Geolocation API. Several fixes and minor enhancements were also made to our Scoreloop SDK.

For many of you these will likely not be a big deal, but for those of you who have been blocked waiting for some of these fixes and enhancements, I hope they help address your issues and concerns.

On the Cascades™ platform side of things, we added in an API to determine device orientation along with a camera specific API to query the preview frame orientation. Another API that might be of interest to our audio developers is the ability to provide an external audio manager handle into the AudioRecorder object.

Many app developers have also expressed the need for APIs that allow them to query the device for information, either for diagnostic purposes or for optimization and fine tuning based on what the system is capable of. With that in mind, we have added a device information API that provides the ability to query device-related information, as well as a memory info API that allows you to query memory related parameters such as total RAM and flash. We have also addressed a bug in our dialogs and toast API that will allow Cascades developers to access the finished signal in their qml code. Speaking of dialogs and toasts, we also enhanced our BPS dialog service to add support for recursive mutexes.

There are also some exciting developments to report on in the tooling front. We are releasing a new beta of the Visual Studio™ Plugin that addresses several of the bugs and issues with the earlier beta. One useful improvement that we addressed is support for variable expansion via the debugger. For performance reasons, we were only able to support up to five levels deep in our last release. We managed to optimize the way we perform variable evaluation so we can loosen this restriction. Developers who have significant nested structures in their games will now have no issues expanding their structures as deep down as possible, as you can see in this screenshot:

Another important usability issue that we addressed in this release is the ability to stop a build that is in progress. Many game developers have large projects that can take some time to build, and it was important to provide the ability to stop a build midway in case the developer decided to cancel it. There was no easy way to do this in our previous beta release, so you would have to wait until the build finished, which could be painful if you had a large project.

As always, please continue to provide your feedback on our forums as you use the Visual Studio plugin. All your feedback so far has been incredibly valuable in helping us understand the issues that cause you the biggest headaches.

Our BlackBerry 10 IDE has also not stood still, and we have a few important new developments to point out. We have added support for Apple’s OSX Mountain Lion so you should be able to develop with our IDE on OSX. Unfortunately, our installers are dependent on the Flexera Install Anywhere which does not fully support Mountain Lion as yet. In the meantime, you can still use the IDE on Mountain Lion but you will have to do a couple of simple workarounds after installation in order to create an icon and deploy the IDE — please see our release notes for details. We continue to be on top of this and once full support is provided in the Install Anywhere software, you will be able to install our IDE without the workarounds. We are also actively testing our Windows 8 version which is progressing to come out in the next release. In case you were not aware, you can view our roadmap information online on our developer site.

If you are actively using our Native SDK to develop BlackBerry 10 applications, I hope you are finding the development experience to be easy and seamless. If you still haven’t gotten your feet wet, I encourage you to do so. You can download our Native SDK and tooling from our developer website. Best of all, it’s free – you do not even need a device to test out your apps. You can just download our device simulator that you can use for developing and testing your apps just as you would on an actual device.

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

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

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

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

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

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

When designing and developing the BlackBerry® 10 UI and our native BlackBerry applications, one of the overall guiding principles has been flow. Most people have a gut feeling of what flow is in a mobile context. When designing our applications and UI framework, we needed a more concrete definition, so we broke it down into these four principles:

1. Eliminate Barriers to Actions and Information
2. Put the User in Control
3. Provide Structure and Focus
4. Give Compelling Feedback

By keeping these principles in mind when designing your application, you can create an astonishingly user-friendly flow. These principles have also been packaged in the Core UI components in Cascades™, and by using them in your app you will get a head start. In this third Cascades Beta released at BlackBerry Jam Americas 2012 in San Jose, we have reached a stage where the flow features have come together and are ready to be used. Also, since we are now showing you some of our own apps, you can see how we use the features.

Let’s look at each principle individually and find some examples where they’re used in the apps.

Eliminate Barriers to Actions and Information

This is about making the common workflow in your application fast and avoid unnecessary stops, re-navigations or modal states.

Example: The BlackBerry 10 context menu. There are a couple of different aspects of the context menu touching this principle. First of all, the context menu allows users to perform actions on list items, without having to do a drill down navigation. The user can quickly work through a list, deleting or performing actions on items, without having to navigate into each item individually. By using the multi select feature built into Cascades, you can also allow users to work even more effective. This is not rocket science, of course, but deserves to be mentioned. Taking advantage of the context menu could be a simple way to improve the workflow of your app.

Another aspect of the context menu that’s worth pointing out is that it’s non-modal. What does that mean? Well, when the context menu is open, you can still scroll and interact with the content. We chose this design to avoid unnecessary stops in the UI flow; for example, when invoking the context menu by mistake. The user can just keep on doing what they were doing and dismiss the menu with a gesture when appropriate.

When the context menu is opened in its compact state, you can still interact with the content. This avoids unnecessary modal states in the UI.

Put the user in control

This principle is about creating the sense that, as a user, you are interacting directly with the application, not through some intermediary tool or device. It’s like driving a car when you are an experienced driver. You stop paying attention to your steering wheel or the pedals and how your body is interacting with them — you simply drive your car to the place you want it to go. You are in direct control of the car. An app with a good flow should have the same feeling. If you have to look for buttons to push hoping they will perform your desired action, you are not in control.

Example: Using the navigation pane in Cascades, you automatically get peek actions for free. This is new in Beta 3 — it gives the user control. A left-to-right swipe when you have drilled down through the navigation pane will take you back to the previous page. But it’s not only a simple gesture; it is a continuous movement, which the user can pause or regret while it is still ongoing. It’s simple and available for free in Cascades, and gives the user a feeling of being in direct control rather than having to look for buttons that will initiate a navigation.

Content Peek is a sloppy way to navigate or peek back in the navigation history. It’s a continuous movement making the user feel in control.

Provide structure and focus

As applications are becoming more and more complex, this principle is getting increasingly important. Bad structure can make what could have been a great app extremely frustrating to use. Poor focus can cause your users to miss the most unique features in your app. By using the Core UI components, you get a lot for free, in terms of structure. TabbedPane, NavigationPane, and so on provide a shell for your app, and in terms of consistency, users will recognize the UI paradigm you are using.

Example: A great way to get a well-structured Cascades app is to use the tabbedPane wisely. With Beta 3 we have introduced the “back button peek.” This gesture reveals the sidebar from anywhere in a navigational flow, providing “shortcuts” to the entry points in your app (the “tabs”). When using a tabbed pane in your app, try to figure out which the main entry points in your apps are. Which are the main flows the user would want to switch between? Also note that the back button peek is continuous so the user can choose to do a small peek, just to see if something interesting has happened in a different tab. You would indicate that using splats.

Example: A simple example of focus that can be found in BlackBerry 10 is the camera app. When taking a picture in manual mode, all UI for settings just disappears from the screen, helping the user to focus on the most important thing – taking the picture.

Taking a picture in BlackBerry 10. All settings are hidden away in the “…” button in the lower right corner.

Compelling feedback

This is a very human principle. When we interact with something we want a reaction, and we want a sensible reaction that fits our interaction. We also expect the reaction to come in a timely manner so we can connect it to our interaction. By providing compelling feedback, an application developer can hide away unavoidable loading time, let the user know when doing something right or wrong, and make the application experience enjoyable and flowing in general. Also, an unexpected moment of charm baked in as feedback in your app can make your app go from “When I think of it, this is a pretty useful app” to “I freakin’ love this app!”

Example: Compelling feedback can also be used to let the user understand what’s going on and how to interact with the application. An example of that is the time warp feature in BlackBerry 10. When adjusting the timeline in a local area of a picture, the result of the operation is immediately fed back to the user. It’s a great example of compelling feedback, inviting the user to fine-tune the photos even more.

Example: Another example is the virtual keyboard in BlackBerry 10. The keyboard suggests words based on predictions, and when the user swipes the words upwards they nicely animate to the text field where they will end up. It’s a nice moment of charm and gives BlackBerry 10 a unique input experience.

The BlackBerry 10 virtual keyboard. When selecting a prediction using a gesture the text animates towards the text field.

These were a few examples of what flow means to us and how we use it in our own apps, as well as a few tips on how to incorporate them in your app. There are more examples and other flow features in Cascades that will be covered in upcoming blog posts, and I’m sure you may have some ideas yourself on how you achieve flow in your app. Good luck, and if you want to share your own flow learnings or want some tips, feel free to comment or drop me a line on Twitter®.

Some of you may have been reading about Nokia’s decision surrounding their investments in Qt and wondering what exactly this may mean for BlackBerry® 10 and the Cascades™ application framework. As many of you know, RIM provides a port of Qt to run on the BlackBerry® PlayBook™ as well as BlackBerry 10 smartphones. Qt is also one of the foundational pieces for the Cascades application framework contributing both the UI declaration in QML as well as many C++ APIs.

We believe that Qt has many great qualities, which is why we have adopted it as part of the core Cascades app framework. The fact that Qt is an open source project has allowed us to both embed it as a core technology layered on top of the POSIX compliant QNX RTOS, as well as contribute changes back to the project. We want to make sure that everyone understands that the BlackBerry 10 platform, and our Cascades application framework, is not tied to the future of Qt in Nokia.

RIM continues to support the Qt community and we are committed to supporting Qt on the BlackBerry platform, including tight collaboration with the Qt community outside of Nokia and with Digia as new potential owner of Qt. We also welcome all Qt developers to bring both their talents and applications to the BlackBerry platform.

While the formal side of the future of Qt is a little foggy right now, we want our community to rest assured that Qt on BlackBerry is here to stay and that Cascades has a bright and long term future with QML.

Cascades, Qt and open source links:

• Introduction to Cascades
• Community Wiki for Qt on BlackBerry
• Open Source Components for the BlackBerry Native SDK
• Building Qt4 for BlackBerry
• Building Qt5 for BlackBerry

About a month ago, I took the plunge and started a Cascades™ project for BlackBerry® 10.

Initially I was in a state of shock. This is an entirely different world compared to legacy BlackBerry Java® development – including the language (C++), the framework (Qt/Cascades), and a declarative language to build the UI (QML). Slowly and surely things started coming together. Fortunately, I had done a lot of C++ programming in my distant past, and somewhere in the back of my brain most of that old knowledge was still there. Nonetheless, I found myself staring at compiler error messages in bewilderment when I attempted to make a static function member call using dot syntax (Java) instead of using :: (C++).

After a couple of days the state of shock wore off and I found myself getting excited about this new way of writing BlackBerry applications. So what’s so great?

RIM® has been spotlighting Cascades with its cool controls and animation as a great framework for a new generation of apps. This is all true, but to me, what really makes the difference is the Qt foundation on which Cascades is built. It is Qt that enables rapid and solid development with a clean separation of the UI from the code behind.

In an attempt to summarize what I like about Qt, here’s a short list of the things that have made me smile so far. No doubt as I progress, the list will grow.

QML

Defining a UI via markup is more intuitive than defining it via code. The markup clearly expresses the hierarchical structure of the UI. Such a hierarchy is almost impossible to see when looking at the equivalent in code. Furthermore, the structure can be expressed with minimal lines of markup in contrast to hundreds of lines of code without any loss of functionality. Needless to say, tweaking the UI and finding and fixing bugs via markup are all a breeze. QML also supports components. This means that I can define QML fragments in separate files and refer to these components from other QML files. I have already found myself defining re-usable pieces of QML. Of course, QML isn’t the only markup language in use today for writing non-HTML applications (e.g., XAML), so it’s great to see this “tried and proven” concept come to the world of BlackBerry development.

Code Behind

QML wouldn’t be very useful if it didn’t connect well with C++ code. Qt’s support for named properties and invocable methods in C++ makes it really easy to put code behind the UI. The UI can easily be configured to read values from a C++ object exposed via “properties”. In fact, when configured as such, a control’s property is “bound” to an object’s property. This means that as the value of the object’s property changes, the UI automatically updates to reflect these changes. C++ objects can also expose “methods” which can be invoked directly from QML.

Qt Threading

Qt expands on the basic notion of a thread by providing a built-in event loop for any thread. Qt allows an object to be “associated” with a thread. Via dynamic method invocation, a method can be invoked on an object associated with another thread. When such invoked, Qt transparently wraps the method invocation in an event and places it in the appropriate thread’s event queue. As such, the method will be ultimately invoked on the object’s thread. I found this to be extremely helpful when dealing with a particular object type, containing long-running methods. If used correctly, one can use this technique to gain the benefits of multi-threading without the dangers of concurrency.

Signals and Slots

Qt uses a mechanism known as signals and slots to allow objects to “listen” to events triggered by other objects. I have found this mechanism to be much more flexible than the Java listener paradigm (i.e., implementing interfaces). Any object can be eligible to listen to “signals” of any other object, simply by implementing a method “slot” with the correct signature. Needless to say, should the receiving object be associated with a different thread, the invocation of the “slot” will be invoked on the object’s thread.

Maturity and Community Support

Qt is not new. That’s good! It’s good because it means that it is stable and mature. It means that it contains hundreds of classes providing everything from a basic string wrapper (QString) to XML processing (QDomDocument). It is also very well documented. Both officially on the Qt site and unofficially by the zillions of posts on various forums.

In short, I’m enjoying the ride. Qt is a great foundation for writing apps. Coupled with Cascades, I can definitely say that we have a strong framework for building the next generation of BlackBerry apps.

After the phenomenal response to the first Cascades™ webcast, I am pleased to let you know that we will be continuing with a second supplementary session Tuesday June 26th: Astonishing UIs using the new BlackBerry® 10 framework continued.

This session will use the knowledge gained in the first session and build upon some of the key concepts that make up Cascades, digging deeper into their functionality. The key features being discussed will be: animations, lists and custom UI components. We will be focusing mostly on the QML aspect of development but will begin to introduce some C++ concepts that will be required to perform some more advanced tasks in Cascades.

Registration is now open — hope to have you there! Come armed with your questions and knowledge gained from the first session.

Get Registered Here:
http://www.blackberrydeveloperevents.com/events/webcast/registration/register.html?scoid=1047459465

Native UI elements

The Cascades SDK provides a full set of native UI elements which can easily be added to your applications: buttons, fields, text areas etc. Each of these elements will provide hooks to let you easily listen for any standard events (touch, click, toggle) and properties to allow you to customize them for your application needs.

Develop using both QML declarative and C++

Whether you are a C++ guru, a declarative czar, or someone just getting started with programming, Cascades has a place for you! The user interface can be handled using entirely C++ or QML (Qt Markup Language). Data processing can be handed off to JavaScript® written in your QML files or passed off to C++ for some additional heavy lifting. The UI developed in either QML or C++ can be identical, and the QML is optimized on load to run just as fast as if it were written in C++.

Of course, for those of you that would like to have the best of both worlds, that’s also a possibility as C++ and QML can work together. QML can be used to rapidly create your UI while C++ is used to handle the business logic of your application. The result: A fast and easy way to prototype application UI while working on building and refining the business logic in tandem.

Animations!

One of my favorite parts about Cascades is the native UI elements: they look great and sync together, but they are also animated. Each element that can be interacted with has its own signature animation; when a check box is toggled, the check mark doesn’t just appear – it springs in to place! Small, non-intrusive, signature effects that result in a fun and inviting experience – even with check boxes – is what makes Cascades great!

Flawless user experience

The Cascades SDK is built using client-server architecture where the client handles all UI is handled by the client thread and the server thread handles all the heavy lifting (data processing, networking etc). To the end user, this means that even if the server is working hard to process data, the client will stay responsive and extremely lag-resistant.

A split screen showing QML coding alongside the real-time design view

Fantastic visualization and design tools

The Cascades SDK provides both Source and Design views when creating your user interface in QML. The source view lets you write the source for your UI while the design mode provides a real-time representation of how the UI will look, saving you loads of time.

To tag along with the theme of expediting UI design, the Cascades team has also developed a plug-in for Adobe® Photoshop®, The Cascades Exporter plug-in for Adobe Photoshop. This plug-in is really worthy of its own blog post, but in short, it allows you to design your UI in Adobe Photoshop then export the design in a way that can be imported right into your application. From design to implementation in a just a few short steps!

What can you expect moving forward?

Expect more and more features, functionality and astonishing ideas to be added to the SDK and IDE as we near the Gold SDK release and beyond. You can also expect to see a great deal of training in the very near future which will cover topics from “Getting Started” right through to more advanced topics like “Using OpenGL in Your Cascades Application”. Stay tuned for announcements on these!

If you would like to find more information on developing applications using the Cascades SDK, then please head over to the Cascades micro-site where you will find SDK and simulator downloads, sample applications and a wealth of documentation.

One last thing: this is a Beta, so if you do find any small bugs or think of some functionality that you would like added to make your application or developer experience even better, please log an issue in Issue Tracker.

That’s it for me. I cannot wait to see what applications you all come up with! Keep us posted with your progress by dropping us a line on Twitter® at @BlackBerryDev.

Jim Tobin, SVP of the Software, Services & Enterprise Markets business unit at Research In Motion® (RIM®), has a great blog post on Inside BlackBerry highlighting the benefits of our recent platform announcements for customers and developers. For your convenience, we’ve pulled out the developer-related information. Click the link at the end to read Jim’s full post!

We recently announced plans to enable developers to leverage existing assets for the BlackBerry® Java® Development Environment and Android® platforms to be easily ported to the BlackBerry® Tablet OS via ‘application players’. The application player for supported Android apps will be available this summer, followed soon after by the application player for supported BlackBerry JDE apps. Both will be available through the BlackBerry App World™ storefront.

What does this mean for Developers?

• For the majority of developers, the way to go is still the BlackBerry platform and the widened set of tools we’ve made available. Only these can ensure that the developer harnesses the full power of the BlackBerry PlayBook tablet in terms of extremely rich graphics, full multitasking, and ultrafast processing. BlackBerry smartphone development options include the BlackBerry® WebWorks™ platform. BlackBerry WebWorks offers leading HTML5, CSS3 and JavaScript support on a mobile platform. The BlackBerry WebWorks platform also supports modern web frameworks such as Sencha, PhoneGap, jQuery and Dojo.
• BlackBerry PlayBook tablet development options currently include BlackBerry WebWorks as well as Adobe® (Flash® and AIR®).
• RIM will add full tooling support for native C/C++ development for the BlackBerry PlayBook tablet over the coming months. We’re highly confident about this. The QNX team RIM acquired to develop our BlackBerry Tablet OS has won awards for its Eclipse-based native Integrated Development Environment (“IDE”).

Because of the app players we’re providing, if there are developers currently developing for the Android platform, they can now rapidly move onto our platform while they evaluate our other development paths. We can now offer such developers an on-ramp to package and distribute their apps to our growing customer base of consumers, enterprises and governments.

Going forward, we will continue to evolve our various development technologies to deliver the most powerful, flexible and open experiences for developers whether they choose to build with HTML5, Java®, Adobe Flash, Adobe AIR, or native C/C++. And for those developers using our BlackBerry platform tools, we will continue to offer access to a growing set of on-device API’s to enable best-in-class integration with core BlackBerry applications and features (which we call “Super App” experiences). We are also planning to provide a range of advanced cloud-based services including the BlackBerry Payment and Advertising Services, advanced location-based services, application analytics, and powerful Push services. Stay tuned for more details on these future release plans.

Read the entire post on the Inside BlackBerry Blog »