The Wholesale Application Community is looking for your input

The Wholesale Application Community is looking for our feedback!

If you are a mobile developer, we would like to encourage you to take some time and provide your input through The Wholesale Application Community‘s developer survey.

What is the Wholesale App….. WAC for short :-) you might ask? The definition on their site describes them as follows:

“The Wholesale Applications Community has been established to increase the overall market for mobile applications. WAC will achieve this goal by encouraging open standardized technologies, driving scaled deployment of those technologies and providing complimentary commercial models. This will allow developers to deploy a single application across multiple devices (through the use of standard technologies) and across multiple operators (without the need to negotiate with each of them). WAC will provide the commercial enablers which will allow the developer to be paid for the applications which are then sold through any associated application store.”

However the blurb in the FAQ section of their site gives a better idea of who makes up WAC:

“The Wholesale Applications Community (WAC) is an open, global alliance formed from the world’s leading telecoms operators. WAC will unite a fragmented applications marketplace and create an open industry platform that benefits the entire ecosystem, including applications developers, handset manufacturers, OS owners, network operators and end users”

So what? why should we care?

We think this is a great opportunity to raise our voices as mobile developers and have a chance to influence the direction of a new framework. WAC will be based on the JIL, BONDI, GSMA OneAPI, and W3C specs. WAC is taking a great step by involving the developer community early on in the process. Let’s take a minute or two and help shape what could be a great platform.

How often do we get a chance to give our opinions on a platform that will ultimately allow us to publish our applications to nearly 3 Billion consumers?

JIL on Android: Thoughts

The Android release of the JIL Widget Manager came out a little while ago with support for Android 1.6 and 2.1. You can download the Android (or Nokia S60) runtime here, listed under “Widget Run-Times”.

Installation

Installing the widget manager and runtime is pretty straightforward. You download the .apk file to your sd card, then install it as an Android app. (Installed as the “Apps” application). From there you can open .wgt files (using a file browser like Astro) and promptly install them with the widget manager. Configuration is more flexible on this runtime as it seems able to install JIL 1.2.x and 1.0 based widgets as well as Opera based widgets.

Now you are rocking the JIL widget manager on Android, time to see what it can do.

First Thoughts

The Android version of the JIL runtime and widget manager seems to be built upon Opera Mini’s widget manager with extra support for JIL baked in. This also means it’s a presto based rendering engine (unlike LiMo’s widget manager). Webkit would of been a much better renderer to go with in my honest opinion (like on LiMo’s runtime renderer), but building upon and leveraging the Opera runtime it can provide some extra capabilities for developers such as remote debugging (with Opera 9.64) and a baked in widget manager.

All in all I’m still very giddy to get my hands on this upcoming widget manager.

Continue reading

Mobile Widgets – Dynamic Layout Example

This is the third post in our on-going series on Mobile Widget development. The first two can be found here:

Mobile Widgets – Persistence Cross-Platform Wrapper
Mobile Widgets – a primer

Over the past few weeks we’ve seen many developers gravitate towards using Position: fixed in their CSS to pin their widget’s header and footer to the top and bottom of the screen respectively. Although this method does work, it’s not the best, nor do all mobile rendering engines support it. There also seems to be a performance issue with regards to rendering. Scrolling content will often make the header and the footer flicker (very visible on the Nexus One using the new Vodafone Widget Manager).

In this article, I would like to present a different approach to solving the same problem. This approach will attempt to also solve the following:

  • Allow for dynamic resizing when switching between portrait and landscape modes
  • Render properly on different screen sizes
  • Render properly on screen sizes with different PPI (Pixel Per Inch) densities (supported, but not shown here. You’ll need to use CSS media queries)

This layout should work for JIL Widgets, Opera Widgets, as well as plain old HTML5 mobile websites.

Let’s get to it!

Continue reading

Beta: A walk through The Ripple Emulator’s features

The Ripple Emulator Goes Beta

Update: For a thorough tour of Ripple in it’s latest form, check out the Ripple Docs here.

Today is the day we launch the Beta version of The Ripple Emulator, a browser based mobile emulator. So we thought we’d explain the current feature set to help you get started and on your way to building and testing mobile widgets faster. Before we get started, here’s how you can get Ripple and what you’ll need to know to run it:

Download:

Requirements:

  • You need to have the Google Chrome browser installed on your computer. You can download it here if you don’t already have it: http://www.google.com/chrome
  • If you’re working with mobile widgets on your computer, you’ll need to run a local HTTP server. This is due to an upstream bug in WebKit and we expect this requirement to go away shortly

Getting started:

We’ve created a Demo Widget that you can load into Ripple. The demo widget will walk you through all of the features currently available in Ripple in a wizard-like format. All you have to do to get started is:

  • Point your browser to: http://ripple.tinyhippos.com/demo
  • Click on the Ripple icon at the top right of your Chrome Browser (once you’ve installed Ripple, of course)
  • Follow along, to play with all of the features available in Ripple

Stay informed:

Along with the Beta release of Ripple, we will also be adding to our online presence with some goodies and help for the widget development community. Here are the various ways you can keep up to date:

  • The Ripple Product Site (which will be launching in the next day or two): http://ripple.tinyhippos.com/, here you’ll find information on Ripple as well as a community forum where you can interact with other Ripple users as well as get advice and ask questions related to mobile widget development
  • This Blog: We will continue to post about new features, provide sample code, and resource to help the mobile widget development community
  • Twitter: follow the @RippleEmulator and @tinyHippos accounts

Features of The Ripple Emulator (Beta)

Continue reading

Mobile Widgets – Persistence Cross-Platform Wrapper

This is the second post in our series on building Mobile Widgets. The first post was an introduction to Mobile Widgets.

Mobile Widgets – a primer

In this post we will build a persistence library that works across multiple platforms and abstracts away the differences of those different platforms into a common set of methods.

Seeing that we are also about to release our Ripple Emulator, we will be using it for our testing to showcase the built-in persistence view and platform switching capabilities of the Ripple Emulator.

Lets get started…

Continue reading

Announcing The Ripple Emulator beta launch – 20 days to go

Wondering what the tinyHippos have been up to for the past few months??  Well – if you haven’t had the pleasure of attending a local event in the Kitchener/Waterloo region where you would have been captivated by our demo…  then you are in for a treat!  The boys are finally ready to come out of stealth mode and show the world!

When are we launching?

On April 27th, 2010 tinyHippos will be releasing the Beta version of our “Ripple Emulator”.

Please join us for our launch party at The Barley Works in Waterloo, ON. Please get a ticket here as space is limited.

Continue reading

JIL Mobile Widget API

Over the past few months we’ve been hard at work building a product that will help mobile widget and mobile web developers better test, debug and deploy their mobile applications. We have started by supporting the JIL mobile widget platform but have been struggling with gaining access to the information we need as well as getting answers from JIL.

Since we believe in the JIL platform and the good that Mobile Widgets will bring to the market, we decided to try and help the community ourselves. We will start posting on a regular basis with any information we think will be helpful to JIL Mobile Widget developers.

The first step is to let everyone know that we’ve created an open gitHub repository into which we’ve checked in Beta 2, 3, and 4 of the full JIL JavaScript API (publicly available from JIL). We did this to allow us to easily see the changes that have been taking place between the different beta releases. The documentation that has been provided by JIL was lacking certain key changes and that was the driving force behind us taking this action.

You can read some more details on our post to the JIL.org forums here: http://www.jil.org/jil-forums/posts/list/307.page

The gitHub repository can be found here: http://github.com/tinyhippos/JIL-API

If you are a JIL Mobile Widget developer and would like to help out by contributing code snippets, advice, etc. Please let us know. We’re currently working on putting together an independent JIL developer community to help our fellow developers get the answers and help they deserve. We’ll blog about that very shortly with more details.

In the mean time, please fell free to leave us a comment here if you have any suggestions.

Mobile Widgets – a primer

This is the first in a series we will be writing over the next few weeks, introducing Mobile Widgets, the different platforms, and why we think they could very well be the future of mobile applications. This article is the primer, an introduction if you will.

Today…

…there are two major and well accepted ways to deliver mobile content to the end consumer. Native applications and the mobile web.

A native mobile application is an application that is installed and runs on the phone, allowing the user to have access to phone functionality such as GPS, contacts, camera, accelerometer, etc. These applications have robust features and tend to work and feel as if they are part of the phone. The challenge here is that they are platform specific. Meaning; if you’ve built your application for the iPhone, you’ll have to re-build it for Android, Blackberry, Symbian, etc. if you want to be able to deliver it across multiple platforms.

The mobile web refers to building a website that is easily accessible to mobile devices. Meaning that it sizes correctly to the mobile device accessing it and delivers it’s content in such a way as to make it easily consumed on the reduced screen real estate available on a mobile device. Many developers are adopting this approach because it allows users on different mobile platforms to access their content. The drawback with this approach is that a mobile website does not have access the same breadth of phone functionality that a native application has access to. Yes, some of the newer mobile web browsers will give websites the ability to retrieve GPS information from the mobile device accessing them (the user has to explicitly approve this), but that is about all they get. HTML 5 is also allowing for much more complex applications to be written (see the Google Voice mobile application).

I’m here to tell you that there is another option! Mobile Widgets have entered the scene and we believe they will change the mobile application development landscape.

What are Mobile Widgets?

Simply put, mobile widgets are mobile applications that are written using web technology (HTML, CSS, and JavaScript) and have access, through a common API, to pretty much all of the mobile phone’s native functions (very much like the native applications mentioned earlier). These mobile widgets are downloaded and installed on a phone the same way native applications are, but since they run on top of common Web Runtime which implements the W3C Technical Recommendation for widgets and then some, it makes them cross platform compatible. That’s right, you can now build your application once and deploy it to multiple platforms. Here is another article on W3C widgets for your enjoyment.

Sounds too good to be true…

It is too good to be true! The above statement is where mobile widgets want and should be. However, much like in the rest of the mobile market, there is fragmentation! Multiple run times, that don’t work exactly the same way and which are not supported to the same extent on all mobile devices that are advertised to support mobile widgets. However, even with those limitations in mind and the platforms being in their infancy (i.e. most are still in Beta), mobile widgets will allow you to, at the very least, re-use a very large percentage of your applications as you port them to different platforms!

The players

There are several big players working hard at trying to bring mobile widgets to a mobile device near you. There is an estimated 1 billion hand held devices in the wild today that will be able to support mobile widgets, compared to the 60 or so million iPhones out there. This number, I’m sure, is making mobile widgets attractive to many. Here are the players involved today (if you know of any that I haven’t mentioned, please feel free to leave a comment).

JIL.org is short for the Joint Innovation Lab; a collaborative effort by Vodafone, Verizon, China Mobile, and SOFTBANK. These large network providers have also teamed up with the following hardware manufactures; RIM (Blackberry), Samsung, Sharp, LG, Dopod, Nokia (supported through a Vodafone runtime installed on the S60 v3 and v5 OS). JIL has created a Mobile Widget API that allows for great access to native phone functionality such as calendar, contacts, camera, accelerometer, local storage, and many more.

Nokia has had widgets for quite a while now. Their widgets run under the Nokia Web Runtime (WRT) and although they are different from JIL, they are remarkably similar as well. Nokia might have fallen behind in sales here in North America, but they still have the largest market penetration across the globe!

RIM, LG,  and Samsung have each published their own widget implementations, even though they will be supporting JIL. This is a little confusing to us, but then again, no one said this market is very clear to begin with. RIMs implementation of their own native widgets is especially frustrating since those widgets are very much proprietary and in my opinion go against the idea of what mobile widgets should be.

Till next time…

In my next article I’m going to expand on widgets in more detail. Talking specifically about JIL and trying to cover the good the bad and the painful aspects of the current implementation as well as where I see things going.

I leave you with another article on a similar topic: http://www.quirksmode.org/blog/archives/2009/11/native_iphone_a.html

Follow

Get every new post delivered to your Inbox.