A very simple example of how to periodically check the availability of an internet connection by using the observer design pattern.

InternetConnection.java

package net;

import java.net.*;
import java.io.*;

public class InternetConnection {
	/*	use at least one reliable host, in most cases you will want
 		to use the one you're working with later	*/
	private static final String CHECK_URL = "http://www.t-online.de/";
	public static InternetConnectionState isAvailable() {
		try {
			URL url = new URL(InternetConnection.CHECK_URL);
			HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
			Object objData = urlConnection.getContent();
		} catch(UnknownHostException exception) {
			return new InternetConnectionState(false);
		} catch(IOException exception) {
			return new InternetConnectionState(false);
		}
		return new InternetConnectionState(true);
	}
}

InternetConnectionState.java

package net;

public class InternetConnectionState {
	private boolean state = false;

	public InternetConnectionState(boolean state) {
		this.state = state;
	}

	public boolean getState() {
		return this.state;
	}

	public void setState(boolean state) {
		this.state = state;
	}
}

InternetConnectionObserver.java

package net;

import java.util.Observable;
import java.util.Observer;

public class InternetConnectionObserver implements Observer {
	public InternetConnectionObserver(ObservableInternetConnection internetConnection) {
		internetConnection.addObserver(this);
		new Thread(internetConnection).start();
	}

	public void update(Observable internetConnection, Object state) {
		InternetConnectionState connectionState = (InternetConnectionState)state;
		if(connectionState.getState() == true) {
			System.err.println("active internet connection detected");
		} else {
			System.err.println("lost internet connection");
		}
	}
}

ObservableInternetConnection.java

package net;

import java.util.*;
import net.InternetConnectionState;

public class ObservableInternetConnection extends Observable implements Runnable {
	private static final long CHECK_INTERVAL = 30000; // 30 sec
	private InternetConnectionState state;

	public void run() {
		this.state = InternetConnection.isAvailable();

		this.updateConnectionStatus();
	}

	public void updateConnectionStatus() {
		while(true) {
			InternetConnectionState newState = InternetConnection.isAvailable();
			if(newState.getState() != this.state.getState()) {
				this.state = newState;
				setChanged();
				notifyObservers(this.state);
			}
			try {
				Thread.sleep(ObservableInternetConnection.CHECK_INTERVAL);
			} catch(InterruptedException e) {
			}
		}
	}
}

Usage:

ObservableInternetConnection observableInternetConnection = new ObservableInternetConnection();
InternetConnectionObserver internetConnectionObserver = new InternetConnectionObserver(observableInternetConnection);

…I just startet programming Java a few days ago so I’m pretty sure there’s a better way to do this but I didn’t find it, yet

Meistens reicht die Methode tslib_cObj::crop vollkommen aus, um Texte – etwa für eine Listenansicht – zu kürzen. Wenn jedoch RTE formatierte Texte im Spiel sind und die Formatierung in der gekürzten Version beibehalten werden soll, ist es reine Glückssache, kein invalides (X)HTML durch nicht geschlossene bzw. “verkrüppelte” Tags zu generieren. Abhilfe schafft die folgende crop-Methode, die eine Portierung der Javascript-Version von Steven Levithan darstellt:

public static function crop($input, $numMaxChars) {
	$output = '';
	$charCount = 0;
	$openTags = array();
	$matches = array();
	$htmlTags = '/\w+|[^\w<]|<(\/)?(\w+)[^>]*(\/)?>|</';
	$selfClosingHtmlTags = '/^(?:[hb]r|img)$/i';

	preg_match_all($htmlTags, $input, $matches);
	$i = 0;
	$numMatches = count($matches[0]);
	while(($i < $numMatches) && ($charCount < $numMaxChars)) {
		// are we dealing with an html tag?
		if($matches[2][$i] != '') {
			$output .= $matches[0][$i];
			// if it isn't a self closing tag
			if(preg_match($selfClosingHtmlTags, $matches[2][$i]) == 0) {
				// if its a closing tag...
				if($matches[1][$i] == '/') {
					array_pop($openTags);
				} else {
					$openTags[] = $matches[2][$i];
				}
			}
		} else {
			$charCount += mb_strlen($matches[0][$i], $GLOBALS['TSFE']->renderCharset);
			if($charCount <= $numMaxChars) {
				$output .= $matches[0][$i];
			}
		}

		$i++;
	}

	// closing open tags
	$i = count($openTags);
	while($i--) {
		$output .= '</' . $openTags[$i] . '>';
	}

	return $output;
}

In manchen Fällen können Bit Flags in PHP-Skripten sehr nützlich sein. Etwa wenn es darum geht,
anhand eines “action”-Parameters zu entscheiden, welche Objekte instanziiert werden sollen. U.a. auf diese Weise kann
- sonst redundanter – Code gesparrt werden.

Kennern des binären Zahlensystems sollten also mal einen Blick darauf werfen. Alle anderen sollten dringend zu
diesen Kennern werden – das macht nicht nur das Verständniss des folgenden Codesnippets sondern das ganze (IT-) Leben einfacher

Das Prinzip ist eigentlich ganz einfach: Es werden einzelne Bits einer Integer Variablen gesetzt. Mit einer
logisch AND Verknüpfung kann dann geprüft werden, ob einzelne Bits gesetzt wurden. Mit AND können Bits gelöscht werden,
mit OR werden sie hinzu addiert. Jedes Bit stellt ein Flag dar. Ist ein Flag gesetzt werden entsprechende Aktionen ausgeführt.

Ein kleines Beispiel zu Bit Flags in PHP5:

class example_controller {
	/**
	 * Flags set by $this->setFlags()
	 *
	 * @var int
	 */
	private		$flags			=	0;
	/**
	 * Instantiate the renderer object if this flag is set
	 *
	 * @var int
	 */
	const		FLAG_RENDERER		=	1;
	/**
	 * Do something cool if this flag is set
	 *
	 * @var int
	 */
	const		FLAG_DO_COOL_STUFF	=	2;
	/**
	 * Do even more cool stuff if this flag is set
	 *
	 * @var int
	 */
	const		FLAG_EVEN_MORE_STUFF	=	4;

	/**
	 * Initializes this object
	 *
	 */
	public function init() {
		$this->setFlags();
		$this->processFlags();
	}

	/**
	 * Setting the flags according to parameters
	 *
	 */
	private function setFlags() {
		if(!empty($_GET['action'])) {
			switch($_GET['action']) {
				case 'createFoo':
					$this->flags |= self::FLAG_RENDERER;
					break;
				case 'saveFoo':
					$this->flags |= self::FLAG_RENDERER;
					$this->flags |= self::FLAG_DO_COOL_STUFF;
					break;
			}
		}
	}

	/**
	 * Instantiates objects by flags
	 *
	 */
	private function processFlags() {
		// instantiate renderer
		if(($this->flags & self::FLAG_RENDERER) > 0) {
			require_once(EXTENSION_LIBPATH . 'class.example_renderer.php');
			$this->renderer = example_renderer::getInstance();
			$this->renderer->init();
		}
		// do cool stuff
		if(($this->flags & self::FLAG_DO_COOL_STUFF) > 0) {
			require_once('./lib/class.cool_stuff_factory.php');
			$myCoolStuff = cool_stuff_factory::makeInstance();
			$myCoolStuff->save();
		}
		// do even more cool stuff
		if(($this->flags & self::FLAG_EVEN_MORE_STUFF) > 0) {
			require_once('./lib/class.even_more_stuff.php');
		}
	}
}

Renderer sind stets einmalig. Das Singleton Design Pattern bilded genau dies ab: Es wird lediglich eine einzige Instanz der Klasse erzeugt und zurückgegeben. Die folgende Klasse kann als Basis für die View-Schicht der eigenen TYPO3 Extension verwendet werden. Sie ist von pi_base abgeleitet und bietet so den gewohnten Funktionsumfang. Der Codeschnipsel stammt aus einer mini TYPO3 Extension, an der ich gerade privat bastel.

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 2009 Thorsten Boock <thorsten (at) nerdcenter.de>
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/

require_once(PATH_tslib . 'class.tslib_pibase.php');

/**
 * Frontend Renderer
 * Till PHP 5.3 this class has to be declared as final because
 * we don't know the names of the classes extending this one.
 *
 * @author Thorsten Boock <thorsten (at) nerdcenter.de>
 */
final class tx_tbwhoisonline_renderer_fe extends tslib_pibase {
	/**
	 * Instance of this class (Singleton Design Pattern)
	 *
	 * @var tx_whoisonline_renderer_fe
	 */
	private static		$instance					=	null;
	/**
	 * Path to the template file used for rendering
	 *
	 * @var string
	 */
	private				$templateFile				=	'';
	/**
	 * The contents of the file $this->templateFile
	 *
	 * @var string
	 */
	private				$templateHTML				=	'';

	/**
	 * Empty constructor (Singleton Design Pattern)
	 *
	 */
	private function __construct() {

	}

	/**
	 * Empty clone function (Singleton Design Pattern)
	 *
	 */
	private function __clone() {

	}

	/**
	 * Instantiating this object (Singleton Design Pattern)
	 *
	 * @return tx_tbwhoisonline_renderer_fe
	 */
	public static function getInstance() {
		if(self::$instance == null) {
			self::$instance = new tx_tbwhoisonline_renderer_fe();
		}
		return self::$instance;
	}

	/**
	 * Initializing this object
	 *
	 * @param array $conf
	 */
	public function init($conf) {
		// init tslib_pibase
		$this->conf = $conf;
		$this->pi_setPiVarDefaults();
		$this->pi_loadLL();
		// get cObj instance and load template
 		$this->cObj = t3lib_div::makeInstance('tslib_cObj');
 		$this->templateHTML = $this->cObj->fileResource($this->templateFile);
		// override defaults with typoscript configuration
		foreach($this->conf as $key => $value) {
			$key = str_replace('.', '', $key);
			if(isset($this->$key)) {
				$this->$key = $value;
			}
		}
	}
}
?>

Vielleicht ganz interessant für PHP-Entwickler die sich nun mit Flash 9 konfrontiert sehen:
In Actionscript 3 gibt es nach meinem Wissen nur die Funktion trace. So etwas wie var_dump sucht man vergebens. Aber natürlich kann man die einzelnen Objekt-Eigenschaften einfach rekursiv durchlaufen und nach für nach tracen:

package helpers
{
	public class ObjectTracer
	{
		public function ObjectTracer()
		{
		}

		public static function traceRecursive(_obj: *, index: String = ''): void {
			var item: Object;
			switch (typeof(_obj)){
				case 'object':
					trace('<object> ' + _obj.toString());
					for(var i: String in _obj){
						ObjectTracer.traceRecursive(_obj[i], i);
					};
					trace('</object>');
				break;
				case 'xml':
					trace('<xml>');
					trace(_obj);
					trace('</xml>');
				break;
				default:
					trace(index + ': ' + _obj + ' (' + typeof(_obj) + ')');
				break;
			};
		}
	}
}

pdftk
pdftk ist eine Open Source Software, die es ermöglicht, PDF-Dateien per Kommandozeile zu bearbeiten. Zu den vielfältigen Features von pdftk gehört etwa die Möglichkeit PDFs übereinander zu legen.

pdftk statisch kompilieren

Einleitung
Möchte man pdftk statisch kompilieren, um es etwa auf einem Hetzner Managed Server betreiben zu können, müssen die mitgelieferten Java Bibliotheken statisch kompiliert werden. Um dies zu erreich genügt es sowohl bei pdftk 1.21 als auch bei pdftk 1.41, die Makefiles
anzupassen – von Änderungen am Quelltext bleibt man verschont. Es ist übrigens durchaus sinnvoll, pdftk als 32bit Applikation zu kompilieren, denn nur so läuft es auf nahezu jedem Linuxsystem – ohne dass man sich auch noch mit Cross-Compiling herumschlagen muss.

Makefiles anpassen
Nachdem man pdftk heruntergeladen hat, das Archiv entpackt hat und in das neue Verzeichnis gewechselt hat, gilt es die Dateien Makefile.Base und Makefile.DEINE-DISTRIBUTION bzw. Makefile.Generic anzupassen. Diese befinden sich im Unterverzeichnis pdftk.

Makefile.Generic / Makefile.DEINE-DISTRIBUTION
In der Datei Makefile.Generic (bzw. in der Datei, die make mit dem Parameter -f übergeben wird, z.B. make -f Makefile.RedHat) werden die Flags für den Gnu Java Compiler GCJ gesetzt:

# itext compiler flags
export GCJFLAGS=

Um GCJ anzuweisen, die (mitgelieferten) Java Bibliotheken statisch zu kompilieren, müssen die GCJFLAGS wie folgt geändert werden:
export GCJFLAGS= -static

In diesem Makefile werden auch die Flags für den C++-Compiler g++ gesetzt.
Default hat die Entsprechende Konstante in dem Makefile Makefile.RedHat folgenden Wert:
CXXFLAGS= -lrt -ldl -lgcj

Auch diese Flags müssen angepasst werden:
CXXFLAGS= -W1,-v -static -W1,-Bstatic -lgcj -lpthread -lm -lz -ldl -lrt -W1,-Bdynamic -lsupc++ -lstdc++ -lc

Die Flags, die mit “-W1,” beginnen, werden an den Linker ld übergeben. Abgesehen von libc, libsupc++ und libstdc++ werden alle Bibliotheken statisch gelinkt, um deren dynamische Versionen auf dem Zielsystem nicht erforderlich zu machen (auf den Managed Servern von
Hetzner ist beispielsweise keine (dynamische) libgcj installiert).

Makefile.Base
In der Datei Makefile.Base werden Konfigurationen vorgenommen, die weniger Distributionsabhängig sind, als jene in den anderen Makefiles. Der Entwickler von pdftk hielt sie offenbar sogar für komplett Distributionsabhängig, deshalb wird dieses Makefile von allen anderen
eingebunden. Für das Vorhaben pdftk statisch zu kompilieren ist sie eigentlich uninteressant – es sei denn man erhält (wie bei mir während des Linkens von pdftk 1.41 passiert) eine Fehlermeldung im Stil von “multiple definition of `convert’”.
pdftk liefert nämlich selbst alte Java Bibliotheken mit. Im Beispiel von Convert reicht es die betreffende Zeile im Makefile auszukommentieren, um das Problem zu beheben:

libgcj_local_libs = \
$(java_libs_root)/java_local/security/security.a \
$(java_libs_root)/gnu_local/java/security/provider/provider.a \
$(java_libs_root)/gnu_local/java/security/security.a# \
#$(java_libs_root)/gnu/gcj/convert/convert.a

Tücken
GCC Versionen
Die aktuelle Version von pdftk stammt vom 28. November 2006 – anders ausgedrückt: pdftk wird nicht mehr aktualisiert. Da sich die GNU Compiler Collection jedoch mit jeder neuen Version ändert und beispielsweise strikter wird, was Syntax angeht, lassen sich pdftk Version 1.21 sowie pdftk 1.41 am besten mit alten Compilern kompilieren. Ich habe pdftk 1.21 erfolgreich mit GCC 3.4.5 kompiliert sowie pdftk 1.41 mit GCC 4.0.4. Statt sein System hierfür vollzumüllen
kann ich die Installation von Fedora Core 2 in einer VM (z.B. der kostenlose VMWare Server) empfehlen.

Statische Libraries mit “falschen” (unerwarteten) Dateinamen
Während des Kompilierens von pdftk werden u.a. die statischen Bibliotheken libgcj.a und libgcc_s.a erwartet. Sind die entsprechenden Pakete (meist libgcc-devel, libgcj-devel o.ä.) installiert, kann es trotzdem sein, dass die entsprechenden Dateien nicht vom Linker ld
gefunden werden können. In meinem Fall hat sich libgcj.a unter dem Dateinamen libgcj_bc.so versteckt, libgcc_s.a hieß libgcc_s.so.1. Ein Symlink (ls -s) auf den richtigen Dateinamen behebt dieses Problem.
Die GCC Bibliotheken befinden sich bei Linuxdistributionen standardmäßig im Verzeichnis /usr/lib/gcc/*/.

GCC 4.0.4 auf Fedora Core 2 kompilieren
GCC 3.4 ist auf Fedora Core 2 bereits installiert. GCC 4.0.4 kann auf einem der zahlreichen GCC Mirrors heruntergeladen werden.

GCC 4.0.4 habe ich wie folgt konfiguriert / kompiliert / installiert:
tar jxf gcc*.tar.bz2
cd gcc-*
mkdir objdir && cd objdir
../configure --enable-languages=c,c++,java --prefix=/opt --enable-threads=posix && make && make -k check
make install

Wer seinen Usern die Möglichkeit geben möchte Videos hochzuladen und beim Abspielen Kompabilitäts-Probleme vermeiden möchte kommt um FLV (Flash Video) nicht vorbei, denn den Flash-Player hat eigentlich jeder installiert und aktiviert. Der Download eines extra Players bzw. Codecs entfällt so auch bei exotischeren Betriebssystemen.

Mit FFmpeg lassen sich diverse Videotypen in das FLV Format konvertieren. Da man aus PHP Skripten heraus beliebige Prozesse mit den Rechten des Benutzers, der PHP ausführt, starten kann, lässt sich FFmpeg auch sehr gut in einem PHP Skript verwenden um Videos direkt nach dem Upload automatisch zu konvertieren.

1. Download, Kompilieren und Installation von LAME:
Auf Sourceforge gehen und aktuellste Version auswählen, Download URL kopieren und per wget auf dem Server herunterladen, also z.B. wget http://surfnet.dl.sourceforge.net/sourceforge/lame/lame-3.97.tar.gz
Nach dem Download den Tarball mit tar zxf lame-3.97.tar.gz entpacken und mit cd lame-3.97 in das Verzeichnis wechseln. Nun das Configure-Skript durchlaufen lassen, kompilieren und installieren: ./configure && make && sudo make install

2. Download, Kompilieren und Installation von FFmpeg:
FFmpeg Sources runterladen: wget http://ffmpeg.mplayerhq.hu/ffmpeg-export-snapshot.tar.bz2 , mit tar jxf ffmpeg-export* entpacken. Jetzt das Configure-Skript durchlaufen lassen, kompilieren und installieren: ./configure –enable-libmp3lame && make && sudo make install

3. FFmpeg von PHP aus starten:
<?php
system(”/usr/local/bin/ffmpeg -i input.mov -ar 22050 -ab 56 -aspect 4:3 -b 200 -r 12 -f flv -s 320×240 -acodec mp3 -ac 1 output.flv”);
?>

Tipp: Wenn FFmpeg den Start verweigert weil es libmp3lame.so.0 nicht finden konnte muss das Configure-Skript von LAME mit –prefix=/usr aufgerufen werden.

Ich habe mich dieses Wochenende endlich erfolgreich dazu zwingen können, an meinem Projekt für das Fach Techniklehre zu arbeiten. Meine Zielsetzung war es eine Software für das Ansteuern einer Relaiskarte in Delphi zu entwickeln. Nach zwei Tagen Arbeit bietet die Relaiskarten Software mit dem hübschen Namen “LPT Master” folgende Features:

- Relais können manuell ein/aus-geschaltet werden.

- Relais können automatisiert per Timer ein/aus-geschaltet werden. Trotz Ablaufs des Timers ist Jederzeit ein manueller Eingriff möglich!

- Timer-Konfigurationen können gespeichert und eingelesen werden

- Alle wechselnden, ausgehenden Werte werden geloggt und übersichtlich dargestellt – so versteht auch jeder die Funktionsweise

- Auf Wunsch setzt das Relaiskarten Programm bei seinem Start den LPT-Port auf den Wert 0

- Die zu benutzende Schnittstelle kann im GUI gewechselt werden

Das Relaiskarten Programm ist in englischer Sprache kommentiert, grundsätzlich aber selbsterklärend.

Die Benutzung des Programms ist kostenlos für den privaten Gebrauch. Wer die Relaiskarten Software kommerziell nutzen möchte, schickt mir bitte eine Mail an thorsten [AT] nerdcenter [DOT] de um sich über Lizenzkosten zu informieren.

Download: LPT Master

Das Ansteuern des LPT-Ports gestaltet sich mit Delphi sehr einfach – selbst für Einsteiger. Das folgende Programm zeigt, wie mit den Prozeduren der DLL-Datei inpout32.dll auf simple Weise Werte gesetzt werden können. Der Computer schaltet die Pins des LPT-Ports dann je nach Wert mit 5V TTL.

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;

type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
Button5: TButton;
Button6: TButton;
Button7: TButton;
Button8: TButton;
Button9: TButton;
Button10: TButton;
Button11: TButton;
Button12: TButton;
Button13: TButton;
Button14: TButton;
Button15: TButton;
Button16: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button9Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;

var
Form1: TForm1;
value: Byte;

procedure Out32(wAddr:word;bOut:byte); stdcall; external ‘inpout32.dll’
function Inp32(wAddr:word):integer; stdcall; external ‘inpout32.dll’

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
value:=$00;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
value:=value OR (StrToInt((Sender AS TButton).Caption));
Out32($378,value);
end;

procedure TForm1.Button9Click(Sender: TObject);
begin
value:=value AND (255-(StrToInt((Sender AS TButton).Caption)));
Out32($378,value)
end;

end.

Zum Verständniss:

Wird der Binärwert 0000 0001 (was Hex $01 entspricht) an den LPT-Port gesendet, so wird der erste Pin geschaltet. Wird der Binärwert 0000 1000 (was Hex $08 entspricht), so wird der 4. Pin geschaltet.

Wer eine günstige Möglichkeit sucht um Geräte mit dem PC ein- und ausschalten zu können, wird sich für Relaiskarten interessieren. Sie sind bereits für 25 Euro als Bausatz zu haben und reichen für viele kleine Aufgaben, etwa dem zeitgesteuerten Einschalten verschiedener Lichtquellen oder gar Wasserpumpen während des Urlaubs, vollkommen aus.

Ich habe mich für eine Relaiskarte von Kemo entschieden. Diese wird via LPT mit dem PC verbunden und kann anschließend mit der mitgelieferten Software (DOS – Windows XP) bzw einer Eigenentwicklung angesteuert werden.

Da mir die Software, die der Relaiskarte beilag, für meine Zwecke ungeeignet erschien, entschloss ich mich für letzeres. Besonders einfach lässt sich der LPT-Port, an dem die Relaiskarte hängt, mit Delphi ansteuern. Am leichtesten geht dies mit der DLL inpout32.dll, die auf logix4u.net zum Download bereitsteht. Der folgende Code binded inpout32.dll in ein Delphi Programm ein:

procedure Out32(wAddr:word;bOut:byte); stdcall; external ‘inpout32.dll’
function Inp32(wAddr:word):integer; stdcall; external ‘inpout32.dll’

Um anschließend einen Wert an den LPT-Port zu senden genügt Out32($378,$02); – mit diesen Parametern wird z.B. eine 2 an den 1. LPT-Port gesendet. Um von dem LPT zu lesen benutzt man Inp32($378).