Scaling your Android App With Modularization

Scaling an Android App from
1 to 100 Developers with
Modularization
@BenSchwab13

A tale of two apps.
Around June of 2011 two android apps were being built…

Splinky
apply plugin: ‘com.android.application'
Airbnb

What is modularization?
App

apply plugin: ‘com.android.library’
App
Lib

Manifest R res
classes.jar
App
Lib
apk/aab
Manifest R res
classes.jar

“App depends on Lib”
App
Lib

Lib2
Lib3
App
Lib1

The first rule of modularization is…

You don’t modularize if you don’t have too.

Project Structure
Report Card
Build times

Build times.
Project/gradle.properties
# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/
multi_project_builds.html#sec:decoupled_projects
org.gradle.parallel=true

Clean Builds
Time(seconds)
0
50
100
150
200
Hundreds of source files
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
1 2 3 4# of modules

Project Structure
Report Card
Build times
Code Ownership

Code Ownership (Attribution)
how effort durability
line git blame
🚌
file/class @Owner(GrowthTeam)
module manifest

Murphy’s Law:
“Whatever can go wrong will go wrong”.
Murphy’s Law of code access:
“Whatever they can access,
they will access
(and it will go wrong)”.

Mall
Code Ownership
(Encapsulation)
Ben’s
Coffee Shop

Mall
Code Ownership
(Encapsulation)
Ben’s
Coffee Shop
CoffeeGrinder

Code Ownership
(Encapsulation)
Mall
Murphy’s
Coffee Shop
Ben’s
Coffee Shop
CoffeeGrinder

Code Ownership
(Encapsulation)
Mall
Murphy’s
Coffee Shop
Ben’s Boba
Shop
BobaMachine

Code Ownership
(Encapsulation)
Mall
Murphy’s
Boba Shop?
Ben’s Boba
Shop
BobaMachine

Code Ownership
(Encapsulation)
internal
public
private
protected
Murphy’s
Coffee Shop
Mall
Ben’s Boba
Shop
Boba Machine

Code Ownership
(Encapsulation)
internal
public
private
protected
Mall
Murphy’s
Coffee Shop
Ben’s Boba
Shop
Boba Machine

Project Structure
Report Card
Build times
Code Ownership
App Bundles

Bigger =/= Better
For every 6mb of app size, install conversion
drops by 1%.
Cutting an 100mb app to 10mb would
see download conversion increase by 30%.

The state of modularization at
Airbnb
160+
modules
2-5
minutes
“Lite”
builds
Lots of
lessons
learned…

Airbnb
experiences
listing
homes
listing

Structure your code link your organization
Conway’s Law.

Base
Modularize by feature.
Base (Core)
• “Pure” Infrastructure.
• Strictly no domain knowledge.
• “Could this be open source-able?”
• Owned by Native Infrastructure team.
• Keep it lean. No deprecated code.

Home Listing
Experience
Listing
Feature Modules
•Owned by a single team.
•Encapsulates a single “feature”.
•A single, addressable entry-point.
•Smaller is better.
•A team might own many feature modules.
•Can not depend on other feature modules.
Base

Airbnb
Home Listing
Experience
Listing
App shell
•No feature-specific code.
•No infrastructure-specific code.
•Creates Dagger Component. Base

Airbnb
Home Listing
Base
Experience Listing

Airbnb
Home Listing
Base
Experience
Listing
Place
List your
space
Mange your
space
Profile Payments Itinerary

Build times?
Airbnb
Home Listing
Base
Experience
Listing
Place
List your
space
Mange your
space

Project Structure
Report Card
Build times
Code Ownership
App Bundles
🏎

Ownership?
Airbnb
Home Listing
Base
Experience
Listing
Place
List your
space
Mange your
space

Project Structure
Report Card
Build times
Code Ownership
App Bundles
🏎
🤝

Instant Apps / Dynamic Features?
Airbnb
Home Listing
Base
Experience
Listing
Place
List your
space
Manage your
space

Project Structure
Report Card
Build times
Code Ownership
App Bundles
🏎
🤝
✅

Common Challenges
Sharing CodeNavigation Upstrea

Common Challenges
Sharing Code
Navigation
Upstreaming depend

fun launch(context: Context, listingId: Long) {
val listingIntent = Intent(context, HomeListingActivity::class.java).apply {
putExtra("listingId", listingId)
}
context.startActivity(listingIntent)
}
Airbnb
Base
Home Listing Experience Listing

Nearby Experiences
val listingIntent = Intent(context, HomeListingActivity::class.java).apply {
}
}
Airbnb
Base

Nearby Experiences
val listingIntent = Intent(context, ExperienceListingActivity::class.java).apply {
}
}
Airbnb
Base

Nearby Experiences
Airbnb
Base
Intents

fun <T> loadClassOrNull(className: String): Class<T>? {
return CLASS_MAP.getOrPut(className) {
try {
Class.forName(className)
} catch (e: ClassNotFoundException) {
// Can't store a null value in the concurrent map
return null
}
}.castOrNull()
object Activities {
fun intentForListing(context: Context, listingId: Long): Intent? {
val args = Bundle().apply { putLong("listingId", listingId) }
return loadClassOrNull<Activity>("com.airbnb.android.ListingActivity")
.let { Intent(context, it) }
.apply { putExtras(args) }
}
}
object Fragments {
fun fragmentForListing(listingId: Long): Fragment? {
return loadClassOrNull<Fragment>("com.airbnb.android.ListingFragment")

object Activities {
fun intentForListing(context: Context, listingId: Long): Intent? {
return loadClassOrNull<Activity>("com.airbnb.android.ListingActivity")
.let { Intent(context, it) }
.apply { putExtras(args) }
}
}
object Fragments {
?.newInstance()
?.apply { this.arguments?.putBundle("args", args) }
}
}

object Fragments {
?.newInstance()
?.apply { this.arguments?.putBundle("args", args) }
}
}

Intent?
•This is a dynamic feature. Need to download it with PlayCore.
•This is debug build and the module is not present. Toast developer.
•A developer deleted the activity/fragment.
Reflect on all fragment/activity entries and assert present.
Airbnb
Base
Intents

Common Challenges
Sharing Code
Navigation Upstreaming dependencies

Home Listing
Experience
Listing
Wishlist Intents
Airbnb
Base
*Same dependencies as before. I’m just lazy…

Airbnb
Base
Home Listing
Experience
Listing
Wishlist Intents
Wishlist
Manager

Home Listing
Experience
Listing
Wishlist Intents
Airbnb
Base
Wishlist
Manager

Base
Wishlist
Manager
SearchFilters
ListingFormat
ter
Home Listing
Experience
Listing
Wishlist Intents
Airbnb

Library Modules
lib.WishlistManager
• Owned by a single team.
• No launchable features.
• Provides consumable
dependencies via an interface.
• Forces API design, instead of
sticking if/when cases in other
teams code.
Base
Airbnb
Home ExperienceWishlist Intents

Keep your base lean.Keep your base lean.

Communicating Deprecation
Base
Home Listing
Experience
Listing
Wishlist

Base
Guava
Home Listing
Experience
Listing
Wishlist

Murphy’s Law of code access:
“Whatever they can access,
they will access
(and it will go wrong)”.

Base
lib.deprecated.Guava
Home Listing
Experience
Listing
Wishlistnew feature

Common Challenges
Sharing CodeNavigation
Upstreaming dependencies

Airbnb
Experience ListingHome Listing
class TrebuchetRequest(val keys: Set<TrebuchetKey>)
Base

Base
enum class HomeListingTrebuchetKeys(override val key: String) : TrebuchetKey {
ShowSimilarExperiences(“android.show_similiar_experiences”),
UseMvRx(“android.use_mvrx_home_listing”),
}
Airbnb

enum class ExperienceListingTrebuchetKeys(override val key: String): TrebuchetKey {
ShowSimilarListings(“android.show_similiar_listings”),
UseVideos(“android.use_videos”),
}
Base
Airbnb

Base
Airbnb
class TrebuchetKey

Base
Airbnb
Violates no infrastructure in shell.
Violates single module owner.
class TrebuchetKey

Base
Airbnb
val trebuchetKeys =
“Plugin” Architecture
class TrebuchetRequest(…)
class TrebuchetKey
interface BaseGraph {
val trebuchetKeys: Set<TrebuchetKey>
}

Base
Airbnb
class AirbnbApplication : Application() {
override fun onCreate() {
val baseGraph = object : BaseGraph {
override val trebuchetKeys: Set<TrebuchetKey>
get() {
return mutableSetOf<TrebuchetKey>().apply {
addAll(HomeListingTrebuchetKeys.values())
addAll(ExperienceListingTrebuchetKeys.values())
}
}
}
BaseApplication.onTargetApplicationCreated(this, baseGraph)
}
}

get() {
}
}
}
}
}
Base
Airbnb

get() {
addAll(Feature1TrebuchetKeys.values())
…
addAll(FeatureNTrebuchetKeys.values())
}
}
}
}
}
Experience
Listing
Home
Listing
Base
Airbnb
Feature1Feature1

Managing Multi-module
Projects with Dagger

Airbnb
ExperienceListingHomeListing

Airbnb
AirbnbComponent
HomeListingComponent ExperienceListingComponent
@ComponentScope
@Singleton
“App scope”
Base

Airbnb
AirbnbComponent
@ComponentScope
@Singleton
“App scope”
Base
AppModule AppModule
@Singleton
“App scope”
@Singleton
“App scope”

Airbnb
AirbnbComponent : AppGraph
Base
AppModule AppModule
AppGraph
@Multibinds @Multibinds

fun trebuchetKeys(): Set<TrebuchetKey>
}
@Module
abstract class BaseAppModule {
@Multibinds abstract fun trebuchetKeys(): Set<TrebuchetKey>
}
class HomeListingDagger {
@Subcomponent
@ComponentScope
interface HomeListingComponent {
@Subcomponent.Builder
interface Builder {
fun build(): HomeListingComponent
}
}
@Module
abstract class AppModule {
@Binds
@ElementsIntoSet
fun provideTrebuchetKeys() : Set<Trebuchet> {
return HomeListingTrebuchetKeys.values().toSet()
}
}
interface HomeListingAppGraph {
fun p3Builder(): HomeListingComponent.Builder
}
}
Base
Features
Airbnb
}
interface AppGraph
}

fun trebuchetKeys(): Set<TrebuchetKey>
}
@Module
abstract class BaseAppModule {
@Multibinds abstract fun trebuchetKeys(): Set<Trebuchet
}
@Subcomponent
@ComponentScope
interface Builder {
}
}
@Module
@Binds
@ElementsIntoSet
}
}
interface HomeListingAppGraph {
}
}
Base
Features
Airbnb
}
interface AppGraph
}

@Subcomponent
@ComponentScope
interface Builder {
}
}
@Module
@Binds
@ElementsIntoSet
}
}
interface AppGraph {
}
Features
Airbnb
interface AppGraph
}

Airbnb
@Singleton
@Component(modules = [
HomeListingDagger.HomeListingAppModule::class,
ExploreListingDagger.ExploreListingAppModule::class
])
interface AirbnbComponent :
BaseGraph,
HomeListingDagger.HomeListingAppGraph,
ExploreListingDagger.AppGraph

Airbnb
@Singleton
])
BaseGraph,
Base fun <T : BaseGraph> component(): T
Home Listing
Experience
Listing
Place
List your
space
Mange your
space

Airbnb
@Singleton
])
BaseGraph,
Base fun <T : BaseGraph> component(): T
Home Listing Place
List your
space
Mange your
space
Profile ItineraryPayments
Experience
Listing

AirbnbApplication Shell
Features
Infrastructure
Libraries
home listing experiencewishlist
lib.wishlistmanager
base
intents
Dagger initialization
Airbnb

Build tooling to support your project structure.

The anatomy of a feature module.
Project/homelisting/
Project/experiencelisting/
build.gradle
TrebuchetKeys.kt
HomeListingDagger.kt
Project/airbnb/
AndroidManifest.xml
res/resources
build.gradle
TrebuchetKeys.kt
ExperienceListingDagger.kt
AndroidManifest.xml
res/resources
AirbnbGraph
AirbnbComponent
build.gradle
settings.gradle

package <%= module_info.qualified_package_name %>
import com.airbnb.android.base.trebuchet.TrebuchetKey
enum class <%= module_info.name_pascal_case %>TrebuchetKeys(override val key: String) : TrebuchetKey

package <%= module_info.qualified_package_name %>
import com.airbnb.android.base.trebuchet.TrebuchetKey
enum class <%= module_info.name_pascal_case %>TrebuchetKeys(override val key: String) : TrebuchetKey
{
…
'TrebuchetKeys.kt' => “#{module_info.main_dir}/#{module_info.name_pascal_case}TrebuchetKeys.kt",
…
}.each do |template, file_name|
erb_template = ERB.new(File.read("#{template_dir}/#{template}"), nil, '-')
File.write(file_name, erb_template.result(binding))
end
ml006617bschwab:android ben_schwab$ bundle exec rake make_module
Module name (with spaces)
home listing
Creating home listing with package name com.airbnb.android.homelisting
Will you be moving/writing Java code in this module? [y/n]
n
Add home listing as a dependency of the flavor.full module? [y/n]
n
Run `./buckw project --skip-build` for intellij to pick up the new module.

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
4 5 6 7 8 9 10# of modules

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
4 5 6 7 8 9 10# of modules
Project Structure
Report Card
Build times
Code Ownership
App Bundles
🏎
🤝
✅

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
4 5 6 7 8 9 10# of modules
Project Structure
Report Card
Build times
Code Ownership
App Bundles
🤝
✅
🐢

build.gradle
android {
...
defaultConfig {...}
buildTypes {
debug{...}
release{...}
}
// Specifies one flavor dimension.
flavorDimensions "version"
productFlavors {
demo {
// Assigns this product flavor to the "version" flavor dimension.
// This property is optional if you are using only one dimension.
dimension "version"
applicationIdSuffix ".demo"
versionNameSuffix "-demo"
}
full {
dimension "version"
applicationIdSuffix ".full"
versionNameSuffix "-full"
}
}
}

build.gradle
android {
...
defaultConfig {...}
buildTypes {
debug{...}
release{...}
}
// Specifies one flavor dimension.
flavorDimensions "version"
productFlavors {
demo {
// Assigns this product flavor to the "version" flavor dimension.
// This property is optional if you are using only one dimension.
dimension "version"
applicationIdSuffix ".demo"
versionNameSuffix "-demo"
}
full {
dimension "version"
applicationIdSuffix ".full"
versionNameSuffix "-full"
}
}
}
./gradlew :airbnb:installDemoDebug

Features
Infrastructure
Libraries
lib.wishlistmanager
base
intents

Features
Infrastructure
Libraries
lib.wishlistmanager
base
intents
Flavors flavor.homes flavor.experiencesflavor.full

Airbnb
lib.wishlistmanager
base
intents
flavor.homes flavor.experiencesflavor.full
Application Shell
Features
Infrastructure
Libraries
Flavors

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
Full build

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
Time
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
Full build

Clean Builds
Time(seconds)
0
12.5
25
37.5
50
Time
.2 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
Full Build Lite Flavor

1) It needs to be easy to create a flavor.

project.flavors.each { flavor, config ->
project.dependencies.add("${flavor}Api", project(config.entryModule))
}
project.ext.flavors = [
// If you want your flavor to be installed as a separate app for side-by-side
installation, do:
// foo: new FlavorOptions(":favor.foo").useSeparatePackageName()
full: new FlavorOptions(":flavor.full"),
homeListing: new FlavorOptions(“:flavor.homelisting”).useSeparatePackageName(),
]
Airbnb
productFlavors {
"$flavor" {
dimension 'scope'
if (flavor != 'full') {
versionNameSuffix ".$flavor"
if (config.useSeparatePackageName) {
applicationIdSuffix ".$flavor"
}
}
}
}
}
build.gradle
Specify the the flavor module to install.

}
Airbnb
productFlavors {
"$flavor" {
dimension 'scope'
if (flavor != 'full') {
versionNameSuffix ".$flavor"
if (config.useSeparatePackageName) {
applicationIdSuffix ".$flavor"
}
}
}
}
}
build.gradle
Allow side-by-side installation of lite apps.
Create the flavor.

}
Airbnb build.gradle

}
Airbnb build.gradle
flavor.homes build.gradle
dependencies {
api project(':homelisting')
api project(':hometour')
}
Airbnb
flavor.homes
home listing
lib.wishlistmanag
base
hometour
Generate the dagger component

2) Flavors need to handle missing code gracefully.

3) Can flavors be more than just faster?
2) Flavors need to handle missing code gracefully.

MvRx
GraphQL
@BenSchwab13
Modularization
Epoxy
Server Driven UI

Scaling your Android App With Modularization

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Scaling your Android App With Modularization

Similaire à Scaling your Android App With Modularization (20)

Dernier

Dernier (20)

Scaling your Android App With Modularization