Qt developers often ask the following questions: Is there a porting guide to help me port my Qt apps to BlackBerry 10? What about porting Qt Quick to BlackBerry 10? How do I configure Qt Creator for BlackBerry 10?

The good news has arrived: you now have a porting guide covering the most commonly-encountered use cases. This guide provides the necessary information to developers of native mobile apps who fall in one of the following categories:

• Developers who have Qt apps written in C/C++/ QML/JavaScript and intend to have their apps running on the BlackBerry 10 platform;
• Developers who want to write new Qt C++, QML and/or JavaScript code for the BlackBerry 10 platform;
• And finally, developers who want to take advantage of the Cascades UI framework and change their existing UI to the Cascades framework.

BlackBerry supports developers in all of the above described scenarios, and so this guide provides developers with best practices for each category. It also explains why a particular practice is considered the best one.

Please check the full Qt porting guide at:

http://developer.blackberry.com/native/documentation/bb10/porting_qt_apps.html

Related Posts:

YouTube: BlackBerry Jam Session (JAM12): Porting Qt Applications to BlackBerry 10
Porting Qt Applications to BlackBerry 10 is Easier than Ever!
Writing Qt apps for the BlackBerry 10 platform
YouTube: QtDD12 – How Qt Helped RIM Build BlackBerry 10
YouTube: QtDD12 – Developing with Qt for the BlackBerry 10

Update – Brian Scheirer pointed out that there have been some awesome community samples too! -Ed.

For me, 2012 has definitely been a year of helping developers learn about our native and Cascades development tools. If you’re like me, you’re probably spending the holiday nights doing some coding – so I’ve put together this list of “The Best of Native Development for 2012″.

Cascades Webcasts
Thousands of developers from across the globe joined us for four webcasts to learn beginner to advanced Cascades concepts.  We were able to interact with developers directly, answer questions, and get immediate feedback as samples and code were displayed.  The format proved so successful that we’ve hosted many more webcasts on topics such as the BBM social platform, augmented reality apps, and OpenGL integration.

The live web casts were recorded and are available for viewing here.

Porting Guides
If you have existing content for another platform, we are making it easy to bring that content to the BlackBerry 10 platform.  Being able to re-use code across platforms reduces development and maintenance costs.  Distributing your application to multiple platforms opens you up to whole new market segments and increases your potential user base.  There a number of informative porting guides available to help you build for BlackBerry 10.

• iOS to BlackBerry 10 - http://devblog.blackberry.com/2012/12/porting-ios-apps-to-blackberry-10/
• Android to BlackBerry 10 - http://devblog.blackberry.com/2012/11/porting-android-game-to-blackberry-10/
• Qt to BlackBerry 10 - http://devblog.blackberry.com/2012/11/porting-qt-apps-to-blackberry-10/

Samples
The best and easiest way to learn to program is to look at sample code.  For every feature that BlackBerry 10 offers there is a sample project showing you how to put it into action.  Whether it’s integrating with BBM, using the Invocation Framework, getting sensor information, or communicating via Bluetooth, we’ve got you covered.

There are samples built right into the Momentics development environment, on the Cascades and Native microsites, and hosted on our github repo.  And if you find a feature that we missed, or an API without a clear example then let us know on Twitter @BlackBerryDev or in our developer forums and we’ll add what you need to get started!

• Cascades Samples - https://github.com/blackberry/Cascades-Samples
• Native SDK Samples - https://github.com/blackberry/NDK-Samples
• Cascades Microsite - https://developer.blackberry.com/cascades/sampleapps/

Stump the BlackBerry Devs
In August we launched a challenge to the BlackBerry Developer community to come up with a UI that would be difficult to implement in the Cascades UI framework.  The Cascades tools development team would try to implement the submissions in a flexible manner that could handle multiple screen resolutions and form factors.  They implemented three of the challenges and presented the solutions during the Unconference Day at BlackBerry Jam Americas.  We were able to show that Cascades is robust framework that is able to create stunning interfaces even when faced with challenging design requirements.  All the solutions are hosted on ourgithub repo.

If you have any Cascades or native dev questions – check out our forums and connect with me on Twitter.

The BlackBerry 10 Community Port-A-Thon will start on noon ET January 11, 2013 and run for 36 hours.  This is also going to be a virtual event, so it is up to you to decide where you would like to join us from.

Get Rewarded

The more you port and build the greater your rewards*:

• Port  one (1) – five (5) approved apps – $100 per eligible app –to  a maximum of 20 paid applications per Vendor
• Port five (5) – ten (10) approved apps – THE FIRST TWO HUNDRED (200) QUALIFIED PARTICIPANTS receive one (1) BlackBerry Dev Alpha Device plus $100
• Port ten (10) or more approved apps -  THE FIRST TEN (10) QUALIFIED PARTICIPANTS one (1) paid trip to BlackBerry Jam Europe to celebrate  the launch of BlackBerry 10 with us plus a Dev Alpha Device as well as $100!!!
• Additionally for those that did not receive a BlackBerry Dev Alpha, or Trip to BlackBerry Jam Europe, we will be conducting a random draw for one hundred (100) BlackBerry 10 Dev Alphas and ten (10) trips to BlackBerry Jam Europe.  All those who meet the criteria for a Dev Alpha  Device or the Trip but were not one of the firs 200 or 10 , respectively, to qualify, are eligible for the respective draws.

Get Ready to Port

Take advantage of the tips below to get a head start before you join the event.

Here’s what you need to get prepared ahead of time.

1. Register as a Vendor at BlackBerry World if you haven’t already.
2. Request signature keys. Make sure that you select for BlackBerry® PlayBook™ OS and BlackBerry 10 and higher. Downloading in advance is strongly recommended as the time involved to do so could prevent you from earning rewards.
3. Load up your laptop BlackBerry tools and plug-ins. Make sure you have your full source code file readily available too.
4. Make sure you have your images and icons ready to go.

Register

Submit your apps into BlackBerry World before BlackBerry 10 launches. Register for the Community Port-A-Thon for BlackBerry 10 today!

Have Questions? See our FAQ.

* A total of $500,000USD is available for distribution. To qualify for a Reward, you must register on the website at http://developer.blackberry.com/offers/communityportathon and submit your App into the BlackBerry World Vendor Portal between 12:00:01 pm on January 11, 2013 and 11:59:59pm ET on January 12, 2013. Any apps submitted outside this time frame are not eligible for this Reward program. Only those apps that have been approved through BlackBerry World and RIM will be considered towards a Reward. No purchase necessary to be eligible for the draw.  The odds of winning the draw depend on the number of eligible Vendors entered.  Skill-testing question applies to Canadian residents.  Limit one (1) Dev Alpha Device and one (1) Trip per person. Cash rewards limited to 20 per Vendor regardless of reward category.    See the Official Terms and Conditions for complete details.

Qt is an important part of our BlackBerry 10 Cascades framework. We were proud to be part of Qt Developer Days in Santa Clara, where we had our own booth set up to showcase the BlackBerry 10 OS and to speak to developers about the excitement surrounding the upcoming BlackBerry 10 launch event on January 30th (not long to go now!). Some developers did not really know what BlackBerry 10 was but after seeing the platform for themselves, they shared our excitement. This was a user interface that they had not seen before, and something a lot of the MeeGo community liked with its simple but powerful gestures.

Alec Saunders, VP Developer Relations at RIM, had a keynote speech where he presented our BlackBerry 10 ecosystem story. He also spoke to RIM’s involvement with Qt and how developers can be rewarded for porting their Qt applications to BlackBerry 10. BlackBerry World is a going to be a level playing ground for your applications to actually have a chance of being discovered and not lost in the crowd like on other platforms.

We seeded eager developers with BlackBerry 10 Dev Alpha testing devices for them to port over their existing MeeGo / Symbian Qt applications, and also provided technical support. For Qt Mobile Application Developers, BlackBerry 10 offers the ability to get a return on your existing development investments. Depending on the complexity of your application, the port over to BlackBerry 10 can really be a painless experience.

We do realize that not everyone can get to these events, and so we have the BlackBerry Qt Porting Program, an online offer so that eligible developers can get their hands on BlackBerry 10 Dev Alpha testing devices. For complete details, see the Official Program Terms and Conditions.

What you need to do is:

• Become a BlackBerry World Vendor.
• Submit your porting plan to bring your Qt app to BlackBerry 10 for approval at https://developer.blackberry.com/offers/qt

We also have an offer of a one-time donation of $10,000 USD to the Qt Project Hosting Foundation if 50 eligible Qt apps are ported to BlackBerry 10 by the Qt Community and then posted and available for sale in BlackBerry World by January 30, 2013 (1)

Criteria:

• Be a BlackBerry World Vendor.
• Apps must be submitted to BlackBerry World by January 20, 2013 and be approved.
• 50 Qt apps must be up for sale in BlackBerry World by January 30, 2013.

It was fantastic being part of Qt Developer Days in Santa Clara, but this is really just the start for us and by no means the end. We are actively working with Digia and the Qt foundation to further strengthen Qt and our relationship with it and also with you.

Below are some links of how we can help you develop for us:

Qt Project Wiki:

• http://qt-project.org/wiki/blackberry

Qt Project Group:

• http://qt-project.org/groups/qt-blackberry-and-qnx

Open Jam Sessions for Qt developers to talk to RIM internal Qt experts about technical problems:

• Qt Live Time with BlackBerry Developer Relations
  • Wednesday, December 12, 2012 @ 10:00 – 12:00 ET
  • https://developer.blackberry.com/devzone/jamcommunity/supportjams/session_registration.html?id=307
• Qt Live Time with BlackBerry Developer Relations
  • Wednesday, December 19, 2012 @ 10:00 – 12:00 ET
  • https://developer.blackberry.com/devzone/jamcommunity/supportjams/session_registration.html?id=308

Porting Qt to BlackBerry 10:

• Porting Qt Applications to BlackBerry 10 is Easier than Ever!
• Writing Qt apps for the BlackBerry 10 platform

Built for BlackBerry and the 10k Developer Commitment:

• http://developer.blackberry.com/10k

1) To be eligible, fifty (50) Qt Apps (“Apps”) must be submitted to BBAW by the Qt Community by 11:59:59 PM Eastern Time (“ET”) on January 20, 2013. Apps will be accepted beginning at 8:00 AM ET on December 8, 2012. Allow a minimum of ten (10) days for BBAW approval. Approved apps must be posted on BBAW for sale on or before January 30, 2013. Apps are not eligible if they simply contain a web launcher or shortcut or a web browser (“Excluded App”). RIM will confirm if Qt Community is eligible for $10,000 USD donation to the Qt Project Hosting Foundation (“Donation”) by February 28, 2013. Allow 8-12 weeks for delivery of Donation. Void where prohibited or restricted by law.

Guest post from Roberto S. – Ed.

Since the introduction of Cascades in May, developers have been asking us one question: Is there something I can do to make my app start faster? Cascades is a marvelous piece of technology, but like any new technology, it takes time to work out the kinks and optimize performance. It took a while, but the Cascades team figured out a way to make it faster. Let me introduce you to Project Zygote.

When a detailed performance analysis was conducted on a Cascades application while it was starting up, it was discovered that loading shared libraries was taking up the majority of time. Cascades uses a number of different Qt and platform-specific libraries, so this made sense. After some investigation, we learned that you can save a lot of time by pre-compiling these shared libraries into one library that could be pre-loaded. Thus, Project Zygote was born.

How do you get in on the party? With this latest beta release of BlackBerry 10, all new Cascades projects will have Zygote enabled by default. You get it for free!

For those with pre-existing projects, there are some minor changes you need to make to your existing projects to enable Zygote for your release target. A little bit of work that goes a long way!

Let’s start by looking at the original project file for the Cascades Cookbook sample app:

TEMPLATE = app
TARGET = cascadescookbookqml

CONFIG += qt warn_on debug_and_release cascades

INCLUDEPATH += ../src
SOURCES += ../src/*.cpp 
HEADERS += ../src/*.h 

device {
	CONFIG(release, debug|release) {		
		DESTDIR = o.le-v7		
	} 
	CONFIG(debug, debug|release) {
		DESTDIR = o.le-v7-g
	}
}

simulator {
	CONFIG(release, debug|release) {
		DESTDIR = o
	} 
	CONFIG(debug, debug|release) {
		DESTDIR = o-g
	}
}

OBJECTS_DIR = $${DESTDIR}/.obj
MOC_DIR = $${DESTDIR}/.moc
RCC_DIR = $${DESTDIR}/.rcc
UI_DIR = $${DESTDIR}/.ui

As mentioned earlier, Zygote is configured primarily for release targets. The reason behind this is that the differences in packaging make it difficult for developers to debug applications built in this way. The first step to upgrading the project configuration is to add a template override from app to lib in the device-release configuration section:

TEMPLATE = app
TARGET = cascadescookbookqml

CONFIG += qt warn_on debug_and_release cascades10

INCLUDEPATH += ../src
SOURCES += ../src/*.cpp 
HEADERS += ../src/*.h 

device {
	CONFIG(release, debug|release) {		
		DESTDIR = o.le-v7
TEMPLATE=lib
QMAKE_CXXFLAGS += -fvisibility=hidden
	} 
	CONFIG(debug, debug|release) {
		DESTDIR = o.le-v7-g
	}
}

simulator {
	CONFIG(release, debug|release) {
		DESTDIR = o
	} 
	CONFIG(debug, debug|release) {
		DESTDIR = o-g
	}
}

OBJECTS_DIR = $${DESTDIR}/.obj
MOC_DIR = $${DESTDIR}/.moc
RCC_DIR = $${DESTDIR}/.rcc
UI_DIR = $${DESTDIR}/.ui

These changes switch the target from an executable to a library and hide the symbols to minimize the size.

The next thing that needs to change is the main.cpp file. Change the main() declaration as follows:

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

The last step is to update the bar.descriptor.xml file as follows:

    <configuration id="com.qnx.qcc.toolChain.1485069140" name="Device-Debug">
       <platformArchitecture>armle-v7</platformArchitecture>
       <asset path="arm/o.le-v7-g/cascadescookbookqml" entry="true" type="Qnx/Elf">cascadescookbookqml</asset>
    </configuration>
    <configuration id="com.qnx.qcc.toolChain.1120265426" name="Device-Release">
       <platformArchitecture>armle-v7</platformArchitecture>
       <asset path="arm/o.le-v7/cascadescookbookqml" entry="true" type="Qnx/Elf">cascadescookbookqml</asset>
    </configuration>

Changes to:

    <configuration id="com.qnx.qcc.toolChain.1485069140" name="Device-Debug">
       <platformArchitecture>armle-v7</platformArchitecture>
       <asset path="arm/o.le-v7-g/cascadescookbookqml " entry="true" type="Qnx/Elf">HelloPhone</asset>
    </configuration>
    <configuration id="com.qnx.qcc.toolChain.1120265426" name="Device-Release">
       <entryPointType>Qnx/Cascades</entryPointType>
       <platformArchitecture>armle-v7</platformArchitecture>
       <asset path="arm/o.le-v7/cascadescookbookqml.so" entry="true" type="Qnx/Elf">libcascadescookbookqml.so</asset>
    </configuration>

After making these changes, export your project to a zip file. If you haven’t already done so, create a new workspace. Import the project into the new workspace, change the active build to Device-Release, and clean and rebuild the project. You should have a Cascades Cookbook sample app that starts up faster! My testing showed a reduction in start time from 1.96 seconds to 0.68 seconds. Feel free to convert all of your Cascades apps and spread the word!

Here’s a guest post from Marysia – Ed.

Calling all UK devs! Want to develop an app for BlackBerry 10?

Have a BlackBerry 10 Dev Alpha testing device, but hit a few stumbling blocks and need some help to just get it moving again?

Got an Android, iOS or Qt app that you want to port to the platform?

Are you an HTML5 dev with a great app that could be a hit on BlackBerry 10?

Then look no further! We are holding a series of open days at our Tech Centre in Slough in December with a technology focus for each event! Just book your place at the event that suits you, come along and spend the day with our experts who will guide you through the process and give you some one to one help with your development issues.

To find out more and register for a place visit https://developer.blackberry.com/supportjams and click on “BlackBerry Support Day” and hover over the relevant date on the calendar!

• 4^th December – Come port your Android apps to BlackBerry PlayBook and BlackBerry 10
• 6^th December – Learn from the experts on how to port from iOS to BlackBerry 10
• 11^th December – No platform loves HTML5 like BlackBerry does – come learn how to port your PhoneGap, Sencha, or jQuery based app to BlackBerry 10
• 13^th December – Love C and C++? This is the day for you.
• 18^th December – Qt pros – come learn how to expand your market using BlackBerry Cascades.

Cascades™ and Qt are two major frameworks available on the BlackBerry® 10 platform. Qt on BlackBerry 10 provides a complete set of standard Qt 4.8 APIs with the exception of the QtWebKit module. BlackBerry 10 provides a selected set of APIs from the QtMobility project as well. I will provide an overview of Qt 4.8 APIs coverage on BlackBerry 10, with a focus on APIs that are different or not available on BlackBerry 10, and will refer to alternative Cascades APIs in relevant cases. More details are provided here:
https://developer.blackberry.com/cascades/reference/qt_index.html

To start, I wanted to share two fundamental facts about the use of Qt within Cascades and Qt on BlackBerry 10 in general:

1. Cascades uses its own backend to render on the screen. This backend does not use Qt because Cascades needed several features, which Qt addresses only starting with Qt5. Developers have to decide upfront if an application will use Cascades or Qt to render on the screen, because it is not possible to mix Qt and Cascades APIs to access the screen in one application. Developers can write “pure” Qt Quick or QWidget apps and have the app directly deployed and run on the BlackBerry 10 platform with little or no platform adaptations. Cascades apps can use all Qt APIs which do not access the screen; e.g. the modules QtCore, QtNetwork, QtSql, QtXml.

2. QtMobility APIs have been developed, published and maintained in a separate project outside of the Qt 4.8 base line; therefore QtMobility does not belong to a standard Qt4 package. QtMobility should be separately built and integrated into mobile and embedded platforms based on Qt4. Since the work on QtMobility was focused on standards and services used by Nokia devices, the use of these APIs on modern platforms provided by other vendors requires changes. This applies to the BlackBerry 10 platform as well. The current release of BlackBerry 10 therefore provides a subset of QtMobility API implementation.

In addition to the Cascades UI framework, RIM® has created a rich set of middleware Qt-based APIs to access the key BlackBerry 10 features. Since these APIs do not render to the screen, they can be used in Cascades apps as well as in applications based on Qt widgets and Qt Quick.

Using Qt widgets with C++ on the BlackBerry 10 platform

Qt widgets are fully supported on the platform and included in the BlackBerry 10 NDK. Even though almost no changes in the code are needed to get a Qt widget-based application running on BlackBerry 10, this approach will rarely provide acceptable results. Qt widgets have been developed for desktop applications and only few of them are suitable for a mobile platform. For example, QButton, QCheckBox or QProgressBar can be effectively used, but using QMainWidow or QDialog in an app for a mobile device does not make much sense. Moreover, the implementation of animations and effects in widget based UIs requires considerable effort or can even be not possible in some cases. Cascades and Qt Quick provide much better solutions tailored to use cases on mobile devices.

Qt in the current Beta releases of the NDK and on Dev Alpha devices uses a default style for Qt widgets. The final version will contain a style tailored to the appearance of the BlackBerry 10 native UI elements.

Developing with Qt Quick

Qt Quick 1.1 is fully supported on the BlackBerry 10 platform as a part of Qt 4.8 package. Additional Qt Quick plugins provided in the QtMobility package are supported according to their general availability on BlackBerry 10.

Developers who used Qt Quick on a desktop platform should note that the “qmlviewer” application is not available on BlackBerry 10. The security and deployment models on BlackBerry 10 require using own C++ code to load Qt Quick files. An example of this code in provided in Qt as well as in the template application which can be created in the category “BlackBerry Qt Quick Application” via the “New Project” wizard in QtCreator 2.6 and newer.

Qt Quick applications intensively using animations and transitions should use QGLWidget as a view port in QDeclarativeView. Using QGLWidget will enable hardware acceleration and therefore usually provides better rendering performance.

When it comes to the UI development, Qt Quick is a good choice when an application needs its own custom appearance with a custom set of UI elements, or when the application code should be ported from another platform to BlackBerry 10. Since Qt Quick 1.1 does not provide high-level UI components, developers have to provide an implementation of these UI elements. If an application needs an authentic BlackBerry 10 look-and-feel and a seamless integration with the platform, using Cascades UI framework is a much better approach.

QtMultimedia

This module is deprecated and not supported. Please use QtMultimediaKit from QtMobility instead.

QtOpenGL

QtOpenGL is fully included in the BlackBerry 10 NDK. However, QtOpenGL APIs cannot be used in a Cascades app. Please check the Cascades documentation to find how to use OpenGL in Cascades apps.

QtScriptTools

QtScriptTools is fully included in the BlackBerry 10 NDK. However, QtScriptTools APIs cannot be used in a Cascades app. Cascades apps use QScriptEngine as described in the BlackBerry 10 documentation.

QtSvg

QtSvg is fully included in the BlackBerry 10 NDK. However, QtSvg APIs cannot be used in Cascades apps.

QtWebKit

QtWebKit is not supported, but RIM is planning to include a solution in later releases of BlackBerry 10.

QtTest

QtTest is fully included in the BlackBerry 10 NDK. However, QtTest APIs cannot be used in Cascades apps.

Not supported

• Phonon
• Qt3Support
• QtDesigner
• QtUiTools
• QtHelp
• QAxContainer
• QAxServer
• QtDBus

APIs from the Qt Mobility 1.2 project:

QtNetwork

Most of these APIs have been included in the Qt 4.8 and are supported on BlackBerry 10.

QtLocation

A subset of QtLocation is supported by QtLocationSubset. Details about QtLocationSubset can be found at https://developer.blackberry.com/cascades/documentation/device_platform/location/

QtMultimediaKit

The QtMultimediaKit module is included in the BlackBerry 10 NDK except for QMediaRecorderControl (and so no QMediaRecorder) and Camera APIs. Development teams in RIM are working to provide support for these and other modules in the future. It is important to note that QtMultimedia APIs in Qt 4.8 have dependencies on the QtGui module and so they cannot be used in Cascades apps. Cascades app should use MediaPlayer APIs instead.

QtSensors

The QtSensors module is fully included in the BlackBerry 10 NDK. RIM has extended the default API set with new and useful features. Most QtSensors APIs can be used in Cascades apps. The exact list of supported APIs is available in
https://developer.blackberry.com/cascades/documentation/device_comm/sensors/index.html

QtConnectivity

RIM is currently working on adding support for NFC and Bluetooth®. BlackBerry 10 also provides the QtNfcSubset module which provides access to NFC on enabled BlackBerry 10 devices. More details will be provided in the BlackBerry 10 documentation.

Following modules are not supported:

• QtServiceFramework
• QtContacts
• QtMessaging
• QtSystemInfo
• QtPublishSubscribe
• QtOrganizer
• QtFeedback
• QtGallery
• QtVersit

Related Resources

We are planning to provide more detailed documentation about Qt applications on BlackBerry 10 in the next blog posts. In the meantime, please find below some selected links related to Qt on BlackBerry 10:

• Community Wiki for Qt on BlackBerry
• Building Qt4 for BlackBerry
• Building Qt5 for BlackBerry
• Qt Creator 2.6.0 released
• http://qt-project.org/wiki/BlackBerry

Related Posts:

• What’s up with Qt and the future of Cascades?
• Porting Qt Applications to BlackBerry 10 is Easier than Ever

Happy Qt development for BlackBerry 10! Please note that RIM is committed to Qt and is continuously working to expand the selection of own add-on modules as well as standard modules provided by Qt in the future.

Qt developers and BlackBerry® 10 developers often ask the following questions:

What is the relationship between Cascades™ and Qt, and how do they interact with each other?

Cascades and Qt frameworks are two major frameworks available in BlackBerry 10 application development. From a high-level architectural point of view, you can say that Cascades sits on top of Qt modules as it is built, using the Qt application framework leveraging Qt object model, event model and threading model. This also uses QtCore, QtXML, QtSql, QtNetwork and QDeclarativeEngine for QML components. Both frameworks use standard C++, signals and slots in Qt for inter-object communication. However, Cascades uses own UI rendering engine and does NOT use any QtGui functionality, while Qt uses raster and the OpenGL graphics engine.

BlackBerry 10 supports BOTH Cascades and Qt

The key point here is that BlackBerry 10 supports BOTH Cascades and Qt frameworks. If you have developed an application using Qt framework for other platforms, you can deploy and run the application on BlackBerry 10 with the minimum effort of fixing a few compile and runtime issues. The downside of this approach is that your application may not have consistent look and feel with the BlackBerry 10 platform, nor have the best integration with the platform itself.

Cascades includes a set of core UI components and platform APIs to create interactive applications accessing the underlying features of the BlackBerry 10 platform. Cascades UI components are designed to have a consistent look and feel, and are optimized for BlackBerry 10 integration such as touch screen interactions. You can use Cascades Builder, the main development tool, for creating BlackBerry Native applications, which is built into the QNX Momentics IDE. The UI preview and the components view are specific features of Cascades Builder when editing QML. Cascades Builder is also integrated to access the BlackBerry platform features and services like audio/video, camera, Ad Service, app integration, BBM™ Social Platform, external data storage access, file system access, internationalization, location, payment service, PIM (Personal Information Management), push services, networking, notifications and sensors. To learn more about the Cascades framework, see Introduction to Cascades.

When porting a Qt application to BlackBerry 10, you can access the same subset of Qt APIs directly without using wrappers for BlackBerry 10. This is powerful and convenient for Qt developers and Qt applications. If you have any Qt applications using Qt APIs such as QGeoCoordinate or QSensor, the same APIs are available and accessible on BlackBerry 10. Currently, the subset of QtCore, QtNetwork, QtLocation, QtSensors, QtSql and QtXML modules are supported. You can check out our sample applications to learn more about these APIs.

Which Framework to Choose to Port your Qt Application?

We recommend that you choose Cascades framework if you are developing a native look-and-feel application on BlackBerry 10 and want to maximize the platform integration. If you are planning to develop an application with specific and customized GUIs, you can choose Qt framework. The decision has to be made before you start writing your application, however, since you can’t mix the UI components between Cascades and Qt. We will walk you through the porting tips based on the framework in the following section.

Basic Step-by-Step for porting a Qt application to BlackBerry 10

1. Set up the tool chains:

• Download BlackBerry 10 SDK/NDK and Set up
• If you choose to use Qt Creator, download and configure Qt Creator 2.6 for BlackBerry 10 development. This version is recommended since it has the full support for BlackBerry 10 development including BlackBerry® PlayBook™ tablet and QNX. In order to deploy an existing Qt application project in Qt Creator, you need to add the kit which you defined for BlackBerry 10 to your project. Read the configuration instructions.

2. Build the application. You will have to fix some make, compile, and linking issues.
3. Set up Package and Deployment by adding the application icon and/or splash screen.
4. Fix look and feel issues by adjusting resolutions, icons, windows or font sizes. You can use Cascades components, make your own customized QML components, or use Qt Quick or QWidgets.
5. Address platform specific runtime issues. If necessary, add BlackBerry Platform Services. Often, different platforms handle inputs differently. Test rotating and adjust orientation issues.
6. Add unique features to the BlackBerry 10 platform to add competiveness. You can apply device integrations like QtMobility Sensors, Native BlackBerry Platform Services and PPS APIs.
7. Submit to the BlackBerry App World™ storefront.
8. Start collecting your money!

If you’d like to learn more about porting Qt applications to BlackBerry 10, stay tuned. We are planning to dig deeper into this topic over the next blog post series.

Here are some Cascades, Qt and open-source related links:

• Introduction to Cascades
• Qt for BlackBerry
• Open Source Components for the BlackBerry Native SDK
• Building Qt4 for BlackBerry
• Building Qt5 for BlackBerry
• Qt Creator 2.6.0 released

Related Posts:

YouTube: BlackBerry Jam Session (JAM12): Porting Qt Applications to BlackBerry 10
Developing in Cascades
What’s up with Qt and the future of Cascades?

By Tehdog (Own work) [CC0], via Wikimedia Commons (Mute_Icon.svg, Speaker Icon.svg)

Some of you may have noticed that the Beta 3 release of the BlackBerry® 10 Native SDK got a bit quieter in the console when creating Cascades™ applications. As of Qt 4.8.3, all output that used to code to the console (qDebug(), qWarning(), qCritical() etc) is now output to slog2. This not only affects the logging from C++ but also any console.log() JavaScript logging done from within QML as well as error messages at runtime. No console output can make troubleshooting even simple issues very frustrating. Luckily there are a few workarounds detailed in the “Known limitations” section of the release notes that can get you access to the logging information.

1) This workaround gets you the logging information back to the console, but should be removed prior to publishing your application to the BlackBerry App World™ storefront. Either of the following can be done:

a. Use the fprintf() function with stdout or stderr as the output stream to receive output directly to the console. This is easy to do to add in-line console output from C++, but will not restore logging to the console from QML.
ex fprintf(stdout, “I am a console message\n”);

b. Register your own message handler with the application to have all qDebug() (etc) and QML output handled however you wish (including using fprintf() as mentioned above). To do this, open your main.cpp file (the default main file for a Cascades application) and add a function similar to the following above the main method:

void myMessageOutput(QtMsgType type, const char* msg){
               fprintf(stdout, "%s\n", msg);
               fflush(stdout);
}

Then in the main method we need to register the above method as a message handler:

int main(int argc, char **argv)
{
    Application app(argc, argv);
    qInstallMsgHandler(myMessageOutput);
    ...
}

After this is done you will once again have console output!

2) To see debug information that is output from qDebug(), you can access the slogger2 logs as follows:

In the IDE, in the Target Navigator view, right-click the device target. Click Launch SSH Session.

In the terminal that appears, do one of the following:

• To view the current slogger2 logs, type slog2info.
• To view real-time output for the processes that are being debugged (for applications that are running in development mode), type slog2info -w.
• To view help information on slogger2, type slog2info -h.

You can also access the log files directly in the /tmp/slogger22 on the device and run these logs through slog2info at a later time.

This works well to retrieve all logs, but has a bit more overhead than option 1b) and also does not allow you to see the logs in the console.

Now you have a few options to get access to the application logs, which can be used in the interim until a solution comes in a future NDK release and the above workarounds are no longer needed.

The workarounds mentioned above are also covered in the following places:

• Cascades Beta 3 – Release Notes
• Upgrading to Beta 3 – QNX Momentics IDE changes
• Getting Started – Debugging and profiling

Guest post from Ash N. – Ed.

BlackBerry® is serious about developers, serious about applications, and serious about Qt. With this in mind, we are asking for all you Qt ambassadors and Qt superstars to try porting your Qt applications over to the BlackBerry® PlayBook™ tablet and upcoming BlackBerry® 10 smartphones.

With this in mind, we have a post on the Qt Project Website. What we need from you is:

• For you to be a member of the “Qt on BlackBerry and QNX” group (if you are not, then please register to become a member)
• Send a proposal of the application(s) you will / are considering porting or have ported
• Send us a link to where you will make your code available OR if you do not to make the code public, then please provide us evidence that you are developing using Qt

In return, you will be automatically entered into our weekly draw for a free BlackBerry PlayBook tablet. We even have Mondays reserved for Qt porting at the BlackBerry Tech Center in Slough, UK if you need some in-person help.

Sounds good? Log on to the Qt Project website for all the links and info!