(For an English version, see below)

Deutsch

Einführung

GreenJ Logo

GreenJ ist eine Open-Source Voice-Over-IP Software aufbauend auf Qt und PJSIP. Das Programm bietet die Möglichkeit ein eigenes VoIP-Telefon zu erstellen. Wir haben uns dazu entschlossen, nicht das komplette Telefon mit Benutzeroberfläche in Qt zu realisieren, sondern nur die Funktionalität eines Telefons und eine einfach anzusprechende Schnittstelle zu bieten. Die gesamte Programmlogik und Benutzeroberfläche kann in HTML und Javascript geschrieben werden. Zentrales Element ist daher der integrierte Browser (Qt bietet Webkit als Browser Engine) und die Javascript-Schnittstelle mit der sich das Telefon steuern lässt.

Dadurch kann zum Beispiel eine auf dem eigenen Server laufende Web-Applikation, wenn sie in GreenJ geöffnet wird, mithilfe unserer Javascript-Library als Telefonsystem dienen. Eine einmalige Installation von GreenJ ist bei den Benutzern notwendig, anschließend sind jedoch Änderungen ohne Update wirksam, da die Programmlogik in der Web-Applikation steckt.

Ziele

Eine Callcenter Implementation in GreenJ

Eine Callcenter Implementation in GreenJ

Open-Source

Wir verwenden die GPLv3 Lizenz (siehe unten); Qt (LGPLv2) und PJSIP (GPLv2)

Plattformunabhängig (Windows, Linux; später auch Mac OS X)

Sowohl Qt als auch PJSIP sind plattformunabhängig. GreenJ ist unter Windows XP, Windows 7 und Linux erfolgreich getestet.

Trennung zwischen VoIP/Kommunikation und Programmlogik / Benutzeroberfläche

Durch integrierten Browser und einfacher Javascript-Schnittstelle mit der darin aufgerufenen Webseite bzw. -anwendung.

Programmaktualisierungen nur selten notwendig

Die gesamte Programmlogik und die Benutzeroberfläche können unabhängig von GreenJ upgedated werden.

Unterschiedliche Telefonsysteme in der selben Anwendung

Die im Browser aufgerufene Webseite steuert das Telefon, kann also als Telefonsystem verstanden werden.

Verbindung mit Telefonanlage (z.B. Asterisk)

Mittels PJSIP kann eine Verbindung mit einem SIP Account auf einer Telefonanlage hergestellt werden.

Voraussetzungen

Windows

Wurde GreenJ mit Visual C++ 2008 kompiliert, kann die Ausführung des Programms eine Installation des “Visual C++ 2008 Redistributable Package” benötigen.

Falls Sie GreenJ selbst kompilieren und erstellen möchten: Das Programm hat zwei Abhängigkeiten, welche wir nicht mit dem Quellcode mitliefern:

Optional:

  • Microsoft Visual Studio 2008 (Express Edition ist ausreichend)

Linux

  • GNU gcc/g++ Kompiler
  • Qt-dev Pakete (empfohlene Version 4.7 oder höher)
  • PJSIP (1.10 oder höher)
    http://www.pjsip.org

GreenJ kompilieren

Windows (Microsoft Visual Studio 2008)

  1. Qt downloaden und installieren (z.B. “Qt libraries 4.7.4 for Windows (VS 2008)” von http://qt.nokia.com/downloads)
  2. Umgebungsvariable mit Namen “QTDIR” und Wert “Pfad/zu/Qt” (z.B. “C:\Qt”) hinzufügen. Optional: “Pfad/zu/Qt/bin” an Systemvariable “path” anhängen, sodass alle benötigten DLL Dateien gefunden werden.
  3. PJSIP downloaden und entpacken (z.B. “pjproject-1.10.zip” von http://www.pjsip.org/download.htm)
  4. GreenJ Quellcode downloaden und entpacken oder GitHub Repository klonen.
  5. Öffnen der VS2008 Solution Datei “greenj.sln”
  6. Entweder den Pfad im Property Manager setzen (6A) oder die pjsip libs zum GreenJ Quellcode kopieren (6B).
    1. Ändern der Property PJSIP_INCLUDE_DIR im Visual Studio Projekt unter Property Manager > Debug und Release | Win32 > greenj > Properties > User Macros > PJSIP_INCLUDE_DIR.
    2. Oder folgende Ordner von “Pfad/zu/pjproject-1.xx” nach “Pfad/zu/greenj/lib/win32/pjsip” kopieren:
      1. pjlib
      2. pjlib-util
      3. pjmedia
      4. pjnath
      5. pjsip
      6. third_party
  7. Erstellen/kompilieren von GreenJ im Debug oder Release Modus (greenj.exe befindet sich anschließend im bin/ Ordner).

Linux

  1. Qt-dev Pakete über den Paketmanager der Distribution installieren
  2. PJSIP downloaden und entpacken (z.B. “pjproject-1.10.tar.bz2″ von http://www.pjsip.org/download.htm)
  3. GreenJ Quellcode downloaden und entpacken oder GitHub Repository klonen.
  4. PJSIP kompilieren und entweder die Libs zum GreenJ Quellcode kopieren (“Pfad/zu/greenj/lib/linux/pjsip”), die Pfade in build/greenj.pro anpassen oder pjsip in die Systemlibs installieren
  5. Im Build-Ordner (“Pfad/zu/greenj/build”) GreenJ Makefile erstellen (qmake) und kompilieren.
  6. Die ausführbare Binärdatei befindet sich anschließend unter Pfad/zu/greenj/bin.

Für eine beispielhafte Schritt für Schritt Anleitung unter Ubuntu, siehe unsere Readme auf GitHub.

Lizenz

Wir lizensieren GreenJ unter den Bedingungen der GNU General Public License (GPL) Version 3.
http://www.gnu.org/licenses/licenses.html#GPL

Auslieferung

Windows

Die folgenden DLL Dateien werden von Qt benötigt (z.B. im Programmordner):
QtCore4.dll, QtGui4.dll, QtNetwork4.dll, QtWebKit4.dll, phonon4.dll
Die Dateien befinden sich unter “Pfad/zu/Qt/bin”.
Wir empfehlen zusätzlich den Ordner “imageformats” (unter “Pfad/zu/Qt/plugins”) mitauszuliefern, um zu verhindern, dass diverse Bilddateien vom integrierten Browser nicht dargestellt werden.
Hinweis: Beim ersten Starten von GreenJ wird ein Ordner namens “.greenj” im HOME Verzeichnis angelegt und die Datei “settings.conf” darin erstellt (z.B. “C:\Users\li\.greenj\settings.conf”).

Linux

Hinweis: Beim ersten Starten von GreenJ wird ein Ordner namens “.greenj” im HOME Verzeichnis angelegt und die Datei “settings.conf” darin erstellt (z.B. “~/.greenj/settings.conf”).

GreenJ anpassen

Die folgende Liste zeigt einige Stellen im Quellcode um das Programm an die eigenen Bedürfnisse anzupassen.

Eigenen User Agent setzen. (QWebView teilt in der aktuellen Version (4.7.4) mittels des User Agents mit, dass ein Touch Screen aktiviert ist. Dies kann zu unerwünschtem Verhalten bei der Interaktion mit Webseiten im Browser führen; z.B. bei der Google Maps Bedienung)
web_page.h: Aktivieren der Methode “userAgentForUrl”.

“Zurück” Aktion deaktivieren. (Dies verhindert, dass der Benutzer versehentlich die “Zurück”-Funktion des Browsers auslöst, wenn er die Backspace-Taste drückt; Hilfreich, falls die Telefon-Webseite hauptsächlich mittels Javascript gesteuert wird)
web_page.h: Aktivieren der Methode “triggerAction”.

Contextmenü (Rightsklick im Browser) und Entwickler-Tools im Release Modus.
gui.cpp: Suchen nach ‘Qt::NoContextMenu’ bzw. ‘QWebSettings::DeveloperExtrasEnabled’

Tastenkürzel hinzufügen
gui.cpp: Suchen nach ‘QShortcut’

Pfad der Konfigurationsdatei ändern
config_file_handler.cpp: Suchen nach ‘file_name_(QDir::homePath()+”/.greenj/settings.conf”)’

Standard-Einstellungen ändern (Falls Konfigurationsdatei nicht existiert / beim ersten Programmstart)
config_file_handler.cpp: ConfigFileHandler::init()
Dort kann auch die Standard-URL (‘my_settings_.setValue(“url”,’) der Telefon-Webseite gesetzt werden. Diese kann entweder eine URL (“http://your.phone.com”) oder ein Pfad (“../testphone/index.html”) sein.

Eigene Qt GUI Elemente einfügen
Obwohl die Benutzeroberfläche mittels HTML erstellt werden kann, besteht die Möglichkeit Qt GUI Elemente zu verwenden (oder die gesamte Oberfläche in Qt zu erstellen). Siehe gui.ui, gui.h und gui.cpp
Hinweis: Wenn Sie die Oberfläche mit Qt erstellen möchten, werfen Sie einen Blick auf den QtCreator.

Tasktray Menü ändern/ausblenden
gui.cpp: Gui::createTrayIcon()

Weitere Anpassungen:

Klingel- und Anrufton: In den Programmordner können Dateien mit den Namen “ring.wav” und “dialton.wav” gestellt werden, welche bei einem eingehenden Anruf bzw. beim Wählen, bevor der Gegenüber abgehoben hat, abgespielt werden.
Hinweis: Der Anrufton kann sich mit dem Ton von der Telefonanlage (z.B. Asterisk) überlagern.
Um die Dateinamen zu ändern entweder die Einträge in der settings.conf (“soundfile” und “sounddialfile”) editieren, und/oder die Standard-Einstellungen ändern (siehe weiter oben).

 

Falls Sie Verbesserungen am GreenJ vornehmen, würden wir uns freuen, wenn Sie diese mit uns teilen.
Natürlich sind wir offen für alle Vorschläge und würden gerne Ihr Feedback oder Kommentare hören.

 

 

Download

 


English

Introduction

GreenJ LogoGreenJ is an open source Voice-over-IP phone software using pjsip and Qt. It can easily be used to build your own VoIP phone system. Our approach was not to build a complete phone with user interface, but instead provide an application that handles only the communication. The program logic and user interface are separated from the application by using an integrated browser. We use webkit as browser engine, which is well integrated into Qt (QWebView). A Javascript interface handles all communications between application and webpage. This means that you can use GreenJ as it is and create your VoIP phone entirely in HTML and JavaScript.

You could, for example, create a web-application on your server. This web-application can use our Javascript library to handle all phone functionality. Now you have to distribute GreenJ to your users. No further client side updates are necessary, because the whole program logic is in your web-application.

Our Goals

A callcenter implementation in GreenJ

A callcenter implementation in GreenJ

Open-Source

GreenJ is under GPLv3 (see below); Qt (LGPLv2) and PJSIP (GPLv2)

Platform independent (Windows, Linux; later also Mac OS X)

Both Qt and PJSIP are platform independent. We tested GreenJ on Windows XP, Windows 7 and Linux.

Separate VoIP/communications from program logic and user interface

An integrated browser is used to display the user interface and our Javascript interface manages the communication between website and GreenJ.

Application updates should be rarely necessary

User interface and program logic can be updated independently from GreenJ.

Build different phone systems on top of the base application

Ability to connect to telephone/communication server (e.g. Asterisk)

PJSIP supports connections to SIP accounts on telephone systems.

Requirements

Windows

If GreenJ has been compiled with Visual C++ 2008, executing it might require the installation of “Visual C++ 2008 Redistributable Package”.

If you wish to build GreenJ for yourself: We have two dependencies, which we are not distributing with our source code:

Optional:

  • Windows: Microsoft Visual Studio 2008 (Express Edition is sufficient)

Linux

  • GNU gcc/g++ compiler
  • Qt-dev packages (recommended version 4.7 or above)
  • PJSIP (1.10 or above)
    http://www.pjsip.org

Building GreenJ

Windows (Microsoft Visual Studio 2008)

  1. Download and install Qt (e.g. “Qt libraries 4.7.4 for Windows (VS 2008)” from http://qt.nokia.com/downloads)
  2. Add an environment variable called “QTDIR” with value = “path/to/Qt” (e.g. “C:\Qt”). Optional: Add “path/to/Qt/bin” to your system variable “path”, so all necessary dll files are found.
  3. Download and unpack PJSIP (e.g. “pjproject-1.10.zip” from http://www.pjsip.org/download.htm)
  4. Download the GreenJ source code and unpack it or clone our GitHub repository.
  5. Open the VS2008 solution file “greenj.sln”
  6. Either change the path to pjsip in the property manager (6A) or copy all pjsip libs to the GreenJ source code (6B).
    1. Change the property PJSIP_INCLUDE_DIR in the Visual Studio project: Property Manager > Debug and Release | Win32 > greenj > Properties > User Macros > PJSIP_INCLUDE_DIR.
    2. Or copy the following folders from “path/to/pjproject-1.xx” to “path/to/greenj/lib/win32/pjsip”:
      1. pjlib
      2. pjlib-util
      3. pjmedia
      4. pjnath
      5. pjsip
      6. third_party
  7. Build the solution in Debug or Release mode.

Linux

  1. Install Qt-dev packages via package manager
  2. Download and unpack PJSIP (e.g. “pjproject-1.10.tar.bz2″ from http://www.pjsip.org/download.htm)
  3. Download the GreenJ source code and unpack it or clone our GitHub repository.
  4. Compile PJSIP and either copy the pjsip libs to the GreenJ source code (“path/to/greenj/lib/linux”), set the paths in build/greenj.pro or install pjsip to your systemlibs.
  5. Create Makefile with qmake in the build directory (“path/to/greenj/build”) and compile it.
  6. The executable binaries can be found in path/to/greenj/bin.

For step by step instructions on Ubuntu, see our readme on GitHub.

License

We license GreenJ under the terms of the GNU General Public License (GPL) version 3.
http://www.gnu.org/licenses/licenses.html#GPL

Deployment

Windows

The following DLL files are needed by Qt (e.g. in the program folder):
QtCore4.dll, QtGui4.dll, QtNetwork4.dll, QtWebKit4.dll, phonon4.dll
The files can be found in “path/to/Qt/bin”.
We also recommend to deploy an additional folder called “imageformats” (located in “path/to/Qt/plugins”) with GreenJ, otherwise the integrated browser might not be able to display various image files.
Note: When GreenJ is started for the first time, a new folder called “.greenj” is created in your HOME directory and the file “settings.conf” will be created (e.g. “C:\Users\li\.greenj\settings.conf”).

Linux

Note: When GreenJ is started for the first time, a new folder called “.greenj” is created in your HOME directory and the file “settings.conf” will be created (e.g. “~/.greenj/settings.conf”).

Change GreenJ to your needs

Once you have successfully built GreenJ, you can change the source code as you wish. The following is a list of places to start or to tweak some behaviour of the application.

Set your own user agent. (Due to an issue in QWebView (4.7.4) the standard user agent indicates, that a touch screen is enabled. This results in unexpected behaviour of some browser interaction; e.g. Google Maps navigation)
web_page.h: Delete comments from method “userAgentForUrl” to set your own user agent string.

Deactivate “Back” action. (It prevents the user from accidentially use the history-back function of the browser by pressing Backspace; Useful if your phone web page is controlled by Javascript only)
web_page.h: Delete comments from method “triggerAction” to catch and deactivate WebAction::Back.

Activate ContextMenu (Right-click in browser) or DeveloperTools in Release mode.
gui.cpp: search for ‘Qt::NoContextMenu’ or ‘QWebSettings::DeveloperExtrasEnabled’

Add custom shortcuts
gui.cpp: search for ‘QShortcut’

Change path of the config file
config_file_handler.cpp: search for ‘file_name_(QDir::homePath()+”/.greenj/settings.conf”)’

Change default settings (if no config file exists or application is started for the first time)
config_file_handler.cpp: ConfigFileHandler::init()
Here you can set the default url (‘my_settings_.setValue(“url”,’) to your phone web page. This can be an url like “http://your.phone.com” or a path like “../testphone/index.html”.

Add some Qt magic to your GUI
Although the user interface can be created using HTML, nothing prevents you from using some Qt GUI elements  in your application (or even create the whole user interface in Qt). See gui.ui, gui.h and gui.cpp
Note: If you want to create the GUI in Qt, take a look at QtCreator.

Change/disable tasktray menu
gui.cpp: Gui::createTrayIcon()

Additional adjustments:

Ring and dial tone: If you create sound files named “ring.wav” and “dialtone.wav” in your program folder, they will be played when an incoming call has been detected respectively a call has been made and not yet accepted.
Note: the dial tone could interfere with the sound provided by a telephone server (e.g. Asterisk).
If you want to change the sound file names, you can do this in the config file (settings.conf):
[gui]
soundfile=ring.wav
sounddialfile=dial_tone.wav
Or change the default settings (see above).

 

 

If you make improvements of any kind to GreenJ we would be glad if you share them with us.
We are also open to suggestions and would like to hear your feedback or comments.

 

Download