Android Things

Creating an Android Battery Widget

2012-02-20T18:22:00.004Z

I recently approached the task of developing an Android widget for the first time. I created an Android battery level widget, mainly so that I could write a tutorial on it.

You can download that tutorial here:
Jump Into Android - Create a Battery Level Widget
[it's premium but a bargain at $6..!]

Anyway, in this article I thought I'd run through a few tips for creating Android widgets, with specific guidance on retrieving and displaying information about aspects of phone state, such as the battery level. We won't go into too much detail here, but hopefully you'll find it a useful overview of Android widget development.

What's the Difference?

In many ways widget development for Android is the same as development for any other app type on the platform. However, although the differences are slight, they can throw you off when you attempt a widget for the first time. I would strongly recommend not attempting a widget as your first app, but instead trying Android widget development after you've tried developing at least one standard application.

You will presumably already know the difference between widgets and other Android apps from the user's point of view, so let's start there. Widgets are not launched from the application menu, but are instead added to the user's homescreen. Some widgets are interactive, normally allowing users to choose settings on pressing the widget once it is on screen, or when it runs for the first time. The download and installation process is basically the same as for other apps.

What you Don't Need to Do

Since widget apps are not launched in the same way as normal apps, your project structure does not need a main Activity class to execute when the application starts up. As well as removing the need for an Activity class file, this means you do not need to include your main launcher Activity in the project Manifest XML file.

What to Do Instead

Instead of a main Activity class, your widget apps need to extend the AppWidgetProvider class. You also need to include your widget provider in the Manifest as a receiver item, specifying a metadata file along with it. If your widget is going to update, you need to indicate this within the Manifest too, using an intent filter. Your metadata file should be saved in "res/xml" and the code within it should define the basic aspects of your widget, including its dimensions and update frequency where appropriate. The metadata file can also specify an initial XML layout resource to use when the widget appears.

Options

That's basically all you need for a widget, but depending on your own project you may need additional elements. For example, you can override the AppWidgetProvider methods, such as onUpdate, specifying what should happen when the widget updates, which will often involve altering the visual display.

You can optionally include an Activity in your app for configuring the widget. Similarly, you can make the widget interactive by supplying a click listener and presenting an options setting section for your users.

Running and Testing

Testing widgets is roughly the same as testing other Android apps, with some exceptions depending on the nature of your own particular projects. For example, when I created my battery level widget, I could only test it properly by running it on a device, because the emulator by default only shows a battery level of 50%. It's always preferable to test your apps on real devices anyway.

Some widgets have serious performance implications. For example, you can use the AlarmManager class to provide more frequent updates to a widget than you can using the XML metadata method. In such apps, you really need to pay extra attention to efficiency, or your users will be dismayed to see their battery levels draining too fast.

Phone State Including Battery Level

So far we've discussed widgets generally, but you have an additional set of considerations if you're creating a widget to indicate phone state such as battery level. To create this type of widget, you need to register for a receiver. This basically means telling the system to inform your app about changes in state.

If you are setting your widget update frequency in the XML metadata, the most often it can receive updates is every 30 minutes. To update more often, you can use a service, implementing an alarm if the widget needs to update when the device is asleep. You will also need a service if your widget is fetching data over the Web.

The Android system issues broadcasts about certain aspects of the device. Some of these are described as "sticky", including the battery level. This means that the last broadcast hangs around the system, allowing your widgets to access the data within it at any time. For a battery level widget that only updates at the frequency set in the XML metadata, this means that the displayed level will actually be whatever the last level broadcast was, which may have been any time in the past half hour at most. Naturally, this is not ideal for all apps, which is why many of them use services and alarms.

Conclusion

So that's an overview of the basics when developing widget apps. Here are a few related links:

And don't forget my lovely Battery Level tutorial!

Object Oriented Concepts for Android Development in Java

2012-01-31T22:03:00.002Z

If you're learning Android development but have no prior experience of either Java or Object Oriented development in general, you can get yourself up to speed on the essential concepts pretty easily. A few aspects of Object Oriented development can help to make the best of your Android projects, without having to embark on a lengthy training process.

Providing you have programming experience of some kind, you can go some way towards getting to grips with OO Android by familiarising yourself with the basic principles we'll introduce in this article. Along the way we'll hopefully demystify some potentially confusing language you may have come across on the topic.

Classes and Objects

Object Oriented development essentially means dividing up the processing tasks in an application between a group of objects. Developers begin designing such applications by defining these objects at an abstract level, assigning the various responsibilities required by the app. To implement objects in code, you create class declarations.

A class declaration is normally a single file in a Java project, in which you declare the properties and behaviour that objects of the class will provide. Think of a class declaration as a description of an object in general terms. Once an app has a class declaration, other code within the application can create objects of the class, each of which will match the description outlined in the declaration, but with differences in terms of data.

The following Java code demonstrates a simple class declaration for illustration:

public class Worker {
  //instance variable
 private String name;
 
  //constructor method
 public Worker(String workerName) {
  name=workerName;
 }
 
  //method to return name
 public String getName() { return name; }
}

Using Objects

Code external to the class, for example within another Java file in the application package, can instantiate objects of this class as follows:

Worker adminHelper = new Worker("Jim");
Worker managementHelper = new Worker("Mary");

This code declares and instantiates two Worker object variables. Stating the name and type of an object is declaring it. Creating an instance of the class and assigning this to the object variable is instantiation. Although these two objects are of the same class, they have different data, in this case simply the string name variable.

When this code executes, Java runs the constructor method within the class declaration. Within the constructor, the code assigns a value to the one class instance variable with the string value passed as a parameter when creating the new object. Once the "customer" code has an object of the class, it can call any public methods in it as follows:

String adminName = adminHelper.getName();

The "getName" method returns the string instance variable. Public methods and variables can be accessed outside the class, while private resources, such as the instance variable, are only available inside the declaration.

These examples are for demonstration and are therefore abstract, we'll get to practical, Android-based examples next.

Android App Classes

If you've already started developing Android apps you will have created classes, although some of them may have a different structure to the example above. The Android platform does certain things slightly differently to the typical Java application, but the same patterns apply.

Your initial Android projects will likely have some Activity classes in them. Unlike a standard Java class, an Activity class is instantiated by the system when your code creates and starts an Intent object, rather than by using the "new" keyword as in the example above. To dictate what should happen when an Activity class is instantiated, you add code to the "onCreate" method rather than a constructor.

You can create standard Java classes to handle specific processing areas within your apps, as well as using the Android classes. When your apps use classes within the Android platform, such as the Activity class, they use inheritance.

Inheritance

If you have any existing Android projects in which you have Activity classes, you have already used inheritance. The class declaration for an Activity starts like this:

public class HelpSection extends Activity

The class name will vary for your own Activities. The phrase "extends Activity" means that the class is inheriting from the Android Activity class. When a Java class extends another class, it inherits the methods of that class. The parent class being extended is referred to as the superclass, with the extending class known as the subclass. The following sample code demonstrates extending the Worker class above:

public class Administrator extends Worker {

 public Administrator(String adminName) {
  super(adminName);
 }
 
}

The constructor method in the subclass calls the constructor for the superclass. This class can provide additional methods and variables that are specific to its own area of responsibility. Inheritance is essentially a way to re-use code, with extending classes able to make use of existing resources within an application or within the Java and Android platforms.

By extending the Android classes, your own classes inherit their functionality, saving you from having to implement certain details. For example, the Activity superclass handles the details of presenting a user interface screen to your users.

The inheritance structures you are most likely to use at first are for user interface elements, but you can extend any existing Java and Android classes you find useful. This is a key feature of Object Oriented development, and allows you to focus your energy on the aspects of your own projects that make them unique.

Overriding

An inheriting class can provide a dedicated implementation of any method in the superclass it is extending. If you provide a method in a subclass that is also in the superclass, this new version of the method overrides the superclass version. If you want to carry out the same processing as the superclass method and then additional processing of your own, you can begin the method implementation by first calling the implementation in the superclass as follows:

public void doSomething() {
super.doSomething();
//additional processing
}

Interfaces

As we have seen, with class declarations, you define the behaviour of object instances. Interfaces are another way to influence object behaviour. An interface in Java is like a contract, specifying a series of methods that implementing classes must provide.

Interface declarations list method signatures, each signature including the method name plus an indication of the parameters and return type. Interfaces do not provide implementation details for the methods, so the implementing classes need to do this. In other words, an interface dictates what the class will do, and the class declaration describes how it will do it.

Again, if you have already started with Android you may have implemented some interfaces. The Android platform provides a range of interfaces for delivering user interaction, such as the "OnClickListener" interface. You can indicate that a class will implement an interface using the following syntax:

public class HelpSection extends Activity implements OnClickListener

If you are programming in an Integrated Development Environment such as Eclipse, the program will display error messages when you initially add this code. This is one of the most useful aspects of an IDE, as it reminds you to provide the interface methods, and will continue to show errors until you do.

For the "OnClickListener" interface, your class must provide the "onClick" method, responding to user interaction with your Activity. Implementing an interface is therefore making a commitment that your class will exhibit certain generic behaviours. It's up to you to decide exactly how your classes implement them.

Developing in Eclipse

Eclipse is designed for developing Object Oriented projects, so it has a number of features you may find useful for your Android apps. The Type Hierarchy view helps to visualise projects with reference to the concepts we've gone over here. For example, if you have a class which is extending another class, you can see its hierarchy within your application, and within the platform as a whole.

To see the Type Hierarchy, open the view by choosing Window, Show View, Hierarchy. The new pane will appear within your Eclipse window. Choose an inheriting class in your application and right-click on a reference to the class name in one of your Java files, then choose Open Type Hierarchy. You should see the hierarchy presented within the new view. All classes in Java ultimately inherit from the class Object, so you will see it at the top of the hierarchy tree structure.

Conclusion

Through Object Oriented development, you can work with re-usable code components which preserve the ability to specialise in unique application areas. This is sometimes referred to as polymorphism. The model allows you to make use of a wealth of existing code resources within both the Java language and the Android platform itself.

Regardless of your development background, learning the basics of Object Oriented development needn't be a difficult task, and can have a hugely positive impact on your Android projects.

The OO model is often used by developers working in teams, who need to be able to use one another's code without having to understand the implementation details within any particular section. This idea of an application being made up of code excerpts, each of which has clearly defined behaviours, is the key one to understand, whether you're working with classes and interfaces from your own apps, from the Android platform or from the Java language itself.

Android Text To Speech (TTS) Basics

2012-01-30T16:38:00.001Z

When I originally attempted implementing TTS functionality in my apps I was yet again surprised by how few practical tutorials there were online. I wrote a detailed, practical one a while back for Mobiletuts+ which runs through a simple app with the Text To Speech engine functions: Using the Text to Speech Engine

However, if you just want to know the basics so that you can get stuck into adding the functionality to create your own Text To Speech apps, here's what you need to do:

Import the TTS Classes
To make use of the Text To Speech API, you need to reference it in your code. Add these import statements to your chosen class for standard functionality - includes the TTS resources and others necessary for basic tasks:

import android.speech.tts.TextToSpeech;
import android.speech.tts.TextToSpeech.OnInitListener;
import android.content.Intent;
import java.util.Locale;

Implement the OnInitListener Interface
When using the TTS functions you configure your speech functionality in the onInit method, so you need your class to implement this interface. Add "implements OnInitListener" to the class declaration in which you plan on providing TTS. The following sample code demonstrates:

public class MyLovelyClass extends Activity implements OnInitListener

Check for User Data
Before you start making your apps speak you need to check that the user has the required resources on their device. Add the following instance variable at the top of your class declaration:

private int DATA_CHECKING = 0;

Next add the data checking code to the section of your class that executes when it starts up. I.E. for a standard Java class put it in the constructor method, for an Activity class put it in "onCreate" and so on:

//create an Intent
Intent checkData = new Intent();
//set it up to check for tts data
checkData.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
//start it so that it returns the result
startActivityForResult(checkData, DATA_CHECKING);

Create a TTS Object
So that you can access the Text To Speech object throughout the class, declare it as an instance variable at the top:

private TextToSpeech niceTTS;

When the app receives the result of your data checking operation, the onActivityResult method will execute, so add the code to instantiate the TTS in there:

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 //do they have the data
 if (requestCode == DATA_CHECKING) {
 //yep - go ahead and instantiate
 if (resultCode == TextToSpeech.Engine.CHECK_VOICE_DATA_PASS)
  niceTTS = new TextToSpeech(this, this);
 //no data, prompt to install it
 else {
  Intent promptInstall = new Intent();
  promptInstall.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
  startActivity(promptInstall);
  }
 }
}

Most users do have the TTS data now but this code takes care of those cases where they don't.

Provide the onInit Method
Your class is extending the OnInitListener interface so that you can set the TTS object up to function when it initialises. Add the method as follows:

public void onInit(int initStatus) {
 if (initStatus == TextToSpeech.SUCCESS) {
  niceTTS.setLanguage(Locale.UK);
 }
}

This is the basic process for choosing UK English but the engine offers a wide range of possibilities.

Say It Loud
Now all you need to do is speak. Add this code wherever you want the speech to occur, passing a text string to speak:

String myWords = "I love you";
niceTTS.speak(myWords, TextToSpeech.QUEUE_FLUSH, null);

This instructs the app to speak straight away, but you can optionally choose to add it to a queue, waiting for any existing speech to finish. Again, there are lots of options to explore.

These are the basics of creating a TTS app on Android, but as mentioned above there are plenty of areas in which you can tailor and adapt the functionality.

If you're having trouble getting this to work in your apps, have a go at my other tutorial first, then try doing it with your own apps again: Using the Text to Speech Engine

Other resources:
Android Developer Guide: Using Text-to-Speech
Android Developer Reference: public class TextToSpeech

Adding a Share Button to Your Android Apps

2011-10-09T20:25:00.008+01:00

The share button and list for one of my apps.

I recently approached what I assumed would be the simple task of adding a share button to my Android apps. While the implementation is indeed simple, I was disappointed, yet again, by the lack of easily digestible guidance online, for what must be a very common task.

Anyway, for anyone in the same boat, here's what I learned. For my purposes I only needed a very basic implementation, so it may not be sufficient for your own applications - it should give you the generic outline in any case. For more specific guidance see my Mobiletuts+ tutorial - Android SDK: Implement a Share Inten t on the subject.

Share Intent

To create a share button you have to start a new Intent, passing it the SEND action. When the Activity for your SEND Intent starts, it will present the user with a list of possible channels to share the content through. What each user sees will depend on their own device setup, but it will typically include email, Gmail, Twitter, Facebook, text messaging etc. You will almost certainly have seen the share button in action as an Android user, for example in the browser program.

Here is a basic outline of the code involved in instantiating a share button with the chooser list:

//create the send intent
Intent shareIntent = 
 new Intent(android.content.Intent.ACTION_SEND);

//set the type
shareIntent.setType("text/plain");

//add a subject
shareIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, 
 "Insert Subject Here");

//build the body of the message to be shared
String shareMessage = "Insert message body here.";

//add the message
shareIntent.putExtra(android.content.Intent.EXTRA_TEXT, 
 shareMessage);

//start the chooser for sharing
startActivity(Intent.createChooser(shareIntent, 
 "Insert share chooser title here"));

The code first creates an Intent with SEND as the action. The "setType" method allows you to choose a MIME type for the content being shared, such as plain text or HTML. The code here features two calls to the "putExtra" method, through which you can set various elements of your share item, subject and text content in this case. Finally, the code starts the Activity using the Intent sharing settings indicated, instructing Android to create a chooser list allowing users to pick a sharing medium.

There are other options within the sharing implementation, and you can obviously alter the parameters, method calls etc. to suit your own apps. What options you pick really depends on what you're sharing.

Considerations

Bear in mind the fact that certain aspects of what you set using "putExtra" will be irrelevant for certain sharing channels. For example, if you choose to set a title like I have, it won't appear if the user opts to share using a text message. Also, if you want your users to share using Twitter, remember the 140 character limit.

It's actually tricky to create sharing content that will suit all of the possible messaging services. If you don't want users to choose from the list of options you can bypass that part of the process, but that means you have to create a button or other user control for each messaging service you want users to choose from.

As well as providing the highest level of choice for your users, in my view it's best to use familiar interaction where possible, and Android users are by now accustomed to the sharing chooser list. The downside is that you need to keep your sharing content pretty simple and standard.

For my apps, I was tempted to include a Twitter hashtag in the share content, since it suits my content, but clearly it would be redundant for users sharing through services other than Twitter. Obviously users can edit the content before going ahead and sending it, but it would be poor practice to include a load of guff the user has to delete each time they want to share something. I've seen some apps in which the developer has crammed a load of publicity text including links etc. in with their sharing content - tempting, but not to be recommended from a usability point of view.

Resources

Hope that proved useful to some people, here are some related resources:

Please feel free to add any of your own tips for sharing in Android apps.

Update November 2011
I've written a tutorial on share buttons for Mobiletuts+ Android SDK: Implement a Share Intent which goes into more detail.

Android Market Comments and Ratings

2011-04-29T00:39:00.008+01:00

As with all Internet and digital discourse, trolls seem to be a part of reality in the Android Market. Some thoughts on the Android Market comments and ratings I've received to date.

My Android apps are pretty niche, and I'm fully aware that they will only ever appeal to a small number of geeks like me. In the future I intend to develop apps that are more likely to be useful to a wide variety of users, but the apps I have on the Market at the moment are pretty odd.

However narrow their appeal, I've always tried to indicate very clearly what my apps do in the descriptions within their Market listings. I naively assumed that people who had no interest in the functionality my apps provide would not download them in the first place, but this appears to have been a mistaken assumption. Lots of my reviews seem to be from people who have absolutely no interest in what my apps do (which is clearly indicated in the descriptions) but who have for some reason downloaded them and subsequently given them a poor review.

While I've always been aware that a certain element of nastiness is standard within any Internet based review system, and know all about trolls and trolling, I must admit I've found my own feedback a little demoralising at times.

Here are a few choice 1 star reviews (the minimum possible rating) I've received for my Nonsense app, which is free by the way:

"Does what it says. However its nonsense."
"Does what it says...NONSENSE!!!"
"Boring, tis nonsense but not funny at all"
"this game sucks!" //nb the app is not meant to be a game
"Stinks!!!!"
"This the dummiest crap ever!!?? It is not wat I wanted."
"Stupid.. don't download"
"Gay!"
"Not amusing at all."
"Wow...waste of 4 sec. Of my life."
"Laaaaaame! Don't do it"
"Dumb...Uninstalled."
"i agree this is stupid and pointless"
"Crap...don't waste ur time downloading.... lame"
"Horrible, very stupid"
"Its stupid!!"
"Super lame."
"Worst app EVER!"
"The shittiest app I've ever seen"
"Boring pointless etc worst app ever do not download this..."
"Rlly retarded"
"Dumb!! Nothing good at all about this.."
"Pointless and stupid."
"This sucked! Waste of time!"
"Sucks"
"Terrible."
"I hate it"
"This is the most stupid thing ever don't get this!!"
"Why anyone would want this is beyond me!"
"This thing is almost as fun as going in the street and smashing your balls in with a hammer. This comment is officially better than this app"
"This sucks and it makes NO sense at all! Removing app" //nb the app is called nonsense
"This was a waist of time and space. I mean there are some bad aps out there but this one is the worse of all"
"Zzzzzzzzz...boring on ov de worst games ever"
"Its F***ING stupid"
"Pointless...don't get it uninstalled. How do u even play this game?"
"Title is accurate. Don't waste time downloading this."

Just to explain, all the app really does is generate nonsense sentences. There's a bit of linguistic geekery involved in that the structures are grammatical and meaningless, but essentially it's just a bit of fun. The free version was my initial foray into Android development but in more recent months I've created a couple of slightly more sophisticated paid versions (including a sweary one).

Anyway, from my point of view what's happened here is that I've spent a significant amount of my time producing and releasing something people can have for free if they happen to want it, and the overwhelming majority of those who have added a comment have responded with anger and some pretty vicious contempt, while in some cases acknowledging the fact that the app is exactly as described. Is it me or is there something wrong here?

An analogy: you see a stand in the street with the words "free chocolate ice cream" displayed above it, you go up and get some, eat a mouthful, spit it out and then start shouting about the fact that you hate chocolate ice cream...

I do realise a certain amount of unfettered nastiness is generally inevitable in the context of digital communications, you only need to look at the comments section on any website to see that. However, as a developer basically creating trivial little apps for fun in my spare time, it does take the shine off things somewhat.

To be fair, some of the comments I've had have been really productive and encouraging, and some of them have actually responded to the idiotic, nasty ones. I suspect some of the more helpful comments are perhaps from other developers, so I now make a point of putting positive comments on any apps I use that seem to be receiving a similar level of unwarranted aggression. However, my apps seem to have attracted this extreme negativity in the overwhelming majority of total feedback.

Anyway, to finally get to the point, I've become aware recently that I, and I think most Internet users, just accept this nastiness as a necessary evil. However, I received an email the other day which chimed with some of what I've read in the press in the last while, from an organisation called CiviliNation dedicated to campaigning against online bullying and the general lack of civility in digital discourse, and it got me questioning some of what I've accepted.

It does seem that the tide may be turning slightly and that the days of totally unfettered bile online are probably numbered, in certain contexts anyway. While one of the great things about Internet communication is the lack of censorship, I don't think it follows from that that the normal expectations we have when interacting with people should not apply to digital communications also.

The reality is that bullying has a very serious impact on some people, as the never-ending stream of stories about people announcing planned suicides on social networks demonstrates comprehensively. While this is the extreme end of the issue, I think the time has now come for us to have higher expectations of online behaviour.

Ultimately the problem lies with a lack of responsibility, but the difficulty is going to lie in making people behave in a more civil way while still preserving a degree of anonymity. How we're going to improve the situation I really don't know, but a healthier breed of online discourse would surely be better for everyone involved.

Here's some related content:

Update July 2011:
A couple of interesting Guardian articles on related topics:

The first one is a fascinating look at the history and psychology of "trolling" with reference to anonymity and the second is a Charlie Brooker article from last month on Spotify, not exactly the same topic but touches on some related issues.

And a few more:

Update September 2011:
Interesting piece in the Guardian pointing out the fact that as with any social problem there's no easy fix and that the reasons for trolling are complex:
Guardian: All you trolls out there - come out and explain yourself

The issue is certainly a complex one, and it seems there isn't even a clear definition of trolling at this stage, in fact it probably refers to a range of distinct activities with different characteristics and effects. The days of unfettered Internet trolls definitely look to be coming to an end, but there may well be negative consequences for Internet discourse too, i.e. the inevitable reduction in privacy.

Here's another incredibly depressing tale of extreme trolling:
Skepchick - Mom, Don't Read This

Something has to change, surely...

Android Developer Tutorial Websites

2011-04-17T23:25:00.005+01:00

I've been pretty disappointed by the lack of Android developer tutorials online and have often spent ages trying to find out how to do something that I thought would pop up instantly after a quick Google.

Learning how to program for Android can be quite a task depending on your own background, so access to decent educational material is vital. From Android widget development to standard Android software app development and getting to grips with the Android SDK, there's potentially a lot to learn.

Anyway, here are some of the better sources for Android developer tutorials I've come across. If I find any more I'll add them to the list, feel free to add comments with any you've discovered yourself!

Android Developer Resources - Tutorials
OK, it may seem obvious but there are so many different ways to browse the official developer guide for Android that I find it useful to have several different parts of it bookmarked...

Vogella - Android Tutorials
Lars Vogel's site is one I find myself returning to again and again. The tutorials are detailed and the techniques always best practice. Thoroughly recommended.

IBM DeveloperWorks
The IBM site has loads of useful resources for many different types of development, and Android is no exception.

anddev.org
The anddev.org site is a must-bookmark for anyone getting started with Android development in my view. I've found information here on numerous occasions that I couldn't find anywhere else.

Hello Android
It's a bit of an arbitrary mix but some of the tutorials on the Hello Android site are really useful.

Mobiletuts+
The tutorials on the Tuts+ network all tend to be very detailed and in-depth, and the mobile site has quite a few good Android guides.

Romain Guy
This is a personal blog by an Android software engineer and has a really good range of Android developer tutorials on different topics.

Android Guys
A lot of the articles in the Tips and Tools section of Android Guys are aimed at users rather than developers, but there are a few development topics in there.

Talk Android
Mostly news-focused but with some guides, Talk Android is always worth a look.

Finally, here are links to some of mine on different sites:

That's it for the moment, if I remember or discover any more I'll add them.

Android Marketplaces and Directories

2011-03-03T22:50:00.005Z

There are already a load of places people can download or access your Android applications, other than the official Market. If you're a developer, you'll naturally want to explore as many places to sell and list your app as possible.

Some of the sites and applications describing themselves as marketplaces simply link into the Android Market, but on some of them you can upload and sell your apps directly. In this article I'll run through some of the main Android application stores I've found, focusing on those sites where you can distribute Android software, i.e. upload your Android APK files and sell them.

On the directories, you can sometimes sign up for an account and alter the details listed for your apps. Here are some I've come across, I haven't tried them all so can't guarantee they're any good. Also, some of these are new services and are just starting out, so they don't always have much of a user base yet.

Make sure you check out the terms, FAQs etc on any service before taking the time to sign up, many of them have high minimum payouts and restrictions on where developers can be resident etc.

AndroidZoom
AndroidZoom is an interface to the Android Market. As a developer you can link your app listings to your Google account, insert additional information about your apps and access additional data, just click the "I'm the developer" link on any of your app listings.

AndAppStore
AndAppStore is a an Android app store aimed at catering to a wider variety of users than the mainstream market. As a user you need to install the app to access your downloads but can shop for them on a computer if you like.
Developer signup

SlideME
SlideME is a community based marketplace for Android apps.
Developer signup

AndroidPIT
AndroidPIT combines an app store with articles and news etc about Android.
Developer signup

AndSpot
AndSpot is a new social networking based app store offering increased exposure and data.
Developer signup

AppsLib
ApplsLib is an alternative marketplace for tablets running Android. To use the service as a customer you need to install the AppsLib application.
Developer signup

Handango
Handango is a major app store for platforms including Android, Blackberry, Windows Mobile, Symbian and Palm.
Developer signup

Appoke
Appoke uses social networking to aid app sales.
Developer signup

MobiHand
MobiHand is an app store for Android, Blackberry, iPhone, Symbian, Windows Mobile and Palm.
Developer signup

GetJar
GetJar is an app store for many different handsets and platforms.
Developer signup

AppStoreHQ
AppStoreHQ covers Android, iPhone and iPad, linking to the Android market for downloads and sales. You can claim your profile.

Androlicious
Androlicious is an interface for browsing the Android market, and you can link your apps to your Google account. You can submit apps and information to them via email.

AndroLib
AndroLib is another listings site, but they have quite a lot of informative statistics and charts on the app pages. You can claim your apps by clicking the "I am the developer" link on the listings page.

So that's it for now. There are also loads of app review sites, but that'll be for another post... If you know of any good Android market store sites please do add them in the comments.

Update October 2011
In the short time since I wrote this post a load more marketplaces have started up and I have to admit I've totally lost track of them! One resource that may be useful for some developers is appbackr which I've just heard about so know very little about. It provides an alternative way of funding your apps and handles the distribution side of things for you. If anyone has experience using the service please do comment on how well (or not) it's worked for you.

Thinking About Android Development?

2011-02-24T20:14:00.004Z

I started Android development in 2009, although when I say "started" that's exactly what I mean. I learned the basics, released a really trivial free application and then did nothing else with Android for about a year and a half.

Having started getting back into Android development since the end of 2010, I've been surprised by the still relatively small number of useful Android development resources online. For that reason I thought I'd start a blog and keep note of the things I learn or come across as I go along, in case any of it proves useful for anyone else. This is going to be pretty simple stuff aimed at developers like myself who are really just doing Android on a casual basis.

Some initial thoughts about the Android development process:

Android development isn't what I expected it to be. My initial training was in Java programming for desktop applications, and I then got into Web and multimedia development (mainly so that I could work freelance). I've always loved Java development, and for that reason was excited by the possibility of getting paid to do it on a freelance basis.

However, the Android development process bears more resemblance to Web development than the type of Java application development I was used to. This is probably good news for people who come from a Web background and want to get into Android. If, like me, your background has been more desktop-oriented, you might need to make a bit of a mental adjustment when you approach Android. I'd recommend reading up on the Android Activity Lifecycle before you get started, as this is the key concept to get to grips with when it comes to structuring your apps.