====== Digital Home : Observer/observable et intégration ====== Objectifs de ce TD : - Appréhender une petite application dans sa totalité - Travailler sur l'intégration - Savoir utiliser un patron "observer" **digital home - Computer Definition.** A residence that is fully automated. It uses computing devices and home appliances that conform to some common standard for internetworking so that everything can be controlled by computer. Les temps indiqués sont là pour vous aider. Il s'agit des temps maximum. ===== Cadre général ===== Nous simplifions la définition précédente comme suit. Une "maison numérique" est équipée de "dispositifs" : //capteurs// (composants qui permettent de relever des mesures) et //actionneurs// (composant permettant d'agir sur d'autres composants en vue de modifier leur comportement ou leur état). Les "dispositifs" sont soit associés à la maison (par exemple, un thermostat central), soit associés aux pièces (interrupteurs, thermomètre, ...). Un tableau de contrôle permet de visualiser les valeurs relevées par les capteurs de la maison. Notre objectif est de permettre de : - créer des maisons numériques auxquelles on peut ajouter des dispositifs - visualiser les valeurs des différents dispositifs contenus dans la maison. QUESTION (15 mn): * Analyser le problème sur papier (préparation à l'examen). * Vous devez maintenant savoir seuls ce dont vous avez besoin pour analyser un problème. * Vous devez vérifier que vous savez faire les diagrammes sans outil. Les capteurs physiques sont des dispositifs qui présentent une grande variabilité. Nous allons les modéliser via des composants logiciels. Déterminer les dépendances envisagées entre vos classes et les tests d'intégration à prévoir si l'on considère que les dispositifs devront être intégrés au reste de l'application. QUESTION (15 mn): * Lire l'ensemble de l'énoncé à présent et compléter ou corriger votre modélisation. ===== Capteurs Passifs ===== Les capteurs "passifs" sont des capteurs qu'il faut interroger pour obtenir la valeur correspondant par exemple à une température ou un éclairage. A un capteur passif nous associons un {{:2014_2015:s3:concprogobjet:td:capteurphysique.zip|capteur physique}} qui vous est donné. Il s'agit d'un composant très simple qui lit et écrit une valeur dans un fichier. Il vous sert de "bouchon" puisque nous ne disposons pas d'un vrai capteur physique auquel nous connecter. A votre convenance un capteur passif peut modifier la valeur lue dans le capteur physique pour lui associer une unité. QUESTION (15 mn): - Mettez à jour votre diagramme de classe si besoin. - Définir la classe CapteurPassif en lui associant un capteurPhysique. Voici les codes dont vous avez besoin : *{{:2014_2015:s3:concprogobjet:td:capteurphysique.zip|}} *{{:2014_2015:s3:concprogobjet:td:fichiero.zip|}} ===== Pièce équipée ===== Une pièce est équipée de capteurs. On peut ajouter des capteurs à la pièce. On peut visualiser les valeurs de tous les capteurs de la pièce. QUESTION (20 mn): - Compléter ou corriger si besoin votre diagramme de classe **sur cette partie** afin d'obtenir un diagramme de classes en conception : toutes vos relations sont bien définies avec les multiplicités et les rôles ; les principales méthodes de vos classes sont bien représentées. - Définir la classe Pièce - Créer un jeu de tests vous permettant de tester votre classe Pièce. Exemple de trace :


Salon
	thermometre:19.0	humidite:12.7	lumiere:120.0

===== Maison numérique ===== Une maison numérique est une composition de pièces équipées. A une maison numérique est associé un tableau de contrôle. Il permet de visualiser tous les capteurs présents dans toutes les pièces de la maison. QUESTION (20 mn): * Implémenter et tester la classe ''MaisonNumerique'' et tout ce qui est nécessaire pour répondre aux exigences. ===== Capteur Passif Réactif (Simple) ===== Un capteur Passif réactif est un capteur passif mais qui peut être observé. Lorsque sa valeur est modifiée par un setValeur, il notifie les observeurs du changement de valeur. Nous n'utiliserons pas les classes prédéfinies en java comme Observer et Observable pour bien comprendre l'intérêt de ce pattern et l'adapter à notre cas d'étude. QUESTION (30mn) : * Définir la classe ''CapteurPassifReactif'' comme une extension de la classe ''CapteurPassif''. * Vous rendez ses instances observables en respectant le pattern ci-après : * Un observeur d'un ''CapteurPassifReactif'' doit pouvoir recevoir des messages ''update(String message)'' : Nous aurons des ''ObserveurDeCapteur'' * On peut enregistrer des ''ObserveurDeCapteur'' dans un ''CapteurPassifReactif'' et en enlever; * A chaque appel au ''setValeur'' d'un ''CapteurPassifReactif'' tous les observeurs sont notifiés par un ''update'' et la nouvelle valeur du capteur en paramètre. Nous n'avons pas encore défini d'observeur d'un capteur. Cependant nous voulons vérifier que les notifications sont bien prévues. ===== Test d'intégration et Capteur Passif Réactif ===== Ces tests sont basés sur http://easymock.org/ Il s'agit de vérifier que lorsque que la valeur du capteur réactif est modifiée, la méthode //update// des observeurs est bien appelée. Pour cela voici un extrait de code qui doit vous aider. {{:2014_2015:s3:concprogobjet:td:easymock-3.2.zip|voici l'archive dont vous avez besoin}}



import java.io.IOException;

import org.easymock.EasyMockRunner;
import org.easymock.EasyMockSupport;
import org.easymock.Mock;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.After;
import org.junit.Before;

@RunWith(EasyMockRunner.class)
public class CapteurPassifReactifTest extends EasyMockSupport {
	CapteurPassifReactif cpTemporaire ;
	
    @Mock
    private ObserverDeCapteur observeur; 
    @Mock
    private ObserverDeCapteur observeur2; 

    @Before
    public void setUp() throws Exception {
       cpTemporaire = new CapteurPassifReactif(new CapteurPhysique("cp1"));		
	}

     @After
     public void tearDown() throws Exception {
		cpTemporaire.unregister(observeur);
	}
	
    //tests integration
    @Test
    public void testCapteurSetValeur() throws IOException, NonAccessibleCapteurException {
	observeur.update("12.2"); //Appel attendu
	replayAll(); //Memoriser
	cpTemporaire.register(observeur);
	cpTemporaire.setValeur(12.2);
        verifyAll(); //Verification
    }
	
	
    //tests integration
    @Test
     public void testCapteurSetValeurMultipleObserveurs() throws IOException, NonAccessibleCapteurException {
	observeur2.update("12.2");//
	observeur.update("12.2"); //Appel attendu
	replayAll(); //Memoriser
	cpTemporaire.register(observeur);
	cpTemporaire.register(observeur2);
	cpTemporaire.setValeur(12.2);
        verifyAll(); //Verification
    }

QUESTION (30mn) : * Vous pouvez faire le choix de continuer à tester avec EasyMock ou de faire les tests en créant les bouchons etc. ===== Pièce numérique "intelligente" ===== L'objectif est à présent de définir des pièces intelligentes qui lorsque l'un de ses capteurs "Observable" a sa valeur modifiée, la pièce est notifiée du changement et le update consiste à ré-afficher les valeurs de tous les capteurs. QUESTION (10mn) : * Vous devez définir une "SmartPiece" sans modifier une Piece. ===== Maison numérique évolutive ===== Lorsque l'on ajoute un capteur à une pièce de la maison on veut que le tableau de bord de la maison prenne automatiquement en compte cette évolution. QUESTION : * Modifier vos classes pour prendre en compte cette nouvelle exigence, si vous ne l'aviez pas déjà fait. Si vous le voulez, vous êtes autorisé à cette étape à utiliser les classes java ''java.util.Observable'' et ''java.util.Observer''. ===== Capteurs actifs ===== Un capteur actif est associé à un capteur physique. Il scrute régulièrement la valeur physique du capteur physique qui lui est associé et notifie ses observeurs chaque fois qu'il détecte un changement. Voici les éléments de code dont vous avez besoin pour le définir : * Ce code vous permet de le déclarer comme pouvant s'exécuter "dans une thread à part" :


public class CapteurActif  ... implements... Runnable{

* Ce code est une méthode de votre CapteurActif qui explicite la boucle qui va lire le composant physique:

 public void run() {
		System.out.println("Run lancé");
		while (!stop) {
			try {
				Thread.sleep(2000);
				if (!(valeurCourante.equals(getValeur())))  {
					setValeurCourante(getValeur());
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

* Le code suivant vous permet de "lancer" votre capteur :


CapteurActif cpTemporaire = new CapteurActif(new CapteurPhysique("cp1"));	
Thread threadCP= new Thread(cpTemporaire);
threadCP.start();

QUESTION (30mn) : * Définir les capteurs actifs ===== Refactoring et Pattern Composite ===== On vient de réaliser que des dispositifs peuvent être associés directement à la maison et pas forcément aux pièces. Proposer une modélisation qui préserve l'ensemble de vos "tests" mais vous permet de prendre en compte cet aspect. * Mettez un mail à votre encadreur avec soit l'adresse où récupérer le TD soit le TD lui-même * Dans votre répertoire de projet se trouvent : - Un document contenant * votre modèle final (Tout le monde n'aboutit pas au même modèle, c'est certain) (merci de l'intégrer dans un document pour que nous n'ayons pas à ouvrir différents modèles dans différentes versions de l'outil). * des explications sur les raisons de ce modèle (dont vous êtes très fiers) et les leçons apprises. - Les codes et les tests.