Tag Archives: QNX

Linux

KDAB at Qt Contributor Summit

Leave a comment
Transport in Bilbao

On the 15th and 16th July this year, KDAB attended the Qt Contributor Summit, which was co-located with the KDE Akademy conference in Bilbao, Spain.

Transport in Bilbao

The program of the Qt Contributor Summit was mostly determined by who was attending and what the important topics at the time were. KDAB attended the summit with strength, and participated in many relevant discussions.

Some pre-scheduled talks were held, including a ‘State of the Union’ from Lars Knoll, where he talked about recent additions and developments in Qt and the focus of Digia for the coming releases. The focus on advancing the mobile platform support in the next releases is well known. Challenges resulting from that focus and other known standing challenges were also listed and were part of the discussions at the summit. These included the ICU Problem, Evolution of the QML language and Bug management discussion, all relevant issues for the community and for the ongoing adoption of Qt.

The QtCore session included some future-looking considerations of how Qt will deal with C++14 and C++17 – what does Qt need from those standards, and what can Qt provide to them in terms of feedback and use-cases. Some of the recent work on the QVariant/QMetaType by Stephen Kelly of KDAB relates to type-erasure, which is a growing topic in C++ standardization discussions. The command line parser, a long requested part of Qt, has been worked on by David Faure, and there were updates about what remains to get it into the next release, and porting existing Qt tools to the new API.

C++11 lambda syntax is gaining adoption

QML and QtQuick were obviously also large topics for the entire summit, with many sessions relating to the technologies. Among the sessions were one dedicated to the Model-View APIs in QtQuick. A new design could be utilized to increase the flexibility and re-use of components for creating new views. Some discussions were had on how to represent hierarchical or tree structures in QML.

Recent developments in the Linux kernel for adding generic multicast local socket support are gathering momentum, and the implications of that for the QtDBus module were discussed. This could reduce the dependency of QtDBus on an external libdbus-1 on Linux. QNX also has a native message passing system which may also be usable to bypass the libdbus-1 dependency on that platform.

Both QBS and CMake were represented with sessions at the Qt Contributor Summit. The QBS session was an introduction to qbs for those who have not worked with it before, and a tour through its capabilities. The CMake session included a summary of recent and future developments in CMake which benefit Qt users, and plans for better CMake integration in QtCreator.

…read more

Source: FULL ARTICLE at Planet KDE

Business, Finance, Occupation & Industry

Better Smartphone Comeback Play: BlackBerry or Nokia?

Leave a comment

By Steve Heller, The Motley Fool

Filed under:

Let’s face it: The smartphone revolution hasn’t been kind to every company that’s been trying to make it out there. In recent years, the headlines have been dominated by Apple and Google for having the smartphone market locked down. Naturally, this incredible success came at the expense of other companies, having seen their fortunes dissipate in recent times. Back in the day, it was Nokia that ruled the smartphone world with its Symbian mobile operating system, but once the iPhone caught the consumer’s eye, everything started to change.

Source: Gartner.

Enterprise-entrenched BlackBerry largely held its own in terms of market share until 2010, when enterprises began reducing their dependence on the company’s enterprise-oriented solutions. At the time, the writing was on the wall that BlackBerry could be in trouble, which helped drive Apple’s enterprise share to more than 50% today.

Although BlackBerry and Nokia have experienced their share of hardships in recent years, both come with an arsenal of new offerings hoping to change their statuses in the smartphone world. Which company has the best chances of success in 2013?


Nokia Lumia 620. Source: Nokia.

Since developed markets are more established for smartphones, Nokia will be primarily placing its focus on emerging-market growth opportunities. Considering that the world has only reached roughly 25% worldwide smartphone saturation, there’s a tremendous amount of growth for companies that cater to less saturated markets. Not to mention that Nokia has aggressively priced its offerings to fare well when consumers decide which device has the best value for the price. Central to this strategy are the $180 unsubsidized Nokia Lumia 520 and the $249 Lumia 620, which together hold the potential to ruffle Android’s feathers in the sub-$250 unsubsidized smartphone market. Until now, the sub-$250 Android smartphone market hasn’t been met with any formidable competition. The hope is that Nokia’s aggressive approach coupled with Microsoft‘s freshly minted Windows Phone 8 ecosystem will be enough to steal some thunder away from Android’s stronghold.


BlackBerry Z10. Source: BlackBerry.

Working from the high end down, BlackBerry has been in the process of (slowly) releasing its first flagship BlackBerry 10 phone, the BlackBerry Z10, into the wild. BB10 is built on an entirely new source code called QNX, which offers the promise of a modern-day mobile OS, coupled with the potential to act as a modern-day cross-compatible platform. BlackBerry promises QNX will one day connect with your car, home, and the health-care system from your device. The Z10 is also a sharp divergence from the traditional designs of the keyboard-entrenched device maker.

Ultimately, BlackBerry is planning on releasing six devices based on BB10 in 2013, split evenly between keyboard and touch models, covering a range of price points from the low end to the high. But considering the Z10 fetches an unsubsidized $599, BlackBerry is a few steps behind Nokia in terms …read more
Source: FULL ARTICLE at DailyFinance

Linux

Geek'ish application development for Blackberry 10

Leave a comment

Hi there again,

As indicated in my previous post, I am now about to summarize my developer experience for the platform Blackberry 10. As written before, the regular way of developing applications for this platform is to use the Momentics IDE or QtCreator.

Those environment usually generate the necessary qmake build system files, bar files for you to a certain extent I guess. Admittedly, I have never used them for this purpose, so this is just a gut feeling. Anyway, this is not so important for the scope of this post.

Goal

When I had started to develop my first application, I made some research if it had ben possible to develop applications the way I like: command line and cmake. For those of you, who are not familiar with cmake, it is a nice cross-platform Makefile generator thoroughly used in many projects. One open source reference is KDE for this.

Interestingly enough, I got some messages in private after my cmake based projects that people found those files and used in a similar fashion one by one. This is nice, but some explanation is necessary for newcomers. So, let us dig into more details about this.

CMake Toolchain file

In order to make cross-platform development with cmake, usually one has to produce a correct toolchain file. I looked around on the internet, and there was some examples available for QNX. I took one of those essentially to start off with. That is also one reason why it is a bit bloated, and a much simpler would be enough for achieving what we wish to.

If you are not interested in the underlying operation, you can skip the explanation below, and you can just use my toolchain file right away.

The important changes I made were the followings:

  • Use the proper toolchain binary

Use the ‘qcc’ build wrapper. It is essentially a wrapper around the compiler, linker, and so forth. You can find more complete documentation about it here.

This is a very important change because I started with the “ntoarmv7-g++” which is a link to the “arm-unknown-nto-qnx8.0.0eabi-g++-4.6.3” toolchain file. I also tried the latter directly, but I encountered crash for my applications even for a very simple test case without cmake. The program crashed even before entering the main function. It took me two nights at least to track the problem down.

  • Use the proper toolchain binary flags

Once I figured out I would have to use ‘qcc’, there were still some problems that I encountered, albeit slightly different. I had to realize the usage of certain flags is necessary. Once I made it work with the proper flags without any build system, I had to figure out the proper way of setting that for the toolchain file. Now, we have all the information necessary so here it goes the statement:

…read more
Source: FULL ARTICLE at Planet KDE