This Is Because You Tried to Do Something Too Many Times. Please Try Again Later. Android

Android. What's not to similar about this platform? It's gratuitous, it's customizable, it'southward speedily growing and it'southward available not only on your phone or tablet, simply on your smartwatch, Television set and machine too.

With the latest Lollipop update, Android programming continues to better. The platform has matured quite a fleck since the initial AOSP release, and set the user expectations bar quite loftier. Await how good the new Textile pattern pattern looks!

There are thousands of unlike devices, with unlike screen sizes, flake architectures, hardware configurations, and software versions. Unfortunately, partition is the price to pay for openness, and there are thousands of ways your app can neglect on different devices, fifty-fifty as an advanced Android programmer.

Regardless of such huge sectionalization, the majority of bugs are actually introduced considering of logic errors. These bugs are easily prevented, as long as we go the basics correct!

Hither's an Android programming tutorial to accost the 10 well-nigh common mistakes Android developers brand.

Mutual Mistake #1: Developing for iOS

To my groovy pleasure, this Android mistake is far less common nowadays (partially considering clients are outset to realize that the days when Apple was setting all the design standards are long gone). Simply still, every now then, we encounter an app that is an iOS clone.

Don't get me wrong, I'm non an Android programming evangelist! I respect every platform that moves the mobile world a footstep forward. Just, it'south 2022 and users have been using Android for quite a while at present, and they've grown accustomed to the platform. Pushing iOS design standards to them is a terrible strategy!

Unless there is a super adept reason for breaking the guidelines, don't do it. (Google does this all the fourth dimension, merely never by copy-pasting.)

Hither are some of the most common examples of this Android mistake:

1. You should not be making static tabs, and they don't belong on the bottom (I'yard pointing at you Instagram).
2. System notification icons should not have colour.
3. App icons should not be placed inside a rounded rectangle (unless that's your actual logo ex. facebook).
4. Splash screens are redundant beyond the initial setup/introduction. Do not use them in other scenarios.
5. Lists should not have carets.

These are but a few of the many other small things that can ruin the user experience.

Mutual Fault #2: Developing for Your Android Device

Unless you are edifice a kiosk/promo app for a unmarried tablet, chances are your Android app won't look good on every device. Here are a few Android programming tips to remember:

• Density-independent pixels (dp) are different than normal pixels (px).
• Resources are included multiple times to account for different densities and orientations.
• 9-patch drawables are stretched to fit the screen.

In that location are literally thousands of possible scenarios, only subsequently a while you develop a sense for roofing them all with a handful of cases.

Y'all don't own thousands of devices? Not a trouble. The Android Emulator is super good in replicating physical devices. Fifty-fifty better, try out Genymotion, it's lightning fast and comes with a lot of different popular preset devices.

Also, have y'all tried rotating your device? All hell tin break loose…

Common Mistake #three: Not Using Intents

Intents are 1 of Android'due south key components. It'due south a mode of passing data betwixt unlike parts of the app or, even better, dissimilar apps on the system.

Permit'due south say you have a gallery app that can share a download link to some images via SMS. Which of the two options seems more logical?

Option 1:

• Asking the SEND_SMS permission.

                                <uses-permission android:name="android.permission.SEND_SMS" />                          

• Write your own code for sending SMS using the SmsManager.
• Explain to your users why your gallery app needs access to services that can cost money, and why they have to grant this permission to employ your app.

Choice 2:

• Start an SMS Intent and let an app designed for SMS do the piece of work

                                Intent sendIntent = new Intent(Intent.ACTION_VIEW);   sendIntent.setData(Uri.parse("sms:" + telephoneNumber));   sendIntent.putExtra("sms_body", 10);   startActivity(sendIntent);                          

In case that yous have whatsoever doubts, best solution is option 2!

This arroyo can be applied to almost anything. Sharing content, taking pictures, recording video, picking contacts, adding events, opening links with native apps, etc.

Unless there is a expert reason to make a custom implementation (ex., a camera that applies filters), e'er use Intents for these scenarios. It will save you a lot of programming time, and strip the AndroidManifest.xml of unnecessary permissions.

Common Mistake #iv: Not Using Fragments

A while agone in Honeycomb, Android introduced the concept of fragments. Think of them every bit split up building blocks with their own (rather complex) life cycles that exist inside an Activity. They help a lot with optimizing for various screens, they are easily managed past their parent action, can be reused, combined and positioned at will.

Launching a split up activity for each app screen is terribly inefficient, since the system will try to keep them in retention as long every bit it tin. Killing 1 won't free the resources used by the others.

Unless yous want to dig deep into the Android core and read this commodity, advocating against fragment usage, y'all should use fragments whenever possible. It basically says that fragments and cursor loaders have good intended purpose, but poor implementation.

Mutual Mistake #5: Blocking the Main Thread

The main thread has a single purpose: keeping the user interface responsive.

Although the science behind measuring the frame charge per unit our eyes/encephalon tin perceive is circuitous and influenced by a lot of factors, a general rule is that anything below 24 fps with filibuster greater than 100 ms won't be perceived as smooth.

This means that the user's actions will have a delayed feedback, and the Android app you lot have programmed will stop responding. Stripping the user of his command over the app leads to frustration, frustrated users tend to give very negative feedback.

Fifty-fifty worse, if the master thread is blocked for a while (5 seconds for Activities, 10 for Broadcast Receivers), ANR will happen.

This was so common in Android ii.x, that on newer versions the system won't allow yous make network calls in the principal thread.

To avoid blocking the main thread, always employ worker/groundwork threads for: i. network calls 2. bitmap loading 3. paradigm processing 4. database querying 5. SD reading / writing

Common Mistake #6: Reinventing the Cycle

"OK, I won't use the main thread. I'll write my own code that communicates with my server in a background thread."

No! Please don't do that! Network calls, prototype loading, database access, JSON parsing, and social login are the virtually mutual things you practice in your app. Not just yours, every app out there. There is a better way. Remember how Android has matured and grown as a platform? Here's a quick list of examples:

1. Use gradle as a build organization.
2. Utilize Retrofit / Volley for network calls.
3. Use Picasso for epitome loading.
4. Utilize Gson / Jackson for JSON parsing.
5. Utilize mutual implementations for social login.

If you need something implemented, chances are it's already written, tested and used widely. Practise some bones enquiry and read some Android programming tutorials before writing your own code!

Common Mistake #7: Not Bold Success

Great. We have learned that there is a better way for handling long running tasks, and we are using well documented libraries for that purpose. But the user volition however have to wait. It's inevitable. Packages are not sent, processed and received instantly. At that place is a round trip filibuster, in that location are network failures, packages go lost, and dreams get destroyed.

Merely all this is measurable. Successful network calls are far more likely than unsuccessful ones. Then why wait for server response before handling the successful request? It's infinitely better to assume success and handle failure. And so, when a user likes a post the similar count is immediately increased, and in unlikely upshot that the telephone call failed, the user is notified.

In this modern earth immediate feedback is expected. People don't similar to expect. Kids don't want to sit in a classroom obtaining knowledge that has uncertain futurity payoff. Apps must accommodate to the user's psychology.

Common Mistake #8: Not Understanding Bitmaps

Users love content! Especially when the content is well formatted and looks squeamish. Images, for instance, are extremely prissy content, mainly due to their property of conveying a thousand words per image. They likewise swallow a lot of memory. A lot of memory!

Before an image is displayed on the screen, it has to be loaded into the retention. Since bitmaps are the almost common manner to do this, nosotros're going to provide an Android programming guide for the whole process:

Let's say you want to display an image on your screen that y'all but took with your camera. The total memory needed for this is calculated with the following formula: memory_needed_in_bytes = iv * image_width * image_height;

Why iv? Well, the most common / recommended bitmap configuration is ARGB_8888. That means that for each pixel we draw, nosotros need to keep eight bits (1 byte) for the alpha, the red, the greed and the blue channel in memory, in order to properly brandish it. There are alternatives, like the RGB_565 configuration that requires half the retentiveness than ARGB_8888, simply loses the transparency and the colour precision (while perchance adding a green tint).

Let's presume you have a brand new device with full Hard disk drive screen and 12 MP photographic camera. The picture you just took is 4000x3000 pixels large and the full retentivity needed to display it is: 4 bytes * 4000 * 3000 = 48 MB

48 megabytes of your RAM just for a single image!? That'southward a lot!

Now let'southward accept the screen resolution into consideration. You are trying to show a 4000x3000 image on a screen that has 1920x1080 pixels, in worst case scenario (displaying the image full screen) you shouldn't allocate more than 4 * 1920 * 1080 = 8.iii MB of memory.

E'er follow the Android programming tips for displaying bitmaps efficiently:

1. Mensurate the view you're showing your images in.
2. Scale / crop the large image appropriately.
3. Evidence only what can be displayed.

Common Mistake #9: Using Deep View Bureaucracy

Layouts have an XML presentation in Android. In lodge to draw content, the XML needs to exist parsed, the screen needs to be measured, and all the elements demand to be placed accordingly. It's a resources- and time-consuming process that needs to be optimized.

This is how the ListView (and more recently the RecyclerView) works.

If a layout has been inflated one time, the organization reuses it. But withal, inflating the layout must happen at some betoken.

Let's say you lot want to make a 3x3 grid with images. One manner of doing this is a vertical LinearLayout containing iii LinearLayouts with equal weight, each of them containing 3 ImageViews with equal weight.

What do we get with this approach? A warning that "nested weights are bad for performance".

There is a saying in the Android programming globe, that I merely made up: "With little endeavor all hierarchy can be flattened".

In this instance RelativeLayout or GridLayout will efficiently supercede the nested LinearLayouts.

Common Mistake #ten: Not Setting the minSdkVersion to fourteen

Well, this is non a mistake, but information technology is bad practice.

Android ii.x was a huge milestone in developing this platform, merely some things should exist left backside. Supporting older devices adds more complexity for code maintenance and limits the development process.

The numbers are clear, the users have moved on, the developers shouldn't stay behind.

I'm aware that this doesn't apply for some big markets with sometime devices (ex. Republic of india), and setting the minSdkVersion to 14, on the Facebook App, means leaving couple of million users without their favorite social network. But, if y'all are starting fresh and trying to create a cute experience for your users, do consider eliminating the past. Users that don't have the resource, or experience the need to upgrade their device/Os, won't have the incentive to try out a superior version of your Android app and ultimately spend coin on it.

Wrap Upwardly

Android is a powerful platform that evolves rapidly. It may not exist reasonable to expect users to go along upwards the step, but it'due south crucial for the Android developers to do and then.

Knowing that Android is not merely on our phones or tablets is even more important. It'south on our wrists, in our living rooms, in our kitchens, and in our automobiles. Getting the nuts right is of utmost importance before nosotros start expanding.

sharpwabiagre.blogspot.com

Source: https://www.toptal.com/android/top-10-most-common-android-development-mistakes

Share this post