Smartphone Usage Statistics Highlight Its Importance In Our Lives

This Infographic is produced by Coupon Audit (provides Finish Line promo code) and Techdroid.Kbeanie

If you would like to add this inforgraphic on your website or blog, copy and paste the below code as given in the textbox.

<img style="max-width: 80%;" src="http://www.couponaudit.com/blog/wp-content/uploads/2013/12/Smartphone-Usage-Statistics-Highlight-Its-Importance-In-Our-Lives1.jpg" alt="Smartphone Usage Statistics Highlight Its Importance In Our Lives" /></p> <p></a></p> <p> This Infographic is produced by <a href="http://www.couponaudit.com/coupons/finishline">Coupon Audit (provides Finish Line promo code) </a> and <a href="http://techdroid.kbeanie.com">TECHDROID.KBEANIE.COM</a> </p>.<br />

Making your Android apps crash-proof

Image courtesy: Crittercism Website

Do you have an android app on the Play Store, and get lots of negative comments/feedback?


Most of the time, apps crash on the first interaction with the user. And that's the reason most users are frustrated of even downloading your app, and that's when most of the negative comments start pouring in.

Of course, you have to look for crashes everywhere in your app, but crashing on the first page itself, is a really really bad situation. When that happens, and the user leaves a bad comment, instead of sending you a support mail, you have no idea how to fix it. You have no idea about the user's device, and other important information that would help you in determining the problem, and fixing it. And if you continue having such a build even for a week on the store, that puts a dent on your overall app reviews. People generally look at the first few reviews, and make a decision based on that, whether to try your app or not.

I have had an app on the store for years now, which I didn't update for a long time. And finally, when I got the time to work on it again, I decided to integrate Crittercism SDK within my app, along with Google Analytics SDK.

The very first update with +Crittercism along with +Google Analytics , my inbox was flooded with crash reports. I was amazed at how many un-reported crashes my app had. I was living in the dark, as to what all problems users were having with my app. Crittercism logs had more information about the crashes than I could have asked for. They were pretty detailed, in terms of the user's device name, and OS versions, the version of the application, and a device snapshot (Memory/Storage) when the crash occurred.

After about a week, I made the next update, and this time, the crash notifications reduced dramatically, although the number of users and the average usage of my app went up. From this, I can guess that the users who are still using my app are a happy lot. And that makes me happy as well.

I would strongly recommend integrating such a live error reporting tool into your apps to get live feedback for your apps. Specifically for Crittercism, there are free and paid plans. Currently, I am on the free plan, and it gives me the almost everything that I need to know to fix those random crashes. With paid plans, you have more reporting, which I think I don't need right away. Receiving crash notifications is just the one part of Crittercism. They call this solution as a "Mobile Application Performance Management" solution. Rightly so?

Have you used Crittercism in your apps? Do you have anything to say?

Easy Video Chooser Library for Android

After I wrote the "Easy Image Chooser library for Android", I thought I could easily extend this library to handle other things as well. For now, I have implemented the option of choosing/recording a video. And in the future, I am planning to extend this library for choosing other types of files.

Choosing videos, is again very similar to how the images are handled. Using this library, you would be also able to choose videos that reside in your Picasa albums on your phone. And this should work for all OSes and devices.

After processing, the library would return a ChosenVideo object, which would contain the original path to the video file, and 2 differently-sized thumbnails which you can directly use as a preview.

Here is how to use this library.

• For capturing a video using the camera

videoChooserManager = new VideoChooserManager(this, ChooserType.REQUEST_CAPTURE_VIDEO);
videoChooserManager.setVideoChooserListener(this);
videoChooserManager.choose();

•  For choosing a video from the gallery

videoChooserManager = new VideoChooserManager(this, ChooserType.REQUEST_PICK_VIDEO);
videoChooserManager.setVideoChooserListener(this);
videoChooserManager.choose();

• On Activity Result, write this

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK &&
(requestCode == ChooserType.REQUEST_PICK_VIDEO ||
requestCode == ChooserType.REQUEST_CAPTURE_VIDEO)) {
videoChooserManager.submit(requestCode, data);
}
} 

•  Implement this method from the VideoChooserListener

@Override
public void onVideoChosen(final ChosenVideo video) {
runOnUiThread(new Runnable() {
@Override
public void run() {
if (video != null) {
// Use the video
// video.getFilePathOriginal();
// video.getFileThumbnail();
// video.getFileThumbnailSmall();
}
}
});
}

• Handling error conditions from the VideoChooserListener interface.

@Override
public void onError(final String reason) {
runOnUiThread(new Runnable() {
@Override
public void run() {
// Show error message
}
});
}

Here's the link to the Github project. Do let me know your thoughts and feedbacks, and also any bugs if you come across. I will try to fix them as soon as possible.

Easy Image Chooser Library for Android

In almost all the Android apps that I have worked on, there has been a requirement for choosing an image or taking a snap and using the device's camera.

Taking a snap, is rather straightforward to implement, but choosing an image from your gallery is sometimes a hard nut to crack. And to implement this correctly, you would always end up writing a lot of code. Assuming that you want to target all OSes, devices, folders etc.

For example, choosing a picture from the Camera folder of your phone is nice and easy. But, if you want to have the user chose an image from one of his picasa web albums, which he has synced on his phone, you will find a dead-end. Well, almost.

For myself, I must have at-least rewritten the same code, multiple number of times. Of course, the platform should help us in achieving this seemingly straightforward feature with as less code as possible. But, right now, it's not possible.

So, I thought of creating a library which anyone could integrate within one's own app, without really worrying about the nitty-gritties and the bugs, to implement or add this feature into his app. And there's more. Most of the time, you would need a scaled down version of the chosen image to show a preview or use it in a listview. This library would give you 3 sizes, as of now.

1. Original Size
2. Thumbnail Size
3. Thumbnail Smaller Size

The sizes are dynamically calculated, based on the original size of the image. It's pretty rough here, but I am looking forward to improve that part.

This version of the library is pretty basic. But, I would be working on improving this library to add more functionality in the future.

You can find more information about this library here.

image-chooser-library (Github Page)

By using this library in the current state, you could handle all these cases/special cases with just a few lines of code. An example of this is shown below.

Usage:

1. For choosing an image from gallery

imageChooserManager = new ImageChooserManager(this, ChooserType.REQUEST_PICK_PICTURE);
imageChooserManager.setImageChooserListener(this);
imageChooserManager.choose();

2. For capturing a picture using your camera

imageChooserManager = new ImageChooserManager(this, ChooserType.REQUEST_CAPTURE_PICTURE);
imageChooserManager.setImageChooserListener(this);
imageChooserManager.choose();

3. On Activity result, do this:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK &&
(requestCode == ChooserType.REQUEST_PICK_PICTURE||
requestCode == ChooserType.REQUEST_CAPTURE_PICTURE)) {
imageChooserManager.submit(requestCode, data);
}
}

4. Implement the ImageChooserListener interface and override these methods:

@Override
public void onImageChosen(final ChosenImage image) {
runOnUiThread(new Runnable() {
@Override
public void run() {
if (image != null) {
// Use the image
// image.getFilePathOriginal();
// image.getFileThumbnail();
// image.getFileThumbnailSmall();
}
}
});
}
@Override
public void onError(final String reason) {
runOnUiThread(new Runnable() {
@Override
public void run() {
// Show error message
}
});
}

That's all you need to code. And the library takes care of handling all kinds of images, and also generates 2 thumbnails which you could directly use. Let me know if you need to add any new features or if you find a bug. I will try to address those as soon as humanly possible. If you would like to contribute to this project, drop me a mail.

Google Maps API v2 on Android

The Splash Screen

I don't even remember when was the last time I did something with MapView on Android. I was aware of the new version 2 of the Google Maps API, but never got a chance to work on it until today.

There were initial hitches to setup the project. But, once the first steps were done, it was quite easy to build up a simple app.

I want to list down the first steps of the process, and then move on to the sample application.

Step 1: Getting the API key.

1. Go to Google API Console
2. Go to Services link, and enable Google Maps Android API v2. (Don't confuse this with Google Maps API v2. I got confused, and was wondering what was I doing wrong when the maps failed to load)
3. After enabling the service, go to the API Access link.
4. In the Simple API access section, click on "Create New Android Key".
5. Enter your keystore's SHA1 fingerprint along with your application's package name separated by a semi-colon in the dialog and click on "Save".
6. Your API should be visible now on the same page.

Step 2: Setting up the project.

1. You need to find the library project for the Google Maps API v2. It should be available in your SDK directory. If not, open up the Android SDK manager and download the same by selecting Google Play Services in the Extras section.
2. You would find the required library project in the following location of the SDK folder. (..\android-sdks\extras\google\google_play_services\libproject)
3. My suggestion would be to make a copy of this project somewhere else, and then import the project into eclipse.
4. Once imported into Eclipse, use this as a library project for your application.

Step 3: Setting up the manifest file.

1. Your manifest file should look like this. AndroidManifest.xml
2. You can change the package names for the permissions to use your own package name.
3. Now, replace your API key with the place-holder API Key in the manifest.

Step 4: MapFragment and more code...

1. To show a map, I used the MapFragment in the activity's layout.

That's it. These are the broad steps to configure the new version of Google Maps for your Android application.

Your Places

Add a new place

What this application does?

1. On opening the application, you would see a splash screen, and it would try to get your current location.
2. Once it gets your location, it would switch to the map view, and display your current location with a marker.
3. Tapping on an unmarked area of the app, you would see a dialog, through which you can add a new place.
4. After saving the new place by providing a name and a description, this place would be saved into the database and you would be able to see the newly added place on the map.
5. Tapping on an already visible marker will show you the details of that place.
6. The next time you open the application, all the previously stored places would appear on the map along with your current location.

Suggested optimizations

1. While loading the points from the database, it would be nice if we can only load the places which are within the currently visible area of your app.
2. When the map is re-sized or moved, we could re-query the database for the fresh list of places and update the markers based on the new visible area.

Problems:

1. The VisibleRegion API, currently, doesn't work. Need to think of a workaround for this.

You can find the full source-code here at the github respository: android-map101-v2