Curious as to what the differences are between Icenium and PhoneGap Build? Good, then hopefully you've come to the right place! First - let's talk disclaimers. This, as you've probably noticed, is the Icenium blog. I am a Developer Advocate for Icenium. I love what we do, I love hybrid mobile development and I'm deeply excited for the present and future of all things Icenium. It's my desire and intent to provide an intellectually honest comparison of PhoneGap Build and Icenium, but I would be lying if I said I didn't prefer Icenium. Regardless, we all stand on the shoulders of giants. Had the developers at Nitobi not worked so hard on the original PhoneGap (now Cordova), both Telerik and Adobe could very well be pursuing other mobile options. The Nitobi crew - many of whom are currently at Adobe - have done (and continue to do) incredible work. They have our deepest respect & admiration - and some might accuse me of having a "developer crush" on the whole lot. With that being said, let's take a look at a high level comparison of where Icenium and PhoneGap Build overlap and differ – but first, let's make sure we know the gist of what they are.

Icenium

  • Set of cloud-based tools to enable you to develop, test (in simulator and on device[s]), build hybrid mobile apps for Android and iOS as well as publish them to the Google Play and Apple app stores.
  • Uses Apache Cordova to let you target multiple mobile platforms with one code base.

 

PhoneGap Build

  • The PhoneGap Build website defines it as "a cloud-based service built on top of the PhoneGap framework. It allows you to easily build those same mobile apps in the cloud".
  • Uses PhoneGap, which is a branded re-distribution of Apache Cordova.

 

So - both Icenium and PhoneGap are geared towards enabling you to build natively-installed-and-run mobile applications using HTML, JavaScript and CSS (since they both utilize Apache Cordova) - and by "build" in this case, I mean actually create installers for your app. Now, on to the high level features of each:

Icenium

PhoneGap Build

Integrated Version Control Support

Any git provider (github/bitbucket, etc.)
github (preferred)
(other git providers possible)

Integrated IDE

Mist - Cloud based IDE
Graphite - Windows IDE
(see note* below table, there are external options)

Mobile Platform Support

iOS, Android iOS, Android, Windows Phone, Blackberry, Symbian, webOS

Provision-less Testing/Reviewing for iOS

CLI/API (for Integration)

(this is on Icenium's road map)
(HTTP API)

Integrated Simulator

Integrated Debugger

Mist - host Browser's dev tools
Graphite - provides WebKit Web Inspector.
(Weinre is on Icenium's road map)
Uses Weinre
(see note** below as well)

Direct-to-App-Store Publishing

Project Collaboration

Collaboration via git
(future collaborative features planned)

Supported Cordova Plugins

ChildBrowser, BarcodeScanner, SQLite, PushPlugin ChildBrowser, BarcodeScanner, Analytics, GenericPush, FacebookConnect

* Regarding IDE integration - while PhoneGap Build doesn't have an integrated IDE, there are extensions to use Brackets/Edge Code with it. Dreamweaver also has built in support for it.

**The recommended option for running a simulator for PhoneGap/PhoneGap Build project is the Ripple Emulator.

Looking Further

The matrix above is only a starting point. It should be obvious that there's quite a bit of overlap in the kinds of problems both Icenium and PhoneGap Build set out to solve. However, even in the overlap, there are some key differences – let's take a look at some.

 

How Does My Code Get There?

Both Icenium and PhoneGap Build support git integration - allowing you to pull code from a repository hosted, for example, on sites like github. PhoneGap Build also allows you to upload a zip archive of your application (you make the choice between uploading a zip and connecting to a git repository as you set your PhoneGap Build project up). Icenium provides a cloud-based IDE (Mist) and a desktop IDE (Graphite - but only on Windows) in which you can edit your project. Mist and Graphite both make use of git integration, so you can push/pull/commit/rollback/etc to/from remote repositories. You aren't required to use a remote repository either - you can create a new project in Mist or Graphite and use the built-in version control (still git, btw). Mist also supports uploading files contained in a zip archive.

 

Approach to Debugging

PhoneGap Build supports running weinre. If you run a debug-enabled build and deploy it to your device, you can launch a debug session from your project's page in the PhoneGap Build website. Weinre effectively allows you to remote debug the app running on your device, giving you a lightweight version (e.g. - console, DOM inspector, resource list) of WebKit tools you're probably already familiar with if you've used Chrome or Safari's debugging tools (or iWebInspector). Weinre can be very useful, but don't expect the full range of tools offered by Chrome - nor the stability. Weinre debug sessions can tend to fail for no apparent reason, at which point you need to re-launch the app and start a new session. You can also use Ripple, a Chrome Extension that lets you run PhoneGap applications in a browser-based simulator (which mocks the Cordova APIs).

While remote-debugging-via-weinre support is on the Icenium road map, Graphite supports remote debugging of provisioned iOS devices (running iOS 6) using the Remote Web Inspector. Mist and Graphite also allow you to run and debug your application locally. Graphite provides WebKit-based tools while Mist will use the debugging tools of the host browser. It's worth noting that if you're running a device simulator in Mist, it will auto-refresh as you make changes to the code. Since these are hybrid mobile applications, local debugging is possible if the Cordova API is simulated (it is). The trade-off here, of course, is that better debugging tools are available while the actual DOM & JavaScript runtime implementation on the device will differ from the locally hosted version you're using to debug your app. That being the case - be aware that you might not catch issues with any implementation-specific features until you test it on an actual device.

 

Running Builds & Downloading Installers

When it's time to test your application on your device, you have several options. With PhoneGap Build, you can download the platform specific installer (and install it on the device yourself), or you can scan a QR code from devices that support direct installation (Android, Symbian and Blackberry) and follow the platform-appropriate instructions to download and install the application. PhoneGap Build also supports "Hydration" - it's a build option which you can enable, causing client devices to check for new versions of the app and auto-update the app if one exists.

With Icenium, you can download the app installer as well (by choosing the Run -> On Device option). You can also run the app in the simulators provided by Graphite and Mist. If you're using Mist, Icenium Ion provides a nice way to quickly deploy and test applications on iOS devices - getting around the usual headaches associated with provisioning an iOS device (provision-less testing). To use Icenium Ion, you need to install it to your iOS device (it's free in the app store) and you will also need a QR Code scanning app. Then, in Mist, you'd select Run -> On Device -> Icenium Ion (under iOS). Scan the QR code that appears on the screen with the iOS device, and Icenium Ion will launch and download your app and act as a container for it to run on your device. You can refresh the local copy of the application by using the "three finger long tap" gesture. When you install an Icenium build on an Android device, you can refresh the client by pressing the menu button.

One other interesting feature of Icenium when it comes to running your apps on a device is Icenium LiveSync. When you're using Graphite, LiveSync allows your changes to be immediately reflected not only in the local simulator, but on any connected device (and you can control which devices refresh automatically, etc.).

 

Collaboration

You can add collaborators to PhoneGap Build projects using the role of "Tester" (read only access) or "Developer" (read/write). Testers can only download the application, while developers have more control for other tasks (other than deleting the project or managing signing keys). Icenium doesn't currently (hint hint) offer anything beyond a single-user login for Icenium projects, however it's possible to collaborate via git.

 

Publishing

As mentioned earlier, PhoneGap Build allows you to download the device installers. You'd then take these binaries and submit them to the appropriate app stores - with iOS, Android and Blackberry apps, this entails providing the correct signing keys/certs too allow for distribution.

Icenium supports direct-to-app-store publishing for Andoid and iOS via the "Publish" option in both Graphite & Mist.

 

Wrapping Up

Both Icenium and PhoneGap Build attempt to solve similar problems, with perhaps a slightly different philosophy. Both can tie into existing development workflows. Both plan for better custom Cordova plugin support in the future. Icenium currently focuses on the largest two mobile platforms, enabling you to build an app end-to-end (development to publishing) for both. PhoneGap Build currently supports more platforms, but leaves publishing up to you. Icenium has focused on providing a usable cloud-based development and debugging story, where PhoneGap Build provides weinre/remote-debugging support, and doesn't currently weigh in with any code editing capabilities of its own. At Telerik, we are very excited about the current and future feature set of Icenium, and really believe we're onto something when it comes to solving the pain of developing, debugging and publishing hybrid mobile applications. Proponents of hybrid mobile like to point out that enabling developers to use existing skills in HTML, JavaScript and CSS reduces the barrier-to-entry for mobile development. We agree, but feel that the lack of good tooling in this space has undermined (and in many cases, negated) the initial skills-reuse gain. With Icenium, we're providing a comprehensive set of tools to make the gain of re-used skills and expertise something that developers can fully realize.

Having said that - if you're new to hybrid mobile development, or if you've been using PhoneGap and PhoneGap Build, why not give Icenium a test drive to see what you think? We'd love to hear your feedback so we can pass it on to our product team!

 

Coming Soon to Icenium

Icenium has some exciting features on the roadmap, including some of the following:

  • Everlive - releasing in May as part of a feature preview. Everlive is a back-end-as-a-service offering, making data storage and synchronization-between-devices a snap.
  • A command line interface/API for integrating external tools (like IDEs) with Icenium
  • Windows Phone 8 support
  • Custom Cordova Plugins support
  • Transpiling for CoffeeScript, TypeScript, Less and more
  • Ion for Android & Windows Phone 8
  • Ternjs support in Mist (and other Mist enhancements)


About the Author

Jim Cowart

Jim Cowart is an architect, developer, open source author, and overall web/hybrid mobile development geek. He is an active speaker and writer, with a passion for elevating developer knowledge of patterns and helpful frameworks. 

Comments

Comments are disabled in preview mode.