Slides from my talk about Design Patterns and Android Development at GDG Dnipro-Art, 2017

1. Quick Look at Design Patterns
in Android Development
Constantine Mars
Team Lead, Senior Developer @ DataArt

2. #gdg_dnipro_art
Patterns everywhere

3. #gdg_dnipro_art
What do “GOF Patterns” mean?
"Each pattern describes a problem which occurs over and over again in our environment,
and then describes the core of the solution to that problem, in such a way that you can use
this solution a million times over, without ever doing it the same way twice"
- Christopher Alexander

4. #gdg_dnipro_art
Pattern structure
1. Pattern name
2. Problem
3. Solution
4. Consequences

5. #gdg_dnipro_art
Bricks and clay
1. Interface
2. Instantiation
3. Subtype - Type - Supertype
4. Dynamic binding
5. Polymorphism
6. Encapsulation

6. #gdg_dnipro_art
Principles
1. Class versus Interface Inheritance
2. Program to an interface, not an implementation
3. Favor object composition over class inheritance
4. Aggregation -> having or being part of
5. Acquaintance -> knows of (association, using)
6. Delegation
7. Inheritance versus Parameterized Types (generics, templates)

7. #gdg_dnipro_art
Applications of reuse
1. Toolkits - code reuse -> you write the main body of the application and
call the code you want to reuse
2. Frameworks - design reuse -> you reuse the main body and write the
code it calls

8. Pattern categorieS8 - GOF
Be together, not the same!

9. #gdg_dnipro_art
Creational Patterns
- Create objects
- Hide creation logic
- Do not use operator “new”
Give program more flexibility
to decide which objects to create

10. #gdg_dnipro_art
Structural Patterns
Class and object composition
Inheritance, interfaces and ways to
compose objects = obtain new
functionalities

11. #gdg_dnipro_art
Behavioral Patterns
It’s all about communication

12. #gdg_dnipro_art
A Mesh of XXIII

13. #gdg_dnipro_art
Table of Design Patterns by Vince Huston :)
Illustration from http://www.vincehuston.org/dp/

14. #gdg_dnipro_art
Organizing patterns space by GOF

15. Free your creativity while patterns work for you :)
Creational Patterns

16. #gdg_dnipro_art
Factory method
Define an interface for creating an object, but let subclasses decide which
class to instantiate

17. #gdg_dnipro_art
Abstract Factory
Captures how to create families of related product objects without
instantiating classes directly
Image from https://sourcemaking.com

18. #gdg_dnipro_art
Builder
Separate the construction of a complex object from its representation so
that the same construction process can create different representations

19. #gdg_dnipro_art
In Android
new AlertDialog.Builder(this)
.setTitle("Metaphorical Sandwich Dialog")
.setMessage("Metaphorical message to please use the spicy mustard.")
.setNegativeButton("No thanks", new DialogInterface.OnClickListener() { …
}})
.setPositiveButton("OK", new DialogInterface.OnClickListener() {...}})
.show();
Builder

20. #gdg_dnipro_art
Prototype
Specify the kinds of objects to create using a prototypical instance, and
create new objects by copying this prototype

21. #gdg_dnipro_art
Singleton
Ensure a class only has one instance, and provide a global point of access it

22. #gdg_dnipro_art
In Android
public class ExampleSingleton {
private static ExampleSingleton instance = null;
private ExampleSingleton() { // customize if needed }
public static ExampleSingleton getInstance() {
if (instance == null) { instance = new ExampleSingleton(); }
return instance;
} }
ExampleSingleton.getInstance();
Singleton

23. Building is under construction :)
Structural Patterns

24. #gdg_dnipro_art
Adapter
Convert the interface of a class
into another interface clients
expect. Adapter lets classes
work together that couldn't
otherwise because of
incompatible interfaces.

25. #gdg_dnipro_art
public class TribbleAdapter extends RecyclerView.Adapter {
private List mTribbles;
public TribbleAdapter(List tribbles) { this.mTribbles = tribbles; }
@Override public TribbleViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
LayoutInflater inflater = LayoutInflater.from(viewGroup.getContext());
View view = inflater.inflate(R.layout.row_tribble, viewGroup, false);
return new TribbleViewHolder(view); }
@Override public void onBindViewHolder(TribbleViewHolder viewHolder, int i) { viewHolder.configure(mTribbles.get(i));}
@Override public int getItemCount() { return mTribbles.size(); }
}
Adapter

26. #gdg_dnipro_art
Bridge
Allows separate class
hierarchies to work
together even as they
evolve independently
Image from https://sourcemaking.com

27. #gdg_dnipro_art
Composite
Captures the essence of
recursive composition in
object-oriented terms.

28. #gdg_dnipro_art
Decorator
Captures class and
object relationships that
support embellishment
by transparent
enclosure

29. #gdg_dnipro_art
Facade
Provide a unified interface to a set of interfaces in a subsystem. Facade
defines a higher- level interface that makes the subsystem easier to use

30. #gdg_dnipro_art
public interface BooksApi {
@GET("/books")
void listBooks(Callback<List> callback);
}
RestAdapter restAdapter =
new RestAdapter.Builder()
.setConverter(new CustomGsonConverter(new Gson()))
.setEndpoint("http://www.someurl.com")
.build();
return restAdapter.create(BooksApi.class);
Facade

31. #gdg_dnipro_art
Proxy
Provide a surrogate or placeholder for another object to control access to it.

32. All about communication, change and interchange :)
Behavioral Patterns

33. #gdg_dnipro_art
Command
Abstract class to provide
an interface for issuing a
request. The basic
interface consists of a
single abstract operation
called "Execute."

34. #gdg_dnipro_art
public class MySpecificEvent { /* Additional fields if needed */ }
eventBus.register(this);
public void onEvent(MySpecificEvent event) {/* Do something */};
eventBus.post(event);
Command

35. #gdg_dnipro_art
Chain of Responsibility
Chain the receiving objects and pass the request along the chain until an
object handles italgorithm in an object

36. #gdg_dnipro_art
Iterator
General interface for access and traversal

37. #gdg_dnipro_art
Mediator
Define an object that encapsulates how a set of objects interact

38. #gdg_dnipro_art
Memento (Token)
Without violating encapsulation, capture and externalize an object's
internal state so that the object can be restored to this state later

39. #gdg_dnipro_art
Flyweight
Use sharing to support large numbers of
fine-grained objects efficiently.

40. #gdg_dnipro_art
Observer
Define a one-to-many dependency between objects so that when one object
changes state, all its dependents are notified and updated automatically

41. #gdg_dnipro_art
apiService.getData(someData)
.observeOn(AndroidSchedulers.mainThread())
.subscribe (/* an Observer */);
Observer

42. #gdg_dnipro_art
State
Allow an object to alter its behavior when its internal state changes. The
object will appear to change its class

43. #gdg_dnipro_art
Strategy
Encapsulating an algorithm in an object

44. #gdg_dnipro_art
Interpreter
Define a represention for
language grammar along
with an interpreter that
uses the representation to
interpret sentences in the
language

45. #gdg_dnipro_art
Visitor
Refer generally to classes
of objects that "visit"
other objects during a
traversal and do
something appropriate

46. Android Patterns
Bald, mad and superperformant! =)

47. #gdg_dnipro_art
Dependency Injection

48. #gdg_dnipro_art
@Module
public class AppModule {
@Provides SharedPreferences provideSharedPreferences(Application app) { return
app.getSharedPreferences("prefs", Context.MODE_PRIVATE); }
}
@Component(modules = AppModule.class)
interface AppComponent { … }
@Inject SharedPreferences sharedPreferences;
Dependency Injection

49. #gdg_dnipro_art
Model-View-Controller (MVC)
● Model: your data classes.
● View: your visual classes
● Controller: the glue between the two

50. #gdg_dnipro_art
Model-View-ViewModel (MVVM)
● Model: your data classes.
● View: your visual classes
● ViewModel: exposes properties
● Binder: generates ViewModel properties

51. #gdg_dnipro_art
Model-View-Presenter (MVP)
● Model - interface defining the data
● Presenter - retrieves data from
repositories (model), and formats it for
display in the view
● View - passive interface that displays data
(the model) and routes user commands
(events) to the presenter

52. #gdg_dnipro_art
Other Patterns...
Loaders,
AsyncTasks,
Broadcast Receivers,
Intents,
Media Framework = Facade,
Object Pools,
Batching and caching
And many other...

53. UI Design Patterns
Have very similar rules, but are yet different

54. #gdg_dnipro_art
Links and books on GOF
- Joshua Kerievsky - Refactoring To Patterns
- Bruce Eckel - Thinking in Patterns with Java
- Eric Freeman - Head First Design Patterns
- Erich Gamma - Design Patterns: Elements
of Reusable Object-Oriented Software
- https://sourcemaking.com/design_patterns
- https://dzone.com/refcardz/design-patterns
- https://github.com/iluwatar/java-design-patterns

55. #gdg_dnipro_art
Links and books on Android Patterns
- Android Design Patterns https://unitid.nl/androidpatterns/
- Alex Lockwood http://www.androiddesignpatterns.com/
- Android Performance Patterns
https://www.youtube.com/playlist?list=PLWz5rJ2EKKc9CBxr3BVjPTPoDPLdPIFCE
- TutsPlus
https://code.tutsplus.com/articles/introduction-to-android-design-patterns--cms-20808
- Ray Wenderlich
https://www.raywenderlich.com/109843/common-design-patterns-for-android

56. #gdg_dnipro_art
Links and books on UI Patterns
- Material Design Guidelines
https://material.io/guidelines/material-design/introduction.html#
- UI Patterns http://ui-patterns.com/patterns
- UI Pttrns https://pttrns.com/android-patterns

57. “Patterns are everywhere -
from enterprise applications
to games and even devices,
the most important is to see them
Alexey Rybakov, DataArt Technical Evangelist

58. Constantine Mars
@ConstantineMars
+ConstantineMars
Q&A
Thank you!