March 25, 2023

Lin Wang | Android Efficiency Engineer

Black magnifying glass with “</” inside of the glass portion and “manifest >” to the right of the magnifying glass

It’s a well known reality for Android builders that an app’s manifest (AndroidManifest.xml) holds essential utility declarations. It’s hardly ever monitored after being arrange as a result of we assume it rarely modifications. At Pinterest, nonetheless, we have now been actively monitoring the manifest after realizing it does change occasionally.

Whereas constructing an app, Gradle downloads all of the dependent libraries to compile and hyperlink them with the app. These dependent libraries every have their very own mini manifest. Through the construct course of, Android Gradle Plugin (AGP) merges them with the app’s principal manifest to type the ultimate manifest. Due to this merging course of, the ultimate manifest typically seems to be fairly totally different from the unique one and incorporates extra declarations. Normally, these further declarations are vital for dependent libraries to operate. Nevertheless, typically they’ll have unintended behaviors.

It first caught our consideration throughout a chilly begin regression investigation. We discovered a third celebration Software program Improvement Equipment (SDK) declaring a particular ContentProvider in its manifest to heat up itself as early as potential. It is because content material suppliers get initialized very early through the utility startup, even earlier than the Software’s onCreate() methodology is invoked. Nevertheless, we need to management each third celebration libraries’ initialization and solely initialize them when it’s vital. Subsequently, we added the next declaration:

<provider android:name=”” … other android properties … tools:node=”remove”/>

Including this declaration to the manifest will trigger the SdkEarlyInitializer to be faraway from the ultimate merged manifest. This transformation resulted in a chilly begin enchancment of 130ms.

From then on, we created the next course of to usually monitor the merged manifest modifications earlier than touchdown a commit, beginning with taking a snapshot of the present merged manifest and holding it within the codebase:

  1. As a part of the PR construct, we evaluate the merged manifest in opposition to the snapshot.
  2. If a distinction is detected, we fail the construct.
  3. The PR developer should then alter the snapshot manifest if the modifications are vital, or add the right “take away” tags to maintain the brand new parts out of the ultimate manifest.

A small group of blocking reviewers will overview each manifest change.

  • Found the WorkManagerInitializer (ContentProvider), which was added by the work supervisor library. We firstly eliminated it and notified Google, who ultimately added assist for initializing the work supervisor with a custom configuration.
  • Discovered a brand new intent was added by upgrading of the exoplayer library to 2.15.0. We then contributed to the continued issue discussion with Google to lastly have this pointless intent eliminated.
  • Detected the AD_ID permission was added by a library.
  • The common cshell diff is enough to match manifests
  • AGP does typically reorder the objects in manifest with out altering the content material, during which case the snapshot must be adjusted
  • Ignoring white areas and newlines is important
  • Often modified objects within the manifest have to be explicitly ignored (e.g. UUIDs, model codes)

With this strategy, we can be alerted when any new element will get added to our app and really feel extra assured every time we add new dependencies.

Android Efficiency Staff: Arun Okay, Ernesto Duhart, Lin Wang, Sheng Liu, Tom Harman

Particular Thanks: Sha Sha Chu (She Her)

To be taught extra about engineering at Pinterest, try the remainder of our Engineering Weblog and go to our Pinterest Labs web site. To discover life at Pinterest, go to our Careers web page.