Mobile

Optimize for Android (Go version): Classes from Google apps – Half 1

Written by admin



Posted by Niharika Arora, Developer Relations Engineer

The Android working system brings the facility of computing to everybody. This imaginative and prescient applies to all customers, together with these on entry-level telephones that face actual constraints throughout information, storage, reminiscence, and extra.
This was particularly essential for us to get proper as a result of, after we first introduced Android (Go version) again in 2017, individuals utilizing low-end telephones accounted for 57% of all machine shipments globally (IDC Cell Telephone Tracker).

What’s Android (Go version)?

Android (Go version) is a cell working system constructed for entry-level smartphones with much less RAM. Android (Go version) runs lighter and saves information, enabling Unique Tools Producers (OEMs) to construct reasonably priced, entry-level units that empower individuals with risk. RAM necessities are listed under, and for full Android (Go version) machine functionality specs, see this web page on our website.

12 months

2017

2018

2019

2020

2021

2022

Launch

Android 8

Android 9

Android 10

Android 11

Android 12

Android 13

Min RAM

512MB

512MB

512MB

1GB

1GB

2GB

Current Updates

We’re continuously making telephones powered by Android (Go version) extra accessible with extra efficiency optimizations and options designed particularly for brand new & novice web customers, like translation, app switching, and information saving.

Beneath are the latest enhancements we made for Android 12:

Quicker App Launches

Longer Battery Life 

Simpler App Sharing 

Extra Privateness Management


Why construct for Android (Go version)?

With the quick rising & simply accessible web, and all of the options obtainable at low price, OEMs and builders are aiming & constructing their apps particularly for Android (Go version) units.

Quick ahead to right now — many individuals worldwide actively use an Android (Go version) telephone. And in addition contemplating the massive OEMs like Jio, Samsung, Oppo, Realme and so on. constructing Android (Go version) units, there’s a want for builders to construct apps that carry out properly particularly on Go units.

However the markets with the quick rising web and smartphone penetration can have some difficult points, resembling:

  • Your app is just not beginning inside the required time restrict.
  • Plenty of options/required capabilities will increase your app dimension 
  • Find out how to deal with reminiscence strain whereas engaged on Go apps?

Optimize your apps for Android (Go version)

To assist your app succeed and ship the very best expertise in growing markets, we now have put collectively some greatest practices based mostly on expertise constructing our personal Google apps Gboard & Digital camera from Google.

Strategy

Phases

Description

Outline Earlier than beginning any optimization effort, it’s essential to outline the targets. Key Efficiency Indicators (KPIs) need to be outlined for the app.

  • KPIs could be frequent throughout totally different apps and a few could be very particular. Some examples of KPIs could be  
KPI Class
App Startup Latency Frequent to all apps
App Crash Charge Frequent to all apps
Finish to finish latency for CUJ – Digital camera Shot Particular to Digital camera app
App Not Responding Charge Frequent to all apps
  • As soon as KPIs are outlined the group ought to agree on the goal thresholds. This may be derived from the minimal consumer expertise/benchmarks in thoughts.
  • KPIs ought to ideally be outlined from the angle of balancing Person Expertise and technical complexity.
Breakdown As soon as KPIs are outlined, the following steps might be to interrupt down a given KPI into particular person sign metrics.

  • For instance → Finish to finish latency for CUJ (pictures in Digital camera) could be divided into → Body seize latency, picture processing latency, time spent on saving a processed picture to disk and so on.
  • Equally, App Crash Charge could be bucketed into → Crash because of unhandled errors, Crash because of excessive reminiscence utilization, Crash because of ANR and so on.
Benchmark Benchmark or measure the KPI values and particular person metrics to determine present efficiency.
If KPI targets are met, issues are good. If not → determine the bottlenecks by trying on the particular person breakdowns.
Repeat the method

After optimizing a sure bottleneck return and benchmark the metrics once more to see if the KPI targets are met. If not, repeat the method. If sure, nice job!
Add Common regression check That both runs for each change or in some frequency to determine regressions in KPIs. It’s harder to debug and discover sources of regressions or bugs than to not permit them to get into the codebase. Don’t permit the adjustments that fail the KPI targets until the choice is to replace the KPI targets.

  • Attempt to put money into constructing a regression infrastructure to take care of such points in early levels.
  • Resolve on how usually checks ought to run? What needs to be the optimum frequency on your app?

Optimize App Reminiscence

  • Launch cache-like reminiscence in onTrimMemory(): onTrimMemory() has all the time confirmed helpful for an app to trim unneeded reminiscence from its course of. To greatest know an app’s present trim degree, you need to use ActivityManager.getMyMemoryState(RunningAppProcessInfo) after which attempt to optimize/trim the sources which aren’t wanted.

GBoard used the onTrimMemory() sign to trim unneeded reminiscence whereas it goes within the background and there may be not sufficient reminiscence to maintain as many background processes operating as desired, for instance, trimming unneeded reminiscence utilization from expressions, search, view cache or openable extensions in background. It helped them cut back the variety of occasions being low reminiscence killed and the typical background RSS. Resident Set Dimension(RSS) is principally the portion of reminiscence occupied by your app course of that’s held in predominant reminiscence (RAM). To know extra about RSS, please refer right here. 

  • Examine if malloc could be changed with mmap when accessing read-only & giant recordsdata: mmap is just beneficial for studying a big file onto reminiscence (‘read-only reminiscence mapped file’). The kernel has some particular optimizations for read-only reminiscence mapped recordsdata, resembling unloading unused pages.

Sometimes that is helpful for loading giant belongings or ML fashions.

  • Scheduling duties which require related sources(CPU, IO, Reminiscence) appropriately: Concurrent scheduling might result in a number of reminiscence intensive operations to run in parallel and resulting in them competing for sources and exceeding the height reminiscence utilization of the app. The Digital camera from Google app discovered a number of issues, ensured a cap to peak reminiscence and additional optimized their app by appropriately allocating sources, separating duties into CPU intensive, low latency duties(duties that have to be completed quick for Good UX) & IO duties. Schedule duties in proper thread swimming pools / executors to allow them to run on useful resource constrained units in a balanced style.
  • Discover & repair reminiscence leaks: Combating leaks is troublesome however there are instruments like Android Studio Reminiscence Profiler/Perfetto particularly obtainable to cut back the hassle to discover and repair reminiscence leaks.

Google apps used the instruments to determine and repair reminiscence points which helped cut back the reminiscence utilization/footprint of the app. This discount allowed different elements of the app to run with out including extra reminiscence strain on the system.


An instance from Gboard app is about View leaks

A selected case is caching subviews, like this: 

 

void onKeyboardViewCreated(View keyboardView) {
  this.keyButtonA = keyboardView.findViewById(…);
  …
}
 

The |keyboardView| is perhaps launched at a while, and the |keyButtonA| needs to be assigned as null appropriately at a while to keep away from the view leak.

Classes discovered:

    • At all times add framework/library updates after analyzing the adjustments and verifying its influence early on.
    • Ensure to launch reminiscence earlier than assigning new worth to a pointer pointing to different object allocation in heap in Java. (native backend java objects) 

For instance :

In Java it needs to be alright to do

 

ClassA obj = new ClassA(“x”);
// … one thing
obj = new ClassB(“y”);

 

GC ought to clear this up ultimately.

 

if ClassA allocates native sources beneath and would not cleanup routinely on finalize(..) and requires caller to name some launch(..)  technique, it must be like this 

 

ClassA obj = new ClassA(“x”);
// … one thing

// Specific cleanup.
obj.launch();

obj = new ClassB(“y”);

 

else it is going to leak native heap reminiscence. 

  • Optimize your bitmaps: Massive pictures/drawables normally eat extra reminiscence within the app. Google apps recognized and optimized giant bitmaps which might be used of their apps. 

Classes discovered :

    • Desire Lazy/on-demand initializations of huge drawables.
    • Launch view when needed.
    • Keep away from utilizing full coloured bitmaps when potential. 

For instance: Gboard’s glide typing characteristic wants to point out an overlay view with a bitmap of trails, which may solely has the alpha channel and apply a coloration filter for rendering.

 

// Creating the bitmap for trails.

trailBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ALPHA_8);

// Setup paint for trails.

trailPaint.setColorFilter(new ColorMatrixColorFilter(new ColorMatrix(new float[] {

  0, 0, 0, 0, (coloration >> 16) & 0xFF,

  0, 0, 0, 0, (coloration >> 8) & 0xFF,

  0, 0, 0, 0, coloration & 0xFF,

  0, 0, 0, 1, 0

})));

// onDraw

@Override

protected void onDraw(Canvas canvas) {

  tremendous.onDraw(canvas);

  if (trailBitmap != null) {

    canvas.drawBitmap(trailBitmap, 0, 0, trailPaint);

  }

}

 
A screenshot of glide typing on Gboard

  • Examine and solely set the alpha channel for the bitmap for advanced customized views used within the app. This saved them a few MBs (per display screen dimension/density).
  • Whereas utilizing Glide, 
    • The ARGB_8888 format has 4 bytes/pixel consumption whereas RGB_565 has 2 bytes/pixel. Reminiscence footprint will get lowered to half when RGB_565 format is used however utilizing decrease bitmap high quality comes with a value too. Whether or not you want alpha values or not, attempt to suit your case accordingly.
    • Configure and use cache correctly when utilizing a 3P lib like Glide for picture rendering.

  • Attempt to decide on different choices for GIFs in your app when constructing for Android (Go version) as GIFs take numerous reminiscence.
  • The aapt instrument can optimize the picture sources positioned in res/drawable/ with lossless compression through the construct course of. For instance, the aapt instrument can convert a true-color PNG that doesn’t require greater than 256 colours to an 8-bit PNG with a coloration palette. Doing so ends in a picture of equal high quality however a smaller reminiscence footprint. Learn extra right here.
  • You may cut back PNG file sizes with out shedding picture high quality utilizing instruments like pngcrush, pngquant, or zopflipng. All of those instruments can cut back PNG file dimension whereas preserving the perceptive picture high quality.
  • You may use resizable bitmaps. The Draw 9-patch instrument is a WYSIWYG editor included in Android Studio that permits you to create bitmap pictures that routinely resize to accommodate the contents of the view and the dimensions of the display screen. Be taught extra in regards to the instrument right here

Recap

This a part of the weblog outlines why builders ought to contemplate constructing for Android (Go version), an ordinary strategy to comply with whereas optimizing their apps and a few suggestions & learnings from Google apps to enhance their app reminiscence and appropriately allocate sources.

Within the subsequent a part of this weblog, we are going to discuss one of the best practices on Startup latency, app dimension and the instruments utilized by Google apps to determine and repair efficiency points.



About the author

admin

Leave a Comment