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.

So, you want to add video to your native OpenGL application on BlackBerry 10? Below I’ll go through the steps that you need to complete in order to get it up and running quickly.

The first thing you’ll want to do is create a window group in your screen creation code. The window group will be used to attach the video window to. The code is as follows:

       // Window group name
static const char *window_group_name = "videowindowgroup";

       if (screen_create_window_group(screen_win, window_group_name)) 
       {
              fprintf(stderr,"screen_create_window_group failed");
       }

The next thing you’ll want to do is handle the initialization of the video screen. There is a screen event called SCREEN_EVENT_CREATE that you need to listen to and initialize the video screen as you see fit. For example, if I wanted my screen to take up an arbitrary width and height I could do the following:

       case SCREEN_EVENT_CREATE:
{
              screen_window_t video_window;
              screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void **)&video_window);

              int size[2];
              size[0] = video_width;
              size[1] = video_height;

              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_SIZE, size);
              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_BUFFER_SIZE, size);

              int order = 1;
              screen_set_window_property_iv(video_window, SCREEN_PROPERTY_ZORDER, &order);
              break;
}

It’s important to set the zorder on the video window as it’s behind your main window by default, so make sure the order is set to a positive number.

Once initialization is complete, you can create a method to play your video. You can just use mmrenderer in order to do the heavy lifting. We just need to point it to use the window group that we’ve already defined called “videowindowgroup”. An example might look like this:

// I/O devices
static const char *video_device_url    = "screen:?winid=videowindowgroup&wingrp=videowindowgroup";
static const char *audio_device_url    = "audio:default";

// Name of video context
static const char *video_context_name = "videocontextname";

// I/O variables
int                video_device_output_id = -1;
int                audio_device_output_id = -1;

// Renderer variables
static mmr_connection_t*     mmr_connection = 0;
static mmr_context_t*        mmr_context = 0;

int playVideo()
{
       int rc;

       /*
       * Configure mm-renderer.
       */
       mmr_connection = mmr_connect(NULL);
       if (mmr_connection == NULL) {
              return EXIT_FAILURE;
       }

       mmr_context = mmr_context_create(mmr_connection, video_context_name, 0, S_IRWXU|S_IRWXG|S_IRWXO);
       if (mmr_context == NULL) {
              return EXIT_FAILURE;
       }

       /*
       * Configure video and audio output.
       */
       video_device_output_id = mmr_output_attach(mmr_context, video_device_url, "video");
       if (video_device_output_id == -1) {
              return EXIT_FAILURE;
       }

       audio_device_output_id = mmr_output_attach(mmr_context, audio_device_url, "audio");
       if (audio_device_output_id == -1) {
              return EXIT_FAILURE;
       }

       /*
       * Build up the path to where the video is.
       */
       char cwd[PATH_MAX];
       char media_file[PATH_MAX];
       getcwd(cwd, PATH_MAX);

       rc = snprintf(media_file, PATH_MAX, "file://%s/app/native/myVideo.m4v", cwd);
       if ((rc == -1) || (rc >= PATH_MAX)) {
              return EXIT_FAILURE;
       }

       /*
       * Start the playback.
       */
       if (mmr_input_attach(mmr_context, media_file, "track") != 0) {
              fprintf(stderr, "failed to attach video\n");
              return EXIT_FAILURE;
       }

       if (mmr_play(mmr_context) != 0) {
              return EXIT_FAILURE;
       }

       return EXIT_SUCCESS;
}

Finally when we’re done, we’ll want to clean up the window and the mmrenderer contexts:

void clearVideoScreen(screen_event_t screen_event)
{
       mmr_stop(mmr_context);
       mmr_output_detach(mmr_context, audio_device_output_id);
       mmr_output_detach(mmr_context, video_device_output_id);
       mmr_context_destroy(mmr_context);

       mmr_context = 0;
       video_device_output_id = -1;
       audio_device_output_id = -1;

       mmr_disconnect(mmr_connection);
       mmr_connection = 0;

       int order = -1;
       screen_set_window_property_iv(video_window, SCREEN_PROPERTY_ZORDER, &order);

       int visible = 0;
       screen_set_window_property_iv(video_window, SCREEN_PROPERTY_VISIBLE, &visible);

       screen_destroy_window(video_window);
}

Hopefully this gives you a good start into incorporating video into your BlackBerry 10 applications. For some other related samples of using video, you can check out the VideoPlayerSample in the Cascades-Community-Samples and also the Video Overlay sample in the native samples.

Have a blog? Facebook page? YouTube Channel?

Great news: you can convert it into a BB10, PlayBook or BBOS App in less than 10 minutes, using BlackBerry App Generator. Watch this short video and learn how:

Step 1: Sign up for a BlackBerry App World Vendor Account: https://appworld.blackberry.com/isvportal

Step 2: Create your App using BlackBerry App Generator: http://www.blackberryappgenerator.com/

Step 3: Publish to App World.

Yes, that easy! Piece of cake! Good luck everyone.

Our pledge to developers at the keynote on Peek & FLOW means that we’ve updated Beta SDKs for every BlackBerry 10 development environment and delivered dozens of new APIs, frameworks, components and controls. On top of it all, we’ve also released a new BlackBerry 10 OS and system components for Dev Alpha devices and simulators that give you everything you need test your apps fully.

Additionally, we furthered our commitment to HTML5 and Web Technology through our adoption and contributions to open standards and our relationships with industry partners like jQuery, Adobe®, and Sencha.

We are truly committed to building an open platform and partnering with developers. Be sure to check our flight arrival boards to see what’s coming up from us next and watch Don Lindsay & Chris Smith’s keynote for full details on announcements and releases!

[ YouTube link for mobile viewing ]

[ YouTube link for mobile viewing ]

Also, check out our latest blog posts released during BlackBerry Jam Americas 2012 for a deeper-dive into our most recent updates:

BlackBerry Java Plug-in for Eclipse now available on Github!
Ripple renewed: Updates to the Ripple Emulator
Who’s ready for dessert? Android Runtime for BlackBerry 10 Beta
Power up! BlackBerry 10 WebWorks SDK super-sized
A four-step guide to BlackBerry 10 Flow
The Coming of Age of the BlackBerry 10 Native SDK
BlackBerry Jam Americas 2012: Flight Arrival Boards and Roadmap Updated

This week we caught up with RIM’s Gregg Ostrowski, Sr. Director of Technical Solutions, and Jeff Holleran, Sr. Director of Enterprise Product Management to chat about both enterprise app development and deployment. Check out the video below:

[ YouTube link for mobile viewing ]

We’ll be sharing more details about the Enterprise BlackBerry Jam events in the coming weeks, so stay tuned by checking back regularly on the BlackBerry Developer blog and the BlackBerry for Business blog.

Do you develop apps for business? What need are they designed to fill? Share in the comments below!

[YouTube link for mobile viewing]

[YouTube link for mobile viewing]

Check out Patrick’s interview in the video:

[ YouTube link for mobile viewing ]

[YouTube link for mobile viewing]

The following demos are being used in this video:

• Guimark3 HTML5 bitmap drawing test, by Sean Christmann
• Rubiks HTML5 canvas, by Remy Sharp
• Origami, by Hakim El Hattab

Leave us a comment and tell us what you think!

[YouTube link for mobile viewing]

Anyone who’s ever done a presentation with a demonstration knows the fear that builds as you take the stage. You’ve rehearsed, you’ve quadruple checked the demo, the Wi-Fi®, Bluetooth®, everything – and then POOF, your demo goes off the tracks in front of 2,000 people.

Our own Vivek Bhardwaj, Head of Software Portfolio EMEA, had this happen today during the keynote at BlackBerry DevCon Europe. Vivek was going to demo the new “Open On…” feature of BlackBerry® Bridge™ 2.0 when taking a photo. “Open On…” allows you to open a photo or other document from your BlackBerry smartphone onto your BlackBerry® PlayBook™ tablet with one click. The demo didn’t go off as planned. This is one of Vivek’s favorite new features, so we grabbed our video production crew to tape a follow up of the demo – watch it above!