I am surprised that there is no Android Hidden Features post yet in the Hidden Features series that I’ve been tracking for a while now.
The Hidden Features series is great for people who are new to a certain language. It shows the ropes and certain valuable tricks, all in one place. I think it’s a brilliant idea. Even experts sometimes find tricks they’d never heard about.
I am starting Android development and I’d love to hear about its hidden features, tips, tricks, and pitfalls.
So, here goes: what are some hidden features of Android?
Hopefully there aren’t too many hidden, hidden features – but here’s some of the less well known and non-intuitive features available for Android that will definitely make your life easier and your apps better.
- All the source code for the platform and all the non-Google native apps is available for you to browse, download, borrow, or steal from the Android Open Source project.
- Using the resources framework, creating localized versions of your app is as simple as adding a new annotated subfolder (Eg. values-fr) that contains an XML file with strings in a different language (Eg. French). Android will choose the right folder at runtime for you.
- The same resources framework lets you use alternate layouts for different hardware configurations, screen pixel densities, and input devices just by dropping them in named folder.
- Since Android 1.6, your app can produce results that will appear in the results from a homescreen Quick Search Box search. This is known as custom search suggestions.
- Using Intents and Intent Filters your apps can make and service anonymous requests for an action to be completed (Eg. The Where app can request a table booking from the Open Table app).
- They can request an unknown application to complete an action without needing to know which application(s) can fulfill that request
- Your app can fulfill requests from unknown apps to complete actions without needing to know which apps will make the requests. Play this right and you can create the ‘default’ Twitter app, or booking app, etc.
- Using Alarms you can set your app to complete tasks at predetermined times, even if your app isn’t running.
- You can save a lot of battery life using the setInexactRepeating method to schedule regular events (like server polling or updates). It will synchronize alarms from multiple apps to occur at the same time rather than adhoc.
- Using the Preferences framework you can create settings screens for your apps in the same style as the system settings. You can even incorporate system settings screens (Eg. Security and Location) into your application’s settings hierarchy.
- Using the AudioTrack and AudioRecord APIs, you can stream audio data directly from and to the PCM audio buffers.
The tools in the /tools directory of the SDK deserve a mention:
- our designer was particularly impressed with
draw9patchwhich helped design stretchable buttons. He gave me assets from there, and I changed from a background colour to a 9-patch drawable and now we have a custom button, rounded corners, etc stretched to fit the text.
ddms, which is also integrated into the Eclipse plugin. It’s immensely powerful, but I use it to take screenshots.
adb– interact with your device or emulator from the command line. I use this to follow the logs from my device in a terminal window on my desktop, though I have found it useful for installing and uninstalling apps which are misbehaving.
sqlite3– great for interacting with an installed database, and trying out queries.
aapt– great for running headless builds
monkeyfor fuzz-testing your app.
Although the Javadoc can be a little sparse at times, it helps no end to have the source right there for you to look at.
It is also very useful to have plenty of sample apps written by Googlers to build, examine and then see how they did it.
I guess I’ll start then.
A nice hidden feature I think is the Best Practices of the Android documentation. It lists plenty of great tips for designing responsive and fast apps.
Best Practices sections are:
- Supporting Multiple Screens (multiple sizes and resolutions)
- UI Guidelines
- Icon Design
- App Widget Design
- Activity and Task Design
- Menu Design
- Designing for Performance
- Designing for Responsiveness
- Designing for Seamlessness
Another hidden feature is that these docs are available offline as part of the SDK. At first I was loading up a few pages every day for my morning train ride but didn’t need to do that anymore after I found them in the SDK directory.
If you use Eclipse, you will notice that it doesn’t format XML files very well and when it does, it’s very inconsistent (sometimes it splits the attributes by new lines, sometimes it doesn’t). To fix it, you can press Ctrl-Shift-F (auto-format). The rules Ctrl-Shift-F uses are in Window->Preferences->XML->XML Files->Editor.
Android supports XML
<shape>‘s which can be used as SVG-like drawables. Unfortunately there’s no documentation for them. This is the best information I could find:
Also with regard to best practices, you may want to check out Android coding style:
as well as the eclipse code and imports formatters (android-formatting.xml, android.importorder) which are found in the platform source code under development/ide/eclipse
hierarchyviewer in /tools allows you to debug/analyze your view layout: padding, positioning, view hierarchy etc.
It saved me a lot of time a couple of times when trying to figure out why things are laid out the way they are.