Modularizing Legacy Apps A PRAGMATIC APPROACH Marcello Galhardo Slides at https://tinyurl.com/y9zcf4u9 

Marcello Galhardo Android Dev @ Quandoo Moderator @ Android Dev BR 

Why? • Build takes too long • Code ownership • Separation of concerns • Dynamic Features 

Strategy #1 Quality Directives 

• Code must be under continuous integration • Automate the build • Test coverage measure the code quality • Small Feature Branches and Pull Requests 

• Code must be under continuous integration • Automate the build • Test coverage measure the code quality • Small Feature Branches and Pull Requests 

Write code Push code to Git Run unit and ui tests Build generation Deploy on Store Distribute to QAs 

• Code must be under continuous integration • Automate the build • Test coverage measure the code quality • Small Feature Branches and Pull Requests 

[#ticket] New search page in separated module ? authored 2 weeks ago Showing 272 changed files with 4582 additions and 365 deletions 

New Branch Your Branch Cherry-pick Cherry-pick PR 1 PR 2 Develop Branch 

Strategy #2 Scout the Codebase 

• Keep things you need • Donate things someone else might need • Discard or recycle the rest 

fun View.isVisible() = this.visibility == View.VISIBLE @Deprecated( message = "Replaced by ViewKt.", level = DeprecationLevel.ERROR, replaceWith = ReplaceWith( expression = "ViewKt" ) ) object ViewUtils {…} 

Strategy #3 Keep It Simple, Stupid 

• Don’t create modules that you don’t need • Don’t plan too much ahead: Emergent Design • There are no final decisions • "Branch by Abstraction” when extracting modules 

Strategy #4 Don’t Talk to Strangers 

• Modules shouldn't reveal anything unnecessary to other modules • Modules don’t rely on other modules' implementations • Explicitly pass required data into your modules • Avoid similar modules: duplication is a symptom of structural problems 

Strategy #5 Don’t Repeat Yourself 

• Make it easier to share code • Centralise your resources • Share versions of dependencies using variables 

• Make it easier to share code • Centralise your resources • Share versions of dependencies using variables 

App 

Feature 2 Feature 1 

Feature 2 Feature 1 Common 

Feature 2 Feature 1 Common 

Build Output :feature2 :feature1 :base Use Use 

• Make it easier to share code • Centralise your resources • Share versions of dependencies using variables 

// ../scripts/gradle/base-build.gradle apply plugin: 'kotlin-android' apply plugin: 'kotlin-android-extensions' apply plugin: ‘kotlin-kapt' android { compileSdkVersion compile_sdk_version buildToolsVersion build_tools_version defaultConfig { minSdkVersion min_sdk_version targetSdkVersion target_sdk_version versionCode version_code versionName version_name } buildTypes {…} } dependencies { implementation “org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" } 

// Feature module apply plugin: 'com.android.feature' apply from: "../scripts/gradle/base-build.gradle" dependencies {…} // Library module apply plugin: 'com.android.library' apply from: “../scripts/gradle/base-build.gradle" dependencies {…} 

Strategy #6 Small Interactions 

:legacy :feature :facade Invokes new feature Access legacy functionalities by well-defined interface and dependency injection Implements interfaces on legacy code 

:legacy :feature2 :facade :feature1 :feature3 Extract features from :legacy 

:app :feature2 :base :feature1 :feature3 Move interfaces from facade and provide new Implementation to :base 

IntelliJ IDEA rocks. Luckily, Android Studio is powered by IntelliJ IDEA. https://www.jetbrains.com/help/idea/refactoring- source-code.html 

Strategy #7 Vertical Slice Architecture 

• Avoid “N-Tier Architectures” • Architectural boundaries don’t run between modules but rather through them 

• Avoid “N-Tier Architectures” • Architectural boundaries don’t run between modules but rather through them 

:app :domain :presentation :data All repositories exposed to the domain module All use cases exposed to the presentation module :app knows about all modules and up the DI framework 

Domain Presentation Data Feature 

• Avoid “N-Tier Architectures” • Architectural boundaries don’t run between modules but rather through them 

:app :feature2 :base :feature1 :component 

:module domain data ui model use case 
 repository activity fragment view model store repository local remote 

Strategy #8 Dependency Injection 

:app App Component Discovery Component Base Component Use Depend Build :discovery Build :base Use Use Build Use 

@Singleton @Component(modules = [ BaseModule::class ]) interface BaseComponent { {…} fun router(): DiscoveryRouter companion object { // workaround val INSTANCE: BaseComponent = DaggerBaseComponent.create() } } 

@ActivityScope @Component( modules = [ DiscoveryModule::class ], dependencies = [ BaseComponent::class ]) interface DiscoveryComponent : AndroidInjector { @Component.Builder abstract class Builder : AndroidInjector.Builder() { abstract fun plus(component: BaseComponent): Builder } } 

DaggerDiscoveryComponent.builder() .plus(BaseComponent.INSTANCE) .create(this) .inject(this) 

@Singleton @Component(modules = [ {…} BaseModule::class ]) interface AppComponent : AndroidInjector { fun inject(target: Activity) {…} } 

Strategy #9 Only Talk to Your Friends 

:app :discovery :base :search :instantapp 

interface Router { companion object { const val BASE_URL = “https://example.com” } } interface DiscoveryRouter : Router { fun startAvailabilityFilterActivityForResult(activity: Activity, requestCode: Int, peopleCount: Int, date: LocalDate, time: LocalTime) object Params { const val PEOPLE_COUNT = “PEOPLE_COUNT" const val DATE = "DATE" const val TIME = "TIME" } } 

@Reusable class UrlDiscoveryRouter @Inject constructor() : DiscoveryRouter { override fun startAvailabilityFilterActivityForResult(activity: Activity, requestCode: Int, peopleCount: Int, date: LocalDate, time: LocalTime) { val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url)).apply { addCategory(Intent.CATEGORY_DEFAULT) addCategory(Intent.CATEGORY_BROWSABLE) setPackage(activity.packageName) putExtra(DiscoveryRouter.Params.PEOPLE_COUNT, peopleCount) putExtra(DiscoveryRouter.Params.DATE, date) putExtra(DiscoveryRouter.Params.TIME, time) } activity.startActivityForResult(fragment, intent, requestCode) } // companion object private const val URL = "${BASE_URL}/availability/filter" } 



class SimpleActivity : AppCompatActivity() { @Inject lateinit var discoveryRouter: DiscoveryRouter fun onButtonClicked(…) { discoveryRouter.startAvailabilityFilterActivityForResult( activity = this, requestCode = requestCode, peopleCount = peopleCount, date = date, time = time) } } 

Strategy #10 Delivery Small and Iterate 

Start State A State B State C Minor change Minor change Minor change Quickly identify issues End Fix issues Rollback as last option New interaction 

A Pragmatic Approach 1. Quality Directives 2. Scout the Codebase 3. Keep it Simple, Stupid 4. Don’t Talk to Strangers 5. Don’t Repeat Yourself 6. Small Interactions 7. Vertical Slice Architecture 8. Dependency Injection 9. Only Talk to Your Friends 10.Delivery Small and Iterate 

Questions? We’re hiring! https://tinyurl.com/y4vfr9ud Marcello Galhardo Slides at https://tinyurl.com/y9zcf4u9