Angel

Espinoza

Patrones contenidos:
Command.
Adapter.

Universidad Tecnologica del norte de Guanajuato. Dolores Hidago, C.I.N, Gto

Table of Contents
INTRODUCCIN. ........................................................................................................................................... 3
PATRON DE DISEO COMMAND ................................................................................................................... 4
ESTRUCTURA ............................................................................................................................................................................................................... 4
VENTAJAS ...................................................................................................................................................................................................................... 4
DESVENTAJAS ............................................................................................................................................................................................................. 4
DIAGRAMA DE COMMAND .................................................................................................................................................................................... 4
DIAGRAMA DEL EJEMPLO ...................................................................................................................................................................................... 5
ADAPTER ...................................................................................................................................................... 5
ESTRUCTURA ............................................................................................................................................................................................................... 5
EQUEMA DE HERENCIA MULTIPLE .................................................................................................................................................................... 6
ESQUEMA DE COMPOSICIN ................................................................................................................................................................................. 6
DIAGRAMA DEL ADAPTER .................................................................................................................................................................................... 6
DESARROLLO. ............................................................................................................................................... 7
BIBLIOGRAFIA: ............................................................................................................................................. 20
OTRAS FUENTES: .................................................................................................................................................................................................... 20

INTRODUCCIN.
Los patrones de diseo no se implementan con el fin de hacer ms sencilla la estructura de las
aplicaciones, estn destinados a llevar un mayor orden en cuanto a estructura e interaccin entre las
clases. Tenemos varias categoras en las que podemos clasificar los patrones de diseo, una de las
ms comes es:
Creacionales:
Creacionales Se implementan para controlar la creacin de instancias de los objetos.
Patrones Estructurales: Describen cmo las clases y los objetos pueden ser combinados para
formar estructuras mayores.
De comportamiento. Tratan de una forma ms especfica con la relacin y la comunicacin entre
los diferentes objetos.
En este manual se ejemplifica el uso de los patrones de diseo, para esta aplicacin utilizaremos los
patrones COMMAND y ADAPTER .

PATRON DE DISEO COMMAND

Este es un patrn de comportamiento. Su implementacin hace ms robusta la estructura de la
aplicacin por lo que no facilita su diseo, por el contrario, se hace ms complejo.

ESTRUCTURA
El patrn Command se compone por las siguientes clases
COMANDO (COMMAND). Es una interfaz utilizada para enlazar el comando concreto y el objeto
que la recibe.
COMANDO CONCRETO (CONCRETE COMMAND). Contiene la accin especfica. Implementa la
interfaz COMANDO. Es el enlace entre la accin y el objeto que la recibe.
IVOCADOR (INVOKER). Almacena el comando llamado, en un objeto y lo manda llamar para
realizar la accin hacer y deshacer, llamando al objeto que lo almacena.
RECEPTOR (RECEIVER). Es una clase abstracta que contiene mtodos que van a heredar cada
COMANDO CONCRETO, en otras palabras, realiza las operaciones asociadas a cada accin.
CLIENTE (CLIENT). Se encarga de crear el comando concreto y su receptor.

VENTAJAS

Permite crear acciones complejas mediante acciones elementales.

Permite el uso del rehacer y deshacer poniendo las acciones en cola.
Encapsula una accin en un objeto por lo que se puede llamar despus.
Desacopla el objeto que invoca la accin del objeto que finalmente la ejecuta.
Se pueden adicionar nuevos comando sencillamente.

DESVENTAJAS
Al igual que muchos patrones, aumenta el numero de clases, haciendo ms complejo el programa.

DIAGRAMA DE COMMAND

DIAGRAMA DEL EJEMPLO

En nuestro diagrama se aprecian otro tipo de relaciones debido a la implementacin de un segundo

patrn de diseo, y los errores del diagramador SimpleUML utilizado. . Se ha agregado una interfaz
al REVEIVER debido a que trabajamos con el patrn ADAPTER para mostrar en pantalla el
comando que se ha invocado, ya sea de nuestra lista de comandos mediante las acciones hacer
deshacer , o bien, agregando una nueva accin a nuestra lista.

ADAPTER
Es un patrn estructural utilizado como un puente entre dos interfaces incompatibles, esto es posible
porque las interfaces usadas desacoplan la clase cliente de la clase de ofrece los servicios.
En este caso ADAPTER nos ayuda a mostrar la lista de acciones en cola creada por el INVOKER,
mediante RecyclerView, del cual los describiremos ms adelante.

ESTRUCTURA
Se puede implementar en un esquema de herencia mltiple o en un esquema de composiscin,
teniendo la misma estructura de clases:
OBJETIVO (TARGET). Es la interfaz que utiliza el cliente.
CLIENTE (CLIENT). Crea nuevos objetos utilizando la interfaz TARJET.
ADAPTADOR (ADAPTER). Se encarga de adaptar la nueva Interfaz ADAPTEE a la interfaz
TARJET utilizada por el Cliente.
ADAPTADO (ADAPTEE). Esta clase defina una interfaz existente que debe ser adaptada a la
interfaz utilizada por el Client, es decir se adapta a la interfaz TARJET.

EQUEMA DE HERENCIA MULTIPLE

En este caso, el objeto ADAPTER hereda al mismo tiempo la interfaz TARJET y la
peticinEspecfica() de una clase ADAPTEE concreta. Debido a que java no admite herencia de
clases convencionales, el TARGET debe ser una interfaz.
La ventaja de este esquema es que se pueden agregar funcionalidades a todos los objetos
ADAPTEE de una sola vez.
La desventaja es que
ESQUEMA DE COMPOSICIN
En este caso el objeto ADAPTER hereda la interfaz de TARGET y est compuesto de un objeto
ADAPTED. Por lo que las peticiones que haga el CLIENTE sern delegadas al mtodo
peticinEspecfica() del objeto ADAPTED.
La desventaja para este esquema es que es muy difcil sobreescribir el comportamiento de la clase
ADAPTEE, y para lograrlo requerira crear una subclase de ADAPTEE y hacer que el ADAPTER se
refiera a esa subclase, y esto implicara disminucin del rendimiento de la aplicacin.

DIAGRAMA DEL ADAPTER

DESARROLLO.
Defina la interfaz command.
Esta interfaz slo llama al comando especfico, en este caso tenemos cuatro definidos en los
siguientes mtodos: execute() undo() y redo().
Adems agregaremos aqu el mtodo setReceiver(Receiver receiver) para inicializarlo en el
COMANDO CONCRETO.
Quedando de la siguiente manera:

Lo siguiente es crear la clase COMANDO

CONCRETO, en donde implementaremos
la Interfaz anterior y definiremos sus
mtodos. Adems aqu se inicializa el
RECEIVER.
Para lograr esto se define una variable del
tipo FLOAT alpha, sobre la cual
almacenaremos los valores calculados al
presionar
los
botones
bajarAlpha,
subirAlpha.

Para mandar llamar a el objeto receive, en este caso llamado ImageReceiver, haremos uso de la
librera PARCELABLE, donde:
PARCELABLE. Es una interfaz predefinida en la librera de Android. Reemplaza el crear un campo
static para guardar un objeto en una clase, y luego tener que recuperarlo en la nueva actividad, es
decir nos ayuda a pasar nuestros objetos de manera rpida entre diferentes actividades o servicios.
Para mas informacin consultar http://androcode.es/2012/12/trabajando-con-parcelables/
Quedando nuestro cdigo de la siguiente manera:

De esta manera al presionar el botn para bajar el contraste nos devolver en la pantalla un Bajar
contraste y en caso contrario un Subir contraste. Al igual que almacena el nuevo objeto valor de
alpha y, haciendo uso del mtodo predefinido CREATOR(), creamos un PARCEL del CONCRETE
COMMAND que utilizaremos ms adelante en el MainActivity.

La siguiente Clase ser el INVOKER.

Para ello importaremos las siguientes libreras:
iava.util.ArrayList; que nos servir para hacer un arreglo llamado historyList del tipo STRING, el
cual ocuparemos en la clase ADAPTER llamada HistoryAdapter. Este arreglo se ir mostrando en
pantalla cada vez que sufra un cambio por la accin de los botones.
java.util.Deque; Esta librera la utilizaremos para trabajar en conjunto con el linkedList para hacer
dos listas, la cola rehacer y la cola deshacer llamadas queueUndo y queueRedo. Dequeue nos
permitir mostrar en pantalla el ltimo mensaje en cola que tenemos en el historyList.
java.util.LinkedList; Esta librera nos permite crear una lista en donde podemos acceder a los
elementos por la posicin y no por el contenido (int, String, float, etc) que tengan los elementos. Esto
nos permitir detener las acciones rehacer y deshacer una vez que hayamos llegado a la ultima o
a la primera accin de nuestra lista historyList.
En la siguiente imagen se presenta la parte donde se crea una linkedList rehacer y otra deshacer
mediante queueUndo.
Luego se instancia la interfaz InvokerListener para implementar los mtodos commandAdded y
commandRemoved(), los cuales los utilizaremos en el MainActivity.

Y ahora declaramos los mtodos para agregar el nuevo objeto command al historyList
(addCommand()), el mtodo deshacer (undo()) y rehacer(redo()).
Al ejecutarse el mtodo addCommand() se agrega la nueva accin a la lista Undo.
Para el caso de ejecutarse undo(), se elimina el comando de la lista queueUndo, se agrega a la lista
queueRedo y se notifica en pantalla quitando la cadena String de nuestro historyList, que es la lista
que nos aparecer en la parte derecha de nuestra aplicacin. La siguiente imagen muestra cmo se
ven estos tres mtodos. Invoker utiliza estos mtodos para llamar de la lista de objetos las acciones
solicitadas por el Client.

Metodo addCommand(), undo() y redo(), definidos en el Invoker.

Al final de esta clase debemos instanciar la interfaz InvokerListener y definir el comando
getHistoryList(), el cual nos devolver el historyList actualizado en pantalla.

Siguiendo el patrn COMMAND, creamos una interfaz para nuestro INVOKER llamada
InvokerListener.

Para el siguiente elemento, el RECEIVER, lo definiremos como una clase abstracta para seguir el
patrn ADAPTER, el cual utiliza una clase abstracta.
Quedando de la siguiente manera:

Ahora definiremos la clase ImageReceiver, la cual utilizar las libreras:

android.util.Log; El cual sirve para enviar logs a la pantalla. En este caso utilizaremos el mtodo
predefinido log.d() para mostrar mensajes de depuracin en pantalla.
android.widget.ImageView; lo utilizaremos para cambiar los parmetros de contraste en nuestra
imagen.
En esta clase crearemos una instancia de ImageView, la agregaremos como contexto en el
constructor de la misma clase y despus la inicializaremos.
El mtodo cambiarContraste() har uso del log definido en la clase MyCons, calcula el contraste de
la imagen cada vez que cambia y se utilizar en el MainActivity para posicionar el valor del contraste
de nuestra imagen en un TextView llamado tvAlpha.

Clase ImageReceiver.

Ahora definiremos la interfaz grfica, para la cual utilizaremos el siguiente juego de LinearLayouts y
relativeLayouts siguiendo el siguiente rbol:
LinearLayout: container, ser el espacio donde pondremos todos nuestros elementos.
o RelativeLayout: section_left. Contendr todos los controles, y los siguientes:
ImageView: iv_utng. Contiene los parmetros y el archivo de imagen.
TextView: tv_alpha. Este campo se actualizar cada vez que realicemos una
accin.

 LinearLayout: section_cambiar_contraste. El cual tendr los siguientes botones:

Button: btnBajarAlpha. Botn que reduce el valor de alpha.
Button: btnSubirAlpha. Botn que aumenta el valor de alpha.
LinearLayout: section_hacer. Contendr los botones:
Button: btnRedo. Botn para rehacer el ltimo comando de la lista
queueUndo.
Button: btnUndo. Botn para deshacer el ltimo comando solicitado y
que se encuentra en la lista queueRedo.

o RelativeLayout: Este RelativeLayout muestra el historyList mediante un RecyclerView

Esta es la vista de nuestra aplicacin:

Ahora el MainActivity, que ser la clase CLIENT para ambos patrones de diseo.
Para ello usaremos las siguientes libreras:
android.os.Bundle; Lo utilizaremos para instanciar los objetos y poder utilizarlos con
PARCELABLE, mediante el comando @Bind
android.support.v7.app.AppCompatActivity;
android.support.v7.widget.LinearLayoutManager;
android.support.v7.widget.RecyclerView; Utilizaremos esta librera para mostrar nuestro
historyList encargndose de reciclar las vistas de los objetos confirme los vamos llamando.
android.view.View;
android.widget.Button;
android.widget.ImageView;
android.widget.LinearLayout;
android.widget.RelativeLayout;
android.widget.TextView;
java.util.ArrayList;
butterknife.ButterKnife; Lo utilizaremos para hacer inyecciones de nuestros objetos del Layout del
XML, a nuestro MainActivity. Esto nos dar un cdigo ms limpio.
butterknife.Bind;
butterknife.OnClick;
giti7083s.angel.command.command.CambiarContraste; Clase CambiarContraste
giti7083s.angel.command.invoker.Invoker; Clase Invoker
giti7083s.angel.command.invoker.InvokerListener; interfaz InvokerListener.
giti7083s.angel.command.receiver.ImageReceiver; Clase ImageReceiver
Para utilizar RecyclerView y el ButterKnife es necesario agregar las siguientes lneas en nuestro
Gradle: app en la parte de dependencies{ }

Ahora inicializamos todos nuestros objetos que tenemos en nuestro Layout, quedando de la
siguiente manera:

Lo siguiente es declarar un campo estatico de tipo FLOAT que nos diga cunto sube o baja el
contraste de la imagen: ALPHA_STEP .
Tambin declaramos un objeto adapter del tipo HistoryAdapter, un Array con datos del tipo String
llamado textHistory, y por ultimo inicializamos nuestro receiver ImageReceiver y el invoker Invoker.

Ahora extendemos a nuestro MainActivity el AppCompatActivity para poder definir el metodo

OnCreate() y nos ahorre el escribir findViewById y en lugar utilizar el @Bind.
Tambin dentro del onCreate se inicializa el ImageReceiver con la variable ivUtng que es la variable
que nos relaciona con la imagen Layout.
Y por ultimo se sobreescriben los mtodos commandAdded() y commandRemoved() de la interfaz
InvokerListener y los cuales trabajan con el Adapter HistoryList .
Quedando de la siguiente manera:

Ahora reescribimos el mtodo predefinido onBindViewHolder() el cual nos devuelve la cadena

completa de nuestro HistoryList ordenandolo por el ID de posicin.

Por ultimo, definiremos una clase HistoryViewHolder dentro del MainActivity la cual almacena el ID
del textView de nuestro Layout en un @Bind.

Como sugerencia revisa que tengas instalado las siguientes SDK Tools:

BIBLIOGRAFIA:
Gamma, E., Helm, R., Johnson, R., Vlissides, J. Desing Patterns: Elements of Reusable ObjectOriented Software, Addison-Wesley, Reading, MA, 1995.
Grand, M., Patterns in Java: A catalog of reusable design patterns illustrated with UML, John Wiley
and Sons, New York, 1998.
Cooper, J.W. Java Design Patterns: A Tutorial, Addison-Wesley, Reading, MA, 2000.
Brown, W.J., Malveau, R.C., McCormick, H.W., Mowbray, T.J., Antipatterns: Refactoring
Software, Architectures and Projects in Crisis, John Wiley and Sons, New York, 1998.

OTRAS FUENTES:
https://erikcaffrey.github.io/2015/10/05/recyclerview/
http://androideity.com/2016/01/31/butterknife-inyecciones-de-vistas-en-android/
https://developer.android.com/reference/java/util/Deque.html
http://androcode.es/?s=serializable
https://developer.android.com/reference/android/os/Bundle.html