Popular with major musicians, the Animoog app is an evolutionary step and mobile extension of the original electronic analog Moog Synthesizer created by Dr. Robert Moog in the 1960s. Today marks Dr. Robert Moog’s 79th Birthday, and to celebrate both his birthday and his passion for high-tech toolmaking in the service of creativity, we are pleased to announce that the promotional Animoog app price of $0.99 will be extended until the end of the weekend in BlackBerry World before returning back to its original price of $9.99.

We hope that you will join us in celebrating Dr. Robert Moog’s birthday by heading over to BlackBerry World and making some awesome music!

This June and July our EMEA superstar evangelists will be heading down to Africa to spread the BlackBerry 10 love.

If you have never developed for BlackBerry 10 before and would like to learn how to go from nothing to a fully functioning app using either HTML5 or C++/Qt Cascades, then you should come and join us for one of the tour stops around the continent.

Our team will be on hand all day to give you all the tips and tricks you need to build a beautiful app that users will love and value.

To find out more and to register for a place check out the links below. Spaces are limited and are filling fast so don’t wait!

BlackBerry Jam Tunisia 14th June

BlackBerry Jam Kenya 21st June

BlackBerry Jam Ghana 1st July

BlackBerry Jam Nigeria 3rd July

BlackBerry Jam South Africa date tbc

For those developers who’ve been part of the BlackBerry 10 Dev Alpha program with either a BlackBerry 10 Dev Alpha A or BlackBerry 10 Dev Alpha B, there’s a date upon which you may have been keeping a watchful eye: June 30^th, 2013… the day the BlackBerry 10 Dev Alpha testing devices are set to be deactivated. Or are they?

The BlackBerry 10 Dev Alpha testing devices were seeded to our development community in advance of the BlackBerry 10 launch to ensure hardware availability to our devs well ahead of launch. Now that launch has come and gone (and so too has the date for the BlackBerry 10 Limited Edition device!), those BlackBerry 10 Dev Alpha testing devices start falling into the category of unsupported hardware since they were never intended to be a full commercial product nor do they support the full OS builds. But really, they still work, so why throw away a perfectly good device? Good news! You don’t have to.

If you saw the blog post advising devs of the BlackBerry 10.1 SDK OS update (SDK OS indicates that it’s not a full OS release, but rather an OS build that features a reduced set of apps – basically what you need to develop and build against), then you’ll be pleased to learn that the 10.1 SDK OS also had the side benefit of removing the date that was to disable the BlackBerry 10 Dev Alpha testing devices. In other words, for any BlackBerry 10 Dev Alpha owners, if you’ve updated to the 10.1 SDK OS build, your device will continue to work beyond the June 30^th date, with no imposed expiry date embedded in the OS.

The BlackBerry 10 Dev Alpha A hardware will continue to be officially unsupported and the BlackBerry 10 Dev Alpha B hardware will join those same ranks on June 30^th, but if you want to continue to developing apps against those devices beyond that date, you’re welcome to do so.

For more info on the BlackBerry 10 Dev Alpha program and to view other FAQs, please visit the BlackBerry 10 Dev Alpha web page.

Today was an amazing day for me at the Unite Nordic conference in Malmo, Sweden. I was able to attend the keynote session where Unity CEO David Helgason announced that they are making their mobile tools free to indie developers and small studios!

Unity is a leader in game development with just shy of two million developers using the tools. Now with this announcement, Unity is making it easy for any developer to bring their games to mobile devices – including the BlackBerry Z10 and BlackBerry Q10 smartphones – and the upcoming BlackBerry Q5 smartphone.

At the keynote, David spoke about how, as game developers, we’re just at the inflection point of mobile and how mobile is surpassing other platforms in adoption. There have been many games that have proven that mobile is a profitable platform, but there is much room to grow.

Take a look oat David’s Video Announcement:

Our booth at the conference was bustling with activity. Game developers were intrigued by the BlackBerry 10 platform and we had many conversations on how they could use Unity to get their apps onto the platform.

We encourage you to take advantage of the Unity open beta for BlackBerry 10!

As developers, when we have an idea for app, we can build it. But what if you’re not a developer, but you have the idea for the next great app? Dandy recently launched their beta where people can share their app ideas with the Dandy community and help build an amazing app together. Last week, I spoke with Karl Allen-Muncey and Taylor Jones during BlackBerry Live to talk apps, BlackBerry 10, and building the next great app.

That said there are…. apparently…. people in this world who have a bit more resolve than I do and take their sporting and fitness activities a bit more seriously. Not only do they manage to get out of the comfy chair, they even like to measure and analyse their performance so they can improve.

Now my colleague Martin (@mdwrim) has normal furniture in his house and seems more than capable of getting out of the comfy chair and down to the climbing wall or out on his bike. He and I (@jcmrim ) talked about the kind of technology available to sporty people, in particular cyclists. Martin had just come back from watching part of the Giro d’Italia and pointed out that all the pro cyclists have sensors on their bikes. BlackBerry 10, Bluetooth Low Energy and cycling! What a perfect combination of great technology, fun and exercise as well as a great opportunity for a new Blog post, video and sample app!

If you haven’t already done so, this is probably a good time to have a read of our previous blog posts and articles on the Internet of Things and Finding Car Keys since they cover the basic concepts needed in this blog post.

As before, the first thing we did was to do a little bit of research to see if the Bluetooth SIG had defined any standards in this area; no point in re-inventing the wheel [no pun intended] and the existence of a standard would mean that a vendor may have already implemented the technology in a product.

Whenever you have a requirement that may be solvable using Bluetooth LE the first place to look is here: http://developer.bluetooth.org/gatt/Pages/default.aspx.

Browsing through the GATT Profiles we came upon this one: Cycling Speed and Cadence (CSC)… this sounded promising, and the description looked like it was just what we needed.

“The Cycling Speed and Cadence Profile is used to enable a data collection device to obtain data from a Cycling Speed and Cadence Sensor (CSC Sensor) that exposes the Cycling Speed and Cadence Service.”

The key element of this profile is the Cycling Speed and Cadence Service (UUID 0×1816) which contains four really useful fields:

• “Cumulative Wheel Revolutions”
• “Cumulative Crank Revolutions”
• “Last Wheel Event Time”
• “Last Crank Event Time”

These are part of the “CSC Measurement” GATT Characteristic (UUID 0x2A5B). They are described in detail here: CSC Characteristics and outlined in Figure 1.

There are some other characteristics that allow configuration and control of the device but we’ll talk about these when we come across them.

Figure 1 Key GATT Characteristics for CSC

So, if you think about these characteristics they allow you to derive a number of key measurements:

1. Total distance travelled – using “Cumulative Wheel Revolutions” – all you need to know is the wheel circumference to calculate this, but if you combine this with a time and a geo-location measurement you can even derive sufficient information to plot your progress on a map.
2. Speed – using “Last Wheel Event Time” – you can figure out how fast the bike is going if you do a simple calculation involving the time between successive Last Wheel Event Time values and the number of wheel revolutions that occurred in that time. But if you combine this with a geo-location measurement you can derive sufficient information to plot your speed on the map as well.
3. Instantaneous effort – using ““Last Crank Event Time”” – this can help identify those times that you’re free-wheeling and not expending energy.

It’s at this point that the engineer in me begins to wonder how to instrument a bicycle to make use of this GATT profile. Martin’s a cyclist, so, after identifying a device that matched the requirements (Wahoo Fitness Blue SC[1] device), he attached it to his cycle as shown in Figure 2.

Figure 2 Attachment of cycle monitor

For those of you who are mechanically minded small magnets on both the crank and the rear wheel spokes activate the sensor strapped to the frame. The sensor maintains the counts and timings and will report them to a suitable Bluetooth LE device such as a BlackBerry 10 smartphone.

The application that we developed based on this is actually very similar in structure to the Heart Rate Monitor application that was described in a previous blog and article. The basic logic is the same:

1. Pair the Bluetooth LE device with the BlackBerry 10 handset before using the application.
2. Launch the application which:
   1. Discovers devices that support the CSC Service (UUID 0×1816)
   2. Connects to a discovered device selected by the user
   3. Requests the device to notify our application as changes are made to the CSC Measurement characteristic (UUID 0x2A5B) which contains the wheel and crank data that we’re interested in.
   4. Receive, parse and display in numerical (RPM) and historical graphical form the CSC Measurement data as they are received.

Here are some screenshots showing what the application looks like:

Figure 3 The CscMonitor Application

Instantaneous values of the wheel and crank readings in revolutions per minute (RPM) are shown in the upper part of the screen whilst historical RPM data are plotted on the lower half of the display. Wheel and crank historical data displays can be toggled by touching the screen. Mapping RPM values to distance or energy expended would require additional information to be provided, such as the wheel circumference or radius of the crank — we’ll leave this for a possible later iteration of the application and focus on the Bluetooth LE aspects for now.

If we inspect the GATT services the CSC device supports using a tool like BTool we can see (Figure 4) that the CSC Measurement Characteristic (UUID 0x2A5B) is exposed at handle 0×0023. Handles are the references to entries in the GATT that our application will discover and use to access the value associated with a characteristic. We’ve used handles before in both our previous examples.

Figure 4 GATT showing CSC Characteristics

Associated with the CSC Measurement Characteristic is a “Client Characteristic Configuration” characteristic (UUID 0×2902) exposed at handle 0×0024. The value of this field determines whether our application will receive Notifications or Indications for the CSC Measurement Characteristic. We’ve used these before as well in our previous examples. In this case this characteristic will be set to enable Notifications using the BlackBerry 10 Bluetooth LE API.

So, how do we manage the data that is notified to us from the CSC device? The CSC data received is managed by a class called “CscDataContainer” … here’s part of its definition:

class CscDataContainer: public QObject {
       Q_OBJECT
private:
       CscDataContainer();
...
       // notification data
       QQueue<csc_notification_t> _csc_notifications;
       // CSC values
       QQueue<csc_values_t> _csc_values;
       int _min_wheel_rpm;
       int _max_wheel_rpm;
       int _avg_wheel_rpm;
       long _total_wheel_rpm;
...
}

At its core are a couple of queues that maintain the data that is received. The queue has a maximum length that can accommodate one notification per second for an 8 hour period. A future version might persist these data in a database but this is sufficient to demonstrate the principle in this case.

Once again the excellent little JavaScript library called “Flot” is used to plot these data in a WebView component in QML.

As notifications are received by our application the addNotification() method of the CscDataContainer class is called with the CSC Measurement data passed as a (uint8_t *) and a length (uint16_t) — that is an array of bytes.

Parsing this data is the first task and it’s instructive to see how this works – the main points are highlighted in the code fragment below:

void CscDataContainer::addNotification(const uint8_t *val, uint16_t len) {
       // parse value, paying attention to the bit settings in the FLAGS field
       bool wheel_revolution_data_present = false; // bit 0 of Flags field
       bool crank_revolution_data_present = false; // bit 1 of Flags field
       uint32_t cumulative_wheel_revolutions = 0;
       uint16_t cumulative_crank_revolutions = 0;
       uint16_t last_wheel_event_time = 0;
       uint16_t last_crank_event_time = 0;
       int index = 0;
       uint8_t flags = val[index];
       wheel_revolution_data_present = ((
flags & WHEEL_REVOLUTION_DATA_PRESENT) == WHEEL_REVOLUTION_DATA_PRESENT);
       crank_revolution_data_present = ((
flags & CRANK_REVOLUTION_DATA_PRESENT) == CRANK_REVOLUTION_DATA_PRESENT);
       // Fields are in the order of LSO to MSO.
       // Where LSO = Least Significant Octet and MSO = Most Significant Octet.
       index++;
       if (wheel_revolution_data_present) {
              // Cumulative Wheel Revolutions, 4 bytes.
             // Field exists if the key of bit 0 of the Flags field is set to 1.
              cumulative_wheel_revolutions =
(val[index + 3] << 24) | (val[index + 2] << 16) |
(val[index + 1] << 8)  |  val[index];
index += 4;
              // Last Wheel Event Time, 2 bytes. 
              // Field exists if the key of bit 0 of the Flags field is set to 1.
              last_wheel_event_time = (val[index + 1] << 8) | val[index];
              index += 2;
...
}
       if (crank_revolution_data_present) {
// Cumulative Crank Revolutions, 2 bytes. 
// Field exists if the key of bit 1 of the Flags field is set to 1.
              cumulative_crank_revolutions =
(val[index + 1] << 8) | val[index];
              index += 2;
              // Last Crank Event Time, 2 bytes. 
              // Field exists if the key of bit 1 of the Flags field is set to 1.
              last_crank_event_time = (val[index + 1] << 8) | val[index];
              index += 2;
    ...
    }
...
}

The first byte of data contains an 8-bit flag field (see Figure 1 for details). This indicates whether crank or wheel data is present in the following data.  If these are present they are represented in Little-endian form and need to be extracted by shifting them out a byte at a time.

The rest of the application is more focussed on the display of this data using QML so I’ll leave that for you to look at yourself since the main learning points are to do with how to interface to the Bluetooth Low Energy device itself.

We made a video which has Martin (@mdwrim) showing the application in action and explaining the code. Here it is:

If you want to know more then check out the following resources:

• The complete source code for this application on Git Hub;
  • https://github.com/blackberry/Cascades-Community-Samples
• If you’re completely new to Bluetooth LE then we recommend you read our “BlackBerry 10 Bluetooth LE Primer for Developers”  which you’ll find in our knowledge base. This and all other Bluetooth LE related developer resources that we’ve created, are listed in a single resource index page:
  • http://supportforums.blackberry.com/t5/Native-Development/BlackBerry-10-Bluetooth-LE-resource-index/ta-p/2326147

I hope you’ve enjoyed this short note and hope it has piqued your interest to find out more about Bluetooth Low Energy and how it can be integrated into your BlackBerry 10 applications.

---

[1] This should not be regarded as an endorsement by BlackBerry, explicit or implied.

http://www.webrtc.org/reference/architecture

I would like take this opportunity and introduce you to our good friends at Hookflash who have successfully ported all major components of both WebRTC and Open Peer libraries to BlackBerry 10. To provide a brief overview, WebRTC is an open source multimedia & network stack that supports real-time audio & video. The value Open Peer delivers to WebRTC applications is peer-to-peer (P2P) signalling on the wire, Instant Messaging, Federated Identities and multiple mobile platform support.

So why is this so important?  Well, it enables developers to build rich, compelling, real-time communication applications integrating Social Identities with Voice, Video and Messaging using BlackBerry 10 Native SDK. Secondly, WebRTC is free to use if you decide to commercialize your application. What Hookflash has achieved on BlackBerry 10 really exemplifies the power of our BlackBerry 10 Native Platform to deliver the best communications experience.

I would like to further highlight Hookflash team’s experience in porting both WebRTC and Open Peer stack’s over to BlackBerry 10 platform. Check out my interview with Erik Lagerway (Co-founder) & Robin Raymond (Chief Architect) from Hookflash below:

What is Hookflash?

Hookflash is a globally distributed software development team building “Open Peer”, new “open” video, voice and messaging specification and software for mobile platforms and web browsers.  Open Peer enables an important new evolution of communications; Open, for developers and customers to create with. “Over-the-top” on the Internet, where users control their economics and quality of service. “Federated Identity” so user’s connections aren’t limited by service provider’s walled gardens and operating systems. “Integrated”, as communications become a native function in software and applications. Hookflash founders, lead developers and Advisors accomplishments include; creators of the world’s most popular softphones, built audio technology acquired and used by Skype, built GIPS technology acquired and open sourced by Google to create WebRTC, and engaged in WebRTC standards development in the IETF and W3C.

What is Open Peer SDK and how would this empower BlackBerry 10 developers?

Open Peer enables direct integration of social identities, video, voice and messaging communications for developers building native BlackBerry 10 (NDK) applications. Voice, video and messaging flow Over The Top (OTT) via the Internet.

These services are delivered peer-to-peer (P2P) providing extremely strong privacy, security and encryption. Open Peer enables federated identities and allows developers to leverage and integrate whatever identity model they currently have, so their users remain their users!

What features does Open Peer SDK support?

The Open Peer SDKs are built according to the Open Peer specification. Here are a few of the features we have built into the current SDKs…

• HD real-time video
• Wideband voice and messaging
• Peer-to peer signalling & media transport (greater efficiency, reliability & privacy)
• Federated identity for cross-platform communications (not to be confused with Single Sign-On)
• Encrypted & secure communications

Would HTML5/WebWorks developers be able to leverage this in BlackBerry 10?

Yes. The current SDK is for BB10 NDK developers at this time. However, we have an active “opjs” project under development that will allow interaction between a native BB10 application and an HTML5/WebRTC enabled browser thus allowing web applications to communicate directly with native BB10 applications.

Share your experience in cross compiling your code for BlackBerry 10

Like all platforms, there’s is a learning curve relative to what you are used to until you find yourself comfortable in a new environment, and BB10/QNX is no different. The richness to the platform experience is impressive on the BB10 and made iOS feel somewhat dated by comparison.

Since QNX is a POSIX compliant system, it was relatively easy to get a majority of open source code ported to BlackBerry 10. The QNX GCC-compliant mode has helped us as well.

There were a few wrinkles along the way. The documentation and NDK felt young compared to other more established platforms but that kind of level of documentation grows out of community support and interaction.

One major difference between this project and other platforms has been the phenomenal support that Blackberry has provided us as developers, especially as Hookflash is pushing the platform and technology harder than most with real time communications in audio and video. This was refreshing, We’ve never seen such incredible support for their developer community.

Have you ported over the entire webRTC engine to BlackBerry?

Yes, we have ported all major components of webRTC library to BlackBerry. We will be extending what is offered by WebRTC’s library as well.

How long did it take to port the WebRTC and Open Peer code to Blackberry 10?

When you consider the size of the code-base that had to be moved, and the fact we had not worked on QNX /  Blackberry 10 before, it went relatively quickly. The entire move took us approximately 90 days.

Are you going to commit this work back upstream to WebRTC project?

Yes, our code will migrate back to the WebRTC project. Hookflash is extremely busy on a number of fronts making Open Peer widely available with limited resources.  We appreciate help from other developers. Pushing the WebRTC codebase back upstream will be of tremendous value to the Blackberry developer community. Requests to join our Open Peer BB10 github project are always appreciated.

What APIs did you use to build your application on BlackBerry 10?

NDK’s audio, camera and rendering subsystems and Boost are the bulk of the components. We use Cascades/QT for the sample application.

Do you have VP8 Video working on BlackBerry 10?

Yes. We had some difficulty getting the assembly to compile properly but with Blackberry’s support we were successful in porting an optimized version of VP8 to the BB10 platform. Keep in mind we have tested this mostly on Z devices at this time with limited testing done on the Q devices.

How was your experience relative to working with other platforms and BlackBerry 10?

As mentioned earlier, Blackberry feels a bit new in the documentation area and there are still a few bugs to take care of in the platform. Having said that, the platform is forward thinking, flexible and impressively powerful. Blackberry’s support has been beyond anything we could have hoped and even expected.

As more developers are drawn to the platform, documentation and community involvement will improve the access to information on the platform and increase the samples available to draw upon.

For such a new entrant into the market, our team is thoroughly impressed.

How was your experience working with the RIM team?

Bar-none, the best support we’ve ever had from a major platform vendor directly into the project. Kudos to RIM / Blackberry for providing such a spectacular community outreach.

When is Open Peer SDK going to be available for BlackBerry 10?

Our SDK is ready now in beta, developers can get it on Github today. We continue to polish this and our other toolkits, we expect commercialization to begin later this year. Follow us on github and twitter to get the latest news on Hookflash and Open Peer development.

I hope you found this interview informative and useful.  If you have any questions or feedback please leave a comment below or reach out to me directly on Twitter _GurtejSandhu. Kudos to Hookflash team for making this all happen.

I received the following email earlier this week from developer Dragos Filipovici. He wanted to share his story about an application he recently created for BlackBerry 10.

As I read the email, it was clear to me that his success was due to the strengths of the BlackBerry 10 HTML5/WebWorks platform and the social power of the open source & blog communities.  As such, I wanted to share.

Some of you might already know Dragos online as BglowDragosh. Before getting into BlackBerry 10 app development, he acquired UI design experience in building BlackBerry themes.

Hi Adam,

About a year and a half ago I tried app development using the Java SDK. I got stuck in the complex ways to achieve simple tasks (even creating a basic UI), the not always clear documentation, and the long deployment processes for OS5-7 devices. Granted, I was still a newbie in Java. 

However, I was (and still am) a JavaScript newbie as well – 6 months ago when I first started learning web app development. 

I believe the biggest factor helping me successfully transition to BlackBerry 10 app development was played by the new tools available, as nothing helps one learn like applying new knowledge into an actual tangible project, if the tools are available. For me, the WebWorks framework, the rich documentation, the forums and Github repositories, even the way the developer.blackberry.com website is designed, helped me immensely as a very-beginner developer. And all of BlackBerry’s efforts in the past year to engage with developers have kept me going, and the company’s new platform vibe kept me excited. 

After getting to know WebWorks and then bbUI.js, the learning curve for me was made much easier. I’ve often sent in questions in the WebWorks & bbUI.js Github repositories and most often it was my own code errors trying to achieve simple things, but I got helped each time anyway. Now I post actual API bug reports and sometimes request API features, as users request new features from my app. And I love this formed cycle which I believe was, for my personal experience, a recipe for success.

Which brings me to the present:

So far, it took me about 14 weeks of (intense) work on my first WebWorks app. Yesterday, CrackBerry.com review my app, and in several hours Workahol became the #1 top paid app in BlackBerry World. I am overwhelmed with user feedback suggesting new features – which I will endeavor to implement. It’s great that we are able to achieve such diverse functionality and performant UI without even using the Native SDK, and no user has complained so far (by invoking the old web apps < native argument). 

Lastly, if there’s any way I can help – either by speaking about my experience, or to promote this platform, BlackBerry World or the BlackBerry 10 user community in any way, please let me know.  

Sincerely, 

Kind Regards,

Dragos Filipovici (@BglowDragosh)

Sent from my BlackBerry® wireless device

If you get a chance, check out Workahol in BlackBerry World today. Do you have a success story building for BlackBerry? We’d like to hear – let us know in the comments below.

Previously, I talked about how to use the MapView APIs to embed your own layers on top of it. While that was nice and very flexible, it still required some work to get basic pins and bubbles going. In BlackBerry 10.1 we have updated the APIs to support push pins and bubbles out of the box. This means you can now use the native APIs such as GeoLocation and MapData to create and manage push pins with custom icons as well as assign a name and description to each that shows up in the bubble.

MapView with pins and bubbles

The bubbles can contain a title, a description as well as an action button. Signals are emitted when the text or the action button is tapped by the user so that applications can carry out the right action in that context. Typical actions would be to show more details about the location or starting a turn-by-turn navigation to that location. Oh and before I forget, did I mention that the title and description supports html tags? Yes it does. You can use html tags to format the text or even insert hyperlinks to open webpages.

A bubble with an HTML hyperlink

I guess I have been saving the best for last. One feature that I am really excited about is the ability to set the MapView to follow a specific pin. This is extremely useful if you want to track friends on a map or keep the user always centered on the map. Simply update the coordinates of the followed pin and watch the map automatically move with it. A full sample app can be downloaded from here.

Finally, a big shout-out to our maps team for their hard work – the MapView now has much better performance, faster tile loading and packs the features most of us need. Let’s get to work and put some more maps in our apps. If you missed the session at BlackBerry Jam Americas 2013, please check out the content on-demand – JAM69 - Maps in your Apps.