Mobile development is much different than desktop programming. When developing desktop software, you can usually assume most users have high-speed internet, are using larger screens, and can use a mouse and keyboard to interact with your pages. Developers moving from desktop to mobile development often make similar mistakes, especially when they’re new to the field.
For Android developers, here are tips on a few common mistakes to avoid when designing and building a mobile app.
1. NOT USING ASYNCHRONOUS DESIGN
When you work with cloud applications, the assumption is that the user is connected to the internet while they’re accessing your application. You shouldn’t assume users always have instant, high-bandwidth access to the internet with a mobile app. If you attempt to make an API call or use remote services, it can cause your application to hang.
Users may not be aware that short hangs in the app can simple mean something is processing in the background. When your app needs to check for network resources or make a call to a remote API, consider using asynchronous cause and threads that perform the background action while still allowing your users to interact with the app. This will avoid user confusion and prevent the “Application Not Responding” dialog box from displaying.
2. WRITING APPS THAT AREN’T OPTIMIZED FOR LOW BANDWIDTH
Many developers disregard low-bandwidth users, because high-bandwidth is so common in most areas. Mobile devices still haven’t caught up to the speeds of LAN connections, and many users pay high fees when they go over their dedicated data allocation for the month.
When you use images, always consider that users might have to deal with low bandwidth and data charges. Images should be designed or sized specifically for mobile apps. They can still maintain most of their quality, but they must have a reduced size. You should also limit the number of images on one screen. Too many images will slow down your app’s performance.
For local images, don’t assume you’re free from limited resources. Even though devices continue to offer larger hard drive space and more memory, they’re still much more limited than a desktop computer. Android gives your applications resource allocations called the “heap space.” If you think images or other assets are taking too much of your heap space, you can use a memory analyzer to identify the culprits.
3. Using UI Elements That Work Better with a Mouse and Keyboard
It’s not easy breaking away from standard development habits. For years, developers optimized their user interfaces (UIs) for keyboard and mouse input. It’s a completely different world in mobile development. Users tap with their fingers and type with their thumbs. Your UI components must make it easy for a user to type a value (e.g., in a text box field) and then tap to go to the next element.
UI elements should be larger and easy for users to tap with their fingers. Having 20 small items for a user to tap isn’t the best idea. Menus should offer options that are easy to find and require minimal scrolling. Input components should be easy to tap and make a selection. Font sizes should be large enough for the user to see.
These examples are just a few differences between a mobile app and a web app. Just remember that users don’t have a mouse to easily click a link or a button. They’re tapping and scrolling with their fingers, so you must design your UI elements specifically for this type of interaction.
4. Using Too Much of the User’s Battery Power
Most batteries on the market give the user at least a half day of battery power. Some users get a full day from their battery. As more apps are installed on the device, the battery starts to drain faster. This is due to apps running too many processes in the background even when the phone is idle.
While some apps require background processes, most of them don’t. Unless it’s absolutely essential to your app, don’t eat up your user’s battery life with unnecessary background processes. Apps that eat up too much battery power are a nuisance to users and are often removed.
Don’t use network and data resources when it’s not necessary. Close processes when they aren’t necessary, and analyze memory usage (covered above in section 2).
5. Not Using Standard Input Elements
When the iPhone was first released, mobile app developers followed standards that made every app look like an iPhone interface. Android and iPhone have different element and input styles, and one common mistake is to make your Android app look like an iOS app. This was much more prevalent in previous years, but it still happens with new developers, especially those who started off in iOS design. Android’s Material Design is a “visual language” all apps must adhere to, and it dictates how nearly every aspect of a UI should look.
Not only should you follow Android’s Material Design development standards, but you should also use standard input buttons, dropdown, and textbox components to avoid confusing the user. Your users should be able to easily identify common elements such as a submit button, a menu dropdown icon, input elements, and sections that contain instructions.
6. Indicating You Support Very Old Versions of the Android OS But Don’t
When building Android apps, you need to indicate the minimum version that you support. Just like with web development, supporting outdated software makes your code cumbersome, complex, and can often lead to bugs. You should support more recent versions of the Android operating system, but don’t concern yourself with very old versions.
Google released statistics on the most common versions installed, which shows that you’re likely covering a majority of users if you only support Nougat, Jelly Bean, and newer versions. By supporting only the latest versions, you limit the amount of code you need to write to support each previous version. It also reduces coding and testing time.
It’s also a mistake to say that your app supports older Android operating systems without doing any testing to ensure that the software can actually run on that system without any bugs.
7. Forgetting to Test Your Apps on Different Screens
One of the top reasons apps fail is poor testing. Developers release code to their clients or deploy it to Google Play and the result is often an app with too many reported bugs. These reports lead to poor reviews and can damage the app’s rating so much that it may never recover.
Always test your apps with different sized screens (tablets and smartphones especially), and each version you support. You might need to hire a QA tester to perform this kind of test, or you can invest in multiple devices to use to create your own testing environment.
If you’re new to mobile development, following these tips can help you avoid making common mistakes. Pro tip: Read Google’s design standards and ensure that your apps are intuitive and responsive for your users. All new developers go through some common pitfalls, but you can avoid these common ones to create specifically designed apps your mobile users will enjoy.