Qando – Test
Die WienerLinien und der Verkehrsbund Ost-Region stellen seit kurzem ein neues Mobiles Service zur Verfügung. Es nennt sich QANDO und soll immer genau über Fahrpläne und Abfahrtszeiten der öffentlichen Verkehrsmittel informieren. Die Auswahl der unterstützen Geräte ist sehr groß! Es gibt Versionen für JavaMe, Windows Mobile, IPhone, Nokia und Blackberry.
Da ich sehr oft mit den WienerLinien unterwegs bin, habe ich natürlich sofort das Programm für Windows Mobile downgeloadet und getestet.
Startet man das Programm so kommt man direkt in das Hauptmenü.
Wie man gleich sehen kann, wird die oberste WindowsMobile Leiste von diesem Quandobalken überschrieben. Das finde ich schon sehr schlecht, da man jetzt weder die Uhrzeit mehr sehen kann, noch andere wichtige Informationen die einem über diese Leite übermittelt werden (z.b. SMS Empfang etc.)
Die einzelnen Menüpunkte sind viel zu klein als das man sie gut mit dem Finger wählen kann. Vor allem bei Untermenüs oder der Scrollleiste wird das ganze dann ohne Stift zum Alptraum.
Die Fahrplanauskunft funktioniert wie auf www.wienerlinien.at. Einfach Start und Zielpunkt auswählen und schon bekommt man eine Route präsentiert. Dabei kann man seine GPS Position genauso verwenden wie Adresseangaben und Stationsamen. Ebenso wie auf der Homepage lassen sich kleine Kartenausschnitte anzeigen. Leider sind diese meiner Meinung nach oftmals viel zu klein. Man kann sie nicht scrollen und bekommt deshalb oftmals keinen ausreichenden Überblick.
Hier 3 Screenshots für die Fahrtplanauskunft von Reumannplatz zum Stephansplatz.
Die Echtzeitanzeige ist wirklich cool 
Man gibt einen Stationsbaneb an und erhält die dortige Abfahrtsanzeige. Ich habe mich jetzt nicht neben eine gestellt und die Zeiten verglichen, aber bin mit einen Bus gefahren und habe Stationen gewählt die vor mir lagen. Es hat ziemlich gut gepasst. Allerdings aufgepasst! Sie funktionieren nur so gut wie die in den Stationen. Das heißt 5min muss nicht 5min bedeuten, weil ja der Bus mal schneller und langsamer als geplant vorran kommen kann! Außerdem ist mir nicht ganz klar, warum ich keine Anzeigen von U Bahnen erhalten habe. Auch sind nicht alle Busse abgedeckt. Doch unter der grafischen Darstellung findet man noch als Text von allen Verkehrsmittel die nächsten Abfahrtszeiten als Text. Wenigstens was
Nett ist auch, dass man genau sieht was für ein Typ von Verkehrsmittel kommt. Also ein Doppelbus oder ein einfacher. Eine moderne ULF Straßenbahn, oder eine alte Negativ hingegen ist, dass man dauernd auf aktualisieren klicken muss. Hier hätte ich mir erwartet, dass alle 30Sekunden ein Autorefresh kommt! Außerdem baut sich bei jedem aktualisieren der ganze Bildschirm neu auf… Viel schöner wäre es, wenn sich nur die neuen Informationen überlagern würden. So hat man oftmals ein paar Sekunden einen weißen Schirm, bevor man wieder was sehen kann
Die restlichen Menüpunkte waren langweilig. Tickets brauche ich mir keine zu kaufen und die sonstigen Informationen sind kaum brauchbar. Gott sei dank kann man sich unter Optionen diese zusätzlichen Infos in den anderen Menüs deaktivieren!
MEIN FAZIT:
Für spontane und schnelle Information ist es recht nett, obwohl man sich mehr Finger-TouchSupport wünschen würde. Die Echtzeitanzeige ist prima, vor allem wenn man nicht ewig in der Station warten will, sondern den Bus genau timen möchte. Sollte man allerdings mehr Zeit für die Planung haben, würde ich weiterhin auf die Homepage der Wiener Linien schauen. Dort ist die Auskunft besser aufbereitet und man kann über GoogleMaps auch schöner die diversen Straßen anschauen, bevor man sich dort verläuft 
Übrigens:
Die JavaME Version ist bei mir dauernd abgestürzt. Auch eine Freundin hatte Probleme mit ihrem Handy… Dieser Test ist nur für die WindowsMobile auf dem XperiaX1 gemacht worden. Ich nehme an durch das SDK vom IPhone wird dort z.b. der Finger-TouchSupport besser sein
General Motors Crash Tests 1960
Ich bin heute zufällig auf ein Crash Test Video auf Youtube gestoßen. Sehr beeindruckend und mit netter Musik untermalt. Dadurch wird das schreckliche Ergebnis ganz schön heruntergespielt
YouTubeLink: http://www.youtube.com/watch?v=Tb_e3tllSfE
Excel mit C# lesen
In einem Ferialpraktikum hatte ich einmal das Problem, dass ich eine Exceldatei aus einer C# Anwendung lesen musste. Dazu habe ich mir 2 Klassen geschrieben. myExcelApplication, welches mir eine Instanz von Microsoft Excel öffnet und nach Beendigung wieder schließt. Und myWorkbook, welche mir den Zugriff auf ein Workbook ermöglicht.
Wichtig sind vor allem die Referenzen. Man muss Microsoft.Office.Core sowie Microsoft.Office.Interop.Excel einbinden, damit es sicher funktioniert
using System; using System.Collections.Generic; using System.Text; using System.Windows.Forms; using Excel = Microsoft.Office.Interop.Excel; using System.Runtime.InteropServices; //Für DllImport! using System.Diagnostics; //Für Process
myExcelApplication:
public class myExcelApplication : IDisposable
{
#region user32 Funktionen
// Windows OS Funktionen deklarieren
[DllImport("user32")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport("user32.dll", SetLastError = true)]
static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);
// Ende Os Funktionen
#endregion
public Excel.ApplicationClass ExApp; //Besitzt alle Excelfunktionen
private string ApplicationID; //Ist meine Programmid
private IntPtr hWnd; // Window Handle
private int iProcID; // Prozess ID des markierten EXCELs
private Process p = null; // entsprechendes Process object
public myExcelApplication()
{
//defaulteinstellungen
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
this.ApplicationID = "Excel_" + System.Guid.NewGuid().ToString().ToUpper(); //ID erzeugen
this.ExApp = new Excel.ApplicationClass(); //Excelklasse zuweisen
this.ExApp.DisplayAlerts = false; //keine Warnmeldungen Anzeigen
this.ExApp.AskToUpdateLinks = false; //Updateabfrage deaktivieren
this.ExApp.Visible = false; //unsichtbar
this.ExApp.Caption = this.ApplicationID; //Id zuweisen
}
~myExcelApplication()
{
this.Dispose();
}
#region IDisposable Members
public void Dispose()
{
/*
* Folgendes funktioniert nicht:
* ExApp.Application.Quit(); oder this.ExApp.Quit();
* Leider weiß ich nicht mehr woher ich das habe.
* Aber deswegen haben wir die EXCEL Applikation markiert
*/
hWnd = FindWindow(null, ApplicationID);
if (hWnd == IntPtr.Zero) return;
// zu dem Fenster holen wir uns die Prozess-ID ...
GetWindowThreadProcessId(hWnd, out iProcID);
if (iProcID == 0) return;
// erzeugen ein entsprechendes .NET Prozess Objekt ..
p = Process.GetProcessById((int)iProcID);
if (p == null) return;
// jetzt ist Feierabend ...
p.CloseMainWindow(); // schliesse Fenster
p.Refresh(); // gebe alle Prozess-Informationen frei
if (p != null)
{
p.Kill(); // und tschuess ...
}
}
#endregion
}
myWorkbook:
public class myWorkbook
{
public Excel.Workbook myWb;
public string Datei;
public myExcelApplication ExApp;
public bool schreibschutz = false;
private bool _calculation;
public bool calculation
{
get { return this._calculation; }
set
{
this._calculation = value;
this.calculate();
}
}
public string aktivsheet;
public myWorkbook(string datei, myExcelApplication EApp)
{
this.Datei = datei;
this.ExApp = EApp;
}
public myWorkbook()
{
//leerer konstruktor
}
public void open()
{
try
{
this.myWb = ExApp.ExApp.Workbooks.Open(this.Datei, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
}
catch (Exception e)
{
//
}
//this.myWb = ExApp.ExApp.Workbooks.Open(this.Datei, 0, true, 5, "", "", true,Excel.XlPlatform.xlWindows, "t", false, false, 0, true, false, false);
if (this.myWb.ReadOnly) { this.schreibschutz = true; }
this.calculation = false; //Abschalten der automatischen Berechnung
}
public void close()
{
object Save = Excel.XlSaveAction.xlSaveChanges; //Speichern oder nicht speichern Variable hier setzen
this.calculation = true; //Noch einmal schnell rechnen lassen vorm schließen
this.myWb.Close(Save, Type.Missing, Type.Missing); //schließen
}
private void calculate()
{
//Schaltet automatische Berechnung ab bzw. aktiviert sie wieder
if (!this.calculation)
{
this.ExApp.ExApp.Calculation = Excel.XlCalculation.xlCalculationManual;
}
else
{
this.ExApp.ExApp.Calculation = Excel.XlCalculation.xlCalculationAutomatic;
this.ExApp.ExApp.Calculate();
}
}
public Excel.Range Zelle(int Zeile, int Spalte)
{
return (Excel.Range)((Excel.Worksheet)this.myWb.Worksheets[this.aktivsheet]).Cells[Zeile, Spalte];
}
public Excel.Range Zelle(int Zeile, int Spalte, string Worksheet)
{
return (Excel.Range)((Excel.Worksheet)this.myWb.Worksheets[Worksheet]).Cells[Zeile, Spalte];
}
}
Hier ein Beispiel, wie man mit diesen Klassen, die Erste Zelle des Blattes “Tabelle1″ auslesen kann:
//Applikation starten
myExcelApplication EApp = new myExcelApplication();
//Workbook erzeugen
myWorkbook ExcelFile = new myWorkbook("c:\test.xls", EApp);
//Excelfile öffnen
ExcelFile.open();
//Sheet wählen
ExcelFile.aktivsheet = "Tabelle1";
//Zeile auslesen
String zelle1 = ExcelFile.Zelle(1, 1).Value2;
//Workbook schließen
ExcelFile.close();
//Applikation schließen
EApp.Dispose();
Tipp: Schaltet die automatische Berechnung von Zellen ab und erst kurz vorm speichern wieder an. Das spart oftmals wertvolle Rechenzeit
AJAX light – Kleine Abfragen ohne großes Framework
AJAX ist eine nette Sache! Dieses Akronym steht für „Asynchronous JavaScript and XML“ und ermöglicht unter anderem dynamisches Nachladen von Inhalten in die HTML Seite. Wer sich ganz genau dafür interessiert, kann ja auf WIKIPEDIA nachschauen
Natürlich findet man jetzt eine große Menge an Bibliotheken die man nutzen kann und sollte, aber hier möchte ich euch eine Quick and Dirty Lösung zeigen.
//AJAX Initialisieren und Funktionen zur Handhabung
var request = false;
// Request senden
function setRequest(url,send,irfunction) {
// Request erzeugen
if (window.XMLHttpRequest) {
request = new XMLHttpRequest(); // Mozilla, Safari, Opera
} else if (window.ActiveXObject) {
try {
request = new ActiveXObject('Msxml2.XMLHTTP'); // IE 5
} catch (e) {
try {
request = new ActiveXObject('Microsoft.XMLHTTP'); // IE 6
} catch (e) {}
}
}
// überprüfen, ob Request erzeugt wurde
if (!request) {
alert("Kann keine XMLHTTP-Instanz erzeugen");
return false;
} else {
// Request öffnen
request.open('post', url, true);
// Requestheader senden
request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
// Request senden
request.send(send);
// Request auswerten
request.onreadystatechange = function() {
interpretRequest(irfunction);
}
}
}
// Request auswerten
function interpretRequest(irfunction) {
switch (request.readyState) {
// wenn der readyState 4 und der request.status 200 ist, dann ist alles korrekt gelaufen
case 4:
if (request.status != 200) {
alert("Der Request wurde abgeschlossen, ist aber nicht OKnFehler:"+request.status);
} else {
irfunction();
}
break;
default:
break;
}
}
//ENDE AJAX Funktionen
Wie verwendet man diese Funktionen nun richtig?
Angenommen wir haben eine Formular bei dem sich ein User registrieren muss und wir wollen checken ob der Nick schon vorhanden ist.
Dazu verwenden wir eine PHP Datei, die auf im selben Ordner liegt und abfrage.php heißt. Diese macht uns eine MYSQL Abfrage und liefert uns dann false zurück, wenn der Nickname schon vorhanden ist. Die 2 JavaScript Funktionen die wir zusätzlich noch in der HTML Datei brauchen sind folgende:
function check_name(nick) {
//Request abschicken mit Post Variable Nickname
setRequest("/abfrage.php","nickname="+nick,check_name_finish);
}
function check_name_finish() {
var content = request.responseText;
//Do something
}
Die Funktion check_name(nick) wird vom Inputfeld aufgerufen, wenn dieses nicht mehr beschrieben wird. (siehe Code vom Inputfeld). Ist Funktion check_name(nick) mit der Ausführung fertig, wird Funktion check_name_finish() aufgerufen und ausgeführt. Diese hat nun in der Variable content die Antwort der Abfrage und kann nun darauf reagieren.
Und das Inputfeld würde so aussehen:
<input type="text" name="nickname" value="" onblur="check_name(this.value)">
Wie bereits erwähnt ist das hier nur Quick and Dirty! Getestet habe ich es mit den neuesten Versionen von IE und FireFox. Viel Spass damit!
GPS Cycle Computer Part II
Ich natte ja bereits über den GPS Cycle Computer berichtet (siehe hier). Da war ich nicht einmal 5km laufen 
Inzwischen war ich auch schon des öfteren damit skaten und neulich auch radfahren!
Jetzt möchte ich euch, zum Vergleich mit der letzten Strecke, noch eine kurze Fahrt auf der Donauinsel zeigen. Hier war ich ca. 30min radfahren.
Hier die Strecke auf der GoogleMaps Karte:
Leider habe ich am Fahrrad keine Halterung für mein Handy. Ich denke wenn man das Display live sieht, ist es noch interessanter. Auch bei den Skates muss das Handy in der Tasche bleiben. 
