Design Patterns in the Android
Framework
Prof. Sheng-De Wang
What are Design Patterns?
In software engineering, a design pattern is a
general reusable solution to a commonly
occurring problem in software design.
is not a finished design
is a description or template for how to solve a
problem that can be used in many different
situations.
Object-oriented design patterns typically show
relationships and interactions between
classes or objects.
Design patterns are widely used in the process
of designing component-based systems
2
Definitions of Software Engineering
The application of engineering to software
Field of computer science dealing with
software systems
large and complex
built by teams
exist in many versions
last many years
undergo changes
More definitions
Application of a systematic,
disciplined, quantifiable
approach to the
development, operation, and
maintenance of software
(IEEE 1990)
Multi-person construction
of multi-version software
(Parnas 1978)
3
Software Development Life Cycle
Object-Oriented Life Cycle
More time is spent in analysis and design,
less time in implementation, testing and
maintenance.
Life cycle phases intermix
Object-oriented (OO) design
The system is viewed as a collection of
interacting objects.
The system state is decentralized and each
object manages its own state.
Objects may be instances of an object class
and communicate by exchanging messages.
OO Design Concepts
Design classes
Entity classes
Boundary classes
Controller classes
Inheritanceall responsibilities of a superclass is immediately
inherited by all subclasses
Messagesstimulate some behavior to occur in the receiving
object
Polymorphisma characteristic that greatly reduces the effort
required to extend the design
Android Framework
Android framework is based on objectoriented design
Part of Android Operating Systems
Whatisa
framework?
Android
Operating
Systems
An important component
WebKit
An open source web page layout engine
Used in Apples Safari browser, Googles Chrome
Browser,
Coded in C++
Ported to Nokia Symbian OS, iPhone OS, Android
OS, Palms WebOS,
First android application
example
Inheritance enables software reuse.
10
package com.android.webviews;
import android.app.Activity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.webkit.WebView;
import android.webkit.WebViewClient;
An inheritance
example
public class HelloWebView extends Activity {
/** Called when the activity is first created. */
WebView webview;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
webview = (WebView) findViewById(R.id.webview);
webview.getSettings().setJavaScriptEnabled(true);
webview.loadUrl("http://www.google.com");
}
11
webview.setWebViewClient(new HelloWebViewClient());
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if ((keyCode == KeyEvent.KEYCODE_BACK) && webview.canGoBack())
{
webview.goBack();
return true;
}
return super.onKeyDown(keyCode, event);
}
private class HelloWebViewClient extends WebViewClient {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;
}
}
}
12
Software Frameworks
Components-Based Software
Engineering means that we build
software by "putting pieces together".
Frameworks provide the context in which the
pieces can be used.
A framework may be seen as:
A reusable design of a system,
A skeleton of an application which can be
customized by an application developer.
13
Component Frameworks
While frameworks in general describe a
typical and reusable situation at a model
level, a component framework
describes a circuit-board with empty
slots into which components can be
inserted to create a working instance.
CoordinationServices(transactions,persistence..)
Component
Framework
14
Relationships Between
Concepts
Interfacethatsatisfiescontracts
Componenttype
Specificinterface
Independent
deployment
CoordinationServices(transactions,persistence..)
Component
implementation
Component
model
Component
Framework
15
The components-based
software engineering aspects
of the Android framework
Key components (classes):
Activity, Service, BroadcastReceiver,
ContentProvider, Intent
16
Activity life cycle
Entire lifetime
Visible lifetime
Foreground
lifetime
3 nested loops
7 hooks or
callbacks
17
Service Life Cycle
18
Frameworks and Patterns
It is important to realize that design patterns and
frameworks are distinct concepts of different natures.
Frameworks are of a physical nature, and are executable
software used in either the design or the run-time phase.
Design patterns are of a logical nature, representing
knowledge of and experience gained with software.
19
Categories of Design Patterns
Creational Pattern: Deal with initializing and
configuring of classes and objects.
Structural Patterns: Deal with decoupling
interface and implementation of classes and
objects
Composition of classes or objects
Behavioral patterns:Deal with dynamic
interactions among societies of classes and objects
How they distribute responsibility
20
Design Pattern Space
Purpose
Defer object creation to
another class
Scope
Creational
Structural
Behavioral
Class
Factory Method
Adapter (class)
Interpreter
Template Method
Object
Abstract Factory
Builder
Prototype
Singleton
Adapter (object)
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Chain of
Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor
Defer object creation to
another object
Describe ways to
assemble objects
Describe algorithms and
flow control
21
Factory Method Pattern
The Factory method lets a class defer
instantiation to subclasses.
22
Android Example of Factory
Method Pattern
Activity
View
GraphicView
OnCreate()
...
View= FactoryMethod()
...
MyDraw
OnCreate()
return new GraphicView
Android Example of Factory
Method Pattern- code
publicclassMyDrawextendsActivity{
@OverridepublicvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(newGraphicView(this));
}
}
publicclassGraphicViewextendsView{
privatePaintpaint=newPaint();
GraphicView(Contextctx){
super(ctx);
}
@OverrideprotectedvoidonDraw(Canvascanvas){
intline_x=10;
intline_y=50;
canvas.drawColor(Color.WHITE);
paint.setColor(Color.GRAY);
paint.setStrokeWidth(3);
canvas.drawLine(line_x,line_y,line_x+120,line_y,paint);
}
}
24
Composite Pattern
Composite allows a group of objects to be treated in the
same way as a single instance of an object.
25
Android View and ViewGroup
26
More Android Composite Pattern
Example
27
Observer Pattern
Asubsetoftheasynchronouspublish/subscribepattern
28
Observer Pattern Example
Observers
Subject
29
More Observer Pattern Example
30
Example: Stock Quote Service
Real time
Market Data
Feed
Stock Quotes
Customer
Customer
Customer
Customer
Customer
Observers
31
Model-View-Controller Pattern
Application of Observer Pattern
Benefits
Design reuse, Loose Coupling
The solid line represents
a direct association, the
dashed an indirect
association via an
observer (for example).
32
MVC Pattern in Android
Cursor: model
ListView: view
Activity: control
control
Cursor
SimpleCursorAd
apter
TextView
ListAda
pter
ListView
33
Model
34
View
35
36
Control
37
More MVC example
// Get a Spinner and bind it to an ArrayAdapter that
// references a String array.
Spinner s1 = (Spinner) findViewById(R.id.spinner1);
ArrayAdapter adapter = ArrayAdapter.createFromResource(
this, R.array.colors,
android.R.layout.simple_spinner_item);
adapter.setDropDownViewResource(android.R.layout.simple
_spinner_dropdown_item);
s1.setAdapter(adapter);
XML
ArrayAdapter
Spinner
38
// Load a Spinner and bind it to a data query.
private static String[] PROJECTION = new String[] {
People._ID, People.NAME
};
Spinner s2 = (Spinner) findViewById(R.id.spinner2);
Cursor cur = managedQuery(People.CONTENT_URI, PROJECTION, null, null);
SimpleCursorAdapter adapter2 = new SimpleCursorAdapter(this,
android.R.layout.simple_spinner_item, // Use a template
// that displays a
// text view
cur, // Give the cursor to the list adatper
new String[] {People.NAME}, // Map the NAME column in the
// people database to...
new int[] {android.R.id.text1}); // The "text1" view defined in
// the XML template
adapter2.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_it
em);
s2.setAdapter(adapter2);
39
SimpeCursorAdapter
cursor
Spinner
SQLite
40
Faade Pattern
A facade is an object that provides a simplified interface
to a larger body of code, such as a class library.
41
Android Media Framework
42
Binder:
IPC
Mechanism of
Android
MediaPlayerBase:
Interface of
some concrete
media player
such as
VorbisPlayer,
PVPlayer
43
Playing a Video
VideoView _player=(VideoView)
findViewById(R.id.videoplay);
Intent intent=this.getIntent();
_player.setVideoPath(intent.getDataString());
_player.start();
44
A video player with simple GUI
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.VideoView;
public class VideoPlayer extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);
final VideoView w
=(VideoView)findViewById(R.id.vdoplayer);
Button cmdload =
(Button)this.findViewById(R.id.cmd_load);
cmdload.setOnClickListener(new
OnClickListener(){
public void onClick(View arg0) {
// TODO Auto-generated method stub
w.setVideoPath("/sdcard/android/kongfu.mp4");
}
});
Button cmdplay =
(Button)this.findViewById(R.id.cmd_play);
cmdplay.setOnClickListener(new
OnClickListener(){
public void onClick(View arg0) {
// TODO Auto-generated method stub
w.start();
}
});
Button cmdpause =
(Button)this.findViewById(R.id.cmd_pause);
cmdpause.setOnClickListener(new OnClickListener()
{
public void onClick(View arg0) {
// TODO Auto-generated method stub
w.pause();
}
});
} //end of onCreate()
} //end of VideoPlayer
45
Some More Design Patterns
Proxy Pattern
Mediator Pattern
Bridge Pattern
46
Proxy Pattern
The proxy could interface to anything: a network connection, a
large object in memory, a file, or some other resource that is
expensive or impossible to duplicate.
47
Android Proxy Pattern
48
Mediator Pattern
With the mediator pattern, communication
between objects is encapsulated with
a mediator object.
49
Bridge Pattern
decouple an abstraction from its
implementation so that the two can vary
independently
50
Bridge and Mediator Patterns in Android
Bridge patterns in linking
Java and Cpp
Mediator
patterns
51
Binder IPC Mechanism
52
Binder IPC Mechanism
53
Implementation of IPC
54
Concluding Remarks
Android Framework
Object-Oriented Design
Making use of Design Patterns
Containing run-time routines
Android Operating Systems
Making use of three well-developed technologies:
Linux Kernel, Java, XML
Design Patterns facilitate
Software reuse
Mainteinance
Flexibility
55
