Przygotowanie do programowania Qt 4.6 na Symbiana

Ostatni post zawierał informacje o tym jak powstawała biblioteka Qt na Symbiana. Teraz warto przygotować swój komputer do pracy do programowania biblioteki Qt. Zakładam że jest zainstalowane poprawnie SDK z Nokii (albo ADT z stron Fundacji Symbiana). Istotny jest wybór SDK-ów. Trzeba zainstalować S60 3rd FP1 SDK,S60 3rd FP2 SDK, S60 5th Edition v1.0 SDK, N97 SDK, albo Application Developer Toolkit i dodatki od Samsunga (DevPack v1.1 for Samsung i8910 HD oraz S60 3rd FP2) oraz SonyEricsson (Satio) . Następnie trzeba do do odpowiedniego SDK w którym chcemy pracować wgrać SDK dla OpenC/C++ 1.6. Dla każdego kto ma zamiar w Carbide C++ programować pod Qt 4.6 to musi pobrać patha x86Tools_3.2.5_Symbian_b482_qt.zip dla Windows XP / Vista / Seven. Trzeba to wypakować tam gdzie ma się zainstalowanego Carbide C++ w folderze \x86Build. Ci którzy używają Vista /Seven powinni zapoznać się z tą sekcją. Ja zainstalowałem najpierw Qt SDK for Windows* (283 MB) który zawiera kompilator MinGW, biblioteki pod Windows oraz QtCreator 1.3. Zazwyczaj zainstalujemy tym celu żeby nauczyć się programowania Qt. Trzeba wiedzieć, że później trzeba będzie odpowiednio przygotować pod pracę z Qt 4.6 SDK dla Symbiana.

Następnie pobieramy Qt 4.6 SDK dla Symbiana Instalujemy to na tym samym dysku co mamy zainstalowane SDKi Symbiana. Podczas instalacji pojawi się okno pytające się do którego SDKa Symbiana ma dodać pliki binarne biblioteki Qt dla emulatorów.

Użytkownicy XP / Visty / Seven muszą ręcznie dodać zmienne środowiskowe PATH na C:\Qt\4.6.0\bin; i restartować komputer (oraz ustawić uruchamianie pliku epoc.exe w trybie zgodności z XP). Następnym krokiem będzie aktualizacja Carbide C++ (istotne jest żeby zaktualizować kompilatora C:\Symbian\Tools\ADT_1.0\Carbide.c++\x86Build\Symbian_Tools\Command_Line_Tools\mwccsym2.exe do wersji większej niż 3.2.5, build 482). Programiści programujący na S60 3rd Edition, FP1 SDK muszą reinstalować bibliotekę RPipe z \Symbian\9.2\S60_3rd_FP1_3\RPipe_3.1.zip i wypakować to do folderu \Symbian\9.2\S60_3rd_FP1_3\Epoc32\ I no trzeba zamienić plik getexports.exe \Symbian\9.2\S60_3rd_FP1_3\Epoc32\tools\getexports.exe.

Najpierw zawsze preferuję sprawdzenie czy Qt będzie działać z linii poleceń. Po zainstalowaniu Qt 4.6 SDK dla Symbiana trzeba skonfigurować Qt z linii poleceń. Następnie trzeba skonfigurować Qt 4.6.0 żeby rozumiało polecenia dla kompilacji dla Symbiana. W folderze E:\Qt\4.6.0\ robimy plik wsadowy z poleceniem:

configure -platform win32-g++ -xplatform symbian-abld

Pojawi się monit pytający się jaką wersje chcemy używać wpisujemy 'o' jeżeli chcemy używać wersji Open Source Edition. Potem pojawi się następny monit z informacjami o licencjach, akceptujemy licencję LGPL wpisując 'y'. Trochę czasu potrwa Running syncqt.....

Kolejnym krokiem ma być dodanie ustawień dla systemu Windows w zmiennych środowiskowych. W większości przypadków wystarczy użyć Start ->Programy -> Symbian Foundation ADT v1.0 -> Carbide.c++ -> Configure environment for WINSCW command line (albo jak mamy tylko Carbide.c++ to trzeba użyć Start ->Programy -> Carbide.c++2.0 -> Configure environment for WINSCW command line, a potem Start -> Programy -> Qt for Symbian by Nokia v4.6.0 -> Qt for Symbian Command Prompt.

Z nieznanych mi powodów to nie zadziało więc postanowiłem ręcznie zmienić zmienną środowiskowej QMAKESPEC z 'win32-g++' na 'symbian-abld'. Gdy nam zechce się programować Qt pod Windows będzie trzeba z powrotem zmienić zmienną środowiskową QMAKESPEC.

Następnie wchodzę w jakiś projekt na przykład E:\qt\4.6.0\examples\widgets\analogclock i tworzę plik wsadowy z poleceniem cmd, który uruchamiam go. W oknie z linii poleceń wpisuję dla folderu E:\qt\4.6.0\examples\widgets\analogclock polecenie

qmake -v

to pojawi się

Qmake vesion 2.0.1a
Using Qt version 4.6.0 in E:\Qt\4.6.0\lib

Oznacza to tyle że mamy to już zainstalowane poprawnie i wystarczy wygenerować pliki konfiguracyjne dla projektu.

qmake -spec symbian-abld -r

Zostanie wygenerowanych sporo plików w tym folderze zawierające m. in. najważniejsze: Bld.inf i *.mmp oraz *.pkg. Jeżeli tych plików nie ma to oznacza że nie dodaliśmy do zmiennej środowiskowej PATH C:\Qt\4.6.0\bin; może być zamiast tego ścieżka dla Qt 4.6 SDK dla Windowsa czyli może być najpierw w PATH ścieżka C:\Qt\2009.05\qt\bin;. W tej sytuacji trzeba zmienić ścieżkę na C:\Qt\4.6.0\bin; tak żeby występowała najpierw. Następnie trzeba wpisać polecenie:

make

które z tych plików zrobi wersję binarną dla emulatora. Trochę to potrwa. Jeżeli w kodzie nie było błędów to można potem uruchomić emulator wpisując

make run

Jak chcemy już zrobić wersję na komórki wpisujemy

make release-gcce

Powstaną pliki binarne na komórkę, które potem trzeba przekształcić w paczkę. Wystarczy wpisać

make sis

Powyższe polecenia udają się pod warunkiem że mamy poprawnie skonfigurowane SDKi pod Symbiana. Podsumowując polecenie make które ma następujące argumenty:

debug-winscw - domyślne ustawienie które tworzy wersję binarną dla emulatora
debug-gcce - tworzy wersję binarną z informacjami do debugowania na komórkę przy pomocy kompilatora GCCE.
release-gcce - tworzy wersję binarną dla komórki przy pomocy kompilatora GCCE
run - uruchamia wersję binarną w emulatorze z projektu w danym folderze
sis - tworzy podpisaną paczkę do zainstalowania w komórce

Mamy 3 sposoby na tworzenie aplikacji: z poziomu Carbide C++, z poziomu QCreatora 1.3 i oczywiście z linii poleceń.

Zakładając że używaliśmy wcześniej Carbide.C++ (zarówno w wersji ze stron Nokii czy ADT ze stron Symbiana) to wystarczy wcześniej odpowiednio skonfigurować to IDE. W menu Carbide.C++ wybieramy Window ->Preferences -> (z listy) Qt. Klikamy w przycisk Add.. Pojawia się okno Add new Qt version gdzie trzeba podać ścieżki dla tej wersji co mamy zainstalowaną czyli u mnie to jest E:\Qt\4.6.0\bin oraz E:\Qt\4.6.0\include.
Klikam w Apply a potem w OK

Następnie trzeba stworzyć projekt Qt w Carbide.C++ używając z menu File -> New -> Qt Project. Zostanie uruchomiony kreator projektu Qt. Otwiera się okno New Qt Project Wizard. Z tego wybieramy z listy rozwijanej Qt GUI Main Window i klikamy w Next. Kolejne okno to New Qt Symbian OS C++ Project gdzie podajemy nazwę projektu. Nazwa projektu nie może zawierać spacji. Lokalizacja projektu musi być na tym samym dysku co zainstalowany Qt, SDK oraz CarbideC++ (u mnie to jest dysk E) i też nie może być spacji w nazwach folderów w ścieżce do projektu. Następne okno kreatora to Build Targets gdzie wybieramy sposób kompilacji dla projektu przy użyciu zainstalowanych SDKów. Do wyboru mamy:
Emulator Debug (WINSCW) tworzy wersję binarną dla emulatora Symbian w Windows.
Phone Debug | Release (GCCE) tworzą wersje binarne dla telefonu przy pomocy darmowego kompilatora GCCE, który zazwyczaj jest instalowany z odpowiednim SDK
Phone Debug | Release (ARMV5) tworzą wersje binarne dla telefonów przy pomocy kompilatora ARM RealView Compiler (RVCT). Ponieważ przeważnie nie mamy dostępu do tego kompilatora to pozostawiamy odznaczone. Kolejne okno kreatora to Qt Modules gdzie wybieramy moduły Qt które mają zostać użyte. Przeważnie do prostej aplikacji w celu przetestowania wystarczy to co jest. Ostatne okno kreatora to BasicSettings, gdzie podajemy nazwę głównej klasy, która zresztą jest nazwą projektu a także wygenrowany identyfikator UID3 i klikamy Finish

Możemy zauważyć jak wygląda dokument projektu

TEMPLATE = app
TARGET = QtWitaj
QT += core \
gui
HEADERS += QtWitaj.loc \
QtWitaj.h
SOURCES += QtWitaj.rss \
QtWitaj_reg.rss \
main.cpp \
QtWitaj.cpp
FORMS += QtWitaj.ui
RESOURCES +=
symbian:TARGET.UID3 = 0xE34838B0


Mamy już okno do pracy z kreatorem GUI jak wybierzemy prace z plikiem *.ui

Następnie z menu Window -> Show View -> Other... pojawi się okienko dialogowe i wybieramy z węzła Qt -> Qt C++ Property Editor i zmieniamy nazwę okna w Property WindowTitle na Witaj Świecie.

Można zmienić kod w pliku main.cpp na ten:

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QtWitaj w;
w.showMaximized();
w.show();
return a.exec();
}

i zapisujemy zmiany z menu wybieramy Run -> Run As... -> Run As Symbian OS Application i pojawia się okno New Launch Configuration Wizard i klikamy Finish i kompilujemy dla emulatora. Możemy sobie podziwiać w emulatorze.

Teraz pozostaje przygotowanie do uruchomienia w komórce Nokia XM 5800. Z menu Project -> Build Configuration -> Manage... i pojawia się okno dialogowe Add/Remove Carbide Build Configuration i z węzła S60_5th_Edition_SDK_v1.0 wybieram Phone Release (GCCE) i klikamy OK Następnie z menu Project -> Build Configuration -> Set Active -> Phone Release (GCCE) [S60_5th_Edition_SDK_v1.0].

Następnym krokiem będzie przygotowanie do robienia paczki instalacyjnej z menu wybieramy Project -> Properties i pojawi się okno dialogowe Properties for QtWitaj. Z węzła CarbideC++ wybieramy Build Configuration . Wybieramy zakładkę Add i z kolejnego okna dialogowego SIS Properties przy liście rozwijanej PKG File wybieramy QtWitaj_template.pkg i klikamy OK waracamy do poprzedniego okna dialogowego gdzie wciskamy Apply a potem OK.
Pozostaje już skompilowanie i zbudowanie paczki instalacyjnej wybieramy z menu Project -> Build Project. Trwa kompilacja i tworzenie paczki instalacyjnej QtWitaj_template.sisx

W komórce odinstaluję poprzednie wersje Qt 4.6 z poprzednich instalacji i uruchamiam E:\qt\4.6.0\qt_demos.sis w swojej Nokii XM 5800 . Po zainstalowaniu sprawdzam czy dema Qt zainstalowane działają.

W Project Explorator CarbideC++ klikamy 2 razy w QtWitaj_template.sisx i rozpoczynamy instalację poprzez Nokia PC Suite. W komórce uruchamiamy w Menu -> Aplikacje -> QtWitaj

Podczas tworzenia tej instrukcji oparłem się na materiałach z wiki dla programistów Symbiana dodałem w tym swoje spostrzeżenia jakie miałem z problemami podczas przerabiania tej instrukcji. Dla programistów preferujących Qt Creatora 1.3 polecam zapoznanie z filmami na blogu dla programistów Qt.

Qt 4.6 na Symbiana

Do przetestowania Qt4.6 w komórce to wystarczy wejść z komórką z Symbianem S60 3rd FP1, Symbianem S60 3rd FP2, Symbianem S60 5th (Symbianem^1) pod adres qt.nokia.com/phonedemos Instalator to paczka zawierająca biblioteki OpenC/OpenC++ 1.6, biblioteki Qt 4.6 i aplikacje (dema) pokazującym możliwości Qt. Aby zaprogramować swoją aplikację warto pobrać instalator SDK pod Windowsem. Trzeba znać ograniczenia jakie są w tym wydaniu biblioteki na Symbiana
Interesująca może być śledzenie listy bugów. Lista większych problemów z którym trzeba się liczyć i może zostaną poprawione.

Qt 4.6 w wersji dla Symbiana rozwijało się od marca 2008 roku. Główna zasługa Espena Riskedala (@snowpong na Twitterze) szefa zespołu który rozwijał kod na Symbiana.Na początek ludzie z Qt rozpoczęli współpracę z firmą Digia . Początkowo tym projektem było związanych 10 programistów. Pierwszą wersją dla publiczności wypuszczono w październiku 2008 "Pyramid" i bazujaca na Qt 4.4 i posiadała moduły QtCore, QtNetwork, QtGUI. W grudniu 2008 wypuszczono już wersję "Tower" już bazująca na Qt 4.5 z następującymi modułami QtSVG, QtDesktopServices. Następnie rozpoczęła się współpraca z firmami Nokia Sosco, Fundacją Symbian, które udziały wsparcia przy tworzeniu kolejnych wersji. W marcu 2009 wypuszczono wersję "Garden". Wtedy rozpoczęto prace nad stworzeniem modułu QtWebkit na Symbiana. W czerwcu wypuszczono wersję "Tower" Następnie doszły do współpracy firmy Accenture i Tieto. We wrześniu doszło generowanie wersji binarnych na bieżąco. W październiku zaktualizowano nową wersję silnika Webkit oraz wprowadzano wersję "Colossus". Postępy prac nad Qt dla Symbiana były pokazywane w Qt DevDays i jak na SEE09 W listopadzie było wydanie Qt4.6 RC1. 1 grudnia 2009 wypuszczono już wersję finalną Qt4.6.

Następnym krokiem ma być rozwój bibliotek rozszerzających możliwości Qt4.6 o możliwości charakterystyczne dla urządzeń mobilnych Qt Mobility Project. Potrzebne jest zrobienie lepszego instalatora bibliotek Qt a także prace nad obsługą OpenGL ES. W przyszłości będzie można się spodziewać środowiska Qt Creator online z mowhi.com i jak wsparcia przy tworzeniu aplikacji za pomocą QML.

Pozostało jeszcze czekać na wydanie 2 książek "The Definitive Guide to Mobile Qt: Symbian Development Platform" autorstwa Ray Rischpater i Dan Zucker wydawnictwa Apress oraz "Qt for Symbian" autorów Frank H. P. Fitzek, Tommi Mikkonen, Tony Torp wydawnictwa John Wiley & Sons.

Widgety - nowe technologie programistyczne

Tempo rozwoju technologii programistycznych do tworzenia widgetów jest zawrotne. Mam wrażenie, że każdy producent technologii na widgety chce promocji swojej technologii.

Wymusza to nową definicję widgeta jako aplikacji na inteligentną komórkę która jest napisana w języku skryptowym i może korzystać z interfejsu użytkownika danego urządzenia mobilnego. Cechą widgetów jest to, że korzystają z możliwości danego urządzenia (robienie zdjęć aparatem fotograficznym, korzystanie z informacji o położeniu urządzenia). Jest też warunek opcjonalny uznania za widget: umożliwia korzystanie z informacji w internecie oraz wykorzystanie HTML, JavaScript, oraz CSS. Technologia FlashLite też mieści się pod warunkiem, że możliwości urządzenia pozwalają na uruchomienie plików SWF wewnątrz widgetów, albo pobierania i uruchamiania plików SWF przez widgety.

Obserwując pojawianie się nowych technologii na widgety spowodowane jest zrozumieniem pewnej istotnej rzeczy - trzeba ułatwić ludziom tworzenie programów na inteligentne komórki. Nokia w 2007 roku wypuściła technologię Web Runtime (WRT), ale dopiero połączenie z Platform Services 1.0 w S60 5th sprawiło, że widgety i aplikacje Flash na Symbiana S60 5th zaczęły mieć dostęp do możliwości inteligentnej komórki.

29 czerwca 2009 opublikowano Nokia Platform Services 2.0 nowością jest dostęp API do robienia zdjęć dla widgetów. Natomiast 4 listopada 2009 wypuszczono WebRuntime Bridge API zestaw API które pozwalał na tworzenie widgetów dla Facebooka czy MySpace w widgetach WRT.

Firma Nitobi przez cały rok rozwijała framework JavaScript Phonegap dla widgetów bazujących na iPhone, Androida. Ostatnio we wrześniu 2009 rozpoczęły się prace nad przeniesieniem możliwości tej biblioteki do widgetów WRT Webruntime. Efektem tej współpracy było wypuszczenie przez 18 listopada 2009 Sony Ericsson WebSDK dla tworzenia widgetów na Symbiana i jak na Androida.

17 listopada wypuszczono Qt 4.6.0 Release Candidate 1 zawierające też biblioteki dla Symbiana. Sprawiło to, że Nitobi rozpoczęło prace nad nowym silnikiem dla widgetów dla Symbiana wykorzystującego Mobile Extensions for Qt for Symbian i dla Maemo.

Opera od dawna intensywnie rozwija technologie widgetów. Najpierw to były widgety w przeglądarce internetowej. Obecnie wraz z współpracą z operatorami telekomunikacyjnymi (Vodafone i T-mobile) rozwija silnik Opera Mobile dla Symbiana i dla Windows Mobile. 3 listopada Nokia ogłosiła wypuszczenie Opera Mobile 10 beta na komórki z Symbianem a 18 listopada wypuściła wersję na Windows Mobile. Więcej informacji można poczytać w tym artykule. Opera dla twórców widgetów przygotowała odpowiednie wersje Opera Widgets SDK Natomiast Vodafone 19 listopada w współpracy z Operą opublikował na Betavine swoje Widget SDK version 2.

Rywalizacja też dotyczy w sferze technologii widgetów na komputerach użytkowników. Opera wypuszcza 15 października 2009 specjalną wersję Opery 10.10 beta zamieniająca widgety Opery na aplikacje komputerowe. Adobe 17 listopada 2009 ogłosiło upublicznienie beta Adobe AIR 2.0 bazującego na najnowszym silniku Webkita (bazującego na Safari 4.0.3) A Microsoft 18 listopada 2009 ogłasza udostępnienie SDK dla Silverlighta 4.

Adobe chce w 2010 roku wypuścić wersję Adobe AIR dla nowych wersji urządzeń mobilnych. Kwestia w tym że do rywalizacji z Adobe AIR w tworzeniu aplikacji widgetów dla urządzeń mobilnych wkroczył Appcelarator Titanium (dla aplikacji Androida i iPhone)

Dużą niewiadomą jest rozwój widgetów na Windows Mobile 6.5. Na tej platformie operuje się na zmodyfikowanym silniku IE6. Po bliższym zapoznaniu się z dokumentacją i prostym przykładem mam wrażenie że możliwości są takie jak opisano w standardzie dla widgetów. Okazuje się że istnieje możliwość rozszerzania funkcjonalności widgetów poprzez napisanie własnych kontrolek ActiveX

27 września 2009 opublikowano JIL SDK wersion 1.1 beta 2 - jest to technologia tworzenia widgetów na komórki z LiMo i jest to preferowane przez Samsunga i Vodafone. Jeszcze nie ma urządzeń które by wspierały tą technologię.

Faktem jest to, że Symbian, PalmOS, Android czy iPhone a także Windows Mobile 6.5 pozwalają na tworzenie aplikacji składającej się głównie z skryptów JavaScript to w praktyce z racji różnych wersji wydań silnika Webkit oraz integracji z interfejsem użytkownika i możliwościami urządzenia a także mechanizmów wdrożenia, powoduje pewną problematyczność w tworzeniu aplikacji na urządzenia mobilne. Fragmentaryzacja i dość szybkie zmiany w rozwoju sprawiają że trzeba solidnie napracować się nad kodem tak żeby działał zgodnie wg możliwości różnych UI i jak możliwości urządzenia.

Aby jakaś mobilna aplikacja reklamowa trafiła do jak największego grona użytkowników różnych urządzeń mobilnych trzeba solidnie popracować nad wersjami JavaMobile, FlashLite, i oczywiście jako widgety dla najnowszych modeli urządzeń mobilnych (z równoczesnym tworzeniem wersji mobilnej strony WWW). A użytkownikowi inteligentnej komórki pozostawić wybór.

Na podstawie tych zbiegu okoliczności w premierach różnych technologii pozostaje pytanie o to jak będzie rozwijać się dalej tworzenie widgetów. Pierwszą rzeczą jaką można zauważyć to że w sferze technologii mobilnych zaczyna dominować silnik Webkit co paradoksalnie przy obecnym tempie implementacji ich powoduje że w najbliższych latach komórki będą bardziej "nowocześniejsze" niż ich odpowiedniki na komputerach. Następną rzeczą będzie to co nazywam udostępnieniem API urządzenia aplikacjom internetowym. Obecnie można by uznać że dostęp do danych o kontaktach, kalendarza, o pozycji komórki, pobraniu informacji o geolokalizacji, wykorzystanie sensorów - położenia, zbliżenia, obrotu, położenia kierunku świata, a także dostęp do multimediów: robienie zdjęć czy filmików będzie wymagało ustalenia jakiegoś standardowego API które by pozwalało na pisanie ujednoliconego kodu .JavaScript. Firma Nitobi już to zrobiła. Natomiast wielką niewiadomą są frameworki UI - właściwie każda technologia widgetów może mieć swoje preferencje Dla Symbiana są to WRTKit i jak Guarana UI, dla iPhone bazuje na jQTouch iUI powstają też różne próby tworzenia frameworków mobilnych z jQuery UI, mochaUI, YUI.

Podsumowując tworzenie widgetów na urządzenia mobilne szybko przekształci się w odrębną specjalizację która będzie wymagać od twórców dość specyficznej wiedzy z JavaScriptu i możliwości programistycznych jakie oferują poszczególne technologie w konkretnych systemach operacyjnych. Wraz z tym będzie coraz większa presja na szybszy rozwój silnika WebKit tak żeby przynajmniej pod Symbianem potrafił mieć takie same możliwości jak aplikacje pisane w JavaScript dla Androida czy dla iPhone.

Jednym z wartościowych źródeł które należy śledzić w tym temacie to Mobile Web Initiative. oraz ich blog W tym temacie istotne jest to, że już napisano szkic roboczy 15 października 2009, który opisuje jakie API ma być dostępne w Java Scripcie dla mobilnych widgetów

No to faktycznie, żyjemy w ciekawych czasach dla programistów i developerów.

Widgety na Symbiana i ich programowanie

Ponieważ możliwości inteligentnych komórek są często poza możliwościami przeciętnych programistów. Sukces Symbiana może opierać się na tym że daje duże możliwości tym co już umieją. Większość programistów w jakiś sposób zetknęło się z programowaniem w Java Script czy stylami kaskadowymi. Więc umożliwienie wykorzystania do programowania w tych technologiach na komórce daje o wiele większy potencjał popularności niż w przypadku tworzenia w natywnych technologiach typu Symbian C++ czy Java Mobile. Sukces iPhone czy Androida (a po części też WebOS Palma) polegał na tym że pozwalał programistom wykorzystać potencjał technologii internetowych w inteligentnych komórkach.

Na platformie Symbian można było już od dawna tworzyć aplikacje wykorzystujące potencjał wbudowanej przeglądarki internetowej a także z możliwości programowania w FlashLite osadzając je w aplikacji pisanej Symbian S60 w C++. Więcej informacji można znaleźć w dokumencie Flash Viewer Framework API łącznie z przykładem How to write a Flash Stub application to protect your SWF file?, natomiast w przypadku tworzenia aplikacji Symbian C++ wykorzystujących silnik przeglądarki internetowej warto zapoznać się z S60 Platform: Browser Control API Developer's Guide v2.0. Jedyny przykład jest zawarty w SDK i jak można też ściągnąć ze strony TSS001012 - Browser Control API: Cloning the connection for Download Manager. Ciekawostką jest to, że te technologia już istnieje sobie od 2004 roku ale jak wiadomo mało kogo to interesowało, albo jak kto to poznał to obowiązywało go przestrzeganie tajemnicy how-know.

W tej sytuacji powstawała idea widgetów na komórki. Więcej szczegółów można przeczytać w pracy doktorskiej Marcosa Caceresa z 2007 roku Ta praca to interesująca historia tego jak powstawała idea widgetów. Nokia w sierpniu 2007 roku wypuściła betę WRT Web Runtime S60 dla SDK S60 3rd Feature Pack 2. Możliwości tej platformy właściwie ograniczały się do wykorzystania potencjału samej przeglądarki S60 Web Browser. Potem wraz z pojawieniem się S60 5th wypuszczono wersję z WRT1.1 które zawierało programistyczny dostęp do danych z komórki. Jest to S60 Platform Services 1.0. Równocześnie Nokia opracowała pluginy do popularnych edytorów developerskich które pozwalały na tworzenie zawartości dla widgetów (dla Aptany, Dreamweawera, oraz VisualStudio). Aby ułatwić szybkie tworzenie zaawansowanych widgetów Nokia opracowała framework WRTKit. Jest zestaw bibliotek JavaScript dedykowany widgetom na Symbiana. Gdy Nokia wypuściła SDK dla N97 w kwietniu 2009 roku to do widgetów dodano nową funkcjonalność - homescreen, co pozwalało widgetom wyświetlać informacje na "pulpicie" komórki. Widgety WRT 1.1 w odróżnieniu od aplikacji na Symbiana miały dość ograniczone możliwości (nie pozwalały na dostęp do plików lokalnie). Idąc naprzeciw oczekiwaniom programistów Nokia wprowadziła nowe Platform Services 2.0 (tylko dla XM 5800 i dla N97) a także Web Runtime Bridge API które ma być dostępne dla wszystkich komórek obsługujących widgety. Na wiki jest dokumentacja tego co można się spodziewać po tej technologii.

Po bliższym spojrzeniu na to rozwiązanie okazuje się że do każdego widgetu będzie można dołączyć paczkę instalacyjną z serwerem HTTP który będzie komunikował się z widgetem lokalnie. Do tego serwera HTTP będzie można robić pluginy ECOM udostępniające funkcjonalności Symbianowego API. Idea całkiem ciekawa biorąc pod uwagę że już napisano takie rozwiązania wykorzystując Pythona S60.

Dla widgetów WRT była już próba napisania takiego serwera HTTP który udostępniałby widgetom API z Pythona takich jak dostęp do bazy danych, wykorzystanie Bluetootha, do wykorzystanie syntezatora mowy. Cały koncept polega na tym żeby zainstalować sobie Mobile Web Serwer z Pythonem albo PAMP z PHP i napisać sobie widget WRT, który byłby w stanie komunikować się z lokalnym serwerem co opisano w artykule How to utilize device resources from a WRT widget. Również można wykorzystać własny miniserwer napisany w Pythonie dla Symbiana co jest opisane w artykule How to access S60 resources in WRT or Flash Lite, using PyS60

Można powiedzieć że same aplikacje w Pythonie dla Symbiana też mogą pełnić funkcje widgetów czyli małych aplikacji rozrywkowych. Przykładem takiego rozwiązania jest framework Flyer współpracujący z FlashLite. Półżartem półserio można zrobić coś jak Adobe AIR na Symbiana czytają poniższe artykuły How to package Flash content in a Widget i How-to communicate with Flash Lite from Javascript in widget (WRT)

Jak tworzyć widgety?

Zainstalować edytor Aptana i plugin do tworzenia widgetów WRT.
Warto na początek wziąć udział w szkoleniu eLearningowym Nokii o widgetach Widgets for the S60 Platform E-learning Następnie ściągnąć sobie aktualna dokumentację Web Developer's Library. Trzeba dowiedzieć się jak importuje się widgety WRT i zacząć naukę na przykładach. Szczególnie polecam dla zaawansowanych RouteWidget Example AccuWidget Example Hue Widget Example a także przykłady aplikacji z fundacji Symbian SEE 2009 Widget OSCON 2009 Schedule Example Widget. Warto też postudiować wiki Forum Nokii i jak Fundacji Symbian

Kompilator ARM RVCT 4.0 for Symbian Foundation

W SDK przeważnie mamy pliki dla 2 kompilatorów GCCE i dla ARM RVCT 4.0 Ponieważ są pewne ograniczenia kompilatora GCCE do większych projektów warto używać kompilatora ARM RVCT. Od pewnego czasu jest coraz więcej dużych projektów OpenSource które są przenoszone na platformę Symbiana. Klasycznym przykładem jest projekt Qt 4.6 for Symbian, ale co z tego że zawiera kod źródłowy w repozytorium Git to jednak do kompilacji binarnej na komórkę jest potrzebny kompilator ARM RVCT który kompiluje wydajniej pod architekturę EKA2.

Ze względu na to że fundacja Symbian staje się być bardziej przyjazną programistom to postanowiono udostępnić kompilator ARM RVCT sporej rzeczy programistów OpenSource.

Instrukcja instalacji kompilatora
1. Wchodzimy na tą stronę https://silver.arm.com/login/
2. Rejestrujemy się
3. Gdy otrzymamy maila z potwierdzeniem rejestracji - logujemy się
4. Klikamy w link - "RVCT 4.0 for Symbian" download
5. Akceptujemy warunki licencji - wersja ta jest ograniczona tylko dla pojedynczych programistów pracujących w małych firmach zatrudniających do 20 osób
6. Pozostaje podanie numeru telefonu i podanie numeru karty Ethernet ( dla nie wtajemniczonych w wystarczy z linii poleceń wpisać "ipconfig /all" i szukamy adresu fizycznego "Karty Ethernet połączenia lokalne" i wpisujemy 12 znaków bez '-')
7. Pojawi się tekst pliku licencji i zapisujemy go na Pulpicie (albo tam gdzie go możecie potem znaleźć)
8. Rozpoczyna się ściąganie pliku zip 76MB
9. Wypakowujemy to w tymczasowym miejscu i uruchamiamy plik Setup.exe
10. Ustawiamy instalację na !:\Symbian\ARM (gdzie ! oznacza literę dysku w moim przypadku to było E:\Symbian\ARM
11. Pod koniec instalacji pojawi się ARM License Wizard i klikamy w Install Licence
12. Uruchomi się okno w którym klikamy Add i dodajemy plik licence.dat
13. Zamykamy instalatora

Okazało się że kompilator zainstalował się w E:\Program Files\ARM, ale okazało się że to nie działa tak jak bym oczekiwał. I raczej nie zanosi się z powodu zmian w architekturze.

Larry Knibb napisał

Apologies for the confusion. SBSv1 (abld) is __not__ being updated for RVCT4.
The reason is that this functionality is already available in SBSv2 (Raptor).
Abld is due for deprecation soon so we are not adding major functionality to
it. Raptor replaces abld as the build system for Symbian OS, so new
functionality will appear in Raptor only.

Coś mi się zastanawia że kolejne SDK i wersje Symbiana już nie będą zgodne z poprzednikami na poziomie binarnym (pomimo architektury EKA2), ale prawdopodobnie kod pozostanie ten sam pod kątem wykorzystania API Symbiana.

W razie czego też można by postarać się o nowszą wersję kompilatora GCCE zamiast czekać na SDK dla modeli z Symbian^2 i Symbian^3 Natomiast Symbian^4 to już zupełnie inna architektura sprzętowa i jak API tutaj trzeba już programować w Qt

Pierwsze kroki w Carbide C++

Od pewnego czasu obserwuję bardzo dużą popularność wśród programistów potrzebę programowania na Windows Mobile czy Androida i co najciekawsze na iPhone. Główny sukces tkwi w tym że programiści otrzymują potężne środowisko IDE, dzięki któremu projektant przed klientem szybko zrobi najpierw prototyp interfejsu użytkownika, designer zadba o kolorystykę i grafikę oraz zwróci uwagę na problemy z interakcją i wtedy do wszystko trafia w tym samym IDE do programisty który ma sprawić żeby to działało. Oznacza to że tak naprawdę programujemy na końcu. Programowanie na Symbiana jest bliższe programowaniu systemów operacyjnych czy gier. W tych przypadkach trzeba najpierw poznać abstrakcję czyli frameworki czy silnik gry oraz zapoznać się z API. Powoduje to pewne problemy z realizacją projektów. Zazwyczaj projektant musi znać frameworka UI czy silnik gry, żeby nie obiecywać czegoś co nie da się szybko zrobić. Specjalista od użyteczności też musi znać niuanse doświadczenia użytkowników z urządzeniami mobilnymi, bo często jest tak że wersja dotykowa na S60 5th powinna być inna niż ta z S60 3rd. Zaplanowanie i zaprojektowanie na Symbiana nie jest takie trywialne jak w przypadku jak się programuje pod IDE w trybie designera (w VisualStudio czy XCode) dla innych platform mobilnych. Jedno jest teraz pewne większość ludzi chce naukę programowania rozpoczynać nie od nauki programowania frameworka czy silnika gry tylko od zaprojektowania interfejsu użytkownika swojej aplikacji w designerze IDE. Nic nie poradzę na to, że ludzie szukają takiego sposobu nauki. Większość autorów książek dla początkujących poleca naukę od używania designera IDE dopiero potem przechodzą do tłumaczenia dlaczego tak zrobili, a teorię i API zostawiają na końcu. Skutkiem tego jest że ci którzy teraz się uczyli z książek programowania tak naprawdę zostają projektantami interfejsu aplikacji. Mała popularność programowania na Symbiana wynika z tego że najpierw trzeba poznać teorię (budowę frameworka AVKON, idomy Symbiana C++) a dopiero potem zmagać się z projektowaniem w IDE Carbide C++. Po części to wynika z tego że trzeba sporo czasu włożyć w przygotowanie środowiska pracy i instalowanie SDKów. Inny powód jest też taki że trzeba lubić C++, że zechcieć programować pod Symbianem profesjonalnie. Istotnym powodem dla którego ludzie zniechęcają się jest brak szerokiego wsparcia dla początkujących. Prawie wszystkie książki jakie napisano dla programistów Symbiana C++ są napisane jakby w stylu akademickim. I zakładają że wcześniej już cokolwiek programowałeś na Symbiana. Sporo piszą o API a za mało przykładów (jak przykłady są, to już jakby dla profesjonalistów). Przykładem dobrych książek dla początkujących tylko że dla programujących w Java Mobile są książki: J2ME Tworzenie gier Janusza Grzyba czy J2ME Praktyczne projekty Krzysztofa Rychlickiego-Kiciora. Tego czego brakuje dla początkujących to przepisu jak zrobić na szybko projekt aplikacji w Carbide C++. Zakładam że czytelnik ma skonfigurowane SDK i wie jak z linii poleceń korzystać przy kompilacji. Klienci czasami są wybredni i projekt aplikacji trzeba zrobić już tak szybko jak to się da.

Uruchamiamy Carbide C++ 2.0



Wybieramy z menu File -> New -> Symbian OS C++ Project



Pojawi się okienko kreatora Select type of project Wybieramy z węzła S60 GUI Application with UI Designer.





Pojawi się kolejne okno kreatora New Symbian OS C++ Project w którym trzeba podać nazwę projektu (nie może zawierać spacji, ani zaczynać się od liczby, ani zawierać polskich znaków). Należy też podać ścieżkę do folderu gdzie ma być projekt. I znowu w ścieżce projektu nie powinno być spacji. Nazwiemy projekt NaszProjekt Klikamy Next.



Pojawi się okno kreatora Symbian OS SDKs - Trzeba wybrać jaką wersję będziemy robić. Z węzła S60_5th_Edition_SDK_v10 zaznaczamy Emulator Debug (WINSCW). Klikamy Next




Pojawia się okno kreatora Application Properties gdzie zmieniamy Initial Languages z listy rozwijanej na Polish (27) Klikamy Next.



Pojawi się okno kreatora S60 UI Design Selection. Wybieramy Empty co oznacza że mamy większy wpływ na to co tam się pojawi. Klikamy Next.




Pojawi się okno kreatora Container Name and Type. Tutaj chodzi o to, że trzeba nazwać naszą klasę która będzie zawierała UI naszej aplikacji, czyli jest kontrolką widoku View a pochodną od klasy bazowej CCoeControl. Warto zaznaczyć, że trzeba wygenerować kod który będzie obsługiwał przełączanie się pomiędzy widokami aplikacji zaznaczając Support view switching. Klikamy Next.



Pojawi się okno kreatora Basic Setting które pokazuje wygenerowany identyfikator aplikacji. Klikamy Next



Pojawia się okno kreatora Project Directories który informuje nas jakie foldery w projekcie utworzy Klikamy Finish




Zostanie nam otworzone okno Projektu. Niektórym może okazać się że nic nie zobaczą. W tej sytuacji trzeba użyć z menu Window -> Show View -> Project Explorer a potem jeszcze raz Window -> Open Perspective -> Other. Pojawi się okno wyboru perspektywy i wybieramy Carbide C/C++ (default).





Trzeba się upewnić czy aplikacja będzie zapisywać naszą pracę w UTF-8. Z menu wybieramy Project -> Properties Pojawi się okno i ustawiamy Text file encoding na UTF-8 Klikamy Apply a potem OK




Zmienimy tytuł aplikacji z NaszProjektContainter na Nasz Projekt. Otóż klikamy na napis NaszProjektContainter z menu podręcznego wybieramy Show Properties View.


Pojawi się na dole zakładka Properties i weżle Data mamy właściwość title i wpisujemy tam jako Value:Nasz Projekt



Kolejnym krokiem będzie pokazanie jak dodać pozycję menu Klikamy w ikonkę optionMenu Pojawi się na projekcie Type here klikamy w to i wpisujemy ShowMe.



Robię to tak dlatego że nazwa ShowMe pojawi się w kodzie jako nazwa pewnych funkcji.
Nie polecam w momencie gdy coś wpisujemy w projekcie Designu używania polskich znaków zawsze je potem można zmienić z poziomu Show Properties View.




Zmienimy teraz to na Pokaż mnie. W zakładce Properties w węźle Appearance mamy Property text to ustawiamy to na Pokaż mnie.


Teraz zostało nam obsłużenie zdarzenia w momencie jak użytkownik kliknie na w menu na Pokaż mnie. Nad tekstem Pokaż mnie wywołujemy z menu podręcznego Handle Selected Event



Pojawi się okienko z monitem o zapisanie projektu



Potem pojawi się okno z kodem źródłowym



Tam gdzie mamy kursor to wpisujemy taki kod w następnej linijce iEikonEnv->AlertWin(_L("Witaj świecie !"));


Zapisujemy projekt wystarczy wcisnąć CTRL+S

Następnie wystarczy uruchomić w emulatorze. Z menu wybieramy Run ->Run (albo wciskamy CTRL+F11)


Klikamy Finish

Po paru minutach mnie wyszło po 5 minutach otwiera się emulator z programem który prze chwilą stworzyliśmy.



Wybieramy z menu Pokaż Mnie to emulator wyświetli komunikat bez polskich znaków tylko z jakimiś kwadracikami - Witaj świecie! Jest taka cecha przy programowaniu Symbiana że w kodzie raczej nie umieszczamy wyrażeń tylko w plikach zasobów (tym razem zrobiłem wyjątek).



Pokazuje tez że sporo plików zostało wygenerowanych przez Carbide.C++ na zrobienie szkieletu aplikacji.

Programowanie rozszerzen dla Pythona

Jedną z najbardziej popularnych paczek dla Pythona jest paczka zawierająca rozszerzenia binarne do Pythona 1.4.5 czyli PyModulePack. Do tworzenia rozszerzeń binarnych potrzeba ściągnięcia odpowiedniego SDK do właściwego systemu którego chce się tworzyć rozszerzenia Pythona. Dla E51 warto pobrać PythonForS60_1_4_5_SDK_3rdEdFP1.zip Po wypakowaniu kopiujemy foldery tam gdzie mamy zainstalowane S60 SDK 3rd Ed FP1. Następnie warto przestudiować jak wygląda tworzenie rozszerzeń binarnych na Pythona na podstawie artykułów z Nokia Forum: PyS60 creating extensions a także PyS60 extensions creation using Carbide. Istotne może być rozpoczecie pisanie własnych rozszerzeń na bazie artykułu Creating C Python extensions using Carbide.c++. Dla bardziej zaawansowanych polecam zapoznanie się z materiałem z wykładu Paula Wisnera ze szkolenia o tworzeniu rozszerzeń
Pomimo tego że Python jest dość elastycznym językiem programowania na komórki to trzeba pamiętać o tym że wersje binarne rozszerzeń nie są często kompatybilne ze sobą. W tej sytuacji warto dużą uwagę poświecić kodom źródłowym do tych rozszerzeń i w razie potrzeby kompilować je we własnym zakresie, szczególnie że będą 2 wersje silników Pythona: linia 1.4.x i linia 1.9.x / 2.0 ( w celu uniknięcia problemów nie powinno instalować się tych 2 silników na jednej komórce)
W teorii można by zrobić jeden duży projekt który by zebrał kody źródłowe rozszerzeń binarnych co umożliwiałoby szybką aktualizację pod kątem zmian i kompilacji pod różne wersje SDKów. Już istnieje taki projekt, PyS60 Community Edition ale on powstał w celu dostarczenia programistom możliwości tworzenia własnej dystrybucji silnika Pythona.
Dla Pythona S60 1.4.5 powstało wiele rozszerzeń co pokazują takie 2 wpisy:
PyS60 extensions i C++ Python Extensions

Warto zwrócić uwagę na strony gdzie są kody źródłowe dla rozszerzeń
Arkadius Wahlig: appuifw2
Mikko Ohtamaa, Simo Salminen, Jussi Toivola: uikludges
Tero Hasu: miso
Christophe Berger: elocation
Lee Chee Meng: applist
Cyke64: activeprofile, xprofile
Bea Lam: lightblue
Temu: pyExpat
Lefevre Damien: Pys60crypto, UItricks, Iapconnect, Appswitch, Akntextutils, Pys60usb, Tsocket, Dialog.