Continuing the last UCOSP posting, where we talked about the release of the Barcode Scanning Extension for BlackBerry 10 WebWorks, we have some thoughts from another student regarding development of BlackBerry 10 WebWorks Extensions. Developing extensions in C++ that can be called from JavaScript involves some challenges, so if you’ve been thinking about diving in, these hints will be quite useful. Here’s what Alex has to say about his experience this term:

“I had the fortune of joining a number of great software development students as we embarked onto BlackBerry’s new platform, BlackBerry 10. During this term, we explored bbUI.js, BlackBerry Webworks, and the Native Development Kit. I had worked specifically on creating new Webworks community plugins. Two plugins that I had worked on were a vibration feature to allow for additional parameters accessible only through the native development kit and a barcode reading feature with Michael Delong and Tim Windsor. In the end, I had done a great deal of research and developed various approaches to tackle the barcode reading feature.

The vibration community plugin was an effective introduction into developing between Javascript and C++. The feature was originally recommended to be completed when another colleague had required additional granularity in the vibration settings. While I had looked into this issue and was able to flesh it out, we found the APIs themselves were somewhat limiting with how the colleague had envisioned the outcome. Overall this situation was a positive experience in understanding the BlackBerry 10 Webworks architecture and the BlackBerry Platform Services.When developing this plugin I ran into a number of issues due to my own lack of patience which lead to some rather confusing errors.

• JNext does method invocation through string matching

Somehow through development I was using a certain keyword for indicating my command I wanted to invoke from Javascript. On the C++ side, I seemed to have switched around the naming and thus was expecting to read an event from a keyword that did not exist. Since these constants are being used in two different languages and there is not much common ground between this two language process, nothing was telling me that I was passing in the wrong keyword. Copy and paste can be your friend.

• Vibration falls under the BlackBerry Platform Services

While creating the vibration code, I was confused why it was not working at all. I had the keywords matching in both Javascript and C++ and it had all compiled from what I could see. Since vibration falls underneath the BPS family, you need to initialize the BPS before it can be used.

bps_initialize();

After completing this feature, I went on to work with Mike on the barcode scanning feature. Barcode scanning is a relatively interesting concept as it would combine a fairly wide knowledge base of media with my current understanding of Javascript and C++. When working with this feature, initially we tried to piece together what we could from other examples in cascades and the NDK github samples. Requiring a rather large knowledge base was something we had not expected from a feature like barcode scanning. Having to take advantage of input from the camera on the C++ layer introduced us to a number of concepts such as image formats and subsampling. In addition to worrying about these fundamental multimedia concepts we were trying to understand how to take a raw frame from the camera and extract a barcode with the ZXing library. While another of methods were taken in attempting to complete this feature I had participated in two approaches of development to get barcode reading to where it is now on WebWorks.

1. Displaying the images from a base64 representation from C++ to Javascript layer

• Attempted to use card invocation to support video feedback for barcode scanning

Prior to this project, I knew of base64 encoding but I had not ever used it in my own development. The ability to encode the bytes of the image in a string was an interesting idea to take advantage of the JNext bridge to carry the image from the native layer to the web layer. Unfortunately during the actual process, the encoding and decoding process can take a fairly long time and actual rendering on the canvas was not fast enough to capture a snappy mobile experience. it was an interesting usage of base64 but this was not quite the answer for the barcode scanner in its current state.

The second attempt that I had looked into was utilizing card invocation to skip the barcode reading altogether and take advantage of a cascades application to do the barcode reading for us. Card invocation is a great idea that can also be seen on other platforms such as Android. Specific functionality that another application may be able to accomplish very well, can be used as a “card”. These cards are invoked from an application which will run that portion of another application. When the card action is complete, that application is closed and the user is returned to the original invoking application. The advantage to this option was visual feedback the user would feel as if it had been built into the Webworks framework and created a fluid native feel to this highly user requested feature, as I was switching into a cascades barcode scanning application. Unfortunately with the card invocation, an application which did the barcode reading would have to exist on the device prior to launching this Webworks application. In addition to this pitfall, Webworks in its current state allows for the ability to query potential cards to handle jobs and the ability to invocate these actions, but was unable to return values. This is an issue if the developer wants to capture a QR code and use this value in their own application. I however did not look into copying the barcode into the clipboard or providing the option to do this however this extra step could be potentially approached by other developers that are fine with running a utility application and a Webworks application.

Overall the experience on BlackBerry 10 with the Webworks framework has been an enjoyable opportunity into the world of mobile web applications. With the ability to utilize open source community driven libraries, BlackBerry has helped build an environment to utilize rich web applications with the raw power of the BlackBerry 10 platform. I look forward to seeing what new applications and innovations can arise from this new way of hybrid mobile/native development.”

You can check out the growing list of BlackBerry 10 WebWorks extensions on our Github repository. The university term is wrapping up now, so our next UCOSP update will have the final thoughts from our last two students and an overview of what the students were able to do this term. If you’re interested in doing some open source coding yourself, I’m putting together some projects for the summer. Contact me through email or twitter.

Perhaps the largest single contribution from UCOSP students was recently pushed to our WebWorks-Community-APIs repository: A Barcode Scanning extension for BlackBerry 10 WebWorks. Two students started working on this during the initial hackathon at Facebook. Before I talk any more about it, let’s hear from Mike, who did the first coding and bulk of the C++ investigation:

“My semester working with Blackberry under the umbrella of UCOSP has been a very rewarding and enjoyable experience. Not only have I learned a great deal and gained invaluable new skills and experience, but I have also built on my previous experiences with GitHub, C++, and mobile Blackberry WebWorks development. From the semester-opening code sprint at Facebook HQ, to finishing a native WebWorks extension, to developing and testing a Blackberry 10 mobile app, working on this project has been an enlightening and rewarding journey.

I have spent the bulk of these past four months contributing to the Barcode Reader native C++ extension for WebWorks with my colleague Alex Kwan and mentor Tim Windsor from Blackberry. The idea of creating native C++ libraries that can be invoked from a Javascript layer was intriguing to me right from the beginning, and I wasn’t disappointed in choosing this option. My contribution was mainly for the C++ portion of the extension, which involved writing code to access the BB10 native camera APIs and attempting to detect barcodes from the camera frames using the ZXing image processing library. Development of the extension initially proceeded quite smoothly. The native APIs for accessing the camera and processing frames from the viewfinder were simple enough and sufficiently documented, and the Zxing library was fairly straightforward to use. Within a month the basic functionality of the Barcode reader was implemented, and our extension was capable of scanning barcodes.

The majority of the challenges involved with this project resulted from attempting to pass the image frames captured by the camera viewfinder back to the WebWorks layer. My colleagues and I experimented with several options; although many initial solutions we tried ended up being infeasible due to various performance-related issues, we finally managed to come up with a solution that works well and the extension is now ready for release.

In addition to working on this exciting new extension, I’ve also had the good fortune of building on my
previous experience with mobile development and creating a new WebWorks app for Blackberry 10. For the remaining week of this term, I’m looking forward to completing and refining my application. The WebWorks SDK is straightforward to use and it’s easy for novice mobile developers to get started with it, and Tim’s Ant build script greatly simplifies the process of building and deploying apps to your BB10 mobile device.

Overall, working with both native extensions and the WebWorks SDK was a great learning
experience, and I would highly recommend developers to contribute extensions for providing any functionality they feel is currently lacking in the Blackberry WebWorks SDK.”

Once Mike had the initial C++ code working, another student worked on wiring in Javascript connections so that it could be called from an extension (I’ve saved that students thoughts for the next blog post in the series). Finally, I took the code at the end to finish integrating it together with some tweaks and testing on different devices. As Mike stated, the hardest challenge was with showing the user what they were aiming at. As the JNEXT interface between C++ and Javascript can only handle string data, we were unable to have the viewfinder paint video or even images directly. The solution in the end was to capture burst images from the camera, save them to the filesystem, and pass the file path to the Javascript layer. The resulting image stream isn’t as smooth as direct painting, but the actual scanning and interpretation of barcodes is unaffected, so users have the ability to aim, and the scanning is as fast as any pure native solution.

This is an outstanding example of what these Canadian university students are capable of, and it’s awesome to be able to work with them. If you’ve been looking for a Barcode Scanner API for your BlackBerry 10 WebWorks app, check it out on Github.

Our open source projects with university students from across Canada have been going superbly this term with many excellent contributions to the BlackBerry Open Source community. This is our second post this term, the first one being about the kickoff sprint at Facebook headquarters. First let’s hear what Amritpal has to say about what he’s been up to.

“Being a part of the Blackberry team through UCOSP has been a world of firsts: contributing to an open source project, bbUI.js, and developing my own mobile application.

In the first month of UCOSP, I was contributing to bbUI.js with bug fixes and features. About three weeks ago, I learned that BlackBerry extended their limited edition device upgrade. From that point, the race was on to create fully functional and entertaining application (who needs productivity!). I chose to create a 2D game in HTML5. Having not created a mobile application before, the entire process was a learning experience that encompassed the canvas element to using bbui.js in real life applications.

During the process, my go to resource was the BB10 Sample apps repository. With a variety of applications that make use of a diverse set of BB10 elements, it provided helpful launch pad and reference. I was able to use code to get my application set up (config.xml and index.html examples specifically), and see examples of API calls, and bbUI.js use cases.”

Here are some helpful tips for a new BlackBerry 10 WebWorks developer:

1. Set up your development environment such that you don’t have to recompile after every modification. (See http://devblog.blackberry.com/2009/12/update-your-blackberry-widget-without-recompiling)
2. Test your application on device frequently! Don’t assume Ripple is an exact replication of the BlackBerry 10 experience. From my own development experience, I had my biggest ‘oh-no’ moment when I tested my application on device after hours of development time and it was not functioning properly. After dreading the hours of reverts I would have to make, I was able solve the issue through a quick search on the WebWorks forum.
3. Finally, use the Web and WebWorks Development forum! Tips, helpful developers and an archive of other issues faced by developers

Since this posting is somewhat delayed from when Amritpal initially wrote it, his application has actually been approved so you can download it to your BlackBerry 10 device and check it out. Another student, Willie, had this to say about his work so far:

“Since the code sprint in mid-January, I mostly focused on getting myself acquainted with BlackBerry WebWorks and the bbUI.js components. Working on bbUI.js allowed me to get my feet wet with mobile web development, and the entire project is a great resource to get acquainted with Blackberry and developing web applications on the platform.

I’ve been mainly focusing on developing a mobile application using HTML5 and jQuery Mobile with PhoneGap to test and deploy on BlackBerry 10 (a health activity tracker). This has been my first experience with mobile development and in the past month it’s been extremely rewarding. Working with the various PhoneGap plugins that is provided allowed me to access the Blackberry camera functionality easily and the built-in Ant build and deploy scripts make it very easy to test on an actual device. The next step is to add bbUI.js elements to give any application a native look and feel, which is all easily accessible on GitHub.

As the technical lead at a mobile health technology startup, it’s been challenging to navigate through the mobile space and its fragmentation. BlackBerry 10 WebWorks has provided an easy and logical way to develop for the BlackBerry 10 platform while also giving the flexibility to use web frameworks that can work on a variety of platforms. BlackBerry has made the development process smooth and seamless for even people inexperienced with mobile development to jump in!

For the rest of the term, I’m looking forward to completing/refining my application and also continue contributing to bbUI.js”

As you can see, the students are doing some great work. In our next update we hope to showcase some achievements in WebWorks Extension development. Until then, maybe you’d like to get involved in Open Source at BlackBerry?

(Our Hackathon space at Facebook)

This is our second term working with the UCOSP organization, with a team of students from across Canada. This term we have 8 students, and I’m thrilled with what they’ve been able to accomplish already. First let’s hear from Karan Khiani, of the University of Ottawa, who is a returning student from last term:

“This past weekend has been a great mix of work and play. We were a huge group of people coming together from all around Canada to hack together for a whole weekend. We all gathered for a weekend in Palo Alto, CA and got to do our hacking at the Facebook Campus. From the moment we got to the campus for the first time (I learnt that Facebook is located on 1 Hacker Way) right to the time we left the campus (I learned that 82% of traffic on Facebook.com comes from outside USA) it was a weekend of discovery.

“Apart from having the opportunity to experience the work culture at Facebook, we managed to get quite a bit of work done ourselves. By happy coincidence, BlackBerry was hosting its final port-a-thon for the BlackBerry 10 platform. This was great timing for me as I was just about ready to get my first BlackBerry 10 app into the app store. By the time I finished my first app (a bucket list app), I had become quite familiar with the development process for the platform. This enabled me to spend another few hours to also come up with a second app (“Clock of Death”). The fact that BlackBerry 10 apps are developed using web technologies made things really convenient for me as I have a fair amount of experience working as a web developer.

“The folks at BlackBerry have done a great job with all the frameworks they have published to make things easier for app developers. That, combined with the power and flexibility of HTML5, makes the entire journey quite smooth! I can’t wait to come up with a killer idea for my third app.”

With 8 students, including 2 returning from last term, we are able to work on a few different areas at once. As a top contributor to bbUI.js, and now with a couple of applications developed using WebWorks, I’ve asked Karan to work on a new template for bbUI.js applications so that new developers have quick starting points for applications using bbUI.js. Two other students with strong C++ experience will be working on WebWorks Extensions using the new Template, and the other four are each contributing to the bbUI.js framework. Now let’s hear from one of those students, Haixuan Chen of Simon Fraser University:

(Team members join a BBM group on their new Dev Alpha devices)

“It was a great experience to meet with a bunch of new faces from other Canadian universities, to work on a new mobile platform (BlackBerry 10), and to use a new version control system (GitHub). Everything is new, but a lot of fun too!

“I have had some experience of building web applications using various frameworks, and basic experience with jQuery for front-end UI. But using HTML5, CSS3, and JavaScript to build mobile application is a brand new wonderland to me.

“Thankfully, Tim has a magic handy Ant build script, which greatly simplifies the process of building and deploying applications. I have already tried the bbUI.js samples at home. So on the first day of the hackathon, I started with the WebWorks extension sample. But I’m more interested in HTML5 and CSS3, so I spent the rest of the weekend working on bbUI.js. We have two students, Karan and Hidaya, who have already worked on bbUI.js for one term. They transferred a lot of valuable experience to newbies like me during the event. By the end of the weekend, I had submitted two pull requests regarding two bug fixes in bbUI.js. More importantly, I had gained a clear picture of the complete workflow of developing a new feature in bbUI.js, and the relationship between WebWorks framework and the underlying native device APIs.”

The students have already been hard at work with coding over the last few weeks and it’s exciting to see their progress. You can see what the students and our other open source developers are working on by checking in on our open source repositories, and perhaps you’ll find a project that you’d like to contribute to as well.

“The past two months have definitely been busy times yet also they have also been a highlight in my four years of university studies. Not mentioning the various school projects that I had to make, I had the honor of working as an open source developer for RIM and for the new BlackBerry 10 device. While learning how to properly use the various SDK’s and programming tools has been time consuming (at least for me), it was thoroughly satisfying to see the app I designed or the extension that I have implemented slowly evolving into something I am proud of. Despite the various tools that I attempted to master in the past two months, I would like to write a little bit specifically about the Native SDK that I had used.

The Native SDK contains a set of tools that greatly aided in my quest to write code for apps or native extensions for the BlackBerry WebWorks SDK. It might sound strange to use one SDK to write code for another SDK, but that is how awesome the program is.

Focusing on the app writing component, the Native SDK contains QNX Momentics, which is an Integrated Development Environment. Momentics has a very user friendly GUI. Based on the open Eclipse IDE, developers who are familiar with Eclipse will find Momentics very simple to master, which is certainly the reason that I chose it to write several testing apps for my native extension and a gaming app.

To write an app, there is the option of using Cascades. Cascades is a framework that is very flexible when it comes to integrating GUI components and your actual code. It uses a mixture of QML and C++. As a developer, you have the option of using both, or either one of them. QML contains numerous UI elements that can be ported onto the phone, while the C++ side allows developers to easily implement the various logics needed for their apps. In addition, the two can be easily combined; one side can easily call the other with only a few lines of code. Apart from using the BlackBerry WebWorks SDK to create apps using JavaScript and HTML5 (which is another excellent way to write BlackBerry 10 apps), I found that Cascades and the Native API simple to learn and flexible enough for wide varieties of tasks.

A few words of advice when integrating C++ with QML:

• Don’t forget to add Q_INVOKABLE in the header file for methods that will be called by your QML code.
• If you do decide to write C++ code, be sure to create your QML Page, NavigationPane, or any AbstractPane that you decide to use, in C, or else your C code would not be able to have a pointer to such page.
• <QmlDocument variable>->setContextProperty(“<Name You Give To Your C++ Class>”, this); is a line in C++ which is needed for your QML side to access the c side.
• ObjectName is a field required for your containers. ID field is only for QML access while ObjectName is used for C++ access.
• And remember to have always fun when creating an app for your new BlackBerry device!!!”

And now, I promised a summary of what we accomplished during the term and what’s being planned for next term. This term was our first time being involved with UCOSP and it was definitely a learning experience. The six students we had participate were all exceptional, and even though they were new to BlackBerry development, they learned fast and are all creating applications to release in BlackBerry World before the launch. One of the greatest challenges we faced was in getting familiar with Git. I told the students that Git is “intentionally hard”, but for next term I intend to put together a getting started guide that will be of use to all our new Open Source contributors, so they get over the initial learning curve easier. Once you get going with Git, it really is pretty great, but at first glance it’s quite daunting.

Our students writing BlackBerry WebWorks extensions were able to create five extensions, which is really outstanding, especially given the short amount of time they actually had to work on them and never having done Extensions before. The students writing for bbUI.js had similar results, getting several updates into the bbUI.js framework as part of version 0.9.5. Most of their updates were in adding dynamic APIs to bbUI.js controls, which is very important for making bbUI.js capable of taking on more advanced application needs.

Finally, our plans continue into next term. We will be working with students from across Canada again on BlackBerry 10 WebWorks projects, and I’m currently investigating some project options. We may do some more extensions and bbUI.js work, but we might tackle a significant project for the benefit of all WebWorks developers. One thing is for sure: I can hardly wait to meet the new and returning students at the kickoff sprint in the New Year and get to work with them.

“Being able to contribute to BlackBerry open source projects has been a real treat. While I am still inexperienced with GitHub, it was great experience to be able to use it in a real world scenario. I knew from the start that I would focus my efforts in the local web apps portion of BlackBerry WebWorks and bbUI.js.

After quickly getting a basic HTML5 web app up and running on my BlackBerry Dev Alpha B, I was keen to dig into creating a BlackBerry specific web app that matched the look and feel of the new BlackBerry 10 operating system. Having had great success, I wanted to share a bit of insight into the key areas for accomplishing this.

If you are like me, you may be used to loading JavaScript on particular HTML pages and then using a window.onload function to get things started.

window.onload = function() {
	//some code!
}

You might do this to grab some data from HTML5 local storage and load some values into your HTML page. With bbUI.js, you won’t be doing this quite the same way! Instead you’ll be using Screens. bbUI.js uses AJAX to load new screens instead of regular old links to load new HTML pages. When loading a new screen, you’ll typically use code like this:

onclick="bb.pushScreen('mypage.htm', myPageID);"

This says to load the new screen myPageID using the code in the mypage.htm file. Simple enough, but now we want to run some JavaScript when this new page (screen) loads and perhaps change or add some elements to the resultant screen.

The key to understand how to use your JavaScript in conjunction with Screens lies with the onscreenready and ondomready functions. Take a look in the index file of the sample bbUI.js app, you’ll see bb.init function and within its constructor, you’ll see code for onscreenready and ondomready. The key difference between these two is that onscreenready represents the HTML code before it is inserted into the DOM, and the ondomready represents the HTML code after it has been inserted into the DOM.

If you are used to using window.onload and accessing the DOM with document.getElementById(‘myEleID’), then you’ll want to put your code within either onscreenready or ondomready instead. Both of these will fire when you load a new screen, first onscreenready, then ondomready. In order to target a particular screen with particular JavaScript code you would have some code like the following:

ondomready: function(element, id) {
	if (id == 'myPageID') {
		document.getElementById('myEleID').innerHTML = locallyStoredData;
	} else if (id == 'someOtherPageID') {
	//more code
}
}

As we saw above, to push a new screen into view you use onclick=”bb.pushScreen(‘mypage.htm’, myPageID);”, now when ondomready is triggered, we use a simple if else statement to determine what code to execute based on which screen was loaded.

So great, myPageID was loaded, and then document.getElementById(‘myEleID’).innerHTML = locallyStoredData; gets executed. This works, and is similar to what we are used to seeing. DOM manipulation, however, can be quite taxing on the system, and you will see a noticeable delay if you try to execute your DOM manipulation from ondomready when you are first loading a screen. To avoid this, we need onscreenready.

onscreenready loads the target screen’s HTML into memory, but it is not yet in the DOM. That means simply moving the code from ondomready to onscreenready won’t work:

onscreenready: function(element, id) {
	if (id == 'myPageID') {
		document.getElementById('myEleID').innerHTML = locallyStoredData; //Fail!
	} else if (id == 'someOtherPageID') {
		//more code
	}
}

This will generate an error: Uncaught TypeError: Cannot set property ‘innerHTML’ of null

Instead, when targeting items by ID, you’ll want to use element in place of document, like so:

onscreenready: function(element, id) {
	if (id == 'myPageID') {
		element.getElementById('myEleID').innerHTML = locallyStoredData; //Success!
	} else if (id == 'someOtherPageID') {
		//more code
	}
}

Further still, if you want to call a function located in another JavaScript file, you’ll want to pass element along, so you can manipulate the pre-DOM HTML data.

onscreenready: function(element, id) {
	if (id == 'myPageID') {
		doThisFunction(element);
	}
}

…

function doThisFunction(element) {
//still uses *document* for new elements
var newParagraph = document.createElement('p'); 
newParagraph.innerHTML = "A new paragraph.";

//use *element* to target existing pre-DOM elements
element.getElementById('myEleID').appendChild(newParagraph);
}

You’ll notice that in your external JavaScript function, you’ll still need to use document when creating new elements, but in order to insert them into your pre-DOM HTML you’ll want to use element instead of document to target existing elements.

So if you’ve been having difficulties interacting with the DOM in your bbUI.js web app, hopefully this small tutorial was helpful! Of course, the best way to learn bbUI.js is to take a look at some sample applications. I’ve had a blast working with bbUI.js and I am almost ready to submit my first web app to the BlackBerry App World.”

Quality tips that should help other new developers make the most of their time with bbUI.js and BlackBerry 10. Stay tuned for part 2 of the end-of-term blog posts to get hear from our final student contributor, see a summary all that we did this term, and what’s next.

It’s been just over a month since the beginning of the Undergraduate Capstone Open Source Project (UCOSP) project. We’re at the midterm point now, and it’s clear that we’re getting the hang of this whole thing: Github, BlackBerry® WebWorks™, bbUI.js and native extension development. The students have put together three BlackBerry WebWorks extensions for LED, Compass, and Image Thumbnails, with two more in development. We’ve also had a few commits to the bbUI.js project which should be pulled into version 0.9.5.

Let’s see what two of the students have to say about the experience at this point in the project. First is Hidaya Sekkal, a student from the University of Ottawa, who said the following:

“During our code sprint in Kitchener-Waterloo, we were provided with an introduction on how to setup and use our environment (Simulator and Ripple emulator), and received a Dev Alpha device to be used for testing purposes. We also learned how to use the Github and the proper procedure to load and commit bbUI.js applications. An explanation of the different commands used on the Git Shell, the difference between the Next branch and the Master Branch was also provided.

“Our main task was to add features in the BlackBerry 10 open source projects. The task that I was to complete was to add functions to bbUI.js. My first modification was to the Slider control. With the help and support of our mentor, Tim Windsor, I was able to add many useful features (add, remove, disable, enable, hide) to this particular control. The second control that I modified was the Toggle button, which I was able to add similar options to. For my final project I am creating an application to detect BlackBerry devices using the PIN number assigned to each device, and the HTML5 Geolocation API. I was able to finish the first part of my project, the detection of the Geolocation Data. This experience of working on the open source BlackBerry projects was both an honor and a great learning experience for me, which I will apply to my future career endeavors.”

The second student commenting on his experience so far is Arman Fallah from the University of British Columbia, who has an outstanding hint for extension developers:

“It’s been a little more than a month and my UCOSP experience is far from over. Being a part of the BlackBerry GitHub community has shown me how open source communities can bring developers together to solve any problem. I’m currently working on the Unzip/Zip extension for the BlackBerry 10 Native SDK.
My first C/C++ Extension contribution to the Native SDK exposed the compass sensor functionality for BlackBerry 10 compatible devices. This extension allows users to monitor the compass sensor to get real-time leading information–a good candidate for that native-accelerated compass app in the future.

One thing that helped me to accelerate my development process was to add some pre-build and post-build steps for my Eclipse project.

Pre-Build:

cp -r ../../../javascript_src/* ../../../output/community.compass/; cp -r ../public/* ../../../native_src/public/; cp -r ../src/* ../../../native_src/src/; cp -r ../../../TestApplication/* C:/Users/<Username>/RippleSites/TestApplication/

Post-Build:

mv compassJnext.so ../../../output/community.compass/device/; cp -r ../../../output/community.compass/* <Path to SDK Directory>/Framework/ext/community.compass/

“Before this addition, I would have to move folders around every time I wanted to package and sign the application. Now, everything would be put in their place and I could open up Ripple, package, sign, and deploy.

“Planning for that final application at the end of the program is coming underway and I hope to deliver something to the app marketplace that will be worth some coin.”

Anyone who’s been a student can appreciate that goal. Ramen noodles lose their appeal for everyone eventually, and let’s not even get started on student loans. For the end of the term, each student is working on their own application which can be either fully open source, or closed source built with open-source components. I’m looking forward to hearing their plans and working with them to bring their applications to the BlackBerry® App World™ storefront.

If you are interested in getting involved in our open source development, check out our site on Github.

This past weekend I participated in the kickoff sprint for a truly remarkable program: The “Undergraduate Capstone Open Source Projects”, or UCOSP. It’s a program offered by Canadian universities, where students contribute to open source projects for course credit. This term there are more than 50 students involved from 19 universities. Six of them – students from UBC, Laurentian, Ottawa, and Waterloo – will be working with me on BlackBerry® Open Source projects, such as bbUI.js and our community BlackBerry® WebWorks™ extensions.

Despite being new to mobile, open source, and BlackBerry development, most students dove right in and were able to contribute right away. Here’s what Andy Wu had to say about the weekend:

“I had a wonderful time at the UCOSP sprint over the weekend. Walking in with no previous open source development experience, I had no idea what to expect. Our mentor, Tim Windsor was very nice and helpful; he helped us getting started with minimum down time. He showed us the basics of BlackBerry development, including application signing, packaging and deployment to the test device. My first assigned task was creating a BlackBerry 10 native extension that exposes the LED API to JavaScript. The BlackBerry 10 NDK was super easy to pickup with the sample codes provided. I was able to get the extension working with a test application by the end of the weekend. Before the weekend ended, I used the fork and pull request on GitHub for the first time. This is my first step to the open source world.”

Based on skillsets and interest, one half of the group is focused on extensions developed with C++ and JavaScript®, while the other half enhances the bbUI.js project for BlackBerry® 10. Karan Khiani, one of the students working on bbUI.js, said:

“This weekend has been quite breathtaking – coming together with likeminded people to work on the BlackBerry 10 platform has been a really rewarding experience. Tim guided us through the initial process, briefing us on the BB10 platform as well as guiding us in terms of the projects that we would be working on through the semester. We were given plenty of flexibility in picking between native application enhancement (C/C++) or UI enhancements using web technologies like HTML 5 and CSS 3. I decided to go with the web project.

“Upon arriving to Waterloo for the weekend, each of our team members picked a task that they would like to accomplish in the next few days. The task I picked was enhancing the functionality of some of the input controls for the BlackBerry 10 front end. This involved forking the existing repositories, writing the code that would add the functionality, testing the code and making a request to merge it back to the central repository. Luckily for me, I managed to finish all my tasks just in time before I had to leave Waterloo for the weekend.

The most refreshing aspect of my entire development experience was that I was able to set up my development environment in a matter of minutes. I look forward to spending the next few months with the guys at RIM and chipping in as much as I can for the BlackBerry 10 platform.”

As participants in our open source development community, you’ll be able to follow their contributions on our GitHub repositories and start using their updates in your own applications. Go there now to see the first pull requests that they have made. We’ll post other updates from different students in early November and again in December, while I’ll be tweeting updates and anecdotes from my account @timothywindsor with the hashtag #bbucosp. If you would like to join our growing community of open source developers, get in touch with me today!