Um überhaupt etwas mit Pywinauto oder Win32com zu machen, muss man Python unter Windows installiert haben. Ich habe mich zum Beispiel für Python 3.2 entschieden. Alternativ gibt es auch noch die Communuty Edition von ActivePython, das schon extra Module wie Win32com mitbringt. Beim original Python muss man auf jeden Fall noch die Erweiterung Pywin32 herunterladen, wenn man das Modul Win32com nutzen möchte. Allerdings kann es passieren, dass der erste Versuch, das Modul zu importieren, auf einen Fehler hinaus läuft:

>>> import win32com.client 
Traceback (most recent call last):
File "D:\EQ\InventoryDumps\testScript1.py", line 1, in <module>
import win32com.client as win32
File "D:\Python32\lib\site-packages\win32com\__init__.py", line 5, in <module>
import win32api, sys, os
ImportError: DLL load failed: The specified module could not be found.

Ist das der Fall, kann man das Problem mit folgendem Befehl beheben:

C:\Python32\Scripts\pywin32_postinstall.py

Wenn die Installation erfolgreich ist, steht einem die Welt der Windows-Objekte wie COM oder WSH mehr oder weniger offen. So kann man mit COM Anwendungen aus dem Microsoft Office-Paket oder den Internet Explorer automatisieren. COM dient dabei zur Interprozesskommunikation und dynamische Objekterzeugung unter Windows. Bevor man die Funktionen von COM-Objekten nutzen kann, muss man sie instanzieren, wofür die COM-Komponenten Schnittstellen anbieten. Im folgenden Beispiel wird eine Instanz des Internet Explorers durch die Angabe seiner ProgID (“InternetExplorer.Application”) erzeugt:

import win32com.client
ie = win32com.client.Dispatch("InternetExplorer.Application")
ie.Visible = 1
ie.Navigate("http://www.datenteiler.de")
ie.GoHome()
ie.quit()

Nach der Instanzierung steht ein Internet Explorer bereit, der allerdings noch nicht zu sehen ist, außer als Prozess im Taskmanager oder mit dem Cmdlet Get-Process in der PowerShell. Der Prozess ist unabhängig vom Python-Interpreter. Wird die Konsole geschlossen, bleibt der Prozess erhalten und aktiv. Erst wenn man der Eigenschaft von Visible auf wahr setzt, wird diese Instanz des Internet Explorers sichtbar.
Wenn man sich mit dem Einsatz von COM-Anwendungen in der PowerShell auskennt, kommt einem der Quelltext doch bekannt vor:

$ie = New-Object -ComObject InternetExplorer.Application
$ie.Visible = $true
$ie.Navigate("http://www.datenteiler.de")
$ie.GoHome()
$ie.Quit()

Das folgende SendKey-Beispiel mit dem WSH kann auch zu einem Déjà-vu führen, wenn man den Python-Quelltext mit dem VBScript-Code vergleicht. Erstmal das Beispiel um Tastendrücke zu simulieren in Python:

import win32api
import win32com.client
shell = win32com.client.Dispatch("WScript.Shell")
shell.Run("Notepad") 
win32api.Sleep(1500) 
shell.AppActivate("Notepad") 
win32api.Sleep(1500) 
shell.SendKeys("Hallo Welt!{ENTER}") 
shell.SendKeys("^s")
shell.SendKeys("{ENTER}")
win32api.Sleep(1500)
shell.SendKeys("Hallo.txt{ENTER}")

Das Äquivalent in VBScript sieht dann so aus:

' SendkeyBeispiel.vbs
Option Explicit
Dim objWScriptShell
Set objWScriptShell = CreateObject("WScript.Shell")
objWScriptShell.Run "notepad"
Wscript.Sleep 1500 ' Warte bis Notepad fertig ist
objWScriptShell.SendKeys "Hallo Welt!{ENTER}"
objWScriptShell.SendKeys "^s"
objWScriptShell.SendKeys "{ENTER}"
Wscript.Sleep 1500
objWScriptShell.SendKeys "Hallo.txt{ENTER}"
WScript.Quit

Man kann mit dem Win32Com-Modul in Python noch einiges mehr anfangen, zum Beispiel die Maus positionieren und Mausklicks senden. Damit sind die Möglichkeiten von Python im Component Object Model oder des Windows Script Host bei weitem noch nicht ausgeschöpft.

# Bubblesort in Python
 
def bubblesort(a):
    for j in range(len(a) - 1):
        for i in range(len(a) - j - 1):
            if a[i] > a[i+1]:
                tmp = a[i]
                a[i] = a[i+1]
                a[i+1] = tmp
    return a
 
a = [3, 0, 1, 8, 7, 2, 5, 4, 6, 9]
print("Unsortiert: ", a)
 
result = bubblesort(a)	
print("Sortiert  : ", result)

Ich hoffe nur, dass ich die Musik auch wieder aus meinem Kopf bekomme. ;-)

[via zipfelmaus.com]

>>> s = 'Ich bin ein String'
>>> i = 123
>>> type(s)
<type 'str'>
>>> type(i)
<type 'int'>
>>> str(i) + ' ' + s + '!'
'123 Ich bin ein String!'

So praktisch sie auch sind, man sollte solche Verkettungen von Zeichenketten mit dem +-Operator vermeiden, da sie zu Lasten der Performance gehen. In Python sind Strings unveränderliche (immutable) Objekte, daher werden außer dem Ergebnis-String temporär weitere Strings angelegt, die hinterher von der Laufzeitumgebung wieder entsorgt werden müssen (garbage collection). In meinem Beispiel wird inklusive Ergebnis-String dreimal ein neuer String konstruiert und die beiden temporär erstellten Vorgänger werden wieder freigegeben. Dabei muss jedes Mal der Inhalt des alten Strings in den neuen kopiert werden, was alles zusammen Performance frisst.

Die Erzeugung des Ergebnis-Strings sollte man daher an einen String-Formatierer übergeben:

>>> '%d %s!' % (i, s)
'123 Ich bin ein String!'

Dabei sind %d und %s Platzhalter für den Inhalt der Variablen i und s. Die Platzhalter sind aber nicht frei wählbar, so steht %d für Dezimalzahlen, %s für Strings, %x für Hexadezimalzahlen, %e, %f und %g für Gleitkommazahlen. Bei der String-Formatierung entfällt nicht nur das Kopieren der String-Inhalte in neue Strings und das anschließende Aufräumen, sondern auch die explizite Typumwandlung der Ganzzahl in i in einen String mit str(), was einfach performanter ist.

Für eine erste Hallo-Welt-Gui habe ich mich an das Elementary-Beispiel im Wiki von Enlightenment gehalten, das in C geschrieben ist, bzw. an das Beispiel im Wiki von SHR, das allerdings in VALA geschrieben wurde.

#!/usr/bin/python
#
# Example for a GUI written with Python-Elementary.
 
import elementary
import evas
 
class HelloWorldGui(object):
 
	def destroy(self, obj):
		# quit the window (mainloop)
		elementary.exit()
 
	def __init__(self):
		elementary.init()
 
		# new window - do the usual and give it a name, title and delete handler
		self.win = elementary.Window("HelloWorld", elementary.ELM_WIN_BASIC)
		self.win.title_set("Hello")
		# when the user clicks "close" on a window:
		self.win.callback_destroy_add(self.destroy)
 
		# add a standard background
		self.bg = elementary.Background(self.win)
		self.win.resize_object_add(self.bg)
		# do not allow bg to expand
		self.bg.size_hint_weight_set(evas.EVAS_HINT_EXPAND, evas.EVAS_HINT_EXPAND)
		# add object as a resize object for the window
		self.win.resize_object_add(self.bg);
		self.bg.show()
 
		# add a box object - default is vertical. a box holds children 
		# in a row, either horizontally or vertically. nothing more.
		self.mainBox = elementary.Box(self.win)
		# do not allow box to expand
		self.mainBox.size_hint_weight_set(evas.EVAS_HINT_EXPAND, evas.EVAS_HINT_EXPAND)
		# add object as a resize object for the window
		self.win.resize_object_add(self.mainBox)
		self.mainBox.show()
 
		# add a label widget 
		self.lbl = elementary.Label(self.win)
		# set text of the label
		self.lbl.label_set("Hello World!")
		# do not allow label to expand 
		self.lbl.size_hint_weight_set(evas.EVAS_HINT_EXPAND, evas.EVAS_HINT_EXPAND)
		# pack the label at the end of the box 
		self.mainBox.pack_end(self.lbl)
		self.lbl.show()
 
		# add a quit button
		self.btnquit = elementary.Button(self.win)
		# set label for button
		self.btnquit.label_set("Quit")
		# do not allow button to expand 
		self.btnquit.size_hint_align_set(evas.EVAS_HINT_EXPAND, evas.EVAS_HINT_EXPAND)
		# pack the button at the end of the box
		self.mainBox.pack_end(self.btnquit)
		# when button is clicked
		self.btnquit.callback_clicked_add(self.destroy)
		self.btnquit.show()
 
		# size of the window
		self.win.resize(150,80)
		# now we are done, show the window
		self.win.show()
 
		# run the mainloop
		elementary.run()
		elementary.shutdown()	
 
# endof class HelloWorldGui
 
gui = HelloWorldGui()

Die Datei habe ich dann auf das OpenMoko kopiert und dort im Terminal ausgeführt. Das Ergebnis sieht zwar nicht sehr schön aus, kann sich aber sehen lassen.

sudo apt-get install python3-dev libsdl-image1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev libsdl1.2-dev libsmpeg-dev python-numpy subversion libportmidi-dev build-essential

Sollte es bei der Installation Probleme geben, insbesondere bei python3-dev, fehlen vermutlich zwei Repositories in der Konfigurationsdatei /etc/apt/sources.list. Die kann man entweder mit dem Lieblingseditor für Lucid hinzufügen

deb http://security.ubuntu.com/ubuntu/ lucid-security restricted main multiverse universe
deb http://de.archive.ubuntu.com/ubuntu/ lucid-updates restricted main multiverse universe

(falls man Maverick benutzt, muss man lucid halt durch maverick ersetzen), oder man setzt einfach zwei Haken in der Paketverwaltung Synaptic unter Einstellungen -> Paketquellen im Reiter Aktualisierungen:

Danach muss man noch seine Paketquellen aktualisieren und eventuell updaten, was im Terminal so geht:

sudo apt-get update && sudo apt-get dist-upgrade

Jetzt sollte die Installation reibungslos funktionieren, und man kann mit Pygame für Python 3 weiter machen, indem man die aktuelle Version vom Server mit Hilfe von Subversion herunterlädt:

svn co svn://seul.org/svn/pygame/trunk pygame

Anschließend wechselt man ins neu erstellte Verzeichnis pygame, um zu kompilieren, und um die Installation zu starten:

cd pygame
python3 setup.py build
sudo python3 setup.py install

Wenn man wissen will, ob alles geklappt hat, startet man Python 3 am besten im Terminal und importiert spaßeshalber einmal Pygame:

$ python3
Python 3.1.2 (r312:79147, Apr 15 2010, 12:35:07) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import pygame
>>> pygame.ver
'1.9.2pre'

Und schon ist man im Besitz der aktuellsten Pygame-Version für Python 3 unter Ubuntu.

Installation

Nachdem man überprüft hat, ob das eigene Handy zur S60-Reihe gehört [2], benötigt man die die Datei PythonForS60_2.0.0.tar.gz von der Webseite garage.maemo.org [3]. Von der Versionsnummer darf man sich nicht irritieren lassen; Python für S60 2.0 liegt Python 2.5.4 zugrunde. Nach dem Entpacken überträgt man die Dateien Python_2.0.0.sis, pips.sis und PythonScriptShell_2.0.0_3_0.sis aus dem Ordner PyS60Dependencies entweder per Bluetooth, USB-Kabel oder WLAN [4] auf das Telefon. Anschließend installiert man sie in dieser Reihenfolge in den Telefonspeicher. Die Installation muss in den Telefonspeicher und darf nicht auf die Speicherkarte erfolgen, da Python-Programme ansonsten Probleme haben, den Python-Interpreter zu finden.

Nach der Installation

Jetzt gibt es verschiedene Möglichkeiten, Python-Programme auf dem Handy auszuführen. Die einfachste ist, das Programm gleich auf dem Telefon zu tippen. Dazu öffnet man die Python-Shell und wählt „Interactive console“. Je nach Tastatur kann das Tippen auf dem Handy sehr anstrengend sein; der schöne Nebeneffekt ist aber, dass man auch in der S-Bahn oder an der Supermarkt-Kasse mit einem Python-Editor wie Ped [5] programmieren kann. Die Menschen um einen herum denken dann, dass man sehr beliebt sein muss, weil man eine SMS nach der anderen schreibt, und man wird ausnahmsweise mal nicht für einen vereinsamten Ober-Geek gehalten.

Eine Python-Shell fürs Handy

Im Lieferumfang von Python für S60 gibt es zwar schon eine Bluetooth-Konsole [6], die man auch sehr komfortabel mit den PUTools bedienen kann [7], aber was macht man, wenn kein Bluetooth, dafür aber WLAN vorhanden ist? Man richtet sich einfach eine Python-Shell übers WLAN ein. Die Verbindung zur WLAN-Shell steht auch schneller als die über Bluetooth, was ein entscheidender Vorteil ist, selbst wenn der Rechner über eine Bluetooth-Schnittstelle verfügt.

Damit die Python-Shell über WLAN funktioniert, benötigt man das Programm netcat, das im Normalfall unter GNU/Linux, Unix oder MacOS X schon installiert ist. Mit dem Befehl nc startet man das Kommando, um Daten mit TCP im Netzwerk zu übertragen:

stty raw -echo ; nc -l 1025 ; stty sane

Auf einigen GNU/Linux-Rechnern muss man noch den Schalter -p hinzufügen und nc -l -p 1025 eingeben. Bevor man das Terminal via netcat in eine Python-Shell des Handys verwandeln kann, werden dessen Einstellungen mit dem Systembefehl stty neu gesetzt. Dabei schaltet die Option raw die Pufferung aus, damit eine Eingabe Zeichen für Zeichen an die Shell weitergereicht wird. Buchstaben werden dabei uninterpretiert weitergeleitet, was soviel heißt, dass es kein Newline-Zeichen oder ähnliches mehr gibt und „Strg“ + „D“ zum Beispiel keinen Datenstrom mehr beendet. Die Option echo verhindert, dass die eingegebene Taste nochmal im Terminal angezeigt wird. Anschließend startet netcat, um auf hereinkommende Verbindungsanfragen am Port 1025 zu lauschen. Im letzten Teil des Kommandos startet man noch einmal stty, diesmal aber mit der Option sane, um die Pufferung des Terminals wieder herzustellen. Damit kann man die Python-Shell erneut mit der Tastenkombination „Strg“ + „D“ beenden.

Das folgende Skript für Ubuntu 10.04 vereinfacht die Verbindungsanfrage:

#!/bin/bash
# Script: wifishell.sh
# Object: Starts TCP/IP Console for S60 mobiles afterwards
# start wifishell.py on your S60
 
IP=$(ifconfig | grep 'inet '| grep -v '127\.0\.0\.1' | cut -d: -f2 | awk '{ print $1}')
PORT="1025"
 
echo "Your IP address is: $IP "
echo "Start now wifishell.py on your phone ..."
 
stty raw -echo ; nc -l 1025 ; stty sane

Im ersten Teil wird die IP-Adresse im eigenen Netzwerk ermittelt und in der Variable IP gespeichert, was aber nur für GNU/Linux-Rechner gilt. Verwendet man ein Betriebssystem wie MacOS X, Free-, Open- oder NetBSD, muss man stattdessen folgende Zeile in das Skript einfügen:

IP=$(ifconfig | grep -E 'inet.[0-9]' | grep -v '127\.0\.0\.1' | awk '{ print $2}')

Als Benutzer von OpenSolaris verwendet man folgende Zeile:

IP=$(ifconfig -a | grep 'inet ' | grep -v '127\.0\.0\.1' | awk '{ print $2}')

Wie bereits erwähnt, muss man bei manchen GNU/Linux-Betriebssystemen darauf achten, dass der Aufruf von netcat im zweiten Teil des Skripts mit den Schalter -p geschieht.

Das Gegenstück in Python, das Skript wifishell.py, muss auf das Handy kopiert werden. Wie alle anderen Python-Skripte auch, sollte es dort auf der Speicherkarte im Verzeichnis E:\Python\ liegen. Sobald wifishell.sh auf dem GNU/Linux-Rechner oder der Unix-Maschine nach Anfragen auf dem Port 1025 lauscht, startet man über die Python-Shell auf dem Telefon das Skript wifishell.py, um eine Verbindung zum Terminal auf dem Computer herzustellen. Läuft alles glatt, verwandelt sich das Terminal in eine Python-Shell auf dem Handy.

# Script: wifishell.py
# Object: Starts TCP/IP Console for S60 mobiles before start
# wifishell.sh on your Unix box
 
import btconsole, appuifw
import sys
try: # next lines are important to select an access point
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
import socket
 
ip = appuifw.query(u"IP address:", "text")
port = 1025
 
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((str(ip), port))
btconsole.run_with_redirected_io(sock,btconsole.interact,None,None,locals())
sock.close()

Im Terminal sieht das dann so aus:

stty raw -echo ; nc -l 1025 ; stty sane
Python 2.5.4 (r254:67916, Nov  6 2009, 04:18:57) [C] on symbian_s60
>>> import appuifw
>>> appuifw.note(u'Hallo Welt!', 'info')

Hallo Welt!

Als erstes Programm in Python für S60 schreibt man klassischerweise eines, das „Hallo Welt!“ auf dem Bildschirm ausgibt. Das wird in diesem Fall schon mit einer grafischen Oberfläche gemacht, was ganz leicht ist. Man lädt dazu einfach das Modul appuifw.

>>> import appuifw
>>> appuifw.note(u'Hallo Welt!', 'info')

Im ersten Teil des Befehls erzeugt die Funktion note() des Moduls appuifw ein Hinweisfenster. Die Zeichenkette in der Klammer muss Unicode sein, daher das vorangestellte „u“. Die zweite Zeichenkette gibt an, dass es sich beim Fenster nur um eine Information handelt. Eine Aktion des Benutzers ist nicht gefordert und das Fenster verschwindet nach einer Weile von allein.

Der erste Programmierergebnis mit Python.

Neben appuifw für das Erstellen von Benutzeroberflächen können noch weitere spezielle Module für PyS60 in Programme importiert werden. Das sind e32 als Schnittstelle zum Betriebssystem, sysinfo liest Geräteinformationen aus, audio zeichnet Klänge auf und spielt sie ab, e32calendar ermöglicht den Zugriff auf den Kalender, camera auf die Kamera, contacts auf Kontakte, e32dbm auf die Datenbank, location auf die Standortinformationen, messaging auf SMS-Funktionen, telephone auf die des Telefons und graphics zeichnet grafische Elemente [8].

Mit jedem einzelnen Modul kann man eine Menge Sachen anstellen, zum Beispiel das Handy etwas sagen zu lassen:

import audio
audio.say(u"Hello World!")

Oder eine MP3-Datei abspielen:

 
import audio, e32
fn = u"e:\\Musik\\mymusic.mp3"
sound = audio.Sound.open(fn)
sound.play(times=1)
e32.ao_sleep(sound.duration()/1000000 + 3)
sound.close()

Oder ein kleines Skript schreiben, das per SMS um Hilfe ruft:

 
import messaging, appuifw
contact_number = "+49123456789"
contact_name = "Linus"
message = (u"SOS, ruf mich an.")
messaging.sms_send(contact_number, message, name=contact_name)
appuifw.note(u"Die Nachricht wurde gesendet", "info")

Dieses Skript könnte man weiter ausbauen: Statt um Hilfe zu rufen, könnte es eine automatisierte Antwort auf bestimmte SMS geben, oder man erweitert die Hilfe-SMS um eine Standortbestimmung mit dem Modul positioning, wenn das Handy GPS unterstützt, um seinen Standort mitzusenden.

Die Akku-Ladung wird normalerweise mit Strichen oder Balken angezeigt. Wer es genau wissen will, schreibt einfach ein kleines Skript mit sysinfo:

import appuifw, sysinfo
battery = sysinfo.battery()
appuifw.note(u'Battery: ' + str(battery) + ' %', 'info')

Als Dateien speichert man die Skripte in das Verzeichnis E:\Python\ auf dem Handy. Die Python-Shell schaut bevorzugt in diesem Ordner nach. Ausgeführt werden sie dann in der Python-Shell auf dem Handy, indem man „Run script“ und anschließend das Skript auswählt.

SIS-Pakete selber bauen

Nun kann es ganz schön lästig sein, immer diesen Weg einzuschlagen, wenn man mal kurz den Ladezustand überprüfen will. Einfacher ist es doch, gleich das Skript ohne Umweg über die Python-Shell zu starten. Dabei hilft das Programm ensymble [9]. Bei vielen Distributionen ist es in den Paketquellen enthalten, da es aber „nur“ ein Python-Skript ist, kann man die Datei auch einfach von der Webseite herunterladen. Mit ensymble gibt es allerdings ein kleines Problem: Das Skript benötigt Python 2.5. Das wird besonders diejenigen nicht freuen, die Ubuntu 10.04 „Lucid Lynx“ benutzen, da dort die älteste Python-Version 2.6 ist. Wer kein Python 2.5 besitzt, sollte es kompilieren, und zwar mit Zlib-Unterstützung. Die freie Programmbibliothek zum Komprimieren und Dekomprimieren von Daten ist bei Python 2.5 standardmäßig deaktiviert, wird aber von ensymble benötigt [10].

Ist ensymble heruntergeladen und steht Python 2.5 mit Zlib-Unterstützung bereit, müssen nur noch die Dateien ensymble.py, ein Skript (zum Beispiel das Skript für den Ladezustand des Akkus, das man batinfo.py nennen kann) und eine SVG-Datei als Icon im selben Ordner liegen. Für die SVG-Datei kann man sich für den Anfang gut bei den Icons des GNOME-Projekts unter /usr/share/icons/gnome/scalable bedienen, wenn man zu bequem ist, ein eigenes zu basteln. Dann kann die Verwandlung des Skripts in eine Installationsdatei für Symbian beginnen:

python2.5 ensymble.py py2sis --version=1.0.0 --icon=battery-low.svg --caption="Battery Info" --vendor="Christian Imhorst" batinfo.py batinfo.sis

Die Datei batinfo.sis lädt man anschließend auf das Handy und installiert es in den Telefonspeicher. Leider läuft das Programm nicht, wenn man es auf die Speicherkarte installiert, und es funktioniert natürlich nur auf Telefonen, auf denen auch Python für S60 bereits installiert ist. Nach der Installation findet man das Programm mit eigenem Icon im Installationsordner.

Das hochgeladene Skript findet man im Installationsordner wieder.

Zum Schluss …

… noch ein kleines Programm, um die Kalenderdatenbank des Telefons auszulesen und in einer Datei zu sichern. Die Termine kann man anschließend in den Kalender von Evolution oder Thunderbird importieren. Für solche kleinen Aufgaben ist Python für S60 einfach ideal:

# vcalendar export
import e32calendar, appuifw
 
cal = e32calendar.open()
if len(cal) == 0:
    appuifw.note( u"No calendar entries.", "info" )
id_list=list()
for id in cal:
    id_list.append(id)
 
vCal = cal.export_vcalendars(tuple(id_list))
 
# define the directory and file name
vCalendar = u"e:\\vCal.vcf"
 
# create file
file = open(vCalendar, 'w')
 
# write vcal into file and close the file
file.write(vCal)
file.close()
 
appuifw.note( u"Success!", "info" )

Zu Beginn des Skripts werden die beiden Module e32calendar für den Zugriff auf den Kalender und appuifw für Benutzeroberflächen geladen. Einmal teilt ein Hinweisfenster im Skript mit, dass es keinen Kalendereintrag gefunden hat, und am Ende, dass es erfolgreich fertig geworden ist. Die Funktion open() aus dem Modul e32calendar öffnet den Kalender und übergibt ihn an cal. Die einzelnen Einträge werden nacheinander einer Liste übergeben, die dann komplett in die Datei vCal.vcf geschrieben wird.

Literatur

• Jürgen Scheible und Ville Tuulos, „Mobile Python: Rapid prototyping of applications on the mobile platform (Symbian Press)“, 2007
• Jürgen Scheible, „Python for S60 Tutorial“ [11]

Das Paket zlib-dev muss installiert sein. Nur darin ist die Header-Datei des Zlib-Projekts enthalten, die man dringend benötigt. Auch wenn Zlib selbst schon installiert ist, benötigt man die Projektdateien. Bei Debian-basierten Distributionen wie Ubuntu ist das Paket schnell installiert.

sudo apt-get install zlib1g-dev

Nach der Installation findet man die Header-Datei im Verzeichnis /usr/include/zlib.h. Jetzt wechselt man in das Verzeichnis mit den Quelldateien von Python 2.5 und führt configure mit der entsprechenden Flag aus:

./configure --with-zlib=/usr/include

Danach kompiliert man ganz normal mit make && sudo make install weiter (oder, wer möchte, mit checkinstall).

sudo apt-get install libnotify-bin

und schon kann man mit folgendem Befehl eine Testnachricht an den Desktop senden:

notify-send "Testnachricht"

Etwas komplexer geht das Ganze auch mit Python, dafür muss man aber kein zusätzliches Software-Paket installieren. Auch wenn letzteres auf dem eigenen System nicht wirklich dramatisch ist, aber was macht man, wenn man zum Beispiel ein Backup-Skript anderen Benutzern zu Verfügung stellen will, das z.B. die Benachrichtigung “Backup beendet” am Desktop anzeigen soll, so wie im Beispiel von linuxnetzer? Man kann sie bitten, das Paket libnotify-bin zu installieren, oder man nutzt die Möglichkeit, sein eigenes Notify-Skript zu erstellen, das etwa folgendermaßen aussehen könnte:

import pynotify
 
pynotify.init("Testnachricht")
n = pynotify.Notification("Testnachricht", "Dies ist ein Test.", "icon")
n.show()

Selbstverständlich geht das auch als Einzeiler in der Shell, was allerdings doch recht lang ist:

python -c 'import pynotify; pynotify.init("message"); n = pynotify.Notification("Testnachricht", "Dies ist ein Test.", "icon"); n.show()'

Damit die Python-Shell über WLAN funktioniert, benötigt man das Programm netcat, das im Normalfall unter Gnu/Linux, Unix oder MacOS X schon installiert ist. Mit dem Befehl nc startet man das Kommando, um Daten mit TCP im Netzwerk zu übertragen. Folgendes Kommando funktioniert so nur unter Gnu/Linux:

stty raw -echo ; nc -l -p 1025 ; stty sane

Auf anderen Unix-Maschinen muss man den Schalter -p weglassen und einfach nur nc -l 1025 eingeben. Bevor man das Terminal via netcat in eine Python-Shell verwandeln kann, werden dessen Einstellungen mit dem Systembefehl stty neu gesetzt. Dabei schaltet die Option raw die Pufferung aus, damit eine Eingabe Zeichen für Zeichen an die Shell weitergereicht wird. Buchstaben werden dabei uninterpretiert weitergeleitet, was soviel heißt, dass es kein Newline-Zeichen oder ähnliches mehr gibt und Strg-D zum Beispiel keinen Datenstrom mehr beendet (End of File, EOF). Die Option echo verhindert, dass die eingegebene Taste nochmal im Terminal angezeigt wird. Anschließend startet netcat, um auf hereinkommende Verbindungsanfragen am Port 1025 zu lauschen. Im letzten Teil des Kommandos startet man wieder stty, diesmal aber mit der Option sane, um die Pufferung des Terminals wieder herzustellen, damit man die Python-Shell mit der Tastenkombination Strg-D (EOF) beenden kann.

Um netcat nicht vergeblich lauschen zu lassen, muss folgender Python-Code auf dem Telefon ausführt werden, damit die Verbindung hergestellt wird:

import btconsole
import sys
# Try to import 'btsocket' as 'socket'
try:
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
import socket
 
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("192.168.0.10",1025))
btconsole.run_with_redirected_io(sock,btconsole.interact,None,None,locals())
sock.close()

Wichtig ist dabei, dass man die IP-Adresse des lauschenden Rechners eingibt. In dem Beispiel ist das 192.168.0.10, in der Realität wird es allerdings eine andere Adresse sein. Außerdem ist wichtig, dass ebenfalls Port 1025 benutzt wird. Man kann auch einen anderen Port wählen, den muss man dann nur auf beiden Seiten ändern. Wenn alles klappt, zeigt das Terminal eine Python-Shell auf dem Handy über WLAN:

Für die Vereinfachungen des Ganzen habe ich zwei Skripte geschrieben: Das erste Shell-Skript wifishell.sh wird auf dem Gnu/Linux-Rechner ausgeführt:

#!/bin/sh
# Script:      wifishell.sh
# Object:      Starts TCP/IP Console for S60 mobiles
#              afterwards start console.py on your S60
 
IP=$(ifconfig  | grep 'inet '| grep -v '127.0.0.1' | cut -d: -f2 | awk '{ print $1}')
PORT="1025"
 
echo "Your IP address is: $IP "
echo "Start now wifishell.py on your phone ..."
 
stty raw -echo ; nc -l -p 1025 ; stty sane

Im ersten Teil wird die IP-Adresse im eigenen Netzwerk ermittelt und in der Variable IP gespeichert. Dies gilt, wie gesagt, nur für Gnu/Linux-Rechner. Verwendet man ein Betriebssystem mit Free- oder OpenBSD, bzw. mit MacOS X, muss man stattdessen folgende Zeile in das Skript einfügen:

IP=$(ifconfig  | grep -E 'inet.[0-9]' | grep -v '127.0.0.1' |awk '{ print $2}')

Außerdem muss man darauf achten, dass der Aufruf von netcat im zweiten Teil des Skripts ohne den Schalter -p geschieht, wie das Beispiel auf einem Mac zeigt:

Als Benutzer von OpenSolaris verwendet man übrigens folgende Zeile im Skript:

IP=$(ifconfig -a | grep 'inet ' | grep -v '127.0.0.1' | awk '{ print $2}')

Das Gegenstück in Python wifishell.py muss auf das Handy gespielt werden. Wie alle anderen Python-Skripte auch, sollte es dort auf der Speicherkarte ins Verzeichnis E:\Python\ kopiert werden. Sobald wifishell.sh auf dem Gnu/Linux-Rechner oder der Unix-Maschine nach Anfragen auf dem Port 1025 lauscht, startet man über die Python-Shell auf dem Telefon das Skript wifishell.py, um eine Verbindung zum Terminal auf dem Computer herzustellen. Läuft alles glatt, verwandelt sich das Terminal in eine Python-Shell auf dem Handy.

# Script:      wifishell.py
# Object:      Starts TCP/IP Console for S60 mobiles
#              before start console.sh on your Gnu/Linux box
 
import btconsole, appuifw
import sys
try: # next lines important for select_access_point()
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
import socket
 
ip = appuifw.query(u"IP address:", "text")
port = 1025
 
sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((str(ip), port))
btconsole.run_with_redirected_io(sock,btconsole.interact,None,None,locals())
sock.close()

~/Musik$ python -m SimpleHTTPServer 8080

Der Inhalt des Arbeitsverzeichnisses, in diesem Fall der Ordner Musik, wird über den HTTP-Server im internen Netzwerk angeboten, also nicht nur für localhost. Sollte sich im aktuellen Verzeichnis eine Datei wie index.html oder index.htm befinden, würde der Webbrowser ihren Inhalt anzeigen. Da sich solch eine Datei dort aber nicht aufhält, wird der Inhalt des Verzeichnisses angezeigt.

Wenn der Server auf dem Netbook gestartet ist, öffnet man den Webbrowser des Handys. Bei meinem Nokia E71 musste ich dazu den Standardbrowser verwenden, da der Opera Mini sich nicht verbinden wollte. In die Adressleiste gibt man die IP-Adresse des Netbooks im internen Netzwerk gefolgt vom Port an. Die IP-Adresse wird auf jeden Fall anders sein. In meinem Fall ist das:

http://192.168.2.105:8080/

Wenn alles klappt, sieht man den Inhalt des Ordners auf dem Netbook präsentiert vom HTTP-Server:

Man kann sich nun durch die Ordner klicken und die einzelnen Musikstücke herunterladen, allerdings nur immer die einzelnen Dateien, keine kompletten Ordner.

In der Shell kann man dann sehr schön beobachten, mit welcher IP-Adresse das Handy auf die Ordner und Dateien des Servers zugreift:

~/Musik$ python -m SimpleHTTPServer 8080
Serving HTTP on 0.0.0.0 port 8080 ...
192.168.2.101 - - [02/Apr/2010 18:37:41] "GET / HTTP/1.1" 200 -
192.168.2.101 - - [02/Apr/2010 18:38:07] "GET /The%20Avett%20Brothers/ HTTP/1.1" 200 -
192.168.2.101 - - [02/Apr/2010 18:38:16] "GET /The%20Avett%20Brothers/I%20And%20Love%20And%20You/ HTTP/1.1" 200 -
192.168.2.101 - - [02/Apr/2010 18:38:23] "GET /The%20Avett%20Brothers/I%20And%20Love%20And%20You/01%20-%20I%20And%20Love%20And%20You.mp3 HTTP/1.1" 200 -

Jetzt möchte man vielleicht eine Datei schnell vom Handy zum Netbook schicken. Das ist mit einem Nokia S60-Modell und Python for Symbian 2.0 kein Problem. Dazu muss folgendes kleine Skript auf dem Telefon gestartet werden:

from BaseHTTPServer import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
import os
 
os.chdir("e:\\")
 
serv = HTTPServer(("", 8080), SimpleHTTPRequestHandler)
serv.serve_forever()

Bevor der HTTP-Server auf Port 8080 gestartet wird, wird als Arbeitsverzeichnis “e:\\” vereinbart, was in diesem Fall die Speicherkarte ist. Bevor man den Server aber startet, sollte eine Internetverbindung über WLAN auf dem Handy schon etabliert sein. Am einfachsten surft man dazu mit dem Webbrowser irgendeine Seite an. Nach dem Start blockiert das Skripts allerdings die Python Shell, dafür hat man jetzt die Möglichkeit, den Inhalt der Speicherkarte entlang zu surfen:

Wenn man möchte, kann man einzelne Dokumente herunter laden oder vom Handy aus starten:

Das alles funktioniert, weil bei neueren Python-Versionen das Standardmodul SimpleHTTPServer dabei ist. Da es auf dem Symbian-Handy leider keine Shell und kein Terminal gibt, kann man hier nicht mit der Option “-m” wie zum Beispiel unter Gnu/Linux auf dem Netbook arbeiten. Ein einfacher kurzer Einzeiler reicht hier nicht, man muss eben ein bisschen mehr ausholen. Es gibt übrigens auch die Möglichkeit, Dateien über WLAN mit einem Client- und einem Server-Programm auszutauschen. Aber das ein anderes Mal.