BlackBerry Hub integration currently consists of the Notification API, which lets you add a notification to the Hub with a custom title, body, sound, and invoke target. The ability to customize the icon will be available in a future OS update.

The concept of Application Menu Items has been broadly replaced by the Invocation framework, specifically the “Share” menu. You cannot add arbitrary menu items to the built in applications, but you can set your application up to handle Share (and other actions). This will make them available from those apps.

Rather than building your own UI to let the user pick or enter PIM data, you may want to use the Cards and Pickers when available.

1. Invoke the camera application and listen for the resulting file
2. Use the javax.microedition.media API (and RIM extensions) to draw the camera inside your app, and capture images/videos there.

With BlackBerry 10, you can accomplish the first by invoking the camera card, and the second by using the Cascades Camera API.

Invoke the Camera Card

This is similar to invoking the Camera App in Java, but more powerful. It is built using the Invocation Framework and with the Camera card, it will seem as though it’s part of your app. You will also prevent the user from going further in your app until they are done with the camera. Use this if you did so before or just want to get a file handle to a photo or video and don’t want to worry about drawing the UI yourself.

Setup:

	_invokeManager = new InvokeManager(this);
	QObject::connect(_invokeManager,
			SIGNAL(childCardDone(const bb::system::CardDoneMessage&)), this,
			SLOT(onChildCardDone(const bb::system::CardDoneMessage&)));

Invoking:

	InvokeRequest invokeRequest;
	invokeRequest.setTarget("sys.camera.card");
	invokeRequest.setMimeType("image/jpeg");
	invokeRequest.setAction("bb.action.CAPTURE");
	invokeRequest.setData("photo");
	InvokeTargetReply *invokeReply = _invokeManager->invoke(invokeRequest);

Dealing with the result:

void CameraInvoker::onChildCardDone(const bb::system::CardDoneMessage
		&message){
	qDebug() << “File URI:” << message.data() << endl;
}

Cascades Camera API

This is comparable to what was offered in Java, though it has extra capabilities and is not tied into the Media Player classes. You can easily build a camera viewfinder into your application in pure QML/JavaScript, or C++, or a combination of the two. You can control most functions like focus region, file quality, and viewfinder size/position.

• Camera Documentation
• Camera class
• Photobomber sample

This API will draw the viewfinder wherever you put it on your screen. Similar to Java, it is up to you to create any UI interactions (like tapping to capture a picture). Unlike Java, you also need to play the capture sound yourself, which is required to be on sale in BlackBerry World in certain regions like Japan.

#include 
...
soundplayer_play_sound("event_camera_shutter");

To do Barcodes, connect a BarcodeDetector to a Camera control. You can also do your own detector (or something else) by processing the camera preview frames yourself.

• BarcodeReader (Using Cascades component)
• Custom Barcode Scanner (Processing preview frames yourself)

C Camera Library

This is the low-level API that the Cascades API is built on top of. It is very powerful and allows for things that are not available in the Cascades API like burst capture, facial detection, and directly modifying the preview stream. This is far more advanced than the Java API and beyond the scope of this article.

It’s worth noting that the Cascades and C Camera APIs are not compatible. If you would like to use the C API in Cascades, you can draw a viewfinder with the C API and the Foreign Window Control.

• Camera Library
• Camera Wiki

http://giphy.com/gifs/TznYiZCFXeLle

Multimedia on BlackBerry 7 was based on the multimedia JSR (135). There were a lot of limitations regarding supported formats, how many sounds could be played at the same time, and even what worked on which device.

In BlackBerry 10, there are a wide range of supported codecs, containers, and protocols.

For video, we recommend an MP4 containing H.264 video at 720p and AAC audio. For audio, it depends a lot on your use case. In addition to mainstays such as MP3 and AAC, we support things like FLAC and Ogg Vorbis.

To actually play your multimedia, you should be looking at the MediaPlayer class. That will handle audio or video. You can also easily play the built in system sounds with the SystemSound class.

• Tutorial: Playing Audio or Video
• Tutorial: Playing SystemSounds in an app

Recording audio is through the AudioRecorder class. You can record a few different formats, including AAC (.mp4) and PCM (.wav).

• Recording Audio

This is all pretty straightforward and should be pretty easy to adjust to if you are used to the Java way of doing things. There are a few key differences that you might not be expecting though.

The first is the NowPlayingConnection. If you are building any sort of media player type application: use it. What it does is let the user control the volume and playback of your app from in another app, using the volume keys on the side. You can also provide a bit of data like a thumbnail image and the current song playing. No user is going to want to have to go back into your application just to change the volume, and it’s really easy to implement.

• Working with NowPlayingConnection

Secondly, unlike in BlackBerry 7, in BlackBerry 10 you can enable echo cancellation in order to do VoIP. There is no convenient Qt API to do this, but you can use QSA and open a connection to the “voice” PCM audio interface.

• BlackBerry 10 VoIP

The other big difference is that you can’t just feed bytes directly into the media player. You need to have an actual file to play, or be using one the streaming protocols supported. Of course, there is nothing stopping you from dropping down to OpenAL/ALUT and doing whatever you need if that’s your style. You also have QSA available as mentioned before, as well as mm-renderer (which is what MediaPlayer is using), but that is all beyond the scope of this article.

Networking in BlackBerry 10 is done through the QNetwork module. You no longer need to worry about transport selection. Your typical HTTP communication can be handled through QNetworkAccessManager. It provides methods such as get() and post(), which take a QNetworkRequest and then asynchronously return a QNetworkReply.

For example:

QUrl *url = new QUrl("http://www.iana.org/domains/example/");

    QNetworkAccessManager *manager = new QNetworkAccessManager(this);

    connect(manager, SIGNAL(finished(QNetworkReply*)),
    		this, SLOT(replyFinished(QNetworkReply*)));

    manager->get(QNetworkRequest(*url));

And then in your replyFinished slot:

void App::replyFinished(QNetworkReply* reply) {
	qDebug() <readAll();

	// Call deleteLater to make sure the reply gets cleaned up
	reply->deleteLater();
}

You can also do TCP with QTCPSocket and QTCPServer, UDP with UDPSocket , and FTP with QFtp.

And of course, lower level libraries such as cURL are available if you should require them.

“PANIC!!!” you might think.

Well, luckily you found this blog post. I am going to walk you through the all the steps you need to get this working, so buckle up and sit tight, because the clock is ticking.

Step one:

Add Q_DECL_EXPORT in front of your main method, so it looks like this:

Q_DECL_EXPORT int main(int argc, char **argv)

Step two:

Nope, that’s it.

We added that requirement in the Gold SDK and added it to the template then, so if your project was created afterwards it’s already taken care of.

If you are still having problems, make sure you aren’t writing to the assets directory, as it’s read-only on release builds. If you want to change something there, copy it to the data folder first.

Anyway, the Q_DECL_EXPORT change was part of Project Zygote, so if you are running into this error you might want to go all the way through the process  and get a big start time decrease for your app. Again, apps built with the Gold SDK have already had this done for them. Don’t let those newbies show you up!

Good luck! We’re almost there!

With the release of the BlackBerry® Native SDK Beta 2 comes the Cascades™ Camera API. If you want to see it in action, check out the spiffy Photobomber sample app available in the BlackBerry Jam Zone and on GitHub. You can just import it, compile it, install it on your BlackBerry® 10 Dev Alpha and go.

However, there are a couple of set-up gotchas in the current beta you are going to run into if you are just trying to add Camera functionality to your own app. Luckily, they are pretty simple to get past, especially with me here telling you exactly what to do! Let’s quickly run through them.

1. QML Imports

In your QML file, right underneath the default:

import bb.cascades 1.0

you want to also add:

import bb.cascades.multimedia 1.0

This will let the QML editor know about the camera components so it doesn’t complain at you.

2. Include the Camera headers

This is pretty standard C++ stuff, but don’t forget to also import the headers into your C++ code. In your default app.cpp you will want to import at least this:

#include <bb/cascades/multimedia/Camera>

You may also end up needing a few others if you are doing more involved camera work in C++, like this:

#include <bb/cascades/multimedia/CameraSettings.hpp>

#include <bb/cascades/multimedia/CameraTypes.hpp>

3. Register the Camera in C++

In your default app.cpp file, right before the call to:

	QmlDocument *qml = QmlDocument::create("main.qml");

Add:

	bb::cascades::multimedia::Camera::registerQmlTypes();

If you don’t do this, the Camera components won’t actually get loaded and you’ll get an error. This is also why you imported the Camera header file, if you are doing the rest of the camera work in QML.

4. Link to the Multimedia Libraries

Right now the linker isn’t quite set up properly to connect your app to some of the new libraries added in R6. For now, you’ll want to manually open the <appname>.pro file and add the following line:

LIBS   += -lcamapi -lscreen  -lbbsystem  -lbbcascadesmultimedia –lzxing

Not all of those are strictly necessary (for example, the zxing library will only be helpful if you want to connect to ZXing to do some custom barcode scanning. We’ll talk about how to do that in a future blog post), but it’s not going to hurt, and the names of the libraries are not terribly discoverable on your own.

You’ll note there is no LIBS line by default in your .pro file. I like to add mine below the CONFIG line, though I’m not sure it really matters.

5. Done!

That’s it, you’re all set up! Now you can use the Camera API to your heart’s content. If doing so results in your app taking a lot of pictures, don’t forget you can use the Invoke Framework to let your users easily share them. It’s a snap.

Turns out I had locked the app’s orientation, but neglected to actually specify which orientation it should be locked to. On the BlackBerry® PlayBook™ tablet it was fine, since the default was landscape and that’s what I wanted, but the Blackberry 10 Dev Alpha is a portrait device. A quick change to add <aspectRatio>landscape</aspectRatio> to my app.xml (not even the code!), and I’m done.

Since I had specified the dimensions of the SWF in my main action script file, I didn’t even need to change any of the sizes of the menus or anything (though I probably should have just made everything scale dynamically in the first place). Either way, it only took me a couple minutes to sort out, and all I did was fix a legitimate bug. I didn’t even have to use the BlackBerry 10 SDK to compile it, since I wasn’t using any new APIs. So if you already have an Adobe AIR app, you are probably good to go. Congratulations on writing your first app for BlackBerry 10!

Reason #1: Touch isn’t supported in that OS

When the BlackBerry® Storm™ 9530 smartphone launched with OS 4.7, it was necessary to have a special touch-only version compiled against OS 4.7 in order to take full advantage of the touch functionality. If you were using the standard BlackBerry UI components, an app compiled for an older OS would probably work fine – but if you wanted to actually capture and use touch events, those methods didn’t even exist until OS 4.7. In this case, not only did it make sense to have a separate touch-only version optimized for the BlackBerry Storm smartphone, it was really the only way to go.

Fast forward a few years, and devices running BlackBerry® Device Software 5.0 and higher are 93% of the market share worldwide for free apps. With paid apps, it’s up to 97%! Since the touch APIs are present in newer OS versions regardless of whether the device supports touch or not, any app compiled for BlackBerry Device Software version 5.0+ (or really 4.7+) can be made touch-aware.

Reason #2: Touch isn’t supported in that form factor

Regardless of if it was even possible to make an app touch aware when targeting OS 4.7+, for a while the BlackBerry® Storm™ smartphones and BlackBerry® Storm2™ smartphones were our only touch-enabled devices. They had a totally different form factor and no trackpad. It made a lot of sense to have a separate version of your app to target those devices. Even with the BlackBerry® Torch™ 9800 smartphone, it was likely just a matter of adding trackpad navigation to your BlackBerry Storm build.

But now with the BlackBerry® Bold™ 9900 and 9790 smartphones, builds targeting the standard 4:3 aspect ratio/full QWERTY form factor need to be touch-aware too. Make that touch aware but not reliant, and now you don’t need a non-touch build.

Reason #3: I want to optimize my UI for Touch-only devices

This is good. The fact is, devices like the BlackBerry® Curve™ 9380 smartphone and BlackBerry Torch family of smartphones have lots of screen real estate in order for you to make buttons nice and big. It’s totally reasonable to have a different UI for those devices compared to something like the BlackBerry Bold 9900 smartphone, where the user might only want to use touch for certain things.
Do you really need a separate build to do it though? Maybe, but it will be easier in the end if you can avoid or minimize that. For example, if you check the VirtualKeyboard.isSupported() method, a return of true would indicate one of the long, touch-based form factors.

What might get you though are resources. If you have different ones you want to deploy to different aspect ratios and you don’t want to just include them all, your only choices are: a) separate builds, or b) downloading them at runtime. Either way, it doesn’t leave much room for a non-touch version.

Deploying to Touch Only

In answer to the original question, unlike GPS, you can’t determine whether or not a device is touch capable in an ALX file. But as I’ve said, I don’t think there is much point. What you can do is use the KeyboardType property, similar to how you’d use the VirtualKeyBoard.isSupported() method in Java™. If it’s “Virtual” or “QWERTYVirtual” (for the sliders), then you can give it that special build with the different resources. But touch itself is easy to implement and present on many devices, so you may as well take advantage of it.

Got questions about implementing touchscreen functionality? Let me know in the comments.

Date: Wednesday, June 29, 2011
Time: 2:00 pm ET
Duration: 1 hour
Presenter: Paul Bernhardt, Application Development Consultant, Research In Motion® (RIM®)

The webcast will cover:

• How to quickly port your current BlackBerry® platform application to BlackBerry 7 and key considerations when designing your app for the new BlackBerry 7 smartphones
• BlackBerry 7 API Overview: Includes new hardware enabled features on BlackBerry 7 devices such as Magnetomer, Near Field Communications, Augmented Reality, OpenGL ES 2.0 as well as APIs that enhance the Super Apps experience
• Q&A with RIM application development expert

Don’t miss out on this event! You must be registered in order to attend, so register today!

UPDATE: We have added more convenient times to our BlackBerry 7 webinar schedule for developers who are based out of Europe or Asia. The details and registration links are below, so sign up today! You must be registered to attend these events:

EMEA
Date: Thursday, July 7, 2011
Time: 2:00 pm BST
Duration: 1 hour
Registration: Sign up here for this webcast
Presenter: Paul Bernhardt, Application Development Consultant, Research In Motion (RIM)

AP
Date: Wednesday, July 13, 2011
Time: 12:00 pm HKT
Duration: 1 hour
Registration: Sign up here for this webcast
Presenter: Paul Bernhardt, Application Development Consultant, Research In Motion (RIM)

The Barcode Capture API included with BlackBerry® 6 comes with a nifty new feature: The ability for a third-party developer to integrate scanning and generating 1D and 2D barcodes inside their app. It’s really easy, too – take a look at this article in our Developer Resource Center to see a sample app that will generate QR codes, or scan them and open the URL in the browser.

If you have a device running BlackBerry® 6 you can compile the app and start playing around with it right now! If not, you may have noticed the new version of BlackBerry App World ™ (version 2.0) has a “Scan a Barcode” menu option. It’s nominally used to open links to apps in the App World, but it will do any URL encoded in a QR Code. Try this one:

QR Codes, if you have never encountered them before, are a type of 2D barcode. This is in contrast to a 1D barcode like the UPCs you see on most products. The big advantage of 2D barcodes (and QR codes in particular) is that they are easy to scan with a camera and can contain a lot of information. QR codes can hold up to 4296 alphanumeric characters, leaving you plenty of space for URLs or other bits of text data. 1D codes are more difficult to detect, and must be viewed straight on by the camera. This means that on a BlackBerry® Torch™ 9800 smartphone, you actually have to rotate the device into landscape mode to detect them properly. QR codes use those squares in the corner to make it easy to figure out the proper orientation.

They are pretty popular in the mobile space, so if you are interested in doing stuff with barcodes, QR codes are probably the one you want. They aren’t the only kind of barcode available to you as a developer, however – we’ve used the open source ZXing library (pronounced “zebra crossing”) to add support for many different kinds of barcode:

2D
• QR Code
• Data Matrix
• PDF 417

1D
• UPC (A and E)
• EAN (8 and 13)
• Code-39
• Code-128
• ITF

The full list is always in the BarcodeFormat class. Currently, as per the ZXing library, Data Matrix and PDF 417 support is alpha quality. These, along with the ease of reading – and an already very large mobile presence – make QR codes the best choice for most applications. As I said, the Barcode API in BlackBerry 6 allows the BlackBerry smartphone to generate a QR code for you, but there are also several websites that will help you do that as well (if you want to print them off, for example) such as here.

Finally, you might be interested to know that the com.google.zxing package is actually very powerful, letting you get down into the nitty-gritty barcode data if you want. You can play around with the bit matrix used to generate 2D barcodes, and it also offers a few nifty methods like a Reed-Solomon encoder and decoder.

And don’t forget, even if you don’t need to use QR codes inside your application, with the function already built into BlackBerry App World they are a great way to promote your app. Just make one using your app’s URL in BlackBerry App World, and if a user sees it on a billboard or in a magazine, they can scan it and buy it right away.

Have you had any experience with the Barcode API yet? What did you think of it?