Entwicklung einer Profilbörse für Konfigurationen von - RWTH
Werbung
/HKUVWXKOIĻU ;;; 3URI'U,QJ;;; Seminararbeit Cand.-Ing.: Patrick Posor Matr.-Nr.: 846228 Kurzthema: Entwicklung einer Profilbörse für Konfigurationen von Smartphones Betreuender Assistent: Dipl.-Ing. (FH) Matthis Laass Aachen, den 14.12.2012 Inhalt und Ergebnis dieser Arbeit sind ausschließlich zum internen Gebrauch bestimmt. Alle Urheberrechte liegen bei der RWTH Aachen. Ohne ausdrückliche Genehmigung des betreuenden Lehrstuhls ist es nicht gestattet, diese Arbeit oder Teile daraus an Dritte weiterzugeben. /HKUVWXKOIĻU ;;; 3URI'U,QJ;;; I Inhaltsverzeichnis I i Inhaltsverzeichnis I Inhaltsverzeichnis......................................................................................................... i II Abbildungsverzeichnis................................................................................................ ii III Tabellenverzeichnis.....................................................................................................iii 1 Einleitung ..................................................................................................................... 4 2 Stand der Technik........................................................................................................ 6 2.1 Objektorientierte Programmiersprache Java .......................................................... 6 2.2 Auszeichnungssprache HTML ............................................................................... 6 2.3 Google Web Toolkit ............................................................................................... 7 2.4 Relationale Datenbanken ....................................................................................... 7 2.5 Schnittstellen-Programmierung .............................................................................. 8 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen ............................. 9 3.1 Anforderungen an eine Profilbörse ......................................................................... 9 3.2 Entwurf einer Profilbörse ........................................................................................ 9 3.3 Implementierung der Profilbörse ...........................................................................12 4 Validierung an einem Anwendungsbeispiel .............................................................22 4.1 Vorstellung Use-Case ...........................................................................................22 4.2 Anwendung des Use-Cases ..................................................................................22 5 Zusammenfassung und Ausblick ..............................................................................24 IV Literaturverzeichnis....................................................................................................26 V Anhang ........................................................................................................................27 II Abbildungsverzeichnis II ii Abbildungsverzeichnis Abbildung 3.1 "Endgültiges Layout der Profilbörse" ..............................................................11 Abbildung 3.2 "Ein neues Projekt erstellen" ..........................................................................13 Abbildung 3.3 "Quellcode der Klasse EmotioProfilboerse.java" ............................................15 Abbildung 3.4 "Klassendiagramm der Klasse Layout.java" ...................................................15 Abbildung 3.5 "Erstellung einer Kategorie mittels eines Hyperlinks" .....................................17 Abbildung 3.6 "Profilbörsendarstellung der Such- und Filterfunktionen" ...............................18 Abbildung 3.7 "Überprüfung einer möglichen Filterung eines Profils" ...................................19 Abbildung 3.8 "Prototyp der Profilbörse" ...............................................................................21 Abbildung 4.1 "Anzeige des Profils beim Use-Case" ............................................................23 Abbildung 5.1 "Klassendiagramm der Klasse EmotioProfilboerse.java" ................................27 Abbildung 5.2 "Klassendiagramm der Klasse Categories.java" ............................................27 Abbildung 5.3 "Klassendiagramm der Klasse SearchAndSort.java"......................................27 Abbildung 5.4 "Klassendiagramm der Klasse ShowProfiles.java" .........................................28 Abbildung 5.5 "Klassendiagramm der Klasse CategoryNamesList.java"...............................28 Abbildung 5.6 "Klassendiagramm der Klasse EmotioObjectMarketDescription.java" ............28 Abbildung 5.7 "Klassendiagramm der Klasse Login.java" .....................................................29 III Tabellenverzeichnis III iii Tabellenverzeichnis Tabelle 3.1: "Auflistung der Profilinformationen" ...................................................................10 Tabelle 3.2 "Liste der Klassen" .............................................................................................12 Tabelle 3.3 "Schnittstellen zur Datenbank" ...........................................................................14 Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen" .....................14 1 Einleitung 4 1 Einleitung Das Forschungsprojekt „EMOTIO“ befasst sich damit, den Kunden, auch während der Produktnutzungsphase, mit in den Entwicklungsprozess zu integrieren und zu Innovationen zu befähigen. Hierfür soll es dem Benutzer möglich sein, ein bereits im Markt befindliches Produkt gemäß seinen Vorstellungen und Wünschen weiterzuentwickeln und innovativ tätig zu sein. (Schmitt et al. 2012) Als Demonstrator wurde ein Smartphone1 ausgewählt, an dem das Forschungsvorhaben prototypisch implementiert wird. Das Ziel dieser Implementierung liegt darin, „einem möglichst großen Anteil der [Benutzergruppe] die Möglichkeit zu geben, vorhandenen Funktionalitäten auf neuartige Weisen miteinander zu verknüpfen, um individuelle Kundenbedürfnisse zu erfüllen“(Schmitt et al. 2012). Der Benutzer hat die Möglichkeit, sich eigene Konfigurationsprofile auf dem Smartphone zu erstellen und diese auf einem zentralen Datenbankserver abzuspeichern. Dafür wird die bereits im Google Play für 4,99€ erhältliche App „Tasker“ verwendet. Hierbei werden die Profile in die eigens entwickelte EMOTIO-Sprache überführt. Nach einer einmaligen Registrierung kann der Benutzer nun verschiedene webbasierte Dienste in Anspruch nehmen. Mit Hilfe des Konfigurators ist es dem Benutzer möglich, seine vorhandenen Profile, die er auf dem Smartphone erstellt und gespeichert hat, zu editieren oder auch komplett neue Profile zu erstellen. Diese Änderungen werden wiederum auf dem Datenbankserver gespeichert und können auf das Smartphone geladen und wieder benutzt werden. Das Einbinden bzw. Abspeichern der Profile in die Datenbank wurde bereits implementiert ebenso ein Prototyp des Konfigurators. Ein anderer webbasierter Dienst, welcher allerdings noch nicht implementiert wurde, ist das Forum. Durch das Forum soll eine Kommunikation zwischen verschiedenen Benutzern bzw. zwischen Benutzer und Entwickler hergestellt werden. Unter anderem soll es dann möglich sein, Fragen an die Entwickler oder auch an andere User zu stellen oder bestimmte Ideen oder gar Profilwünsche zu äußern. Der dritte und letzte webbasierte Dienst, der von den Benutzern in Anspruch genommen werden kann, ist die sogenannte Profilbörse. In der Profilbörse kann sich ein Benutzer alle öffentlichen Konfigurationsprofile ansehen. Voraussetzung dabei ist, dass die Profile vorher vom Nutzer freigeben worden sind, um sie anschließend zu veröffentlichen. Dies ist aller- 1 Das Smartphone besitzt ein Android-Betriebssystem. 1 Einleitung 5 dings nicht zwingend, sondern freiwillig. In der Profilbörse soll es außerdem möglich sein, andere Profile in seinen eigenen Konfigurator zu laden und diese in seinen eigenen Konfigurationen zu verwenden. Kommentare und Bewertungen können ebenfalls abgegeben werden. Ebenso soll es eine Suchfunktion, um nach bestimmten Profilen zu suchen sowie eine Filterung nach bestimmten Kategorien, geben. In dieser Seminararbeit soll die Profilbörse prototypisch implementiert werden. Dabei sollen die Konfigurationsprofile angezeigt werden, die von den Benutzern veröffentlicht wurden. Außerdem soll das Einbinden eines Profils in den eigenen Konfigurator funktionieren, sowie die Anzeige der einzelnen Kategorien. Die Such- und Filterfunktionen sollen ebenfalls funktionsfähig sein, um nach bestimmten Profilen suchen zu können. 2 Stand der Technik 6 2 Stand der Technik 2.1 Objektorientierte Programmiersprache Java Für die prototypische Implementierung im Rahmen des Forschungsprojektes wurde die Programmiersprache Java ausgewählt. Java ist eine objektorientierte Sprache. Diese zeichnen sich dadurch aus, dass sie eine bessere Übersichtbarkeit und Verständlichkeit hervorbringen aufgrund von Klassen und Objekte. Außerdem können diese Klassen einfacher wiederverwendet und auch durch eventuelle Vererbung erweitert werden. (Boles und Boles 2010) Java hat den Vorteil, dass diese einfach zu erlernen ist und als plattformunabhängig und architekturneutral gilt, weshalb JavaProgramme weitgehend auf allen Computern entwickelt werden können(Dornberger und Telesko 2010). Ein Grund für die Entscheidung für Java im Forschungsprojekt war der, dass man sich als Demonstrator für ein Smartphone mit Android-Betriebssystem entschieden hat und deshalb die Wahl automatisch auf Java fiel. Denn Android wird ausschließlich in Java programmiert2, so auch die App „Tasker“. Deshalb ist es von Vorteil, ein und dieselbe Programmiersprache zu benutzen. Ein weiterer Punkt für die Entscheidung von Java ist das verwenden einer Datenbank und das Überführen der Konfigurationen in die EMOTIO-Sprache. Da es ein Android-Plugin für die Entwicklungsumgebung Eclipse gibt, wird mit dieser Entwicklungsumgebung gearbeitet. In dieser Seminararbeit verwende ich die Version Eclipse Juno 4.2.1. 2.2 Auszeichnungssprache HTML Die Hypertext Markup Language, kurz auch HTML genannt, ist eine textbasierte Auszeichnungssprache, die im World Wide Web Verwendung findet. Diese wird von unterschiedlichen Webbrowsern dargestellt, so werden z.B. Webseiten mit Hilfe von HTML-Dateien erstellt. Kurz gesagt ist „HTML eine Sammlung von Anweisungen, die in die Inhalte einer einfachen Textdatei eingebettet werden und die das Aussehen und Verhalten einzelner Textkomponenten festlegen“(Html 4 Fur Dummies 2008). 2 Mosemann und Kose 2009 2 Stand der Technik 7 Bei der Implementierung der Profilbörse wird HTML dahingehend gebraucht, da das Forschungsprojekt webbasierend ist und die Profilbörse ein Teil einer Webanwendung ist. Jedoch wird in dieser Seminararbeit nicht direkt mit HTML programmiert, sondern der JavaCode wird mit Hilfe des Google Web Toolkits in HTML übersetzt (siehe Kapitel 2.3). 2.3 Google Web Toolkit Das Google Web Toolkit, im folgenden GWT genannt, ist ein freies und kostenloses Toolkit, um mit Hilfe von Java (siehe Kapitel 2.1) eine Webanwendung entwickeln zu können. Dabei wird ein Compiler zur Verfügung gestellt, der den Java-Code in JavaScript3 und in HTML4 übersetzt. (Gupta 2008) Der große Vorteil von GWT ist, das sowohl die Client- als auch die Serverseite mit Hilfe von Java programmiert werden kann. GWT wird von der Google Incorporated entwickelt. Am 17.Mai 2006 hat die Google Inc. die erste Version, mit Namen 1.0 RC 1, veröffentlicht. Seither wird GWT ständig weiterentwickelt, um die Software auf dem neusten Stand zu halten. Aktuell gibt es die Version 2.5, die seit dem 26.Oktober öffentlich benutzt werden kann. Die Entscheidung für GWT im Rahmen des Forschungsprojekts liegt an der Benutzung des Konfigurators. Denn im Konfigurator ist es möglich, sich Profile mittels Drag&Drop5 zu erstellen. Durch gründliche Recherche hat sich GWT dafür sehr gut geeignet. Außerdem gibt es ein Plugin für Eclipse, das als Entwicklungsumgebung in diesem Forschungsprojekt benutzt wird. In dieser Seminararbeit wird die Version 2.5 verwendet. 2.4 Relationale Datenbanken Um alle Konfigurationsprofile der einzelnen Benutzer dauerhaft zu speichern, ist eine Datenbank unvermeidlich. Deshalb gibt es die EMOTIO-Datenbank. Zum einen gibt es eine Trennung von öffentlichen und privaten Daten. Zum einen gibt es Informationen, die in privaten 3 JavaScript ist eine Skriptsprache, die meistens in Webbrowsern verwendet wird. (vgl. http://de.wikipedia.org/wiki/Javaskript) 4 Siehe Kapitel 2.2 5 Man kann im Konfigurator einzelne Profile mit der Maus in seine Konfigurationen ziehen und auch wieder entfernen. 2 Stand der Technik 8 Tabellen hinterlegt sind. Diese sind nur für den jeweiligen Nutzer zugänglich. Zum anderen gibt es öffentliche Tabellen, in der die Informationen auch für andere Benutzer zugänglich sind. Außerdem gibt es eine Trennung von Logik und Parametern. Diese Trennung wird deshalb gemacht, weil oftmals die Parameter6 einer Konfiguration den eigenen Bedürfnissen angepasst werden müssen. Dahinter steckt dann eine Logik7, die genau festlegt, was passieren soll. Deshalb werden hier die Parameter und die Logik einer Konfiguration getrennt gespeichert. In dieser Seminararbeit wird auf die EMOTIO-Datenbank nur indirekt zugegriffen. Es steht eine Testklasse zur Verfügung, mit der die Testprofile angezeigt werden können. Dabei stellt diese Klasse die ganzen Methoden der Datenbank bereit. Ich benutze sozusagen ein Interface der Datenbank samt Methoden. 2.5 Schnittstellen-Programmierung Aufgrund der Einbindung der Profilbörse in die Webanwendung gibt es einige Schnittstellen, die vorher definiert werden müssen. Dadurch wird festgelegt, welche Methoden zur Verfügung gestellt werden bzw. welche vorhanden sein müssen. Mit diesen Methoden ist es dann hinterher möglich, eine Kommunikation zwischen der Profilbörse und der Datenbank zu ermöglichen. In einem Projekttreffen wurden diese Schnittstellen definiert, die wichtig für die Profilbörse sind. Diese werden im weiteren Verlauf der Seminararbeit näher erläutert. 6 z.B. das Bestimmen der Uhrzeit, wann das Handy lautlos gestellt wird. 7 z.B. was soll ab einer bestimmten Uhrzeit geschehen. 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 9 3 Entwicklung einer Profilbörse für SmartphoneKonfigurationen 3.1 Anforderungen an eine Profilbörse Ein Aspekt im Rahmen des EMOTIO-Projekts ist die Integration des Kunden in den Entwicklungszyklus eines Produktes. Mit Hilfe des Nutzungsverhaltens der Kunden kann ein bestehendes Produkt weiter verbessert und somit effizient nach Kundenwünschen erweitert werden. (Schmitt et al. 2012) Mit Hilfe einer Profilbörse im Rahmen der prototypischen Implementierung des Forschungsvorhabens ist ein Kundenverhalten gut zu beobachten, wenn die nötigen Funktionen zur Verfügung gestellt werden. Daher ist es wichtig, dass zuallererst die Profile angezeigt und zur Verfügung gestellt werden. Dadurch können die Kunden bzw. Benutzer schon fertig erstellte Profile nutzen bzw. unter Umständen weiter verbessern. Diese neuen Profile können dann wiederum veröffentlicht werden, was andererseits für die Entwicklung des Produktes von Vorteil ist, da somit ein Entwicklungszyklus entsteht. Eine weitere Anforderung an die Profilbörse sind Suchfunktionen. Hierbei soll dem Benutzer die Möglichkeit gegeben werden, nach bestimmten Profilen zu suchen, die für Ihn potentiell Interessant sein könnten. Ebenso wichtig ist die Auswahl der Suche, d.h. nach welchen Bedingungen gesucht und gefiltert werden soll. So soll es möglich sein, nach Profilen mit bestimmten Tags oder auch nach Profilen von bestimmten Benutzern zu suchen. Eine Kategorisierung von Profilen gehört ebenfalls zu den Anforderungen einer Profilbörse im Rahmen des Forschungsvorhabens. Dadurch können Profile einer bestimmten Kategorie angezeigt werden, um das Suchen ungemein zu erleichtern. Eine Anwendung ist z.B. wenn man nicht nach einem speziellen Profil suchen sondern sich aussuchen möchte, welches Profil am besten zu den entsprechenden Anforderungen passt. 3.2 Entwurf einer Profilbörse Nachdem die Anforderungen an die Profilbörse gestellt wurden, ist es nun die Aufgabe, die Profilbörse zu entwerfen und ein festes Layout festzusetzen. Denn erst wenn die wichtigen Eckpunkte festgelegt sind, kann mit der eigentlichen Implementierung begonnen werden. Zuallererst ist es wichtig die ganzen Informationen eines Profils zu definieren, die hinterher in der Profilbörse angezeigt werden können, wie man in Tabelle 3.1: "Auflistung der Profilinformationen" sehen kann. Dabei ist eine Absprache mit der Datenbank-Schnittstelle wichtig, da 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 10 die Informationen hinterher von der Datenbank kommen und dafür die entsprechenden Tabellen angefertigt werden müssen. Tabelle 3.1: "Auflistung der Profilinformationen" Name des Profils String name Benutzername String publisherName Beschreibung String description Kategorie String category Tags String[] tags Bewertung int amountOfvaluations Durchschnittliche Bewertung double averageValuation Kommentare String[] comments Anzahl Downloads int amountOfDownloads Benutzer-ID String publicID Elementtyp String elementType Wie in Tabelle 3.1: "Auflistung der Profilinformationen" zu sehen ist, gibt es elf relevante Informationen, die für ein Profil bzw. für die Profilbörse wichtig sind. Besonders zu erwähnen sind die Benutzer-ID und der Elementtyp. Jedes Profil besitzt eine eigene Benutzer-ID, um es eindeutig zu identifizieren bzw. zuzuordnen. Diese Benutzer-ID wird später wichtig für das Laden in den Konfigurator, dass allerdings in Kapitel 3.3 näher beschrieben wird. Mit Elementtyp wird auf die Art des Profils hingewiesen. Es können nämlich nicht nur ganze Profile, sondern auch Teilprofile8 veröffentlicht werden. Dieser Zusatz wird in der Profilbörse im Namen des Profils kenntlich gemacht. 8 Es ist möglich, nicht nur ganze Profile zu veröffentlichen, sondern auch nur einzelne Teile davon. So kann man z.B. nur ein Script veröffentlichen, was dann mehrere Statements der Reihe nach ausführen kann, z.B. die Lautstärke auf 50% setzen oder das WLAN einschalten. 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 11 Ebenfalls ist die Definition der Schnittstellen (siehe Kapitel 2.5) zu erwähnen. Hierbei muss es zum einen eine Schnittstelle zur EMOTIO-Datenbank und zum anderen eine Schnittstelle zum Konfigurator geben. Diese wurden in einem Treffen mit den betroffenen Personen festgelegt. Aufgrund der Meilensteinplanung des Projekts ist für den Prototyp der Profilbörse im Rahmen der Seminararbeit ein Profilbörsen-Dummy vorgesehen. Dort sind die festgelegten Schnittstellen vorhanden ebenso wie einzelne Testprofile. Einzig die Anbindung an die Datenbank fehlt. Nach der Schnittstellendefinition folgt nun ein weiterer wichtiger Punkt zum Entwurf der Profilbörse: das Festlegen des Layouts. Dabei wird entschieden, wie die Aufteilung der Profilbörse ist, sprich welche Informationen angezeigt oder wo z.B. einzelne Funktionalitäten platziert werden (siehe Kapitel 3.1). Daher wurde in einem ersten Workshop die grobe Einteilung der Seite mit den jeweiligen Funktionalitäten festgelegt. In dem Workshop wurde grob entschieden, dass die Profilbörse in drei Teile gegliedert wird: In Kategorien, Profilanzeige und Such- und Filterfunktionen. Außerdem wurde ein erstes Layout festgelegt. Bei einem weiteren Treffen wurde dann das endgültige Layout, siehe Abbildung 3.1 "Endgültiges Layout der Profilbörse", beschlossen. Hierbei wurde das Layout auch in Anlehnung an den anderen Webanwendungen gestaltet. Abbildung 3.1 "Endgültiges Layout der Profilbörse" Wie in Abbildung 3.1 "Endgültiges Layout der Profilbörse" zu sehen ist, gliedert sich nun auch das endgültige Layout der Profilbörse in drei Teile. Auf der linken Seite werden die 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 12 Kategorien aufgelistet, in der die einzelnen Profile eingeteilt werden können. Auf der rechten Seite finden sich die Funktionen, um nach bestimmten Profilen zu suchen bzw. zu filtern. Hier ist z.B. das Suchen nach bestimmten Profilnamen oder auch nach einzelnen Wörtern in der Beschreibung möglich. Im Zentrum der Seite werden die Profile angezeigt. Hier wird zuerst der Name des Profils angezeigt, gefolgt von der Beschreibung. Anschließend werden die Tags und die Kommentare angezeigt. Die Bewertung und der Button zum Laden in den Konfigurator werden ebenfalls angezeigt. Nach der Planung der Profilbörse kann nun mit der Vorbereitung der eigentlichen Implementierung und der Realisierung der prototypischen Profilbörse begonnen werden. 3.3 Implementierung der Profilbörse Nachdem der Entwurf der Profilbörse bzw. das Layout festgelegt ist, ist es nun an der Zeit mit den Vorbereitungen der Implementierung zu beginnen. Dafür müssen zuerst die einzelnen Klassen definiert werden. Wie in Abbildung 3.1 "Endgültiges Layout der Profilbörse" zu sehen ist, ist die Profilbörse in drei Teile unterteilt. Das hat zur Folge, dass diese einzelnen Teile durch jeweils eine eigene Klasse definiert und separat aufgerufen werden, um sie dann einheitlich in der Profilbörse anzuzeigen. Ebenso muss es eine Hauptklasse geben, die diese ganzen Klassen bzw. Objekte aufruft. In der Tabelle 3.2 "Liste der Klassen" sind die Klassen zu sehen, die im Rahmen der Seminararbeit erstellt und implementiert werden. Allerdings sind dort auch die Klassen des Profilbörsen-Dummys zu finden, die vorläufig von der Datenbank-Schnittstelle zur Verfügung gestellt werden. Tabelle 3.2 "Liste der Klassen" EmotioProfilboerse.java Starterklasse des Projekts, mit der die Profilbörse aufgerufen wird. Layout.java Das Layout der Profilbörse wird erstellt. Categories.java Die Kategorien werden angezeigt. ShowProfiles.java Die ganzen Profile werden angezeigt. SearchAndSort.java Die Suchfunktionen werden angezeigt. Login.java Die Login-Funktion. (nur Anzeige der Textfelder) CategoryNamesList.java Dummy-Klasse, mit der Liste der Kategorien. EmotioObjectMarketDescription.java Dummy-Klasse, in der die Profile sind. 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 13 Nachdem die Klassen definiert sind, kann nun mit der Implementierung begonnen werden. Als erstes muss ein neues Projekt erstellt werden, was in Abbildung 3.2 "Ein neues Projekt erstellen" zu sehen ist. Abbildung 3.2 "Ein neues Projekt erstellen" Wichtig hierbei ist, dass ein Google Web Application Project und nicht ein reines Java Project ausgewählt wird, da in dem Forschungsvorhaben mit GWT gearbeitet wird. Nachdem das Projekt erstellt worden ist, werden drei Packages automatisch erstellt: ein client-, ein server- und ein shared-Package. Da in der Seminararbeit mit einem Dummy gearbeitet wird, sind alle Klassen (siehe Tabelle 3.2 "Liste der Klassen") im client-Package vorhanden. Da das Projekt erstellt ist, kann mit der Programmierung der Klassen begonnen werden. Als erstes werden die Klassen CategoryNamesList.java und EmotioObjectMarketDescription.java (siehe Tabelle 3.2 "Liste der Klassen") in das Projekt eingebunden und hinzugefügt, da diese die vorläufigen Schnittstellen zur Datenbank sind. In CategoryNamesList.java sind die Kategorien aufgelistet und werden mittels der Methode getCategories() zurückgegeben, die in der Tabelle 3.3 "Schnittstellen zur Datenbank" zu sehen ist. In EmotioObjectMarket- 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 14 Description.java sind die ganzen Testprofile vorhanden, die mit Hilfe der Methode getEmotioObjectMarketDescription() zurückgegeben werden. Tabelle 3.3 "Schnittstellen zur Datenbank" getEmotioObjectMarketDescription(String searchWord, String searchType, String ele- Es werden die Profile (Objekte) zurückgegeben, die in der Profilbörse angezeigt werden können mentType, String order) bzw. sollen. getCategories() Es werden die Kategorien als String[] zurückgegeben, in der die Profile eingeteilt werden können. addRating(String user, String password, String Es wird eine bestimmte Bewertung bei einem publicID, int rating) bestimmten Profil abgegeben. (In der Seminararbeit nicht funktionsfähig) addComment(String user, String String publicID, String comment) password, Es wird ein Kommentar an ein bestimmtes Profil angehängt. (In der Seminararbeit nicht funktionsfähig) Die vier Übergabeparameter searchWord, searchType, elementType und order, siehe Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen", in der Methode getEmotioObjectMarketDescription sind wichtig für die Such- und Filterfunktionen. Außerdem werden diese Übergabeparameter auch von den Konstruktoren der Klassen Layout.java und ShowProfiles.java verwendet, um so die Profile gefiltert anzeigen zu können. Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen" searchWord Nach welchem Wort soll gesucht werden. searchType Nach welchem Typ soll gesucht werden: category, tags, name oder publisherName. elementType Welcher Typ von Profil soll angezeigt werden. order Wie genau sortiert werden soll. (In der Seminararbeit nicht funktionsfähig) Nachdem der Profilbörsen-Dummy eingebunden ist, kann mir der Klasse EmotioProfilboerse.java begonnen werden. Wie man in Abbildung 3.3 "Quellcode der Klasse EmotioProfilboerse.java" sehen kann, hat die Klasse zwei Methoden. Eine davon ist die Hauptmethode, die 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 15 beim Start des Projekts aufgerufen wird. Die andere ist eine Hilfsmethode, die als private deklariert ist. Abbildung 3.3 "Quellcode der Klasse EmotioProfilboerse.java" Die Methode onModuleLoad() ist die Hauptmethode, diese wird zuerst aufgerufen wenn das Projekt gestartet wird. Diese Methode ruft wiederum die private deklarierte Methode start() auf, die dann den Konstruktor der Klasse Layout aufruft. Dabei werden dem Konstruktor vier leere Strings mitübergeben, damit beim ersten Aufruf alle Profile angezeigt werden (siehe Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen"). Da die Methode start() den Konstruktor der Klasse Layout aufruft, muss als nächstes die Klasse Layout.java (siehe Abbildung 3.4 "Klassendiagramm der Klasse Layout.java") programmiert werden. Abbildung 3.4 "Klassendiagramm der Klasse Layout.java" 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 16 Mit dieser Klasse wird die GUI, also im Allgemeinen die Profilbörse, erstellt. Mit dem Attribut „mainLayout“ wird der Teil dargestellt, der die eigentlichen Funktionen der Profilbörse (siehe Kapitel 3.1) beinhaltet. „headerLayout“ hingegen stellt den Header9 der Profilbörse dar. Der Konstruktor mit den vier Übergabeparametern, siehe Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen", ruft dann die getter-Methode von „mainLayout“ auf. Diese ruft daraufhin die Setter-Methode von „mainLayout“ auf, falls das Attribut gleich null ist. In der Setter-Methode createMainLayout(String searchWord, String searchType, String elementType, String order) wird zuerst ein DockLayoutPanel10 erstellt, damit anschließend in diesem Panel die gesamte Profilbörse angezeigt werden kann. Dafür werden nacheinander die Getter-Methode vom Attribut „headerLayout“, sowie die Konstruktoren der Klassen Categories.java, SearchAndSort.java und ShowProfiles.java aufgerufen. Einzig der Konstruktor von ShowProfiles.java besitzt Übergabeparameter. Es werden die einzelnen Layouts folgendermaßen in „mainLayout“ platziert: • Der Header mit dem Login im Teil North • Die Kategorien im Teil West • Die Anzeige der Profile im Teil Center • Die Such- und Filterfunktionen im Teil East Zuerst wird also der Konstruktor der Klasse Categories.java aufgerufen. Die Klasse Categories ist von der Klasse VerticalPanel11 abgeleitet. Die Klasse besitzt nur einen Konstruktor, in der die ganzen Kategorien als Hyperlinks angezeigt werden. In Abbildung 3.5 "Erstellung einer Kategorie mittels eines Hyperlinks" sieht man beispielhaft die Erstellung einer solchen Kategorie. 9 Im Header befinden sich die Eingabefelder für den Login, welche im Rahmen der Seminararbeit angezeigt werden, jedoch nicht funktionsfähig sind (siehe Abbildung 3.1 "Endgültiges Layout der Profilbörse"). 10 Ein DockLayoutPanel besitzt fünf separate Teile (North, West, Center, East und South), in der jeweils verschiedene Komponenten eingefügt und angezeigt werden können. (vgl. API DockLayoutPanel) 11 In einem VerticalPanel werden die einzelnen Komponenten untereinander angezeigt. (vgl. API VerticalPanel) 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 17 Abbildung 3.5 "Erstellung einer Kategorie mittels eines Hyperlinks" Zuerst wird ein neues Objekt vom Typ Hyperlink erstellt. Danach wird der Text gesetzt, d.h. es wird festgelegt, wie der Hyperlink später angezeigt werden soll. In diesem Beispiel hat der Hyperlink den Kategorienamen „Alltag“. Hierbei wird die Information12 aus der DummyKlasse CategoryNamesList.java13 mittels der Methode getCategories()14 entnommen. Danach wird noch die Schriftgröße angepasst und ein ClickHandler15 mit der Methode onClick(ClickEvent event) wird hinzugefügt und programmiert, um die Profile der Kategorie „Alltag“ angezeigt zu können. Dafür wird dann der Konstruktor der Klasse Layout.java wieder aufgerufen, nur diesmal sind es keine leeren Strings, wie beim ersten Aufruf (siehe Abbildung 3.3 "Quellcode der Klasse EmotioProfilboerse.java"). Denn jetzt wird nach dem searchWord „Alltag“ mit dem searchType „categories“ gefiltert. Mit dem Befehl add(category1) wird das Objekt dem VerticalPanel hinzugefügt und dadurch wird es erst in der Profilbörse angezeigt. Nachdem die Kategorien angezeigt werden, wird nun der Konstruktor der Klasse SearchAndSort.java aufgerufen. Ebenso wie Categories.java ist auch diese Klasse von VerticalPanel11 abgeleitet. In SearchAndSort.java sind die ganzen Such- und Filterfunktionen vorhanden, um nach bestimmten Profilen zu suchen. So kann man nach Wörtern in der Beschreibung oder auch nach bestimmten Tags suchen. Außerdem besteht die Möglichkeit nach Profilen, die ein bestimmter Benutzer erstellt hat, sowie nach bestimmten Profilnamen zu suchen. All diese Funktionen sind im Konstruktor definiert. Es wird zuerst eine TextBox erstellt, die als Eingabefeld der Suche dient, gefolgt von den einzelnen Suchkriterien. Diese werden mit Hilfe eines Labels und einer CheckBox darge- 12 Der Name der Kategorie. 13 Siehe Tabelle 3.2 "Liste der Klassen" 14 Siehe Tabelle 3.3 "Schnittstellen zur Datenbank" 15 ClickHandler ist ein Interface mit der Methode onClick(ClickEvent event). 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 18 stellt, siehe Abbildung 3.6 "Profilbörsendarstellung der Such- und Filterfunktionen". Zum Schluss folgt ein Button, um die Suche zu starten. Abbildung 3.6 "Profilbörsendarstellung der Such- und Filterfunktionen" Je nachdem welche CheckBox aktiviert ist, wird eine entsprechende Suchanfrage gestartet, indem der Konstuktor der Klasse Layout.java aufgerufen wird. Mit dem entsprechenden Text des Eingabefeldes als searchWord und dem entsprechenden searchType, der durch das anklicken der entsprechenden CheckBox festgelegt wird, als Übergabeparameter. Da der searchType nur einen bestimmten Typ annehmen kann, siehe Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen", wird somit immer die letzte Anfrage angezeigt, falls mehrere CheckBoxen aktiviert sind. Die gesamte Abfrage, welche CheckBox aktiviert ist, findet in der Methode des Suchbuttons statt. Wenn der Button gedrückt wird, dann wird überprüft, welche CheckBox aktiviert ist und ruft dementsprechend den Konstruktor samt den entsprechenden Übergabeparametern von Layout.java auf. Somit sind auch die Such- und Filterfunktionen funktionsfähig, die in Kapitel 3.1 gefordert sind. Zu guter Letzt müssen jetzt noch die ganzen Profile in der Profilbörse angezeigt werden und dafür gibt es die Klasse ShowProfiles.java. Die Klasse, welche von ScrollPanel16 abgeleitet ist, zeigt die Profile an und bietet die Schnittstelle zum Konfigurator mittels eines Buttons. ShowProfiles.java besitzt zwei Attribute, von denen eines „layout“ vom Typ VerticalPanel ist, in dem die ganzen Profile angezeigt werden. Dieses Attribut wird dann wiederum dem ScrollPanel hinzugefügt. Es wird ein ScrollPanel verwendet, weil durch das ScrollPanel alle Profile angezeigt werden können, da beim VerticalPanel nur die ersten Profile angezeigt werden aufgrund einer fehlenden Leiste zum Scrollen. Das zweite Attribut ist „profile“ vom 16 Ein ScrollPanel kann nur eine Komponente aufnehmen und besitzt eine Leiste, mit der man scrollen kann. (vgl. API ScrollPanel) 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 19 Typ EmotioObjectMarketDescription. Wie der Name schon sagt kann man mit diesem Attribut auf die Methoden des Profilbörsen-Dummy zugreifen. ShowProfiles.java besitzt ebenfalls zwei private Hilfsmethoden, die im Konstruktor Verwendung finden, da dort die ganze Gestaltung der Profilanzeige stattfindet. Der Konstruktor besitzt vier Übergabeparameter, die für die Such- und Filterfunktionen17 nötig sind. Denn es wird hier die Entscheidung getroffen, welche Profile angezeigt werden und welche nicht. Im Konstruktor selber wird eine for-Schleife durchlaufen, in der die gesamten Profile durchgegangen werden. In jedem Durchlauf wird dabei das entsprechende Profil samt den nötigen Informationen dem Attribut „layout“ hinzugefügt, wenn es die nötigen Bedingungen durch die Übergabeparameter erfüllt, siehe Abbildung 3.7 "Überprüfung einer möglichen Filterung eines Profils". Abbildung 3.7 "Überprüfung einer möglichen Filterung eines Profils" Am Beispiel der Kategorien sieht man in der Abbildung 3.7 "Überprüfung einer möglichen Filterung eines Profils", dass überprüft wird, ob der searchType hier in dem Beispiel gleich „categories“ ist. In der zweiten if-Bedingung wird nun überprüft, ob das Profil auch in dieser Kategorie18 vorhanden ist oder nicht. Wenn das Profil nicht in der Kategorie vorhanden ist, dann geht man mit dem continue-Befehl wieder an den Anfang der for-Schleife und es wird mit dem nächsten Profil weitergemacht. Wenn es allerdings die Bedingung erfüllt, werden als nächstes noch die anderen möglichen Filterungen überprüft. Diese treffen allerdings alle nicht zu, da bekanntlich nach nur einem searchTyp gefiltert werden kann. Daraufhin wird nun das entsprechende Profil mit den entsprechenden Informationen dem Attribut „layout“ hinzugefügt. Zuerst wird der Profilname angezeigt mit der entsprechenden Schriftgröße, die etwas größer ist als im Vergleich zu den anderen Informationen, damit man auch gut ein Profil erkennen kann. Zusätzlich wird noch die Art des Profils8 kenntlich ge- 17 Siehe Tabelle 3.4 "Liste der Übergabeparameter für die Such- und Filterfunktionen" 18 Die mit dem Übergabeparameter searchWord gekennzeichnet ist. 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 20 macht, d.h. um welche Art von Profil es sich handelt. Es folgt die Beschreibung sowie die durchschnittliche Bewertung und die Anzeige der Tags. Danach folgt der Kommentarbereich, in dem man einen Kommentar verfassen und absenden kann. Dieser funktioniert allerdings im Rahmen der Seminararbeit noch nicht, da mit dem Profilbörsen-Dummy gearbeitet wird. Die bisherigen Kommentare, die zu dem Profil verfasst worden sind, werden ebenfalls angezeigt. Zum Abschluss eines jeden Profils gibt es noch den Button, mit deren Hilfe man das Profil in den Konfigurator laden kann. Beim klicken des Buttons wird die URL des Konfigurators aufgerufen, die die Benutzer-ID19 angehängt bekommt. Mit der entsprechenden Benutzer-ID holt sich der Konfigurator dann das entsprechende Profil aus der Datenbank. Da zur Zeit der Server für das Forschungsvorhaben aufgesetzt wird, ist die endgültige URL des Konfigurators noch nicht bekannt. Jedoch ist die Funktionalität des Ladens der neuen Seite vorhanden, somit sollte das Laden eines Profils in den Konfigurator funktionieren, sobald die richtige URL bekannt ist. Nachdem nun der letzte Konstruktor in der Klasse Layout.java aufgerufen wurde, ist die Profilbörse nun komplett und kann angezeigt werden. Das Projekt wird als Web Anwendung gestartet und nachdem das Programm fertig kompiliert hat, wird eine URL angezeigt, mit der sich das Projekt öffnen bzw. anzeigen lässt. Wenn man nun auf die URL klickt, öffnet sich ein Webbrowser20 und dieser zeigt die prototypische Profilbörse an, die man in Abbildung 3.8 "Prototyp der Profilbörse" sehen kann. 19 Siehe Tabelle 3.1: "Auflistung der Profilinformationen" 20 In diesem Fall ist das der Internet Explorer. 3 Entwicklung einer Profilbörse für Smartphone-Konfigurationen 21 Abbildung 3.8 "Prototyp der Profilbörse" In der Abbildung 3.8 "Prototyp der Profilbörse" kann man nun die prototypische Profilbörse sehen, so wie Sie in Kapitel 3.2 beschrieben und festgelegt worden ist. Oben im Header9 befindet sich der Login, mit dem sich ein Benutzer später anmelden kann. Auf der linken Seite befinden sich die einzelnen Kategorien, die als Hyperlinks dargestellt sind, um sich bestimmte Profile einer Kategorie anzeigen zu lassen. Im Zentrum befinden sich die Profile samt den Informationen, die angezeigt werden. Zu guter Letzt befindet sich auf der rechten Seite die Such- und Filterfunktionen, um nach bestimmten Profilen suchen zu können. 4 Validierung an einem Anwendungsbeispiel 22 4 Validierung an einem Anwendungsbeispiel 4.1 Vorstellung Use-Case Nachdem die Profilbörse erfolgreich implementiert wurde (siehe Abbildung 3.8 "Prototyp der Profilbörse"), müssen nun auch die ganzen Funktionalitäten auf ihre Funktionsfähigkeit hin überprüft werden. Dies wird mit Hilfe eines geeigneten Use-Case herausgefunden. Der Use-Case zur Überprüfung der Funktionalität sieht folgendermaßen aus: • Ein Benutzer sucht das bestimmte Profil „WLAN-Einschaltung“ • Er durchsucht zwei Kategorien, doch er findet das Profil nicht • Er benutzt die Suchfunktion und sucht nach dem Profilnamen Mit diesem Use-Case werden alle Funktionalitäten von der Anzeige der Profile bis hin zu der Suche und Filterung von bestimmten Profilen getestet. 4.2 Anwendung des Use-Cases Nachdem der Use-Case vorgestellt wurde, ist es nun an der Zeit, dass dieser auch angewendet wird. Der Benutzer sucht also nach dem Profil „WLAN-Einschaltung“, jedoch findet er es auf Anhieb nicht. Deshalb versucht er mit Hilfe der einzelnen Kategorien das gewünschte Profil zu finden. Zuerst probiert der Benutzer die Kategorie „Alltag“ aus, jedoch findet er dort das gewünschte Profil nicht. Als nächstes wird die Kategorie „Kommunikation“ gewählt, welche ebenso wenig zum Erfolg führt. Da jedoch die blinde Suche auf Dauer nicht erfolgsversprechend ist, entscheidet sich der Benutzer für die spezielle bzw. benutzerdefinierte Suche von Profilen. Deshalb wird in das Suchfeld das Stichwort „WLAN“ eingegeben mit der Hoffnung, dass das gewünschte Profil angezeigt wird. Und in der Tat wird das Profil „WLAN-Einschaltung“ nun in der Profilliste angezeigt und der Benutzer kann sich das Profil und deren Informationen genauer anschauen, siehe Abbildung 4.1 "Anzeige des Profils beim Use-Case". 4 Validierung an einem Anwendungsbeispiel 23 Abbildung 4.1 "Anzeige des Profils beim Use-Case" Wie in Abbildung 4.1 "Anzeige des Profils beim Use-Case" zu sehen ist, wird das richtige Profil angezeigt, was bedeutet, dass die Funktionalitäten der Profilbörse für diesen Use-Case funktionieren. 5 Zusammenfassung und Ausblick 24 5 Zusammenfassung und Ausblick In der Seminararbeit im Rahmen des Forschungsprojekts „EMOTIO“ wurde die Profilbörse prototypisch implementiert. Dadurch hat der Benutzer nun die Möglichkeit, sich Profile anzuschauen und diese evtl. in seine eigenen Konfigurationen mit einzubeziehen, sobald die endgültige URL des Konfigurators vorhanden ist. Die Profilbörse ist nahe am vorgeschriebenen Layout implementiert und gestaltet worden, die durch die Klasse Layout.java festgelegt ist. Ebenso hat dieser Prototyp die in der Einleitung beschriebenen Anforderungen weitestgehend erfüllt. Das wichtigste ist das Anzeigen und das Laden in den eigenen Konfigurator der Profile. Mittels ShowProfiles.java kann sich der Benutzer die angezeigten Profile anschauen und für sich selber entscheiden, ob er Verwendung dafür findet und es dann in seinen Konfigurator lädt. Das Laden in den Konfigurator geschieht mittels eines Links, in dem der Konfigurator aufgerufen und mit Hilfe der Benutzer-ID wird dann das entsprechende Profil aus der Datenbank geholt. Da jedoch die endgültige URL nicht vorhanden ist, ist zurzeit das Einbinden in den Konfigurator nicht möglich, obwohl die eigentliche Funktionalität, sprich das Laden einer neuen Seite, vorhanden ist. Die Such- und Filterfunktionen sind ebenfalls implementiert und funktionieren, wie im UseCase (siehe Kapitel 4.2) dargestellt wird. Durch Categories.java ist es dem Benutzer möglich, sich bestimmte Profile aus speziellen Kategorien anzeigen zu lassen, um die Suche zu erleichtern. Das Suchen nach einzelnen Profilen wird durch die Klasse SearchAndSort.java ermöglicht. Dabei ist dem Benutzer die Möglichkeit gegeben, nach bestimmten Kriterien Profile zu suchen und sich anzeigen zu lassen. Der weitere Verlauf dieser Programmieraufgabe sieht so aus, dass der Profilbörsen-Dummy durch die richtige Datenbankanbindung ersetzt wird. Dabei wird der Dummy schrittweise ersetzt, um hinterher eine Kommunikation mit der Datenbank zu haben. Jedoch kann das erst stattfinden, wenn die Methoden bzw. Tabellen der Datenbank fertig implementiert sind. Durch die Datenbankanbindung können dann auch das Bewerten und Kommentieren von Profilen programmiert werden, da die nötigen Methoden zurzeit nicht funktionsfähig sind. Ebenso kann der Login eines Benutzers dann durch die Datenbankanbindung realisiert werden, da im späteren Verlauf der Anwendung die Benutzung der Profilbörse nur für angemeldete Benutzer möglich ist. Ein weiterer Punkt ist die graphische Verfeinerung der Profilbörse. Da die Profilbörse zurzeit ein Prototyp ist, müssen noch ein paar Verfeinerungen vorgenommen werden, um an das finale Layout noch näher heranzukommen. So muss noch z.B. der Header mit dem Login dem finalen Layout angepasst werden, um für die gesamte Webanwendung eine einheitliche Festlegung zu haben. 5 Zusammenfassung und Ausblick 25 Nachdem die beiden Punkte abgearbeitet sind muss noch die Profilbörse in die eigentliche Webanwendung des Forschungsprojekts mit eingebunden werden. Denn die Profilbörse ist nur ein Teil der Anwendung und die besteht noch aus einem Konfigurator, einem Forum und einer Startseite. Nur wenn die Einbindung der Profilbörse in die Webanwendung geschafft ist, dann kann das Projekt vorgestellt werden. IV Literaturverzeichnis IV 26 Literaturverzeichnis Html 4 Fur Dummies (2008): John Wiley & Son Ltd. Boles, Dietrich; Boles, Cornelia (2010): Objektorientierte Programmierung spielend gelernt mit dem Java-Hamster-Modell. 2. Aufl. Wiesbaden: Vieweg + Teubner. Dornberger, Rolf; Telesko, Rainer (2010): Java-Training zur objektorientierten Programmierung. Leitfaden für Lehre, Unterricht und Selbststudium. München: Oldenbourg. Gupta, Vipul (2008): Accelerated GWT. Building Enterprise Google Web Toolkit applications. Berkeley, CA, New York: Apress; Distributed to the Book trade by Springer-Verlag New York. Mosemann, Heiko; Kose, Matthias (2009): Android. Anwendungen für das HandyBetriebssystem erfolgreich programmieren. München [u.a.]: Hanser. Schmitt, Robert; Humphrey, Sean; Köhler, Markus (2012): EMOTIO-Systematische Integration von Kunden in den Produktlebenszyklus. In: Günther Schuh, R. Neugebauer und Eckart Uhlmann (Hg.): Future trends in production engineering. Proceedings of the first conference of the German Academic Society for Production Engineering (WGP), Berlin, Germany, 8th9th June 2011. 2012. Aufl. Berlin ;, London: Springer. V Anhang V Anhang A.1. Klassendiagramme Abbildung 5.1 "Klassendiagramm der Klasse EmotioProfilboerse.java" Abbildung 5.2 "Klassendiagramm der Klasse Categories.java" Abbildung 5.3 "Klassendiagramm der Klasse SearchAndSort.java" 27 V Anhang Abbildung 5.4 "Klassendiagramm der Klasse ShowProfiles.java" Abbildung 5.5 "Klassendiagramm der Klasse CategoryNamesList.java" Abbildung 5.6 "Klassendiagramm der Klasse EmotioObjectMarketDescription.java" 28 V Anhang Abbildung 5.7 "Klassendiagramm der Klasse Login.java" 29
