Lexikalischer, Syntax- und semantischer Fehler – Grundlagen der Informatik

Bei dem kompilieren des Quellcodes können verschiedene Arten von Fehler passieren, die jedoch in einer bestimmten Reihenfolge abgefangen werden.

1. Lexikalischer Fehler

Das erste was der Compiler macht, ist das ganze Dokument durchsuchen nach unerlaubten Zeichen. Früher konnte man nur im ASCI-Schriftsatz programmieren, deshalb konnte man Sonderzeichen wie “ä”,”ö”,”ü” und “ß” nicht verwenden. Aber heutzutage unterstützen die meisten Programmiersprachen den UNI-Code und somit sind weitgehend alle Zeichen verwendbar. In Java hat man mit Sonderzeichen auch keine Probleme mehr.

2. Syntaxfehler

Die häufigsten Fehler überhaupt sind die Syntaxfehler, den diese kommen zustande wenn man z. B. die Klammern vergisst “}”,”)” und “[” oder je nach Programmiersprache auch das beliebte Abschlusszeichen “;”. Man bedenke: Jede geöffnete Klammer benötigt auch eine geschlossene Klammer.

3. Semantischer Fehler

Diese Fehler entstehen, wenn man in seinem Quelltext auf Klassen und/oder Methoden zugreifen will, die nicht zur Verfügung stehen bzw. nicht vorhanden sind.

Grundlagen der Informatik : Compiler und Interpreter

Jede Programmiersprache benötigt ein Compiler und manche sogar noch einen Interpreter. Einleuchten wird dieser Satz, wenn wir uns den Aufbau eines Computers genauer anschauen, denn wenn wir programmieren, schreiben wir Texte in leserlichen ASCII oder UNI-CODE Zeichen, mit denen unser CPU eigentlich nichts anfängt. Daher benötigen wir einen Übersetzer, der unseren geschriebenen Quellcode in den Maschinencode umändert.

Wozu brauchen wir einen Interpreter?

Da es viele Programmiersprachen gibt, müssen wir den Quellcode für jedes Betriebssystem und Architektur anders Übersetzten. Denn z. B. der Aufruf von einem Fenster läuft auf einem Windows PC ganz anders ab, als in einem Mac oder Linux Computer.

Interpreter sind somit notwendig, wenn das Programm für mehrere Plattformen funktionieren soll.

Genauer Ablauf in Java

Zuerst wird unser geschriebener Quelltext (*.java Dateien) mittels den Java Compiler umgewandelt in einen Bytecode.

Dieser Bytecode ist nicht komplett leserlich, aber sobald ein System/Plattform abhängiger Aufruf stattfindet, kann man einen leserlichen Schriftzug erkennen. Der Bytecode wird in der “*.class” Datei abgespeichert oder in ganzen Gruppen als “*.jar” Datei.

Der Interpreter liest nun diesen Bytecode und wandelt die fehlenden Stellen um, sodass ein vollständiger Maschinencode entsteht. Deshalb muss man bei der Installation des Interpreters auf das eigene Betriebssystem achten, damit die Übersetzung erfolgreich und ausführbar ist.

Der Maschinencode wird dann sofort ausgeführt, im Rahmen der Java Virtual Machine.

- Zu dem Compiler Interpreter Tutorial ->
- Zu dem Java Virtual Machine Tutorial ->

Ein Java 2D Spiel entwickeln mit der GTGE

Um ein 2D-Spiel in Java entwickeln zu können, benötigen wir die gesamten GTGE libarys. Diese können wir sogar in Eclipse mittels SVN (Subclipse Plug-In) einfach einrichten.

In einem neuen VHPD Videotutorial erklären wir Schritt für Schritt, wie man Eclipse so konfiguriert, damit man die GTGE herunterladen kann.

Verwendete Links

SVN -- Subclipse: http://subclipse.tigris.org/update_1.6.x

GTGE Source -- SVN: http://gtge.googlecode.com/svn/trunk

GTGE

Der Sourcecode von der GTGE ist unter der GPL-Lizens veröffentlicht und kann auch über der GTGE direkt heruntergeladen werden.

Zu der GTGE-Homepage ->

2D Spiele in Java selber programmieren

Wir vom VHPD-Team sind schon seit geraumer Zeit auf der Suche, nach der ultimativen Java 2D Engine und wir haben nun unseren eindeutigen Sieger ermittelt:

Golden T Game Engine (GTGE)

Dieses Powerpacket beinhaltet eine voll funktionierende 2D Engine die sogar mittels OpenGL rendern kann und auch problemlos in Browser eingebunden werden kann. Auch in den Testreihen wurden auf Windows Systemen und Linux (Ubuntu) getestet, ob die Engine auch wirklich überall läuft.

Unser Ergebnis

Von der 2D Ausgabe bis hin zum Netzwerktest lief die GTGE-Engine problemlos unter allen Systemen und das programmieren macht richtig Spaß. GTGE ist durch ihren einfachen Aufbau und anhand der gelungenen Tutorials ein toller Begleiter, wenn es um die Entwicklung von 2D Spielen geht.

Lizenz

Der Source Code von GTGE wurde unter der GPL veröffentlicht und frei verfügbar über eine SVN Schnittstelle.

Danksagung

Durch Swen Schreiter’s Testunterstützung, konnten die Linux (Ubuntu) Tests erfolgreich durchgeführt werden. Zu seinem 3G-Phoneblog ->

Mittels Maximilan Häge’s Unterstützung, konnten wir die Engines untereinander austesten und besser vergleichen. Zu seinem IT’s Real Blog ->

Vielen Dank auch an allen anderen, die während des Laufzeittests uns unterstützt haben.

Wie geht’s weiter?

In den kommenden Wochen wird ein 2D Ping Ping Tutorial mit Eclipse und der GTGE auf dem VHPD-Blog für alle veröffentlicht, sodass jeder sehen kann, wie einfach es ist, ein 2D Spiel zu programmieren.

Java wurde auf 3D Basis stark erweitert

Überall 3D, von Spielen bis hin zur Office-Anwendung -- Heutzutage ist 3D fast ein fester Bestandteil der Entwicklung.

Durch was kann man 3D in Java benutzen?

Mittels JavaFX wurde zuerst direkt von SUN ein pseudo 3D-Libary vorbereitet für Anwendungen. Natürlich ist diese zu OpenGL und DirectX fast nichts, aber die ersten Schritte in Richtung 3D wurden gebaut.

Auf der anderen Seite aber, gibt es ein Team von Programmierern, die es sich zur Aufgabe gemacht haben, ein gut funktionierendes 3D Libary für Java zu entwickeln. JMonkey Engine (JME) ist das Zauberwort. Diese Libary erweitert Java auf viele OpenGL Funktionen die sogar dann mit OpenGL oder DirectX (nur Windows) gerendert werden.

jME -- Java Monkey Engine

Jeder kann problemlos mit Eclipse diese 3D Engine verwenden und kann leicht 3D in Java einbinden.

- Zur offiziellen Websiete von jME (englisch) ->

Tutorial zur Installation von jME mit Physik Engine

This Tutorial shows, how to install Subclise and setup jMonkeyEngine and jMEPhyscs in a fresh Eclipse 3.5.

Used URLs:

subclipse:http://subclipse.tigris.org/update_1.6.x

jMonkeyEngine:http://jmonkeyengine.googlecode.com/svn/trunk

jMEPhysics: http://jmephysics.googlecode.com/svn/trunk

Mittels diesem Video ist das Installieren kein Problem mehr.

Probleme mit Java und der 3D-Welt

Java ist bei weitem keine 100% geeignete Spielesprache, ihr nicht direkter Hardwarezugriff sorgt für Performanceschwäche und somit wären solche Spiele wie FarCry2 und GTA4 niemals möglich.

Jedoch für kleine Spielereien und Minigames ist dieses Paket Gold wert.

Mit Java in Eclipse ein Adressbuch programmieren

Vorwort

In diesem Tutorial werden wir ein Adressbuch programmieren, dass mit Hilfe eines Arrays von einem benutzerdefinierten Datentyp, die Kontakte Speichert. Daraus sollte man die Verwendung des 3. Schichten Modells besser verstehen können.

Profil

Um dieses Tutorial mitmachen zu können, sollte man die Grundkenntnisse von Java beherrschen und wissen, wie man mit Arrays umgeht. Dazu wird als Formgestalltungsprogramm Jigloo verwendet. Jigloo ist für nicht-kommerzielle Software kostenlos.

Einführung in das 3 Schichten Modell

Das ist die Grundlage des Tutorials, das 3 Schichten Modell. Wie man gut Heraushören kann, war es mal wieder ein langer Tag und dazu noch leicht erkältet .

Struktogramme und UML

Alle Struktogramme wurden von der Gewerblichen Schule Göppingen im Unterricht bereitgestellt und das UML stellen wir nun bereit.

[Zeigen als Slideshow]

[Mit PicLens anzeigen]

Der Start

Erstellen eines neuen Javaprojektes mit dem Titel “P_AdressBuch”. Danach legen wir unsere StartKlasse mit static void main() an.

Erstellen des EingabeForms

Nun kommen wir schon zur GUI, die GUI sollte uns die Möglichkeit geben, alle Inhalte anzeigen und bearbeiten zu lassen. Wir müssen daher zwingend Textfields nehmen. Bitte beachtet die Einstellung: Set Layout > AbsoluteLayout und optional Set look and feel > System. Die Oberfläche sollte danach so aussehen:

Fehlende Klassen erstellen

Danach sollte man die fehlenden Klassen erstellen, die Steuerungsklasse und Datensatz. Mithilfe der gegebenen Stuktogramme und UML sollte jeder problemlos wissen, was er nun zu machen hat. Noch eine Kurze Erklärung wie: Zuerst UML anschauen, danach feststellen welche Methoden, die als Struktogramme gegeben wurden, in welche Klasse gehören.

Die Klasse Datensatz.java sollte nun erstellt werden mit folgendem Inhalt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Datensatz {
 
	//Globale Attribute der Klasse
	public String vorname, nachname, adresse, plz, email, ort, telnr;
 
	//Konstruktor - 2 Versionen für vorhandene Daten und ohne
 
	//Konstruktor mit Daten füllen
	public Datensatz(String p_vorname, String p_nachname, 
			String p_adresse, String p_plz, String p_email, 
			String p_ort, String p_telnr){
		vorname = p_vorname;
		nachname = p_nachname;
		adresse = p_adresse;
		plz = p_plz;
		ort = p_ort;
		email = p_email;
		telnr = p_telnr;
	}
 
	//Konstruktor ohne Daten
	public Datensatz(){
		vorname = null;
		nachname = null;
		adresse = null;
		plz = null;
		ort = null;
		email = null;
		telnr = null;
	}
}

Hier kann man gut erkennen, wie man 2 Konstruktoren für verschiedene Fälle anwendet. Einfach einen weiteren Konstruktor anlegen mit anderen Parametern und schon entscheidet Java, welcher Konstruktor verwendet wird.
Durch das null Setzen der Attribute, kann es nicht zu einem Fehler führen, wenn man auf ein Attribut zugreift

Nun kommt der Inhalt der Steuerungsklasse.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

public class Steuerungsklasse {
 
	//Atribute
	private int feldGröße = 100;
	public int derZeiger = 0;
	private EingabeFrame fenster = null;
	private Datensatz[] dieDaten = new Datensatz[feldGröße+1];
 
	//Konstruktor
	public Steuerungsklasse(EingabeFrame p_fenster){
		fenster = p_fenster;
	}
 
	//Funktionen von Struktogramm siehe UML
 
	public Datensatz erstesElement(){
		derZeiger = 0;
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz letztesElement(){
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			while (dieDaten[derZeiger +1]!=null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz links(){
		if (derZeiger > 0){
			derZeiger--;
		}
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz rechts(){
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			if (dieDaten[derZeiger +1]!= null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz refresh(){
		if (dieDaten[derZeiger] == null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public boolean insert(Datensatz d){
		if (dieDaten[derZeiger]== null){
			dieDaten[derZeiger] = new Datensatz();
			dieDaten[derZeiger] = d;
			return true;
		} else {
			if (dieDaten [feldGröße - 1] == null){
				int derZeiger2 = feldGröße -1;
				while (derZeiger2 > derZeiger){
					dieDaten[derZeiger2] = dieDaten[derZeiger2-1];
					derZeiger2--;
				}
				dieDaten[derZeiger] = d;
				return true;
			} else return false;
		}
	}
 
	public boolean delete(){
		int derZeiger2 = derZeiger;
		while(dieDaten[derZeiger2]!= null){
			dieDaten[derZeiger2] = dieDaten[derZeiger2+1];
			derZeiger2++;
		}
		return true;
	}
 
	public boolean modify(Datensatz d){
		if (dieDaten[derZeiger] != null){
			dieDaten[derZeiger] = d;
			return true;
		} else {
			return false;
		}
	}
 
}

Die erstellten Methoden wurden aufgrund der Struktogramme der Gewerblichen Schule angefertigt, jedoch sollte man dazu sagen, dass Variablennamen sich unterscheiden. z. B. bei dem VHPD Adressbuch dieDaten und im Struktogramm dasDatenfeld.
Profis werden die Assoziation fenster nicht verstehen, natürlich ich diese in diesem Fall mehr als unnütz, jedoch hier sollte es die gegenseitige Verbindung wie im UML darstellen. In der fenster-Variable wird nur die Adresse zu dem echten Fenster gespeichert.

Nun kommen wir zu dem schweren Teil, das erweitern von dem EingabeFrame. Als Erstes sollte man alle Buttons, außer New, auf disabled stellen. Danach erstellen wir eine weitere Methode in der EingabeFrame Klasse.

1
2
3
4
5
6
7
8
9

	private void clearAll(){
		tfVorname.setText("");
		tfNachname.setText("");
		tfAdresse.setText("");
		tfPLZ.setText("");
		tfOrt.setText("");
		tfTelNr.setText("");
		tfEMail.setText("");
	}

Diese Erweiterung erspart uns viel Tipparbeit. Sollte sich jetzt jemand Fragen, wie man eine Methode einfügt in eine Klasse, dann sollte dieser Hinweis reichen: Zwischen zwei bereits vorhandenen Methoden aber nicht nach der Abschließenden Klassenklammer }.
Danach erstellt man die Buttons nach der Reihe, davor sollte man aber wissen, wie das Programm jetzt eigentlich genau funktioniert:

Wenn man auf Neu klickt, dann werden die Buttons Neu, Ändern, Löschen deaktiviert und im Gegenzug Sichern und Abbrechen aktiviert. Nach dem Umstellen der Schalter wird ein Leerer Datensatz eingefügt. Als Letztes verwenden wir unsere clearAll() Methode, um die Textfelder zu leeren. Dass sieht im Java Code so aus:

1
2
3
4
5
6
7

	private void bNeuActionPerformed(ActionEvent evt) {
		bAbbrechen.setEnabled(true);
		bSichern.setEnabled(true);
		bNeu.setEnabled(false);
		clearAll();
		dieSteuerung.insert(new Datensatz());		
	}

Nun schauen wir uns Sichern an, wenn wir auf Sichern klicken, dann wird ein Datensatz mit dem Formularinhalt erstellt und dann wird mit Hilfe von modify der Steuerungsklasse, der vorher neu erstellte Eintrag geändert, mit dem Inhalt des Formulars. Im Java Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

	private void bSichernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
 
		if (dieSteuerung.modify(d)!= true){
			System.out.println("Kontne nicht Gesichert werden");
		}
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
	}

Mit einem Klick auf Löschen erstellen wir einen leeren Datensatz, um die Daten des nachfolgenden Elementes anzeigen zu können. Damit keine Lücken im Array der Datensätze entstehen, müssen wir alle Einträge dann immer aufschieben. Danach benutzen wir die void Methode delete() von derSteuerung und zum Schluss laden wir in unseren leeren Datensatz d, die Informationen vom Aufgerutschten Element. Die Inhalte von d werden dann mit der setText() Methode der Textfelder angezeigt. Das sieht in Java so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

	private void bLöschenActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		dieSteuerung.delete();
 
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun gibt es noch Ändern, wenn man darauf klickt, wird ein Datensatz mit den Inhalten des Fensters erstellt und mit der Methode modify von derSteuerung übertragen an dieDaten. Im Java Code:

1
2
3
4
5
6
7
8
9

	private void bÄndernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
		if (dieSteuerung.modify(d) != true){
			System.out.println("Konnte nicht Geändert werden");
		}
	}

Nun gibt es noch Abbrechen, wenn man darauf klickt, wird Neu, Ändern, Löschen aktiviert und Abbrechen und Sichern deaktiviert. Danach werden die Textfelder mit clearAll() geleert und wir benutzen die refresh() Methode der Steuerungsklasse, um die Orginaldaten wiederherzustellen. Natürlich müssen wir wie davor, einen leeren Datensatz d erstellen, den wir mit refresh() füllen und dann auslesen um die Textfelder mit dem richtigen Inhalt voll stopfen zu können. In Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

	private void bAbbrechenActionPerformed(ActionEvent evt) {
		clearAll();
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
 
		Datensatz d = new Datensatz();
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun muss man noch Blättern können, mit einem klick auf das erste Element wird, wie bereits schon 4 mal geschrieben, ein leerer Datensatz d erstellt, der mit den Inhalt von dem ersten Element in der Steuerungsklasse, gefüllt wird. Danach wird der Inhalt wieder im Fenster angezeigt. Java:

1
2
3
4
5
6
7
8
9
10
11
12
13

	private void bErstesElementActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		d = dieSteuerung.erstesElement();
 
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Um jetzt nach links, rechts oder zum letzten Element zu kommen, muss man nur die 4. Zeile anpassen und anstelle von erstesElement, die gewünschte Methode aufrufen.

Nun ist das Grundgerüst einwandfrei fertig und alles läuft so, wie es sollte. Um die Anzeige noch besser machen zu können, kann man den Zeiger anzeigen lassen. Dazu sollte man auf dem Form ein Label mit dem Namen lZeiger erstellen und den folgenden Baustein zu jeder Button-Methode einfügen:

1

lZeiger.setText(Integer.toString(dieSteuerung.derZeiger));

Wenn alles Geklappt hat, sollte das Fertige Programm so aussehen:

Hier noch die Source zum Download, jedoch wurde der EingabeFrame entfernt, denn sollte man mindestens noch selber hinbekommen . Download Source.

Entwicklung für mobile Geräte

Für jeden, der sich mit der Entwicklung für mobile Geräte befasst hat, kennt die Problematik: Für jeden Typ brauch man spezielle SDKs, Entwicklungsumgebungen sind meist bescheiden und vor allem Typ abhängig.

Das Pulsar (Eclipse) packt alles unter ein Dach, sodass die Entwicklung einfach ist. Pulsar war zuerst ein kleines Eclipse Plug-In mit dem es möglich war, mit SDKs von Drittanbietern unter Eclipse zu programmieren. Heute gibt es Pulsar auf der Eclipse Webseite zum Download als eigenständiges Programm, natürlich auf Eclipse basierend und erleichtert die mobile Entwicklung.

SDKs können schnell und unkompliziert über Pulsar (Eclipse) heruntergeladen werden und somit können unerfahrene Benutzer, ohne großartig zu Suchen, schnell die SDKs verwenden für volle Komplexität.

Optisch unterscheiden sich Eclipse und Pulsar nur sehr gering, somit fällt die Umstellung von Eclipse auf Pulsar überhaupt nicht schwer. Zusätzlich können eigene Konfigurationen zum erstellen von den Java-Programmen geschrieben werden, um das Programm für das jeweilige Gerät 100 prozentig anpassen zu können.

Erste Java Tutorials veröffentlicht

Heute Abend haben wir auf unserer Seite Tutorials zu Java und dem Binären-System veröffentlicht. Damit ein theoretischer Einstieg in Java leichter wird .

Tutorials die heute Abend veröffentlicht worden sind:

JVM – Java Virtual Machine

Algorithmus – Nassi Schneidermann

Phasen der Programmübersetzung

Komplement durch Uz

Compiler und Interpreter

oder die Übersicht:

Tutorial Seite

Viel Spaß beim Anschauen,

VHPD-Team.

Einfacher Start mit dem Tracking, für Open Street Maps und Google Maps

Benötigt werden:

Handy, das Java (J2ME) unterstützt,

Eine Bluetooth GPS-Maus

und gute Laune

Erste schritte:

Herunterladen des Handyprogramms “Mobile Trail Explorer” auf der Entwicklerseite, oder direkt als .JAR oder .JAD downloaden. Das Hadyprogramm ist unter der GPL (General Public Licence) veröffentlicht und ist somit kostenlos.

Ich benutze dieses Programm, da es nach meiner Meinung das stabilste und einfachste war, auf meinem Nokia 5300 Xpress Music.

Die heruntergeladene Java-Datei auf das Handy kopieren.

Erste Einstellungen:

Sollte die neuere mobile Javaumgebung installiert sein, muss man die Sicherheitseinstellungen verändert, dass das Programm die Trackings auch auf der Speicherkarte speichern kann.

Das geht in den man die Javadatei “TrailExplorer” markiert und dann auf Optionen->Programmzugriff->Datenzugriff-> Dat. hinzufüg./bearb. es erlaubt, bzw. auf “jedes Mal fragen” stellt.

Erster Programmstart:

Wenn man den roten Punkt in der mite seiht, drückt man auf die mittlere Taste und kommt somit in das Menü. Danach geht man auf Settings->GPS  und das Handy verlangt nun, das Bluetooth zu aktivieren und möchte damit eine Verbindung aufbauen. Dann einfach seine Bluetooth GPS-Maus auswählen.

Leichter geht es, wenn man die Bluetooth GPS-Maus schon vorab mit dem Handy im Bluetooth Menü gekoppelt hat. Der Sicherheitscode ist bei den meisten Bluetooth GPS-Mäusen “0000″.

Sollte das Handy die Bluetooth GPS-Maus nicht finden, liegt es daran, dass die Java-Sicherheitseinstellungen dies verwehren, somit muss man wie mit dem Datenzugriff auch den Verbingunszugriff bestätigen.

Weiterlesen »