With the new Nokia N900 I’ve been looking for a way to get my Ubuntu Karminc netbook & Ubuntu Jaunty laptop online, preferably with Wifi, but at least using Bluetooth. Wifi is unfortunately not yet supported because the some kernel-modules  (iptables, iptables_nat) are not available for Maemo (they are working on it). Bluetooth is possible, and quite easy to archive with Ubuntu Karmic. I’ll explain how to get your Ubuntu Karmic laptop online with a N900 using the DUN-service (DailUpNetworking)

You need to be comfortable with the commandline/terminal and have rootsh installed on your N900 to do this! If you’re NOT comfortable with the Terminal : do not proceed, you will need to be root, and that enables you to brick your N900!

On the N900

You’ll need the following script (taken from Maemo Wiki):

sdptool add --channel 1 DUN
while true; do
        rfcomm -S -- listen -1 1 /usr/bin/pnatd '{}'
        sleep 1
done

I copied the script,  pasted it into a new text-file on my laptop (called it dun.sh) and sent it to my N900 with bluetooth. Your N900 will ask where to store the script, I stored into Documents. Now fire up the terminal application on the N900 and become root:

~ $ sudo gainroot

Move the uploaded file to /usr/bin :

/home/user # mv /home/user/MyDocs/.documents/dun.sh /usr/bin/

Make the file dun.sh executable;

/home/user # chmod +x /usr/bin/dun.sh

Start the DUN-service:

/home/user # dun.sh

You should see something like this:

Dial-Up Networking Service Registered
Waiting for connection on channel 1

Configuring the N900 is finished, next;

configuring Ubuntu (Karmic)

Be sure you have paired the N900 with your laptop

Configuring the network-connection

• Left click on the network-manager from the notification area of the gnome-panel, select “Edit connections”
• Select the “Mobile Broadband”-tab and press “Add”
  
• Click “forward” (leaving the selection to “any device”)
• Select the country, click “forward” and select your mobile operator.
• If you have the option to select a plan, do so (I needed to select Vodafone Business to get the correct APN), else click “forward”
• Click “Apply” to save the new Mobile Broadband-service
• A new window will appear to configure the Service, be sure to enable “Connect automatically” and click “apply”
  
• Close the window “Network connections”
  

Next: connecting to your N900 with DUN

First; be sure you have Blueman Installed, you’ll need this to configure the connections. If you do not have Blueman running install it following the instructions found here

• Check if you have enabled the correct plugin;
• Right-click on the bluetooth-icon in the notification area in the panel and select “plugins”
  
• Enable “NMDUNSupport” (optionally you can enable the “NetUsage” plugin to monitor data-usage) and close the Plugins window.
• Open the bluetooth manager (by  left-clicking on the bluetooth-icon in the notification area in the panel) and look for your N900.
  
• Right-click on the N900-icon and select “Refresh Services”
• Again; right-click on the N900 and click “Dail-Up Networking”.. your laptop will try to connect to your N900
• If the connection is OK you can establish the network-connection to your Mobile Broadband provider, left-click on the Network-manager in the notification area and select the network connection you created in the previous section (“Configuring the network-connection”).
• If all goes well you should be online now! (if you had a ‘normal’ wifi connection, disconnect it to be sure you’re using the Dail-Up with your N900).

Possible Issues

If you disconnect from dail-up networking and try to reconnect you could get an error : “Connection Failed: Port already in use”.. To fix this, restart bluetooth on your laptop:

sudo /etc/init.d/bluetooth restart

Loose ends

You could leave the DUN-script running in a terminal on your N900, I’m not yet sure if this could drain the battery. If it doesn’t it may be possible to add the script into the /etc/rc2.d directory, this way the script will be started at boot and you can connect to your N900 quickly without manually starting DUN. I’ll look into this when I’m sure the script doesn’t drain the battery (Update: It doesn’t; it’s save to autostart the script).

Ubuntu Jaunty doesn’t have the bluetooth manager which is used in Ubuntu Karmic; I’ll update this post with instructions for Jaunty later, and if anyone has a step by step howto for Windows, please let me know so I can add a link to your site or add the howto here

Update : If you’d like DUN started automatically, check out this and this helpful post

Update 12-30-09:
The DUN script is now available in the Maemo-repositories; still in testing though.
Also; I forgot to mention Blueman . I assumed it was part of Karmic and installed by default; but it’s not, i’ve added instructions (Thx to Alex & Alex in the comments).

Also check out this list of other Wave-bots and gadgets;

Nokia N900

Yay! Got my N900 directly from Nokia yesterday and I’ve been playing with it a lot. Overall I’m very happy with this new phone, finally something that beats the Nokia E90.

My findings for now;

Hardware
It’s a lot smaller than I expected, ok.. I was used to a E90 which is a huge brick (or my “mobile fridge” as I used to call it). It feels well constructed and solid; no creaky sounds when you squeeze it. The keyboard is a bit too small IMHO, but again; I was used to the keyboard of the E90 which is pretty large. The keyboard sliding-mechanism feels stirdy and will probably survive the phone.
The touchscreen has a very soft feel, probably not very scratch-proof (I ordered a 3M Vikuiti DQC-160 screenprotector rightaway). Touch-response is good, though I do need the stylus for browsing, clicking a link with my fingers is practically impossible without zooming in.
The speakers are quite good, though not as loud as the E90, but it has a surprisingly good stereo-sound with a large range. The headphones are also pretty good, have a lot of bass, but I’ll keep using my Sony MDR-E888’s for a while.

Software
It’s clearly a phone for geeks; Maemo is very stable, pretty fast, but there are some things a ‘regular’ phone-user will miss. Don’t get me wrong; almost everything works, but there are some issues I came across;

• The email-client; IMAP is supported, but my IMAP-account is filled with a lot of folders and emails (from over 7 years worth of business-email) and you can’t unsubscribe IMAP folders. The N900 checks them all and this take a lot of time and processor-usage (which will eventually drain the battery). After a while the mail-client just refused to open the Inbox-folder. According to this bugreport this will be fixed in Nokia’s next update. There’s a workaround; you can use Nokia Messaging, in which you can select the IMAP-folder which need to be synced. Also there’s no support for IMAP-Idle.. which kinda sucks.
• No MMS-support unfortunately. Maybe this will be implemented in a while.
• Almost all apps have to be used in landscape mode; only the Phone-application switches. This is supposed to be fixed in next update (though I’m not sure about that)
• “only” 256 mb storage available in the root-filesystem; though Nokia fixed this by creating a 2GB Ext3-filesystem and mounted this in /home/opt there are a lot of app’s out there that are not ‘optified’ and use the root-filesystem. This shouldn’t be a problem if you only use the repositories from Nokia and Maemo Extras, but if you’re using Extras-testing and Extras-Devel you’re filling up the root-filesystem.. Which I found out the hard way .. Also most third-party apps are not optified, eg. Mozilla Fennec which takes roughly 35 mb of storage.  I’ll be trying some other file-system layouts later, after making backups
• Nokia Maps is verrrry slow and uses a lot of processor. There’s no guided navigation available yet.. Sygic announced they will ship their navigation software at the end of 2009 .. I’d also like Google Maps for the N900, but there’s still no support for it (yet?).
• I still haven’t found a way to select multiple files/messages (yet), mainly in the file-browser or in the mail-client.  If you want to remove multiple messages or move/delete multiple files this is annoying, you have to move/delete each file/message individually. Any tips on this are greatly appreciated.
  Update 09-12-09: selecting multiple files/email is supported, just click “delete” in the email-app and select the emails you’d like to delete, same goes for file-management..
• Battery-life is kinda bad.. depends on what widgets and programs you’re running. I think I have to order a desktop-charger and some extra batteries soon.

The good things about the N900:

• IM Integration: Skype, Gtalk, MSN, ICQ are integrated into the Contacts-app, which is very cool IMHO. You just select a contact and you’re able to choose; message using SMS, any kind of IM (if they are online), email, call using cellular, skype or GTalk.. the works! This really makes the N900 a multipurpose communicator ..
• I wouldn’t use it; you can update the IM-status with your location, you can even choose which level of detail you’d like to expose: region, city or street.
• The browser is verrrrry good, very fast, renders everything, also Flash and just works like the browser you have on your computer. Only small thing ; bookmarks.. I didn’t find a usable bookmarks-manager. You can only create folders in bookmarks by adding a bookmark, not by editting (but maybe I missed something). I’ve tried Fennec also, but the default browser is much faster, uses less memory and has better controls.
• When connected using Wifi in my home-network the media-player and filebrowser automatically detected uPNP-shares from my Mac and my MediaTank.
• Finally a phone on which I can be ROOT! (without hacking/jailbreaking)
• Syncing Google Calendar works great with the Mail For Exchange-feature.. as long as you keep syncing of email and contacts disabled.
  Update 09-12-09 : Syncing Google Calendar worked great, but now it keeps telling me “Cannot connect to server” .. annoying!
• The FM-transmitter is very cool.. It even sends the text “Nokia” to RDS-enabled radios..
• I can use WAVE from my Mobile!!! w000t!

In general I’m very happy with the N900, mainly because everything that in my house that has a processor is running some kind of Unix/Linux-flavour. Maemo has a promising future and I can’t wait for the next update; not only for bugfixes, also because I’m very curious what new features will be added.

Crudder in action

It took a while.. a long while actually.. but I finally made a new release of Crudder. This new release 0.50 has a lot of new features and bugfixes, to name a few;

• New Field-type: HTML-editor
• New Field-type: File-upload
• New Field-type: Enum
• Export to CSV
• Adding records from the many-2-many-editor
• Bugfixes; language-support works better, datefield has been fixed, the many-2-many-editor should work better

Check out the DEMO or read more

Nokia N900

After almost 3 years of Nokia E90 usage I  ordered a Nokia N900. Imho it’s the only phone/MID worthy of replacing my E90.  Ok; it’s bulky, heavy (the E90 is a brick too)  and the OS is probably a bit rough around the edges, but it runs Linux (maemo), has a 800×480 px screen, 1 gb of RAM (of which 768 mb is swap) and a whopping 32 gb storage.  I will miss Route66 though, not sure if Nokia Maps is capable of keeping me on track…

Can’t wait to get root on my phone

Op http://wps.i-v-o.nl/ staat sinds vandaag een vernieuwde demo-website van WPS.  Met deze demo-website kan je lezen over wat WPS is, wat het kan, hoe het werkt en je kan spelen met het systeem.

Wat is WPS

WPS staat voor Web Publishing System. Geen spannende afkorting, maar het dekt de lading wel goed. WPS is namelijk geen klassiek Content Management Systeem (CMS) maar veel meer. Een klassiek CMS zorgt er eigenlijk alleen maar voor dat je de inhoud van je website kunt bewerken, dat doe je dan eigenlijk altijd op een aparte website (ook wel backend genoemd). Zo’n CMS is harstikke mooi, maar er moet ook een ‘voorkant’, je website, geprogrammeerd worden, en dat kan best een tijdrovende klus worden. WPS is een publicatiesysteem en zorgt dus niet alleen voor de CMS functie, maar ook voor het publiceren; de voorkant van je website.

Publicatie-systeem

Er zijn gerust wel andere publicatie-systemen, bijvoorbeeld Joomla of Wordpress, maar toch heeft I-V-O de keuze gemaakt om een heel nieuw systeem te ontwikkelen. Waarom? Flexibiliteit.
De meeste andere systemen zijn nogal rigide in functionaliteit of opmaak, en dan nog maar niet te spreken over veiligheid. WPS is extreem flexibel door het gebruik van XML. Alle gegevens die in WPS rondgaan worden omgezet in XML en komen in 1 groot document samen; het WPSDoc. XML is een speciale manier van gegevens opmaak die zich uitermate goed leent tot ‘translaties’. Stel je voor dat je een tekst hebt ingevoerd en je wilt daar een deel van dikgedrukt maken; normaliter wordt dat in html aangegeven met de b-tag. In WPS wordt dit de bold-tag, niet “b”, en bij het publiceren van de pagina kan de programmeur dit transleren/vertalen naar de standaard “b”-tag, maar ook naar iets heel anders, bijvoorbeeld “strong” of “h1″.
De taal die gebruikt wordt voor dit vertalen heet XSL-t, een soort HTML, maar dan met logica; je kan als programmeur o.a if-then-else, loops, en variabelen gebruiken. Hierdoor wordt de XML een stuk slimmer, en je site dus ook!

Bewerken en beheren

Wat WPS nog meer bijzonder maakt is de manier waarop je de teksten in je website kunt beheren; dit doe je namelijk gewoon in je site en niet op een aparte website of backend. Hierdoor zie je veel beter wat en waar je wat doet. Dit is veel gebruiksvriendelijker dan de standaard CMS’en en geeft veel beter weer wat de cohesie is tussen website en content.

Plugins

Een standaard WPS-site kan al heel veel;

• Pagina’s aanmaken, teksten maken en aanpassen
• Meta-tags (voor zoekmachines) beheren
• Linkjes in je teksten controleren of ze nog goed zijn
• Bestanden (pdf’s, Word-documenten, plaatjes) uploaden
• Een site in meerdere talen publiceren (en dat doet WPS heel slim want als je een pagina in het nederlands naar bijvoorbeeld het engels hebt vertaald dan weet WPS welke pagina’s bij elkaar horen, als een engels-sprekende op een nederlandse pagina komt kan hij/zij met 1 klik naar de engelse versie zonder de pagina opnieuw te moeten zoeken)
• Rechten instellen per pagina

Verder zijn er heel veel extra functies gemaakt in de vorm van ‘plugins’, een greep uit de collectie;

• Nieuws-plugin: zorgt voor het beheer en publicatie van nieuws-berichten (ook naar RSS!)
• Poll-plugin: maak zelf een poll en zorg dat je bezoekers kunnen stemmen
• Search-plugin : zorgt ervoor dat bezoekers kunnen zoeken in je website
• Shop-plugin: volledige webwinkel, met betalingsmodule voor IDEAL en Mollie (micropayments)
• Enquete-plugin: zeer uitgebreide plugin voor het maken van grote enquetes, compleet met uitnodigings-email-functie, toegangscodes en export-functies.
• Catalogus/Portofolio-plugin: laat je bezoekers zien wat je verkoopt of wat je hebt gemaakt.
• Download-beveiliging voor Audio: als je bijvoorbeeld muziek wilt laten horen vanaf je website via een zg. FlashPlayer dan zorgt WPS ervoor dat bezoekers niet stiekem de bestanden kunnen downloaden.
• Google-Maps-plugin: zorgt ervoor dat je bezoekers op een kaartje kunnen zien waar je bedrijf is gevestigd
• Reactie-plugin: geeft je bezoekers de mogelijkheid om korte reacties op je website te plaatsen (en ze kunnen ook op elkaar reageren)
• PDF-output; maakt automatisch PDF-bestanden van de tekst op een pagina die bezoekers kunnen downloaden
• Blog-Plugin: samenvoeging van de nieuws-plugin en de reactie-plugin
• Gallery-plugin: maakt automatisch een mooie foto-gallery van foto’s
• En in ontwikkeling; Google WAVE-integratie; een mogelijkheid om bezoekers via Google Wave te laten reageren op nieuws-berichten.

Verder maakt WPS gebruik van slimme caching; je site zal altijd rete-snel blijven omdat alle veel gebruikte informatie in het geheugen van de webserver bewaard blijven, zodat ze snel weer voor handen zijn als het nodig is.

Voor meer informatie over WPS, klikkerdeklik!

Installation is quite easy; there’s a perfect howto available on Howtoforge.

Virtual Pre

Update: Palm released the SDK, you can download a Linux, Mac Or Windows-SDK at : http://developer.palm.com/

The windows-version of the Palm Pre SDK leaked out last month; though still in beta it’s supposed to work, but unfortunately the installer itself is Windows only. Wine-to-the-rescue! I installed the SDK using Wine and checked the installed files. I found the emulator as a VirtualBox image in ~/.wine/drive_c/Program Files/Palm/SDK/share/emulator/images/sdk47, in windows it looks like it’s booted from a bat-file using several jar’s, but that doesn’t work on linux.  So I added the virtual disk to the “Virtual Media Manager”, created a new virtual machine with 256 mb ram, added grub.iso as CD-rom and tried to boot the VM.  Booting worked, kind-of; the bootmanager complained about “undefined video mode : 360″, if you don’t select a display-mode the VM will eventually halt with an error

PmCertificateMg[1092]: segfault at 0 ip 0804fd18 sp bf869228 error 4 in
PmCertificateMgrService[8048000+b000]

If you do select a video-mode the emulator will boot, however; the Virtual Pre doesn’t understand the resolution and controlling it with the mouse is very difficult. It seemed the Virtual Palm needed the right resolution to work OK, but this resolution/video-mode is not available from the bootmanager.
Then I found this post, you need VBoxManage to add some configuration to VirtualBox, so open up a terminal and enter:

VBoxManage setextradata "NAME OF VM" "CustomVideoMode1" "320x480x32"

Change NAME OF VM to the name you’ve given to the VirtualBox instance (and keep the quotes!), boot the VM again and your Virtual Palm Pre should work like it’s supposed to.

After playing around with the VM I’m quite impressed with the Pre. I was considering a Nokia N97 because the Palm is still not available here in Holland (and it will probably take some months before they release it here), but having seen the Pre-software in action I decided to keep using my 3-year-old Nokia E90 until the Palm is available here. As soon as I get the chance to look at the SDK in detail I’ll post my findings here, there’s supposed to be an Eclipse Plugin somewhere in the SDK, can’t wait to try that and write my first “hello world” TwitterClient (a tutorial on writing your first app for the Pre can be found here, has nice wordpress-skin too!)

More detailed description on how to get the VirtualBox image working can be found here

Some more screenshots:

Palm Pre booting in VirtualBox

Splashscreen after boot on Virtual Palm Pre

Applications overview on Virtual Palm Pre

Dialer on Virtual Palm Pre

Syntacticsugar.nl from the Pre Webbrowser

Trackman Marble FX Cordless

My all-time-favorite mouse trackball is the Logitech Trackman Marble FX (Cordless).  Logitech stopped making those a couple of years ago, but I’ve bought 5 of them and since the first one still works fine I’ll probably be using this model until USB is replaced with a new kind of port;)

The Trackman FX has 4 buttons and no dedicated scrollwheel. Before Ubuntu Jaunty (9.04) I was able to configure the buttons from /etc/X11/xorg.conf, but I upgraded from Ubuntu Hedgy (8.04) to Ubuntu Intrepid (8.10) all the way to Ubuntu Jaunty (9.04) and Ubuntu dropped the mouse-configuration from xorg.conf in favour of the HAL-device-manager.

My xorg.conf setup for the Trackman FX looked like this:

Section "InputDevice"
	Identifier "TFX"
	Driver "mouse"
	Option "CorePointer"
	Option "Device" "/dev/input/mice"
	Option "Name" "TrackMan Marble FX"
	Option "Vendor" "Logitech"
	Option "Protocol" "ExplorerPS/2"
	Option "Buttons" "9"
	Option "Emulate3Buttons" "true"
	Option "EmulateWheel" "1"
	Option "EmulateWheelButton" "8"
	Option "YAxisMapping" "4 5"
	Option "XAxisMapping"   "6 7"
EndSection

Using this configuration the upper-left button was assigned as scroll-switch; if I’d keep the button pressed and use the trackball I could scroll.  The left-middle button was used as “normal” left-mouse-button, and the lower-left button used as back-button for Firefox and Nautilus.
However; xorg.conf configuration didn’t work anymore in Jaunty; HAL took over, but how to configure the Trackman FX from HAL? After several searches in Google I came across this bugreport in Launchpad. According to the posts I’d had to create the file /etc/hal/fdi/policy/mouse-wheel.fdi and enter the following :

<deviceinfo version="0.2">
        <device>
                <match key="info.product" string="Logitech USB Receiver">
                        <merge key="input.x11_options.Buttons" type="string">9</merge>
                        <merge key="input.x11_options.EmulateWheel" type="string">true</merge>
                        <merge key="input.x11_options.EmulateWheelTimeout" type="string">300</merge>
                        
                        <merge key="input.x11_options.EmulateWheelButton" type="string">8</merge>
                        <merge key="input.x11_options.XAxisMapping" type="string">6 7</merge>
                        <merge key="input.x11_options.YAxisMapping" type="string">4 5</merge>
                        
                        <merge key="input.x11_options.Emulate3Buttons" type="string">true</merge>
                </match>
        </device>
</deviceinfo>

After a reboot (which isn’t neccesary; unplugging it and plug it in again is enough) the Trackman didn’t do what I wanted it to do.  After some digging I suddenly realized the Trackman I used was cordless, and the model in mouse-wheel.fdi was defined as Logitech USB Trackball, the wired model.  It seemed HAL didn’t match the info.product-string with the cordless Trackman, so I needed to find out what would match my Trackman.  This was quite easy; from a terminal type:

sudo hal-device|less

You’ll get a list of all devices in HAL,  press slash (/) and enter Logitech to search for any device from Logitech and you’ll run into “info.product = ‘Logitech USB Receiver’  (string)”. The Cordless Trackman FX apparently had the product-id : “Logitech USB Receiver”, so I changed the line match key=”info.product” in  mouse-wheel.fdi to this product-id. Unplugged the Trackman, plugged it in again and hurray!!! Scrolling worked!

If you have a Trackman Marble FX Cordless, all you have to do is create /etc/hal/fdi/policy/mouse-wheel.fdi and enter/copy-paste:

<deviceinfo version="0.2">
        <device>
                <match key="info.product" string="Logitech USB Receiver">
                        <merge key="input.x11_options.Buttons" type="string">9</merge>
                        <merge key="input.x11_options.EmulateWheel" type="string">true</merge>
                        <merge key="input.x11_options.EmulateWheelTimeout" type="string">300</merge>
                        <merge key="input.x11_options.ButtonMapping" type="string">1 8 3 4 5 6 7 2 9</merge>
                        <merge key="input.x11_options.EmulateWheelButton" type="string">8</merge>
                        <merge key="input.x11_options.XAxisMapping" type="string">6 7</merge>
                        <merge key="input.x11_options.YAxisMapping" type="string">4 5</merge>
                        
                        <merge key="input.x11_options.Emulate3Buttons" type="string">true</merge>
                </match>
        </device>
</deviceinfo>

Unplug the Trackman (or the Receiver), plug it in again and you should be ready!

Small update:
The outer left button didn’t act as third-mouse-button, as I was used to. Using the method above it will be used as back-button. If you’d like it to be used as third-mouse-button, remove the line :

<merge key="input.x11_options.ButtonMapping" type="string">1 8 3 4 5 6 7 2 9</merge>

Be sure to check out the demo’s here. Read more about the API over here and on this blog

Installing Moonlight was quite easy, just go to http://www.go-mono.com/moonlight/, click on the image under “2. Download the plugin” and Firefox will ask if it may install the Moonlight Add-on. But; Moonlight by itself is quite useless without the copyrighted audio & video codecs from Microsoft. Novell (moonlight’s daddy) can’t distribute those codecs in Moonlight itself and you need to install them after Moonlight has been installed. This is supposed to be easy, go to the Moonlight-website, rightclick on the notice at the top saying “Congratulations!! You’re running the current release of Moonlight” and select “install microsoft codecs”. You’ll need to accept that you’re willing to sell your soul to Microsoft .. eh.. the EULA and the codecs will be downloaded and installed.
However, after the download I got the message “Permission Denied“. Obviously some directory was off limits for me, but I didn’t know which directory. So I tried to install Moonlight and the codecs as root,  gksudo firefox, which went fine. Next I started looking for files, where did Moonlight leave the codecs? In /usr/lib? /usr/share/firefox? I found it in the home-directory of root; /root/.mozilla/plugins/moonlight/silverlight-media-pack-linux-x86-5-1.so.  Next stop; copy the .so-file to my own home-directory, but wtf? No directory /home/[me]/.mozilla/plugins? So.. i created the directory, and while I was at it, also created /home/[me]/.mozilla/plugins/moonlight, chmodded it to allow writing by me and tried to install the codecs;  Success!!! And they actually work; the codecs:)

So.. all you need to do to get Moonlight with Microsoft Codecs Pack installed, step by step

1. Go to http://www.go-mono.com/moonlight/ and click on the image under “2. Download the plugin” (see here for moonlight installation instructions )
2. You’ll be asked to restart firefox, don’t.. Bookmark this page and open up a terminal.
3. In the terminal; type:
   mkdir ~/.mozilla/plugins [enter]
   and
   mkdir ~/.mozilla/plugins/moonlight [enter]
   and
   chmod +w ~/.mozilla/plugins/moonlight
4. Restart firefox
5. Go to the Moonlight website again, and if Moonlight was installed successfully you’ll see “Congratulations!! You’re running the current release of Moonlight” somewhere at the top of the page. Right click on that (the normal context menu of firefox will show up, click somewhere on the page to hide it)
6. Click “Install Microsoft Codecs”
7. A popup will appear with a lengthy EULA, accept it (if applicable) and the download of codecs will start
8. When finished installation will start as well and you should be done.
9. Check the moonlight site again to make sure it’s running OK; if you right click the notification you shouldn’t see the item “Install Microsoft Codecs” anymore

Please upgrade (by www.robotjohnny.com)

From: http://www.robotjohnny.com/

My personal favorites:

//
// Dear maintainer:
//
// Once you are done trying to 'optimize' this routine,
// and have realized what a terrible mistake that was,
// please increment the following counter as a warning
// to the next guy:
//
// total_hours_wasted_here = 16
//

//When I wrote this, only God and I understood what I was doing
//Now, God only knows

# To understand recursion, see the bottom of this file
At the bottom of the file:
# To understand recursion, see the top of this file

There are some pretty good uses for a Singleton though; a registry and the database-connection;

Download example code here

Database-connection

I use ADODB to access databases, don’t ask me why, I just do. ADODB uses a DSN to connect to a database, which looks something like:

mysql://dbUser:dbPass@localhost/someDb

Normally you’d use $connection = &ADONewConnection($DSN) to connect to the database and run your query ($rs = $connection->execute($sqlQuery) ). The problem here; you keep creating new connections anywhere you run a query, you need to pass the value for $DSN into your objects,  you’ve made your class depend on ADODB and it take 2 lines of code   You can bypass these ‘problems’ by using a Singleton to connect to your database and run a query:

$rs = basicDBConn::getConnection()->execute($sqlQuery);

Now, what is wrong here? Did you see $DSN anywhere?
Nope… This statement assumes you’ve passed $DSN already somewhere before, in fact the first time you call getConnection() from this singleton you must pass $DSN as argument in getConnection(). The first time you call getConnection() is the moment the singleton creates an instance of itself, and uses $DSN to connect to the database (&ADONewConnection($DSN)). After this initialization the connection is kept within the Singleton, and $DSN isn’t needed anymore. Take a look at the files, basicDBConn.php in particular to get an idea of how the Singleton creates an instance of itself and the database-connection.

Registry

Another good use for Singletons is a Registry-object; A registry-object is used for configuration; global settings that you might need in your code (path’s, DB-configuration etc.). Since I’m infected by the XML-virus my configuration-files always are XML :

<config>
    <item index="DSN">mysql://dbUser:dbPass@localhost/singletondemo</item>
    <item index="someKey">someValue</item>
</config>

There is a drawback though; these XML-files are not protected by Apache by default, anyone can open them from a browser (if they are somewhere in the public root of the website). There are 2 solutions for this; prefix the file with .hta (in which case Apache will protect them just as .htaccess files are protected) or add the following lines to your Apache-configuration :

<Files ~ "configuration_filename.xml">
   Order allow,deny
   Deny from all
</Files>

The registry-object works the same as the Database-object; it needs a reference to a XML-file the first time you call it, after that it’s fully initialized and doesn’t need that reference anymore.

The first call to a registry object (and get the value for ’some_key’):

$someValue = basicRegistry::getInstance('/path/to/configuration/file.xml')->get("some_key");

Any call after that:

$someValue = basicRegistry::getInstance()->get("some_key");

Why is a singleton a good thing?
Getting configuration-values or a $DSN-string from within objects should be simple, you do not want to pass the path and filename to your configuration file or $DSN to a database every time you create an instance of an object. It will create dependencies and spaghetti in your code. If you make sure the registry and/or database-object are created before your other objects start doing something you do not need to worry about file-names and/or $DSN’s. They have been safely put away in a singleton.

Another very nice side-effect ; you’ve decoupled database-connections and configuration-settings. In my examples I use XML to setup the values in the registry, if you want to use some other method of keeping key-value-pairs, just modify the inner workings of the Registry-singleton, the objects using the registry won’t notice and work just as well. I usually keep session-variables in the registry, if I can’t use PHP’s $_SESSION, I can fall back onto Cookies, my classes won’t notice.

Download example code here

IE6 showing Facebook (in WINE)

rant-alert :  IHMO You would only use IE6 if  ;

• You’re using an illegal version of windows and you’re not able to Windows Update, why would that be supported by anyone? If you’re too lame to buy a legal copy, switch to a OS that’s free (and stable, and secure, and  looks better.. and.. and.. well)
• You’re at work and the ICT-dept.  is lame and not doing their job (security blackholes)
• You’re a complete n00b and don’t know what windows-update is (you shouldn’t use a computer at all)

[download code]

This is how these RPC-calls are done:

Since I like XML a lot, I wanted to use XML as transport mechanism for doing requests to the RPC-interface. Because I use XML I was also able to group RPC-calls into one single request. A simple method of authenticating these RPC-calls is something to consider if you’re not running a public service, but that’s beyond the scope of this article

A typical call would look like this:

<command>
	<method name=”remote_method” object=”some_object”>
		<arg key=”some_argument”>value_of_some_argument</arg>
		<arg key=”another_argument”>value_of_another_argument</arg>
	</method>
	<method name=”another_remote_method” object=”another_object”>
		<arg key=”some_argument”>value_of_some_argument</arg>
		<arg key=”another_argument”>value_of_another_argument</arg>
	</method>
</command>

Now, what does this XML actually mean?

First of all; the methods need to be nested into a single node: <command>, the XML would not be valid otherwise. Each method-node has an name-attribute and object-attribute, the object-attribute defines the remote PHP-object which contains the method you’d like to call, the method is defined in the name-attribute.

Each method-node contains one or more arg-nodes, these nodes are passed to the method as a hashed-array and used as arguments for the method. Attribute “key” will be the key or name in the arguments-array, the node-value will become the value.

The example above will eventually call 2 methods,

1. the first method, “remote_method” is part of object “some_object”, and receives 2 arguments;
   • “some_argument” with value “value_of_some_argument”
   • “another_argument” with value “value_of_another_argument”
2. the second method, “another_remote_method” is part of object “another_object”, and also receives 2 arguments;
   • “some_argument” with value “value_of_some_argument”
   • “another_argument” with value “value_of_another_argument”

Now, let get some coding done, let’s focus on the RPC-server first, download this code-snippet and unpack it in a fresh webroot (it contains all the files described in this article, also the RPC-client).

First take a look at /include/classes:

• tools.php : contains static “helper” methods, I hate procedural spaghetti-code and I always put methods which are not part of a larger object-model into several helper-classes. In this particular example a single helper-class is enough. All methods in this class are static and can be called without first creating an object.
• abstract_object.php : this is important and can be confusing if you’re not used to an object oriented approach. This class contains methods which are inherited into child-classes, but you cannot create an object-instance of this class, because it’s abstract. Why is it abstract? It’s arguable to just let it be a normal class in this particular example, however; using abstract classes in larger projects really keeps your code clean and separates the implementation of your object-design from the structure you’re using.
• some_object.php : inherited from abstract_class.php; example implementation.
• another_object.php : inherited from abstract_class.php; another example implementation.

The actual object available for the RPC-interface are some_object and another_object. Now let’s take a look at rpc.php, which is in the root. The only really interesting part is from line 56

	// gather 'method' nodes and execute them;
	$methods = $dom->getElementsByTagName('method');

	for ($i=0;$i<$methods->length;$i++){
		$methodNode = $methods->item($i);
		$method = $methodNode->getAttribute('name');
		$obj = $methodNode->getAttribute('object');
		$obj = new $obj();
		$arguments = tools::getArgumentsAsArray($methodNode);
		$obj->$method($arguments);
		$messages .= $obj->getMessages();
	}

	echo tools::wrapMessages($messages);

So, what’s really happening here?

The first statement; $methods = $dom->getElementsByTagName(‘method’); will retrieve all method-nodes from the request. PHP-DOM (or any other DOM-implementation for that matter) will always return the nodes in a nodeset, even if it’s only one method-node, but not if there aren’t any nodes found.
This nodeset is used to loop upon, the classic for-next statement on the next line.

In each loop the method-node is examined; the attribute-values for object and method are determined ($method = $methodNode->getAttribute(‘name’) and $obj = $methodNode->getAttribute(‘object’)) and using a static function from the tools-class the arguments are converted into a PHP-array ($arguments = tools::getArgumentsAsArray($methodNode) ).

Now we’re ready gathering all the values needed to really create the object ( $obj = new $obj() ) and execute the requested method ( $obj->$method($arguments) ).

The method should not return anything, instead it’s return-values are stored into a protected variable (defined in abstract_object). To get these values, use $obj->getMessages(). This method doesn’t seem to be available in the class of $obj, it’s defined in abstract_object.

After the loop has finished the $message-string should be wrapped into a node to make sure the XML is valid, this is done with the tools’ class wrapMessages-method.

Ok, the RPC-interface is ready, let’s test it! Enter the following URL into a browser (assuming you’re running PHP on localhost, in a folder called rpc:

http://localhost/rpc.php?req=<command><method name="remote_method" object="some_object"> <arg key="some_argument">value_of_some_argument</arg><arg key="another_argument">value_of_another_argument</arg> </method><method name="another_remote_method" object="another_object"> <arg key="some_argument">value_of_some_argument</arg><arg key="another_argument">value_of_another_argument</arg> </method></command>

You’ve just called a 2 functions from your RPC-interface! The output should look like this:

<servermessages>
    <message object="some_object" method="remote_method" code="200">remote_method was executed
        succesfully with arguments : value_of_some_argument, value_of_another_argument </message>
    <message object="another_object" method="another_remote_method" code="200">another_remote_method
        was executed succesfully with arguments : value_of_some_argument, value_of_another_argument
    </message>
</servermessages>

Now let’s move on to the RPC-client: take a look at rpcClient.php in the root. It’s quite large, and I will not go into all the details (the comments in the file should be enough). Most of the functions in rpcClient take care of constructing the XML needed to execute the RPC-call, absolutely no rocket-science.  However; I do want to highlight the actual “executing” of the RPC-call, take a look at the private function sendToHost:

 private function sendToHost($data) {
	$postdata = http_build_query(
	    array(
	        'req' => $data
	    )
	);
	$opts = array('http' =>
	    array(
	        'method'  => 'POST',
	        'header'  => 'Content-type: application/x-www-form-urlencoded',
	        'content' => $postdata
	    )
	);
	$context  = stream_context_create($opts);
	$this->result = file_get_contents($this->rpcURI, false, $context);
}

This method uses file_get_contents, http_build_query and stream_context_create to POST the constructed XML to the RPC-server and stores the reply in a local variable ($result). I’ve tried using fopen like this:

function sendToHost($host,$path,$data) {
	$fp  = @fsockopen($host,80);
	$buf = '';
	if ($fp) {
		@fputs($fp, "POST $path HTTP/1.0\n");
		@fputs($fp, "Host: $host\n");
		@fputs($fp, "Content-type: application/x-www-form-urlencoded\n");
		@fputs($fp, "Content-length: " . strlen($data) . "\n");
		@fputs($fp, "Connection: close\n\n");
		@fputs($fp, $data);
		while (!feof($fp)) {
		  $buf .= fgets($fp,128);
		}
		fclose($fp);
	}
	return $buf;
}

This method failed. I kept getting weird responses from my RPC-server (command not understood etc.). And honestly;  I like the clean call using file_get_contents, http_build_query and stream_context_create much better.

Ok; we have a nice object-structure, a RPC-server and a RPC-Client. What’s left is a real world implementation of the client. Take a look at example.php:

 include('rpcClient.php');

 $hsClient = new rpcClient();
 $hsClient->createCall('some_object', 'remote_method', array('some_argument'=>'some_value', 'another_argument'=>'another_value'));
 $hsClient->createCall('another_object', 'another_remote_method', array('some_argument'=>'some_value', 'another_argument'=>'another_value'));
 $hsClient->execute();
 $str = $hsClient->getXMLResponse();
 echo "<pre>";
 echo $str;
 echo "</pre>"; 

If you’d leave out the debugging-statement at the end you end up using 4 lines of code to create, execute and retrieve a RPC-call (ok; 5 lines if you consider I’ve made 2 RPC calls). First you create an instance of the RPC-client, secondly you create a call using createCall and last but not least; you execute the call and intepret the response. If you’d enter the URL to example.php into your browser you’ll get:

remote_method was executed succesfully with arguments : some_value, another_value
another_remote_method was executed succesfully with arguments : some_value, another_value

That’s it! You have a RPC-server, RPC-client and a working implementation! You should take care of authenticating your RPC-calls, and design a nice Object-structure to implement ‘behind’  the RPC-server, this all depends on the kind of logic you need. I’ve used this method of RPC-ing to allow 3rd-parties to update certain values in a shop-database, and with a little effort you could make your RPC-server handle AJAX-requests and return JSON to clients. But that something for the next article.

[download code]