8 Mistakes to Avoid While Developing an Android App
The Android platform is popular for obvious reasons. It’s free, it’s available across a variety of devices, and it’s easy to customize. With all these obvious benefits it would surprise many to know that there are many mistakes that mobile app developers make when using this platform. Most of these mistakes fall within the area of logistics. However, many of the mistakes can be avoided. In fact, there are a few areas that you should focus on to avoid making these common mistakes as well as a few tips and strategies that will also help your app perform better.
1. Develop an App that Will Work Well Across a Variety of Different Devices
With so many different android devices available, there’s no way that your web content is going to look good on every device. However, you can improve the way you app will appear by utilizing a few android specific programming strategies:
- Use DP Pixels (Density Independent Pixels) instead of Normal PX Pixels
- Include Resources to Cover Different Densities and Orientations
- Create Resizable Bitmaps also Known as 9-patch drawables
- Use the Android Emulator or the Genymotion to Replicate Physical Android Devices
2. Utilize Intents
Many developers forget to use intents. Intents are an essential part of the app development process because they pass information between different parts of an app. Start your SMS Intent by adding specific commands. These commands are good for a variety of different reasons. However, SMS Intents should be used mainly because they assist with a wide variety of functions and help your device operate smoothly while performing a variety of tasks;
- Sharing Content
- Taking Pictures
- Recording Video
- Picking Contacts
- Adding Events
- Opening Links with Native Apps
3. Use Fragments
Fragments are powerful when it comes to optimizing your content to fit various screens parameters because they can be controlled through parent activity. The flexibility they provide is a true benefit because they are reused repeatedly, combine well with other operations, and are easily repositioned. They are essentially individual building blocks with lifecycle’s of their own that operate within an activity. Fragments should be consistently used in the development of android apps for these reasons.
4. Use What’s Already There
Android’s been around for a long time which means a lot of basic code for Android apps has already been written. All apps require network calls, image loading, database access, JSON parsing, and social login. Don’t make the mistake of writing your own code for things like this. Use what’s already in place, has been widely tested, and used repeatedly with success. Resist the urge to reinvent the wheel.
- Build System ( gradle)
- Network Calls (Retrofit / Volley)
- Image Loading (Picasso)
- JSON Parsing (Gson / Jackson)
- Social Login (common implementations)
5. Display Bitmaps Efficiently
Images can take a lot of memory. However, there are ways to display quality images without robbing yourself of this precious resource. Learn to strategically manage memory and disk caching while you load multiple bitmaps into memory. This will ensure that the responsiveness and flow of the user interface don’t suffer. Instead, use the Glide library to fetch, decode, and display bitmaps in your app. This tool will reduce a great deal of the complexity in dealing with bitmaps and other images on the Android platform. However, you can employ a few other strategies as well:
- Measure the Display that Shows your images
- Make Adjustments to Large Images (Scale/crop)
- Show What Can be Presented.
6. Don’t Block the Main Thread
This is simple. The main thread keeps the interface responsive. We all understand the importance of a responsive user interface. There is no need for any explanation here. Keep in mind that a less responsive interface is usually the result of fewer than 24 fps and a delay greater than 100 ms. This creates a sluggish UX for the user, resulting in a delay that usually ends with an app that eventually stops responding. No app developer wants this end result. However, to avoid this, don’t block the main thread. Use worker and background threads for:
- Network Calls
- Loading Bitmaps
- Processing Images
- Querying a Database
- SD reading/writing
7. Developing Your App for Apple iOS
Apple is no longer the leader for design standards. As a result, there’s no longer a need to develop an iOS clone. This is no longer necessary and is also considered a bad strategy when it comes to developing android apps. This is mostly because the android platform has been around for a long time and grown by leaps and bounds. As a result, people have gotten used to an Android platform. An iOS design would be a bad move for this reason.
8. Accommodate the User Mindset and Assume Success
It’s best to assume that an app is going to successfully do what it’s supposed to do. More often than not, they do. As a result, it’s ok to assume that success is inevitable and learn to manage failures. Get inside the head of the user and ask yourself what they’d want. They wouldn’t want to wait. Immediacy is extremely important. Successful network calls are more prevalent than unsuccessful ones. In other words, don’t wait for the server response before handling the successful requests. It’s better to assume success because that’s the most likely outcome.
The android platform is one of the easiest to develop. Much of the code has already been written for a large majority of apps. However, it’s important that you avoid the pitfalls that many app developers fall into when they start to build Android apps.
Many of the mistakes made with coding and images can be avoided if you follow guidelines and are careful with how images and bitmaps are handled. Don’t wait. An immediate response is almost always favorable. Users aren’t always going to keep up with how fast things develop but android developers should. Change is inevitable, however, it’s the app developers job to ride the waves of change and stay abreast of the changes in app development.
