Da Netstumbler unter Windows 7 definitiv nicht funktioniert, dachte ich mir: “Hey, bau dir deinen eigenen Stumbler!” Und das habe ich auch getan. Dabei ist mir aufgefallen, dass ich gar nicht weiss, welche Daten fuer mich eigentlich relevant sind. Ich habe mir angeschaut, wie inSSIDer arbeitet und habe mir dort abgeschaut, wie ich Daten erfasse:

Zunaechst verbinde ich mich mit dem GPS Geraet und beginne zeilenweise die Daten zu parsen. Dann starte ich den Wifi-Scan. Jedesmal, wenn ein Scan abgeschlossen ist, schaue ich nach, ob ich das jeweilige Netzwerk schon kenne. Wenn ich es bereits kenne, dann ueberpruefe ich, ob der alte RSSI Wert geringer ist, als der neue. Ist das der Fall, dann setze ich die Position des gefundenen Netzes auf die aktuelle GPS Position, ansonsten lasse ich die alte bestehen. Kannte ich das Netzwerk noch nicht, dann habe ich es in die Liste der gefundenen Netze aufgenommen und die aktuelle GPS Position als Netzposition gesetzt.

Positionsapproximation

Letztendlich erhalte ich so eine nette Liste von Wifi-Infrastrukturen, und die GPS Koordinaten von dem Ort, an dem man sich am Nächsten an der Infrastruktur befunden hat. Natuerlich koennte man das noch verbessern, indem man sich der Mathematik bedient, aber da die Reichweite von Access Points noch weit unter Sichtweite ist, ist das erstmal egal.

Bei der Programmierung ist mir aufgefallen, dass ich Wifi-orientiert arbeite, d.h. ich finde Netze und suche mir dazu die Positionen. Es geht natuerlich auch andersherum: Jedesmal, wenn mir der GPS Receiver eine Koordinate rauswirft, also meist mit einem ausreichenden Takt von 1Hz, dann kann ich die zur Zeit verfuegbaren Netze dazu assoziieren. Letztlich geht es hierbei um zwei Betrachtungsweisen, die sich zwei verschiedenen Fragen widmen:

1. Welche Infrastrukturen gibt es an der Position X?
2. Welche Position hat die Infrastruktur Y?

Beide Fragen sind durchaus interessant. Die Frage, die von den meisten Geoprogrammen beantwortet wird, ist die zweite, da gerade diese beim Wardriving interessant ist. Was ich mich jetzt frage ist:

Gibt es Anwendungsfaelle, bei denen es wichtiger ist, zu wissen welche Infrastrukturen an einer bestimmten Position sind? Wenn ja: Ist ein Hybridverfahren* eventuell geeignet?

* Das Hybridverfahren, das ich mir vorstelle, laesst sich wohl am Besten durch ein Event-basiertes System und einer Datenbank entwickeln:

Uebersicht: Hybridverfahren

Hierbei registriert sich die Klasse Main bei zwei Listenern, und implementiert deren Interfaces. Beide Methoden networkFound() und positionChanged() machen jetzt im Prinzip das Gleiche:

• Gefundene Netzwerke (im networkFound()-Fall genau eins) werden in die Datenbank geschrieben (z.B. in die Tabelle networks).
• Die Position wird in die Datenbank geschrieben (z.B. in die Tabelle positions).
• Es werden Relationen in eine dritte Tabelle (z.B. network_positions) geschrieben. Darin enthalten sind nur die jeweiligen IDs der Netzwerke bzw. Positionen.

Mit dem Verfahren lassen sich beide Fragen beantwortet. Dieses Verfahren ist jedoch nicht verbreitet (keins der bekannten Tools arbeitet auf diese Weise). Aber wieso nicht?

Durch Dirks Umfrage zum idealen Arbeitsplatz fuehle ich mich gezwungen auch etwas zu schreiben…

Mein idealer Arbeitsplatz erfuellt folgende Kriterien:

• das Arbeitsklima ist freundschaftlich; bei Fragen wird man unterstuetzt und Hilfe muss nicht erbettelt werden
• die Arbeitszeit ist frei; solange X am Y fertig ist, ist alles okay; es gibt kein Zeiterfassungssystem
• der Arbeitsort ist variabel. Wenn das Buero nervt, arbeitet man von Zuhause oder wo man moechte
• das Geld stimmt
• die Wahl der Hilfsmittel/Tools/Entwicklungsumgebungen/Software/Hardware ist frei
• es gibt keine Rufbereitschaft
• man muss nicht um Urlaubstermine streiten
• die Arbeit wird dokumentiert
• es wird strukturiert gearbeitet
• die Vorgesetzten wissen, wovon sie reden
• die Aufgabenstellungen werden klar formuliert
• Deadlines werden sinnvoll gelegt
• Risikoabschaetzung wird durchgefuehrt

Die meisten Punkte werden von meinem Job am Lehrstuhl extrem gut erfuellt, muss ich feststellen.

Wie ich schon hier beschrieben, bastel ich im Moment etwas herum. Zur Zeit steht Android auf dem Programm. Ich habe gerade einen GPS Receiver vom Lehrstuhl hier liegen (und suche im Moment auch nach einem geeigneten Geraet fuer private Zwecke) und da kam mir heute die Frage auf: Wie zum Teufel bekomme ich die echten Daten in den Android Emulator?

Tja, das ist gar nicht so einfach. Es gibt die Möglichkeit, über die Eclipse IDE einzelne Koordinaten an den Emulator zu senden, sodass er diese als aktuelle Position annimt. Das geht auch ueber Telnet ganz wunderbar. Wie das geht ist hier beschrieben: You Are Here: Using GPS and Google Maps in Android. Das klaert aber noch nicht ganz, wie man jetzt die Daten vom echten GPS Geraet da hineinbekommt und das auch noch in Echtzeit.

Ich bin ja der Typ, der – statt endlos lang nach einer Loesung zu suchen – einfach mal ein Programm schreibt. Da der Emulator ja die aktuelle Position via Telnet annimmt, kann man das doch glatt ausnutzen. Wie das geht? So:

Erstmal ist Java alleine ja langweilig, also verwende ich C# und .NET, um mein kleines Problem zu loesen. Ich schreibe mir also eine Klasse, die das ermoeglicht:

public class LocationPipe
{
    private SerialPort serialPort;
    private int port;
    private Socket socket;
 
    public SerialPort SerialPort
    {
        get { return this.serialPort; }
        set { this.serialPort = value; }
    }
 
    public int Port
    {
        get { return this.port; }
        set { this.port = value; }
    }
 
    public void Start()
    {
        if (this.socket == null)
        {
            this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            this.socket.Connect("localhost", this.port);
        }
 
        if (this.serialPort != null && !this.serialPort.IsOpen)
        {
            this.serialPort.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
            this.serialPort.Open();
        }
    }
 
    public void Stop()
    {
        this.serialPort.Close();
 
        this.socket.Shutdown(SocketShutdown.Both);
        this.socket.Close();
        this.socket = null;
    }
 
    private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        try
        {
            string data = this.serialPort.ReadLine();
 
            Console.WriteLine(data);
 
            if (!data.StartsWith("$GPGGA"))
            {
                return;
            }
 
            data = "geo nmea " + data + "\r\n";
 
            byte[] bytes = Encoding.ASCII.GetBytes(data);
            this.socket.Send(bytes);
        }
        catch (Exception)
        {
        }
    }
}

Dabei referenziert serialPort die Verbindung zum GPS Receiver und port gibt den Port zum Emulator an. Start() startet den Spass, Stop stoppt den Spass – easy as hell. Die Methode port_DataReceived() macht dann nichts anderes als eine Zeile vom COM Port zu lesen, zu pruefen, ob der Emulator damit was anfangen kann, um sie letztendlich dem Emulator zu senden.

Und so nutzt man die Kiste:

SerialPort serialPort = new SerialPort("COM8");
serialPort.BaudRate = 38400; // Haengt vom Endgeraet ab; 38400 sollte aber passen
serialPort.Parity = Parity.None;
serialPort.StopBits = StopBits.One;
serialPort.ReadTimeout = 10;
 
LocationPipe pipe = new LocationPipe();
pipe.SerialPort = serialPort;
pipe.5554; // Haengt vom Emulator ab; 5554 sollte es aber sein, sofern nichts massiv geaendert wurde
this.pipe.Start(); // Irgendwann sollte man das ganze noch stoppen!

Nunja, jetzt behaupte ich, dass das funktioniert. Damit man mir nicht widerspricht (das mag ich naemlich gar nicht), folgt jetzt noch eine Testapplikation, die im Android-Emulator die aktuelle Position stupide als Text anzeigt.

Die Activity nenne ich mal LocationViewer, demnach sollte es eine solche Datei geben, die folgendes enthaelt:

package net.visus;
 
import android.app.Activity;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.widget.TextView;
 
public class LocationViewer extends Activity implements LocationListener {
	private LocationManager locationManager;
	private TextView textView;
 
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
 
		this.textView = (TextView) this.findViewById(R.id.textBox);
 
		this.locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
 
		for (String provider : this.locationManager.getAllProviders()) {
			this.locationManager
					.requestLocationUpdates(provider, 1000, 0, this);
		}
	}
 
	@Override
	public synchronized void onLocationChanged(Location location) {
		if (location != null) {
			this.textView.setText("Latitude:\t\t" + location.getLatitude()
					+ "\nLongitude:\t" + location.getLongitude()
					+ "\nAltitude:\t\t" + location.getAltitude() + "\nSpeed:\t\t"
					+ location.getSpeed() + "\nAccuracy:\t\t"
					+ location.getAccuracy() + "\nBearing:\t\t"
					+ location.getBearing() + "\nTime:\t\t\t" + location.getTime());
		}
	}
 
	@Override
	public void onProviderDisabled(String provider) {
	}
 
	@Override
	public void onProviderEnabled(String provider) {
	}
 
	@Override
	public void onStatusChanged(String provider, int status, Bundle extras) {
	}
}

Damit das ganze laeuft, sollte es auch eine Textbox im Layout geben (res/layout/main.xml):

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello"
    android:id="@+id/textBox"/>
</LinearLayout>

Das Programm braucht jetzt noch die Rechte, auf den Location Service zugreifen zu duerfen (ApplicationManifest.xml):

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="net.visus"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".LocationViewer"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
 
    </application>
    <uses-sdk android:minSdkVersion="4" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/> 
</manifest>

Und dann sieht das so aus:

Android Location Demo

Zur Zeit suche ich ein geeignetes GPS Geraet, das folgende Eigenschaften erfuellen soll:

• Bluetooth + USB
• Logging + Real-Time Navigation
• Manuelle Speicherung der Position (Push-To-Log)
• mind. 50 Kanaele
• lange Akkulaufzeit (Minimum: 10 Stunden)
• mind. 1 Hz (Logging & Receiving)
• AGPS Unterstuetzung
• NMEA via COM Port lesbar
• Real-Time Navigation via Google Earth soll moeglich sein
• Speicher fuer mind. 100.000 Wegpunkte
• geringe Cold/Warm/Hot-Startzeiten
• geringer Preis (< 80 EUR)

Hat jemand zufaellig Erfahrungen und Vorschlaege?

Nachtrag (10.11.2009):
Ich habe mir heute einen GPS Receiver von Nokia bei Amazon gekauft, weil ich das Teil heute life testen konnte und positiv ueberrascht war. Das werde ich erstmal durchtesten. Vorschlaege fuer andere Geraete sind immernoch willkommen, da ich einen Logger haben moechte. Ich habe das Geraet aber nur gekauft, weil es extrem guenstig und dafuer sehr gut ist. Gekauft habe ich es bei Amazon: Nokia LD-4W Bluetooth GPS Modul.