JAM 24 – HTML5 Frameworks: Up-And-Comers that are Building Steam

Ask any Web developer how many JavaScript frameworks there are out there and you’ll likely end up waiting a long time as they answer. There are so many to choose from and new ones appear in the wild on a daily basis: UI frameworks, libraries, shims & polyfills, animation, graphs, gestures, MVC, performance, etc. We developers who solve difficult coding problems are eager to share their solutions in the form of JavaScript frameworks, allowing others to also build compelling application content. In this session, I’m going to share a few of my own personal favorite frameworks that are focused on improving the quality of your HTML5 applications or games. I even plan on doing a live coding demo of an HTML5 gaming framework. Wish me luck!

JAM23 – Lab: Getting Deep Device Integration with Third Party Extensions

Okay folks, I’m really excited about this one. This session is actually a 2 hour lab that will empower developers to boost the quality of their HTML5-powered WebWorks applications and take them to the next level of awesomeness.  Developers – have you ever built a Web app using technologies like HTML5, CSS or JavaScript and encountered a situation where the feature you wanted to implement could not be added because it was not defined in any Web standards?  Some examples include: blinking the LED light, sending a message via Bluetooth or keeping the device backlight on (none of these are features that can be added using standard JavaScript).  The BlackBerry 10 OS has a powerful native API platform that can be leveraged in a WebWorks application by exposing native code to the JavaScript engine via custom Third Party extensions.  During this lab, attendees will not only learn how to build WebWorks extensions for BlackBerry 10, but they will actually create their own!  By the time this lab is over, everyone will have a functional WebWorks application running on their free BlackBerry Z10 smartphone that makes use of a native extension. It’s going to get crazy in there.

We’ll be posting videos as part of this series leading up to BlackBerry Jam Americas in Orlando in order to give some more background surrounding the topics that we’ll be discussing in detail during the conference.

This particular video will give you some information about the upcoming roadmap items that we’re looking at for extending BBM capabilities for developers. In this video we’re joined by Nick Kalkounis to talk about new APIs that are coming to better connect your application through BBM.

Next week isn’t just CES in Las Vegas; it’s also the 2013 AT&T Developer Summit – and the BlackBerry Developer Relations team will be there in full force.

Our own Larry McDonough will be presenting “Building Applications for Launch of the New BlackBerry 10 Platform” on Monday, January 7th, 2013 from 2:00 PM – 2:45 PM. On the same day, our good friend Andrew Poliak from the QNX Auto Team will be a panelist on “Navigating the Connected Vehicle Vision” from 3:00 PM – 3:45 PM.

That’s not all – we’ve also got an exciting BlackBerry 10 live porting challenge during the hackathon portion of the summit:

“Be part of open source history and participate in the AT&T API for BlackBerry 10 “Live Port” challenge! Using the iOS version of the AT&T API as reference, complete the port and build the best BlackBerry 10 app leveraging the AT&T API and be eligible for prizes including a trip to BlackBerry Jam Europe in Amsterdam! There will be plenty of help onsite to help with any question you may have. Are you up to the challenge?”

• What’s involved:
  • All participating teams contribute to porting AT&T API for BlackBerry 10
  • Each team builds their “best app” using the API with the BlackBerry Native SDK
• Prizes:
  • Chance to go home with a BlackBerry 10 Dev Alpha B!
  • All apps are eligible for the BlackBerry 10K challenge (turn your app into $10K)!
  • The “best app” (as judged by our panel of experts) wins trips to BlackBerry Jam Europe 2013 in Amsterdam!

Hope to see you at the AT&T Developer Summit next week!

Developing for BlackBerry® has never been faster or easier.  We have been working hard to give you the same experience when incorporating sensors into your game or application.  With the release of Beta 3, we have added complete support for sensors in Cascades™, leveraging the power of Qt Sensors from Qt Mobility.  QML gives you the unparalleled flexibility and simplicity of adding a sensor to your app in as little as 4 lines of code!

   Compass {
      active: true
      onReadingChanged: {
          console.log("Azimuth" + reading.azimuth);
      }
   }

Of course we still also support the C++ Qt Sensor API for those hardcore developers out there.  For more information on including and using sensors in your project check out the newly updated documentation here.

The device movement alarm is a great example on leveraging some of RIM®’s exclusive API extensions.  Use them to differentiate your app.  Look for the following APIs:

• axesOrientationMode
• accelerationMode
• alwaysOn
• skipDuplicates

By now you are probably screaming “Show me the code!”.  We have you covered and have created several examples that we want you to copy, paste, and mash up into your applications.  Show us what you can do!

• Sensor Examples:
  https://github.com/blackberry/Cascades-Samples
  
• User documentation:
  http://blackberry.github.com/Cascades-Samples
  

We recently added support for the HTML5 File system API in our web rendering engine and BlackBerry WebWorks.  With this release, you can now emulate the file system, both sandboxed and unsandboxed.  Ripple will create an area your application can write to, and mimics the file system layout of the device.

A really cool piece of Ripple is the emulation of geolocation.  We recently added the live map view that allows you to select a new location on a map, and inject the location into your app code.  With this release, we received a great community contribution that really takes geolocation emulation to the next level.  Mark Dineen provided a patch that allows you to specify a route to follow by providing a GPX file.  Ripple will read the file and inject location update events into your code based on the route provided! Now you can better emulate end-user navigation and movement.

To better reflect the relationship between Cordova and PhoneGap – and due to the fact their core is the same – they are now both under the same entry in the Platforms window, and are represented by version number.

Quite often an application will wish to know when the virtual keyboard is displayed and closed, so that it can react accordingly.  You can now fire the relevant keyboard events into your application to test out your logic.  In the Events panel when you are emulating the BlackBerry 10 platform, you should now see the blackberry.event.keyboard… events.

HTML5 being inherently cross-platform in nature, there are many applications built using web technologies that are designed to target multiple form factors.  Part of designing a cross-platform application is ensuring that your application appears and lays out in a useful way depending on the capabilities of the target platform.  CSS media queries are a powerful tool in this regard, and Ripple now emulates media queries based on the target platform you have currently chosen to emulate.  Try it out and have some fun with this one.

So, be sure to visit our HTML5 developer site to get all the most recent updates, and particularly the downloads page.  Get Ripple, and the latest WebWorks SDK, and start building!

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

The first fix addresses an issue with the Invocation API. The invocation framework does not launch the target on the simulator. For all practical purposes, this means that if you create an invocation target application and install it on the simulator, no app will be able to invoke it. This functionality does already works on the device, so if you are developing your BlackBerry 10 app on the BlackBerry 10 Dev Alpha testing device, you should be fine. But for all those developers who are using the simulator for development, we felt it was necessary to provide a fix to this as soon as we could.

The other noteworthy fix is with regards to the Notifications API. When you develop an app with the capability of posting notifications, it gets vibrate set to ON and Badge set to OFF by default in the Notification Settings. It should actually be the other way around – vibrate should be set to OFF and Badge should be set to ON by default. Oops, reminds me of something Dr. Nick would do.

Other than that, there are no new features included in this patch. If these fixes are not important to your development, you can continue to use the Beta 2 version of the BlackBerry 10 Native SDK that you currently have installed.

You can download the latest BlackBerry 10 Native SDK here.

OpenAL, from Khronos, is designed to solve that exact problem. It is an open source, cross platform 3D Sound API for use in games and multimedia apps. Thankfully, OpenAL 1.1 is readily available on BlackBerry® 10. It is supported on multiple platforms and due to its API looking strikingly similar its 3D graphics cousin OpenGL API, it has proved to be very easy to learn and integrate. OpenAL, however, does not directly support compressed audio formats out-of-the-box. This could result in games having bigger audio files and hence a bigger memory footprint.

Enter OggVorbis.

There are several compressed audio formats and associated libraries available and I recommend OggVorbis for the following reasons:

• It’s lightweight
• It’s open source
• It’s professional quality audio encoding
• It’s streaming support

If you need further convincing, please visit their site.

This blog post uses a sample project to show how to set up and use OpenAL and OggVorbis with the BlackBerry 10 Native SDK. The sample is forked off the famous “cascades cowbell app” and minor modifications have been made to show how to load and play .ogg and .wav files. Assuming you are already familiar with the BlackBerry 10 Native SDK, here are the main steps to follow:

Convert your assets

Download a tool of your choice from
http://www.vorbis.com/software
to convert the heavy WAV PCM files to the slender OGG files.

Add the OggVorbis library to your project

OggVorbis is already ported and available at the BlackBerry Github community, so go ahead download the source code () and compile it using BlackBerry 10 Native SDK. Once compiled, add the library (example: libvorbis.a) and the headers into a folder inside the cowbell application project directory. Let’s call it “external-lib”. Now modify the cowbell.pro project to include the header and library files.

LIBS   += -lOpenAL -lalut -L../external-lib/oggvorbis/lib/qnx/arm/ -L../external-lib/oggvorbis/lib/qnx/x86/ -lvorbis

INCLUDEPATH += ../src ../external-lib/oggvorbis/include
SOURCES += ../src/*.cpp 
HEADERS += ../src/*.h

Now that we have the project setting done, we can focus on loading and playing the .ogg file.

Open the OGG file

The function that opens up the access to the OggVorbis file is ov_open. Declare an OggVorbis_File file type that is returned by the ov_open. This file will be used to decode the OggVorbis file.

OggVorbis_File ogg_file;
ALenum format;
int result;
unsigned int size = 0;

rewind(file);

// Open the ogg file
if (ov_open(file, &ogg_file, NULL, 0) < 0)
fclose(file);

Calculate the unpacked audio file size

In order to load the uncompressed data into an OpenAL buffer, we need to store the audio data in a temporary buffer. The size of the audio buffer can be found using a simple formula: (number of channels) * (number of samples) * (number of bytes per packet)

The number of channels info can be retrieved into vorbis_info using the ov_info function. The number of samples can be found using the ov_pcm_total function.

vorbis_info* info;
// Get the file info for creating the audio buffer
info = ov_info(&ogg_file, -1);

if (info->channels == 1)
	format = AL_FORMAT_MONO16;
else
	format = AL_FORMAT_STEREO16;

// buffer size = (no. of channels) * (no. of samples) * 2 (for 16 bit)
unsigned int data_size = ov_pcm_total(&ogg_file, -1) * info->channels * 2;

Decode the audio file

Once we have a temp buffer allocated, the ov_read function can be used to read and decode blocks of audio data.

char* data = new char[data_size];

// Read the Ogg file into audio buffer
while (size < data_size) {
	result = ov_read(&ogg_file, data + size, data_size - size, 0, 2, 1, &section);
	if (result > 0)
		size += result;
	else if (result < 0) {
		delete data;
		return false;
	}
	else {
		break;
	}
}

Load the data into an OpenAL buffer

Assuming we have already initialized OpenAL context and audio buffers to hold audio data, we can now upload the unpacked data into it.

// Load PCM data into OpenAL buffer.
alBufferData(buffer, format, data, data_size, info->rate);

ALenum error = alGetError();
if (error != AL_NO_ERROR)
	reportOpenALError(error);

Playing the audio is no different than playing regular PCM audio data.

The full sample is available under an Open Source license at here. Enjoy and consider participating in our Open Source community

As I am sure you are aware by now, we released a major update of the BlackBerry® 10 WebWorks SDK last week. This brought some awesome features for web developers on the BlackBerry® platform, such as Invoke framework, Push, context menus, and file transfer. Probably one of the biggest was the file API, using the HTML5 File API with support for both a sandboxed (default) and unsandboxed file system.

Thanks to your feedback, we identified an issue where the sandboxing logic was not working as we documented. The default for the file system should be sandboxed, but it was actually unsandboxed. Further, the blackberry.io.sandbox property could not be set, so you could never actually get a sandboxed file system.

We have fixed the issue and pushed up a patch to the BlackBerry® WebWorks™ SDK so that you can continue working with the File system API as you would expect. Please head on over to the download page to get the latest SDK, and keep working on your BlackBerry WebWorks application for BlackBerry 10!

Before we talk about what’s new in BlackBerry 10, let us recap what is available for the BlackBerry Runtime for Android Apps for BlackBerry PlayBook OS 2.1. There were three major enhancements added to the Android Runtime in 2.1:

• Each Android app will now run in its own window. This greatly improves the user experience and consistency among the other application runtimes.
• Access to the cameras is now supported for Android apps, allowing many more application types to work on the BlackBerry PlayBook tablet.
• In-App Payments are now supported through the BlackBerry App World™ storefront, so Android applications can include virtual items for sale in their applications.

Building on this fantastic set of features, there is now support for telephony APIs for the Android Runtime in the BlackBerry 10 Beta. This includes support for cell location, and access to information about the network services on the device. For additional information, head on over to our API support page. We have completely revamped our Documentation and API Support page to make it easier to find the information you need! Let us know what you think.

All these features are now available for the Android Runtime on the BlackBerry 10 Dev Alpha device and simulator. How do you start using these great new features? Jump to the newly updated Runtime for Android Apps microsite. There is an updated 1.2 Beta release for the BlackBerry Eclipse™ Plug-in for Android Development Tools and Command-line tools to get starting using all these new Android Runtime features for the BlackBerry 10 Beta. For the Eclipse users, point your update site to https://bdsc.webapps.blackberry.com/android/downloads/eclipseplugin/beta/