This document discusses important decisions for new Android projects, including adopting architectures like MVx patterns from the beginning, using dependency injection with Dagger, and organizing code into packages by features rather than screens. It emphasizes that dependency injection, MVx patterns, and package-by-feature organization will provide a solid architecture for most projects. The document also recommends focusing on tools you're already familiar with and prioritizing maintainability.

1. New Android Project:
The Most Important Decisions
Vasiliy Zukanov
Freelance Android developer & consultant

2. @VasiliyZukanov 2
Who started a new professional Android project
in the past 3 years?
…past 2 years?
…past year?

3. @VasiliyZukanov 3
Which language, frameworks, libraries, practices, etc.
should I use in a new project?
RxJava
Kotlin
Java
Coroutines
ViewModel
Koin
Dagger Flow
Navigation
Conductor
MVI
MVVM
MVP
MVC
AutoValue
ConstraintLayout
Timber
ThreadPool
WorkManager
LiveData
Glide
Fragment
Single-activity
EventBus
Gson
Picasso
Fresco
Coil
SqlDelight
Room Moshi
Firebase
Modularization

4. @VasiliyZukanov 4
Architecture

5. @VasiliyZukanov 5
Architecture represents the
significant design decisions that shape
a system, where significant is
measured by cost of change.
“
Architecture – Grady Booch

6. @VasiliyZukanov 6
Architecture is the set of decisions
that are hard to change.
“
Architecture – Martin Fowler

7. @VasiliyZukanov 7
Architecture
≈
Subset of design decisions that affect the cost of change the most
≈
Maintainability!

8. @VasiliyZukanov 8
Maintainability is important
As well as staying pragmatic and getting stuff done!

9. @VasiliyZukanov 9
The Pareto principle (80-20 rule)
80% of the effects come from 20% of the causes

10. @VasiliyZukanov 10
Dependency Injection

11. Dependency injection misconception
@VasiliyZukanov 11
public class SomeClient {
private final SomeService mSomeService;
public SomeClient() {
mSomeService = new SomeService();
}
}
public class SomeClient {
private final SomeService mSomeService;
public SomeClient(SomeService someService) {
mSomeService = someService;
}
}
That’s bad because UNIT TESTS!
(can’t replace the implementation)
That’s good because UNIT TESTS
(can replace the implementation)
So, no need for DI if you don’t unit test and never replace implementations?

12. Reuse challenge
@VasiliyZukanov 12
public class FetchCurrentUserUseCaseSync {
public FetchCurrentUserUseCaseSync(ParseUserConverter parseUserConverter,
ParseUsersRetriever parseUsersRetriever,
OfflineDetector offlineDetector,
MyLogger myLogger) {
...
}
@WorkerThread
public CurrentUser fetchCurrentUser() {
...
}
}
+ 4 services + 3 transitive services = instantiate 8 objectsthis client
To get current user’s info I need:
FetchCurrentUserUseCaseSync is used in 14 different places!

13. Reuse strategies
Manually instantiate 8 * 14 = 112 objects
Reduce objects count through code duplication (multiplication)
God Objects
Static calls and global static state (e.g. Singletons)
Dependency injection
@VasiliyZukanov 13
Pretty much guaranteed if you don’t use DI

14. Dependency Injection Architectural Pattern
@VasiliyZukanov 14
Application
Construction Set
class
Functional Set
classintegration
Instantiation logic for each service is defined once in construction set,
and then all classes from functional set simply get the required dependencies from outside

15. Dependency Injection example
@VasiliyZukanov 15
public class ClipSettingsFragment extends BaseFragment {
@Inject ViewMvcFactory mViewMvcFactory;
@Inject ClipSettingsController mController;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
getControllerComponent().inject(this);
super.onCreate(savedInstanceState);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater,
@Nullable ViewGroup container,
@Nullable Bundle savedInstanceState) {
...
}
...
}
Declare the required services
Delegate resolution to Dagger
Reused tens of transitive dependencies; thousands of lines of code

16. @VasiliyZukanov 16
Dependency Injection is very beneficial, but extremely hard
to introduce into existing code
Adopt it from the onset of your new project!

17. @VasiliyZukanov 17
Dagger dependency injection framework is the best choice
for most Android projects today

18. @VasiliyZukanov 18
Decoupled User Interface Logic

19. Define application’s UI
Capture user’s interactions with the UI
@VasiliyZukanov 19
UI logic responsibilities

20. @VasiliyZukanov 20
Why decouple UI logic specifically?

21. Detailed and accurate requirements (UI mockups)
Much higher rate of change in most cases
Unreadable - verbose, messy, hacky, etc.
Easiest to test manually
Hardest to test automatically
@VasiliyZukanov 21
UI logic characteristics

22. @VasiliyZukanov 22
Decoupling of UI logic is the main rationale behind
MVx presentation layer architectural patterns

23. Kotlin Multiplatform?Jetpack Compose?
@VasiliyZukanov 23
Example of decoupled UI

24. @VasiliyZukanov 24
More information about UI decoupling and MVx in my talk
from Droidcon Berlin 2018

25. @VasiliyZukanov 25
Adopt some MVx at the beginning of a new project
You can change your mind later*

26. @VasiliyZukanov 26
Package by feature
Top-level packages should correspond to core
concepts of app’s business domain

27. Package by feature examples
@VasiliyZukanov 27
Google IO 2019 app

28. Feature ≠ screen
@VasiliyZukanov 28
Clip playback
screen
Settings screen
Standalone domain features prevent
inter-dependencies between
unrelated screens
Looks like a single “clips” feature…
…but…

29. Avoid preliminary modularization
@VasiliyZukanov 29
Feature packages are
straightforward to extract as
feature modules IF and
WHEN the need will arise

30. @VasiliyZukanov 30
As you add more features, you learn more about your
business domain
Constantly refactor feature packages to reflect your most
up-to-date understanding

31. @VasiliyZukanov 31
Dependency Injection, MVx and Package-by-Feature will give
you the “80% of architecture” on most projects

32. @VasiliyZukanov 32
Use the tools you’re familiar with

33. @VasiliyZukanov 33
Questions

34. My Android Development Courses
@VasiliyZukanov 34
www.TechYourChance.com

35. @VasiliyZukanov 35
Thank you!

36. References
1. Making Architecture Matter (Martin Fowler) - https://youtu.be/DngAZyWMGR0
2. Dependency Injection in Android - https://www.techyourchance.com/dependency-injection-
android/
3. Activities and Fragments are not MVx Views (Vasiliy Zukanov) -
https://youtu.be/oOARoQr4H5U
@VasiliyZukanov 36