Pages

Ads 468x60px

Tuesday, March 25, 2008

Shozu -One to Watch #10

London-based Shozu has reason to be pleased with itself. Last year, it scooped a GSMA award for 'Most Innovative Mobile Application' and has since been somewhat of a benchmark when it comes to sharing and uploading content from mobile to web as well as share content purely with other mobile users.

Shozu also recently raised $12m in new venture financing (Series C funding) and is supporting the growth in partners and integrations with other social networking or multimedia sharing sites. The list of partner sites is long, from Picasa to Flickr, from YouTube to Seesmic and from Facebook to Blogger.

They also recently announced that they had struck up a deal with 3 for its one-click mobile-to-Web image uploading service for mobile phones to be amongst a handful of applications featured on 3neXt, a new mobile applications community website from mobile operator 3. The site is designed to aid consumers in finding innovative mobile lifestyle applications that fit 3's focus on mobilising the Internet, as reflected in 3's X-Series phones introduced last year.

ShoZu currently supports 250 Symbian, Java, Microsoft Windows Mobile-based and BREW devices available from multiple manufacturers. The ShoZu service can also be used with select WiFi-enabled mobile phones such as the Nokia N80 in Europe and Dash in the U.S., permitting multimedia files to be routed over users' home, office or WiFi connection (or AirPort connection for Mac users) rather than the cellular network to reduce data transport costs.

I'm looking forward to listening to and exchanging views on Shozu's future plans with its CEO, Mark Bole, who will be presenting next week at the Mobile Internet Conference in Berlin. I will, of course, keep readers posted on salient points of the presentation.

Thursday, March 20, 2008

AOL acquires Bebo & How to value an Online Social Network









I am deep in the throes of analysing the online social network 'market' for a presentation I am preparing and stumbled across the recent news of Bebo's acquisition AOL for no less than $850m and thought wow!That is a lot of cash!

Bebo was set up in 2006 and now has (only) 100 employees. It achieved significant success early on, when it offered a free trial for 7 weeks in 2006 and obtained 40,000 user sign-ups.It later changed its business model, dropping member fees for a more 'traditional' advertising supported medium.

Having to hand the numbers for the last big acquisition in the sector, that of MySpace by NewsCorp in 2005 for $580m I could do a quick calculation. Given that back then, MySpace had 25 million members, NewsCorp paid $23 for each user.


Fast forward to 2008, and the value of online social networks is clearly on the rise. Bebo has an estimated 22 million visitors (I will assume this means members), so AOL paid a neat $38 for each one, a whopping 65% more than the amount paid for the MySpace members.

As far as I can work out from public information, rival Facebook has about 60 million subscribers (4m of these users of the mobile Facebook site) and in 2007 generated $100m in advertising revenue i.e just under $2 per member per year. At these levels, AOL will require around 20 years to breakeven on its acquisition in terms of ad revenue alone (ok, a simplistic calculation, but a revealing one nonetheless).

One could argue that AOL probably has plans to integrate Bebo with its other business(es) and cross-sell media etc. but based on the social network alone, either AOL knows something we don't in terms of how much advertising can be pumped through the pipes of a social network or they have some cunning plan to create new value from it by some (yet unknown) proposition.

Needless to say, eyes will be peeled for any developments just as much as they will be on the last remaining independent players in the online social network space, like Friendster and Tagged (with claims to 60m and 30m subscribers each).... a whiff of consolidation in the sector is definitely in the air..question is, how much will the next brave acquisition cost and will the premium keep on rising despite a probable plateauing of subscriber numbers across the board...?

Wednesday, March 19, 2008

WikiNotes for Android: Routing Intents

In the last article, we talked about using Linkify to turn wiki words (those that match a regular expression we defined) into a content: URI and defining a path to data that matched a note belonging to that wiki word. As an example, a matching word like ToDoList would be turned into a content: URI like content://com.google.android.wikinotes.db.wikinotes/wikinotes/ToDoList and then acted upon using the VIEW action from the Linkify class.



This article will examine how the Android operating system takes this combination of VIEW action and content: URI and finds the correct activity to fire in order to do something with the data. It will also explain how the other default links created by Linkify, like web URLs and telephone numbers, also result in the correct activity to handle that data type being fired. Finally, this article will start to examine the custom ContentProvider that has been created to handle WikiNotes data. The full description of the ContentProvider and what it does will span a couple more articles as well, because there is a lot to cover.



The Linkify-calls-intent Workflow


At a high level, the steps for Linkify to invoke an intent and for the resulting activity (if any) to handle it looks like this:




  1. Linkify is invoked on a TextView to turn matching text patterns into Intent links.

  2. Linkify takes over monitoring for those Intent links being selected by the user.

  3. When the user selects a link, Linkify calls the VIEW action using the content: URI associated with the link.

  4. Android takes the content: URI that represents the data, and looks for a ContentProvider registered in the system that matches the URI.

  5. If a match is found, Android queries the ContentProvider using the URI, and asks what MIME type the data that will be returned from the URI is.

  6. Android then looks for an activity registered in the system with an intent-filter that matches both the VIEW action, and the MIME type for the data represented by the content: URI.

  7. Assuming a match is found, Linkify then invokes the intent for the URI, at which point the activity takes over, and is handed the content: URI.

  8. The activity can then use the URI to retrieve the data and act on it.



If this sounds complicated, it really is a simpler process than it sounds, and it is quite lightweight as well. Perhaps a more understandable statement about how it works might be:



Linkify is used to turn matching text into hot-links. When the user selects a hot-link, Android takes the data locator represented by the hot-link and looks for a data handler for that data locator. If it finds one, it asks for what type of data is returned for that locator. It then looks for something registered with the system that handles that type of data for the VIEW action, and starts it, including the data locator in the request.



The real key here is the MIME type. MIME stands for Multipurpose Internet Mail Extensions - a standard for sending attachments over email. The MIME type (which is the part Android uses) is a way of describing certain kinds of data. That type is then used to look for an Activity that can do something with that data type. In this way, ContentProviders and Activities (or other IntentReceivers) are decoupled, meaning that a given Content URI might have a different ContentProvider to handle it, but could still use the same MIME type meaning that the same activity could be called upon to handle the resulting data.



Linkify on a Wiki Word



Using the above workflow, let's take a look at exactly how the process works in WikiNotes for Android:



First, Linkify is used to turn text matching the wiki word regular expression into a link that provides a Content URI for that wiki word, for example content://com.google.android.wikinotes.db.wikinotes/wikinotes/ToDoList.



When the user clicks on the wiki word link, Linkify invokes the VIEW action on the Content URI. At this point, the Android system takes over getting the Intent request to the correct activity.



Next, Android looks for a ContentProvider that has been registered with the system to handle URIs matching our Content URI format.



In our case, we have a definition inside our application in the AndroidManifest.xml file that reads:



<provider name="com.google.android.wikinotes.db.WikiNotesProvider" 
android:authorities="com.google.android.wikinotes.db.wikinotes" />


This establishes that we have a ContentProvider defined in our application that provides the "root authority": com.google.android.wikinotes.db.wikinotes. This is the first part of the Content URI that we create for a wiki word link. Root Authority is just another way of thinking about a descriptor that is registered with Android to allow requests for certain URLs to be routed to the correct class.



So, the whole definition is that a class called com.google.android.wikinotes.db.WikiNotesProvider is registered with the system as able to handle the com.google.android.wikinotes.db.wikinotes root authority (i.e. URIs starting with that identifier).



From here, Android takes the rest of the URI and present it to that ContentProvider. If you look at the WikiNotesProvider class and scroll to the very bottom - the static block there, you can see the pattern definitions to match the rest of the URL.



In particular, take a look at the two lines:



URI_MATCHER.addURI(WikiNote.WIKINOTES_AUTHORITY, "wikinotes", NOTES);
URI_MATCHER.addURI(WikiNote.WIKINOTES_AUTHORITY, "wikinotes/*", NOTE_NAME);


These are the definitions of URIs that our ContentProvider recognizes and can handle. The first recognizes a full URI of content://com.google.android.wikinotes.db.wikinotes/wikinotes and associates that with a constant called NOTES. This is used elsewhere in the ContentProvider to provide a list of all of the wiki notes in the database when the URI is requested.



The second line uses a wildcard - '*' - to match a request of the form that Linkify will create, e.g. content://com.google.android.wikinotes.db.wikinotes/wikinotes/ToDoList. In this example, the * matches the ToDoList part of the URI and is available to the handler of the request, so that it can fish out the matching note for ToDoList and return it as the data. This also associates that match with a constant called NOTE_NAME, which again is used as an identifier elsewhere in the ContentProvider.



The other matches in this static block are related to forms of searching that have been implemented in the WikiNotes for Android application, and will be covered in later articles. Likewise, how the data is obtained from this matching pattern will be the subject of the next article.



For right now we are concerned with the MIME type for the URI. This is defined in the getType() method also in the WikiNotesProvider class (about half way through the file). Take a quick look at this. The key parts for now are:



case NOTES:
return "vnd.android.cursor.dir/vnd.google.wikinote";


and

case NOTE_NAME:
return "vnd.android.cursor.item/vnd.google.wikinote";


These are the same constant names we defined in our pattern matchers. In the first case, that of the all notes URI, the MIME type returned is vnd.android.cursor.dir/vnd.google.wikinote which is like saying an Android list (dir) of Google wiki notes (the vnd bit is MIME speak for "vendor specific definition"). Likewise, in the case of a NOTE_NAME match, the MIME type returned is vnd.android.cursor.item/vnd.google.wikinote which is like saying an Android item of Google wiki notes.



Note that if you define your own MIME data types like this, the vnd.android.cursor.dir and vnd.android.cursor.item categories should be retained, since they have meaning to the Android system, but the actual item types should be changed to reflect your particular data type.



So far Android has been able to find a ContentProvider that handles the Content URI supplied by the Linkify Intent call, and has queried the ContentProvider to find out the MIME types for that URI. The final step is to find an activity that can handle the VIEW action for that MIME type. Take a look in the the AndroidManifest.xml file again. Inside the WikiNotes activity definition, you will see:



<intent-filter>
<action name="android.intent.action.VIEW"/>
<category name="android.intent.category.DEFAULT"/>
<category name="android.intent.category.BROWSABLE"/>
<data mimetype="vnd.android.cursor.item/vnd.google.wikinote"/>
</intent-filter>


This is the correct combination of matches for the VIEW action on a WikiNote type that is requested from the LINKIFY class. The DEFAULT category indicates that the WikiNotes activity should be treated as a default handler (a primary choice) for this kind of data, and the BROWSABLE category means it can be invoked from a "browser", in this case the marked-up Linkified text.



Using this information, Android can match up the VIEW action request for the WikiNotes data type with the WikiNotes activity, and can then use the WikiNotes activity to handle the request.



Why do it like this?



It's quite a trip through the system, and there is a lot to absorb here, but this is one of the main reasons I wanted to write WikiNotes in the first place. If you follow and understand the steps here, you'll have a good grasp of the whole Intents mechanism in Android, and how it helps loosely coupled activities cooperate to get things done.



In this case, we could have found another way to detect wiki words based on a regular expression, and maybe written our own handler to intercept clicks within the TextView and dig out the right data and display it. This would seem to accomplish the same functionality just as easily as using intents, so what is the advantage to using the full Intents mechanism?



In fact there are several advantages:



The most obvious is that because we are using the standard Intent based approach, we are not limited to just linking and navigating to other wiki notes. We get similar behavior to a number of other data types as well. For example, a telephone number or web URL in a wiki note will be marked up by Linkify, and using this same mechanism (VIEW action on the linked data type) the browser or dialer activities will be automatically fired.



It also means that each operation on a wiki note can be treated as a separate life cycle by our activity. We are not dealing with swapping data in and out of an existing activity - each activity works on a particular wiki note and that's all you have to worry about.



Another advantage is that we now have a public activity to handle VIEW actions in WikiNotes no matter where the request comes from. Another application could request to view a wiki note (perhaps without even knowing what kind of data it is) and our activity could start up and handle it.



The backstack is automatically maintained for you too. As you forward navigate through WikiNotes, Android maintains the history of notes visited, and so when you hit the back button you go back to the last note you were on. All this is free because we rely on the Android intents mechanism.



Finally, if you run WikiNotes for Android and then start DDMS to take a look at the Activity threads in the WikiNotes application while it is running, you can see that despite what you might think, letting Android manage the navigation is very efficient. Create a few linked notes, as many links deep as you like, and then follow them. If you follow links hundreds of notes deep, you will still only see a handful of WikiNotes activities. Android is managing the activities, closing the older ones as necessary and using the life cycle to swap data in and out.



Next Time



This was a long article, but necessarily so. It demonstrates the importance of the Intents mechanism and to reinforce the notion that it should be used whenever possible for forward navigation, even within a single application. Illustrating this is one of the primary reasons I wrote WikiNotes for Android in the first place.



In the next article we will look deeper into the ContentProvider and examine how it turns a Content URI into a row (or several rows) of data that can be used by an activity.

Friday, March 14, 2008

Golden Gekko -One To Watch #9


Founded in London in 2005, Golden Gekko has been pushing the boundaries of mobile marketing since its inception, with the innovative use of widely accessible mobile applications to support multi-channel branding and advertising campaigns for world-recognised brands like Absolut Vodka, Coca Cola and Nicotinell.

It also successfully raised an undisclosed amount of venture capital from ACP Partners in 2007 which is underpinning its expansion in new markets and a widening of its already ample product portfolio.

The mobile marketing community is appreciative of Golden Gekko's innovation and at the Mobile Marketing Awards 2008 celebrated in London earlier this month, the company stole a march on its competitors by winning a 'double whammy' of both "Best use of content in mobile marketing" and "Best use of mobile in brand building" for their Lynx ‘Get in There’ campaign in association with BBH.


This follows hot on the heels of the BIMA Award obtained in 2007 for "Best Use in Mobile" for the
Air Action Vigorsol (chewing gum) campaign also with BBH.

Golden Gekko is developing a new type of application that it plans to roll out 'shortly' that it claims will set a new standard for mobile marketing...could it be what they require to win the coveted 'Best Use of Mobile in Driving Revenue' award next time round?

Thursday, March 13, 2008

Linkify your Text!

This is the first in a series of technical articles about WikiNotes for Android, part of the Apps for Android project.



This article covers the use of Linkify to turn ordinary text views into richer link-oriented content that causes Android intents to fire when a link is selected.



Linkify: The Linkify class in the SDK is perfect for creating a wiki note pad. This class lets you specify a regular expression to match, and a scheme to prepend. The scheme is a string that, when the matched text is added, forms a Content URI to allow the correct data to be looked up.



For example, in our case we want to look for a regular expression match for a WikiWord (that is, a word with camel case and no spaces). Linkify can then turn this into a Content URI - something like >content://com.google.android.wikinotes.db.wikinotes/wikinotes/WikiWord which can then be used to locate the correct wiki page from a content provider.



As a bonus, the Linkify class also defines several default matches, in particular it is able to turn web URLs, email addresses and telephone numbers into active links which fire Android intents automatically.



Linkify can be passed any TextView in your application, and will take care of creating the links and enabling their "clickability" for you.



Default Linkify: Using the set of default active link options is very straightforward - simply pass it a handle to a TextView with content in it, and the Linkify.ALL flag:



TextView noteView = (TextView) findViewById(R.id.noteview);
noteView.setText(someContent);
Linkify.addLinks(noteView, Linkify.ALL);


and that's it. The Linkify.ALL flag applies all of the predefined link actions, and the TextView will be immediately updated with a set of active links which, if you select them, fire default intents for the actions (e.g. a web URL will start the browser with that URL, a telephone number will bring up the phone dialer with that number ready to call, etc.).



Custom Linkify: So what about our WikiWord? There is no pre-defined action for that, so it needs to be defined and associated with a scheme.



The first task is to defined a regular expression that matches the kind of WikiWords we want to find. The regex in this case is:



\b[A-Z]+[a-z0-9]+[A-Z][A-Za-z0-9]+\b


Obvious no? Well actually this is equivalent to the following description: "Starting with a word boundary (the \b) find at least one upper case letter, followed by at least one lower case letter or a numeric digit, followed by another upper case letter, and then any mix of upper case, lower case or numeric until the next word boundary (the final \b)". Regular expressions are not very pretty, but they are an extremely concise and accurate way of specifying a search pattern.



We also need to tell Linkify what to do with a match to the WikiWord. Linkify will automatically append whatever is matched to a scheme that is supplied to it, so for the sake of argument let's assume we have a ContentProvider that matches the following content URI:



content://com.google.android.wikinotes.db.wikinotes/wikinotes/WikiWord


The WikiWord part will be appended by Linkify when it finds a match, so we just need the part before that as our scheme.



Now that we have these two things, we use Linkify to connect them up:



Pattern wikiWordMatcher = Pattern.compile("\\b[A-Z]+[a-z0-9]+[A-Z][A-Za-z0-9]+\\b");
String wikiViewURL = "content://com.google.android.wikinotes.db.wikinotes/wikinotes/";
Linkify.addLinks(noteView, wikiWordMatcher, wikiViewURL);


Note that the \b's had to be escaped with double backslashes for the Java Pattern.compile line.



Linkify can be used multiple times on the same view to add more links, so using this after the Default Linkify call means that the existing active links will be maintained and the new WikiWords will be added. You could define more Linkify actions and keep applying them to the same TextView if you wanted to.



Now, if we have a WikiWord in the TextView, let's say MyToDoList, Linkify will turn it into an active link with the content URI:



content://com.google.android.wikinotes.db.wikinotes/wikinotes/MyToDoList


and if you click on it, Android will fire the default intent for that content URI.



For this to all work, you will need a ContentProvider that understands that Content URI, and you will need a default activity capable of doing something with the resulting data. I plan to cover these in future blog entries (and soon). In fact, the whole Wiki Note Pad application is currently undergoing some clean up and review, and will then hopefully be released as a sample application.

Tuesday, March 11, 2008

Android Developer Challenge Deadline Approaching Quickly

The Android Developer Challenge is proceeding nicely. We're excited about the interest people have shown so far and have enjoyed talking to everyone working on new Android Apps.

As a quick reminder, the first phase of the challenge will be ending on April 14. In the Android Developer Challenge I, the 50 most promising entries received by April 14 will each receive a $25,000 award to fund further development. Those selected will then be eligible for even greater recognition via ten $275,000 awards and ten $100,000 awards.

Keep working on your applications, and be sure to post in the forums if you have any questions!

Saturday, March 8, 2008

Mobile Payments -NFC Trials steaming ahead


I posted an item at the start of the year explaining the rise of the 'mobile wallet' and stumbled across a related piece this week where the Financial Times explain NFC technology and its rollout.

According to research they quote from ABI Research, 30% of the mobile phones in the world will be NFC-enabled by 2011 (down from a rosier prediction made originaly in 2004 of 50% by 2009).

The point about the lack of hardware infrastructure to support faster NFC rollout made by the FT is a valid one -once again, too many standards existing across the globe with inherent vested interest in retaining one above the others.

Equally valid, is the discussion of how mobile operators are simply unprepared to relinquish the lion's share of the transaction fees from mobile payment transactions to financial institutions -something which has the potential to significantly delay any mass-market launch anwhere in the world.

Nontheless, o2 has been undertaking a 6-month project with Transport for London, Barclaycard and other partners to trial cashless payments amongst 500 selected customers. A smaller portion of the sample was also given the opportunity to make payments of up to €15 at a range of outlets.The trial is due to end in May and could give useful insights into take-up of the technology.

The article wraps up by predicting that in the future, the mobile phone will replace swipecards for accessing offices and hotel rooms, as well as paper tickets at concert venues.

Certainly based on some of the innovation that Japanese operators showcased at the Mobile World Congress, the idea of NFC handsets for accessing buildings is probably more imminent
than we think (according to NTT DoCoMo around 100,000 of their Tokyo subscribers open the door to their home with their handset).

If only operators and Banks would end their squabbling over revenue sharing, an acceleration of the use of NFC-enabled phones for mobile payments could be just round the corner...

Friday, March 7, 2008

IIR Mobile Internet Conference-Berlin




I'm pretty excited about the next Mobile Internet Conference organised by IIR Telecoms & Technology in Berlin's prestigious Kempinski Hotels at the end of the month.

The line up of speakers is impressive and confirms the trend evident at the Mobile World Congress -Mobile Content (particularly User Generated) is the key to future growth in the sector and is driving the agenda for manufacturers and operators alike.

It is not easy to single out key speakers from the line-up, but I'm going to be particularly tuned in to Alejandro Romero (Yahoo Spain), Simon Davis (Socialight), Reg Cox (Vodafone UK) and Mark Bole (Shozu).

Top of the agenda will be how to drive monetization of Mobile Social Networking and different models for diviing up responsibilities amongst stakeholders of the mobile ecosystem.

Being a big believer in simple browsing on mobile handsets as THE key to drive users to the mobile web, I am keen to hear from Flash Networks how they see future technology assisting the quest for universal i-phone style (or better!) browsing.

Tuesday, March 4, 2008

Announcing: Apps for Android

Screenshot of WikiNotes for AndroidWe are pleased to announce that a new open source project has been created on Google code hosting called apps-for-android. Our goal is to share some sample applications that demonstrate different aspects of the Android platform.



The first application to be included in the new project is called WikiNotes for Android.



For anyone not familiar with the concept of a wiki, it is a simple way to link up pages of information using WikiWords (words that use CamelCase). For example, in the previous sentence, both WikiWords and CamelCase would become live links in a Wiki, and would take you to pages of information.



WikiNotes for Android is a form of wiki known as a personal wiki. These run on desktops or (in this case) mobile computing devices, and many people like them. They bring a bit more structure to your notes than just a list of subjects. You can choose to link notes or pages up in any manner you like.



This particular implementation uses a regular expression to match WikiWords and turn them into links that fire Intents to go to other notes. Because of the way the links are implemented, the application will also create links out of telephone numbers that take you to the dialer and URLs that start up the browser.



Search by title and content is also implemented, so even if you forget the structure, you can still find that all-important note about where you left your car in the airport car park.



This wiki has a view mode and an edit mode. In view mode, the links become active and allow you to navigate to other notes, or to other activities like dialer and web browser. In edit mode, you see a plain text view that you can edit, and when you confirm the changes it goes back to view mode. There is both a menu entry and keyboard shortcut to switch to edit view, so that you can very quickly make changes. And, if you get lost in the note structure, there is also an option to take you back to the start page.



WikiNotes for Android was written to demonstrate a number of core concepts in Android, including:




  • Multiple Activities in an Application (View, Edit, Search, etc.)

  • Default intent filters for View/Edit/Search based on MIME types

  • Life cycle of Activities

  • Message passing via Bundles in Intents

  • Use of Linkify to add Intent-firing links to text data

  • Using Intents within an application

  • Using Intents to use an Activity within another application

  • Writing a custom ContentProvider that implements search by note title

  • Registration of ReST-like URIs to match titles, and do contents searches

  • SQLite implementations for insert, retrieve, update, delete and search

  • UI layout and creation for multiple activities

  • Menus and keyboard shortcuts



The application remains small in size and features to make it easy to understand. In time, more features will be added to the application to make it more useful, but a sample version with the minimal functionality will always be available for developers new to the Android platform.



If you believe that firing an Intent for every link that is clicked is sub-optimal and will waste resources, please take a look at the running application using DDMS. You will see how efficiently Android re-uses the running Activities and indeed, this is one of the main reasons WikiNotes for Android was written. It demonstrates that using the Android Activities and Intents infrastructure not only makes construction of component-based applications easy, but efficient as well.



There will also be a series of technical articles about the application right here on the Android Developer blog.



And please, keep an eye on the apps-for-android project, as more sample applications will be added to it soon.



Happy wiki-ing.

Monday, March 3, 2008

Android SDK update: m5-rc15 released

Earlier today we released an update to the Android SDK – we're calling it m5-rc15. With this update, the SDK now includes all of the incremental changes we've been making to the online documentation since m5-rc14 was released in mid-February. In addition to the latest documentation, we've also fixed a security issue involving handling of image files.



We recommend that you install m5-rc15 at your earliest convenience. The update doesn't change any of the Android APIs or introduce any new ones. Eclipse users don't need to update the ADT plug-in either.



Once you've unzipped the file on your machine, you will want to update things like your PATH variable and, if you're using Eclipse, the SDK location setting for ADT (hint: Preferences > Android).

Related Posts Plugin for WordPress, Blogger...