wtorek, 29 grudnia 2009

Symbian S60. Programowanie urządzeń mobilnych

Kupiłem książkę Pawła Gali o Symbianie wydaną przez wydawnictwo Helion. Z dużym zapałem zacząłem ją czytać. Podczas czytania zauważyłem, że styl pisania zaczynał być bardzo akademicki, co zmuszało mnie do przerywania lektury, żeby zastanowić się o co chodziło autorowi. Z wielkim trudem dobrnąłem do końca książki. I mam duże wątpliwości, co do tego kto ją powinien kupować i czytać. Pierwsze skojarzenie to studenci, którzy będą uczyć się programować na Symbiana. Oni są na dobrej drodze żeby kupić tą książkę i razem z wykładowcą na ćwiczeniach przerabiać wiedzę z tej książki. Druga grupa czytelników to ci, którzy już programują na Symbiana. Im bardzo polecam tą książkę ze względu żeby mogli uporządkować sobie wiedzę na temat programowania na Symbiana. Natomiast odradzam kupowanie tej książki ludziom, którzy wcześniej nie programowali na Symbiana, ponieważ w tej książce jest zawarta wiedza teoretyczna, bez praktycznie działających przykładów (czyli przygotowanych projektów z kodem do skompilowania). Są natomiast listingi, które tak naprawdę służą do pokazania jakiejś teoretycznej podstawy w kodzie. To już zmusza czytelnika do dużego wysiłku intelektualnego, żeby sprawdzić tą teorię w praktyce.

Z pierwszego rozdziału czytelnik dowie się o systemie operacyjnym Symbian i o jego budowie i zrozumie dlaczego jest to jeden z najbardziej restrykcyjnych systemów operacyjnych i jednocześnie bardzo trudnym w zrozumieniu. Istotne jest zrozumienie architektury EKA2. Z drugiego rozdziału można dowiedzieć się że jak trzeba przegotować warsztat programisty. Autor poleca żeby użytkownik instalował SDK S60 3rd FP2 i Carbide.C++. Właściwie to już trochę nie trafiony wybór, bo ja bym zaproponował instalowanie ADT ze stron Fundacji Symbian. Zmartwiło mnie, że to tylko wspomniał o Designerze UI twierdząc, że nie poleca używania tego kreatora bez znajomości teorii o programowaniu. Dzisiaj większość ludzi zaczyna naukę programowania właśnie od takich kreatorów. Zrozumiale jest to, że bez teorii nie ma sensu uczyć programowania, ale przecież można było krok po kroku pokazać gdzie wstawiać odpowiednie fragmentów kodów z listingów. Autor od razu przedstawia w rozdziale 3 architekturę GUI czyli framework AVKON. Podczas tej lektury zauważyłem że celem autora przedstawienie wiedzy niż pomóc czytelnikowi w zrozumieniu jej. Potem spróbowałem wykorzystać listingi do zbudowania sobie aplikacji. Nie udało się, bo listingi nie zawierały wszystkiego co było potrzebne do zbudowania tej aplikacji. Następnie wygenerowałem sobie projekt z Carbide, oraz zacząłem badać jakie są różnice z tym kodem autora, a tym z kreatora. Sęk w tym, że raz autor pisze o standardowym kodzie tj takim który nie uwzględnia wersji językowych, a potem nagle pisze o tworzeniu wersji językowych. Można było się pogubić w lekturze, pomimo że merytorycznie treść jest w porządku. Skończyło się na tym, że zrobiłem 2 wersje raz tylko z wersją angielską a raz z wersją polską. Tylko, że wersja polska nie poprawnie wyświetlała znaki polskie. Poszukałem na Forum Nokia rozwiązania problemu. Wymagało to podania makra CHARACTER_SET UTF8 w pliku lokalizacyjnym. Zadowolony, że uporałem się z problematycznym rozdziałem zacząłem czytać rozdział 4 o platformie bezpieczeństwa. Rozdział ten dość dokładnie omawia o uprawnieniach aplikacji i podpisywaniu aplikacji na Symbiana. Także bardzo dobrze omówił procedurę certyfikacji i sposób uzyskiwania identyfikatorów dla aplikacji w Symbian Signed. Według mnie to najlepiej napisany rozdział w całej książce. Tak zadowolony przeszedłem do czytania 5 rozdziału o emulatorze Symbiana. Jakoś nie darzę szczególną estymą ten emulator z tego powodu, że jest bardzo powolny i trzeba mieć dużo cierpliwości do niego. To co mnie zainteresowało to wykorzystanie narzędzi do diagnostyki czyli zainstalowania ecmtagent_cpp.sis i monitorowanie aktywności aplikacji w komórce z poziomu panelu diagnostycznego Carbide. Wcześniej w tym celu korzystałem tylko z AppTRK. Zawsze można coś dla siebie odkryć ciekawego. Od rozdziału 6 rozpoczyna się wykład o niuansach programowania w Symbianie. Jedyne co mogę uznać za plus to, że autor ustala terminologię w języku polskim dla programistów Symbiana. Rozdział 6 dotyczy konwencji nazewniczych. Tutaj miałem problem z szybkim załapaniem co powoduje ze dana klasa jest na stercie lub na stosie. Czy jest jakiś wyznacznik w kodzie co pozwala na rozróżnienie tego czy daną klasę należy nazwać z przyrostkiem C albo T? Jakoś to rozumiem, ale jeszcze brakuje mi wprawy w tym. Rudział 7 dotyczy obsługi wyjątków w Symbianie. Po prostu podczas tworzenia Symbiana trzeba było wymyślić jakiś sposób obsługi różnych problematycznych sytuacji. W tej sytuacji wymyślono cały unikalny mechanizm oparty na wyjściach, podwójnym konstruktorze, panikach, oraz stosu czyszczącego. Najcenniejszą informację dla mnie była informacja o pliku ErrRd, dzięki któremu programista czy użytkownik może dowiedzieć się o tym jaka panika wystąpiła. Rozdział 8 dotyczy używania deskryptorów. Deskryptory są po to żeby umieć zarządzać danymi w Symbianie. Zarówno tymi tekstowymi i jak binarnym. Szczerze mówiąc zawsze miałem problemy ze zrozumieniem dobrze deskryptorów. Po przeczytaniu tego rozdziału mam jeszcze większy mętlik w głowie - głownie dlatego, że trzeba będzie do każdego listingu zrobić wersję programu który pokazywałby to w działaniu. A tego jest bardzo dużo do przyswojenia i nie da się tego od razu zrozumieć. Czytając te listingi przyszła mi myśl, że skoro takich rzeczy w nauce C++ wystarczy zwykła aplikacja konsolowa to w tym przypadku też można byłoby sobie napisać aplikacje konsolowe i sprawdzać to w trybie debugowania na komórce. Myślę że bardzo to ułatwiłoby naukę. Zrobiłem przerwę w lekturze, czasami polecam przerwanie lektury książki jak okaże się za trudna i wrócić do niej po jakimś czasie. Rozdział 9 traktuje o tablicach dynamicznych. Ten rozdział koncentruje się na klasach typu CArray, o tym że niektóre klasy mają zdolność do wyszukiwania elementów, sortowania. To co mnie zainteresowało to mechanizmy zarządzania pamięcią. Będę musiał przemyśleć jeszcze raz ten rozdział przerabiając do każdego przypadku klasy odpowiedni przykład. to co wyróżnia Symbian od innych systemów operacyjnych to koncepcja aktywnych obiektów. To można potraktować jako pewnego rodzaju AJAX w aplikacji. Kod w aplikacji może zostać wykonany synchronicznie czy w wg odpowiedniej kolejności a także asynchronicznie czyli równolegle. Asynchroniczność zakłada istnienie stanów aplikacji co za tym idzie określanie informacjo o zdarzeniach. Każda klasę która ma być wykonywana w sposób asynchroniczny musi dziedziczyć od klasy CActive i być uruchamiana przez obiekt klasy CActiveScheduler, którzy często jest zwany Zarządcą Aktywności. Ma to sens bo sporo aplikacji na Symbiana, może działać w tle, co tez sprzyja pisaniu aplikacji, które mogą działać długi czas. To jednak trzeba kilka razy czytać ten rozdział. Pomyślałem, że warto by przeczytać cała książkę jeszcze raz pod katem panik różnego rodzaju oraz specjalne napisać takie kody źródłowe które by pokazywały wywołanie określonej paniki a to tak żeby wiedzieć czego unikać. Każdy system operacyjny który ma być wielozadaniowy ma w sobie wątki i procesy o czym omawia rozdział 11 W Symbianie można powiedzieć w dużym uproszczeniu, że proces to załadowana biblioteka bądź uruchomiona aplikacja w której działają różne wątki które wykonują różne zadania. To jak zostaną zadania wykonane zależy też od ustawionych priorytetów. Przynajmniej dzięki tej lekturze lepiej zrozumiałem mechanizmy synchronizacji od strony teoretycznej o semaforach, muteksach i sekcjach krytycznych oraz o klasie Rendezvous. Ponieważ nie miałem okazji do zastanawiania się nad takimi subtelnościami, to w większości ten temat będzie wymagał ode mnie kilkakrotnej lektury. Zauważyłem, że bardzo przyda się zastosowanie klasy RUndertaker w celach diagnostycznych do śledzenia działania wątków w aplikacji. Jak czytam od kilku dni tą książkę to tym coraz bardziej czuję bardzo skomplikowane mechanizmy, których nie da się zrozumieć bez eksperymentowania na listingach i czytania dokumentacji o samym systemie Symbian. Z taką raczej obawą, że nie zrozumiem wszystkiego do końca postanowiłem zrobić przerwę w lekturze. Gdy wróciłem do lektury to uświadomiłem sobie, że autor musiał zrobić pewnego rodzaju kompromis pomiędzy tym żeby w sposób treściwie przedstawić materiał a tym co jest dydaktyką. Kierując z lekturą w stronę bardzo świadomego i samodzielnego czytelnika aspirującego do poziomu wiedzy autora powoduje bardzo zawężenie grupy ludzi, którym ta książka może się przydać. Ja jako czytelnik zacząłem czytać o architekturze klient-serwer i odkryłem fakt, że prawie wszystko w systemie Symbian działa w architekturze klient - serwer. Prawie całą komunikacja w tym systemie od środka polega na tworzeniu sesji i podsesji. Bardzo trafna analogia, że sesja z podsesjami to taki kabel wielożyłowy. Podstawowa klasą odpowiedzialną za tworzenie sesji jest klasa RSessionBase, a za obsługę podsesji odpowiada klasa RSubSessionBase, natomiast serwer i jak klient tworzą instancje obiektów klasy CSession2 aby przesyłać wzajemnie komunikaty, które są obiektami klas TIpcArgs (po stronie klienta) lub RMessage2 (po stronie serwera). Tworząc serwer bazujemy na klasie CServer2. Zauważyłem, że te mechanizmy związane z uprawnianiami i z polityką bezpieczeństwa w tej architekturze mają kluczowa rolę. Po dość długim wprowadzeniu autor zaprezentował to na teoretycznym przykładzie serwera usług kryptograficznych. Znowu autor liczy na samodzielność czytelnika, że sam sprawdzi kod z listingów i przerobi to w kod projektu, a potem sam zaimplementuje klienta. Pomyślałem, że raczej lepiej to zaimplementować w postaci biblioteki dll niż uruchamianego serwera EXE. Ponieważ tworzenie bibliotek dll jest omówione na końcu książki to do tego przykładu warto powracać. Najbardziej zagadkowy okazał się rozdział o właściwościach i repozytoriach. Można przeczytać w nim jak Symbian przechowuje dane globalne o stanach różnych funkcji w komórce. Zaletą właściwości jest to że aplikacja która je zaimplementuje może je rozgłaszać ale już inny program w dowolnym momencie może odebrać tą informację. W architekturze serwer klient obydwie strony wiedzą o sobie nawzajem. Natomiast program który wykorzystuje klasę RProperty nie musi nic wiedzieć o tych klasach które wykorzystują te dane. Repozytoria to już taka specjalna biblioteka która stale przechowuje informacje nawet po restarcie komórki. Dostęp jest możliwy za pomocą obiektów klasy CRepository. W praktyce możliwy jest dostęp do repozytoriów systemowych takie jak stan sieci, profile użytkownika (czyli dostęp do ustawień użytkownika). Tak naprawdę lekturę książki rozpocząłem od rozdziału 14, w którym analizowałem kod z listingów jak tworzyć aplikację wielookienkową. Trochę to różni się od tego co potrafi zrobić kod za pomocą Designera UI z Carbide C++. Jak zwykle autor wymaga od użytkownika zaangażowania, żeby przerobił i uzupełnił kod z listingów w projekt do kompilacji. Czytając na przykład stronę 418 o klasach widoków mam wrażenie, że można pogubić się w tym jak napisać kod brakującej w listingach klasy. Zresztą za pierwszym razem mi nie wyszło. To co mnie zainteresowało też bardzo to aplikacje bez interfejsu użytkownika. I znowu skupiłem swoja uwagę na aplikacji konsolowej. Ten przykład co podał autor jest asynchroniczny co mnie zaskoczyło, że nie mogłem zamknąć tej konsoli w odróżnieniu od aplikacji konsolowej generowanej przez Carbide C++. Największe zdziwienie wywołał u mnie skrypt instalacyjny dla komórki z wyłączoną platformą bezpieczeństwa tak żeby mieć dostęp do plików w folderze !:sys/bin w celu uruchomienia. Potem częściowo to wyjaśniło się jak zacząłem czytać o tworzeniu plików zasobów dla aplikacji, która ma sama się uruchomić. Wyszło na to że aplikacja ma uruchomić się podczas startu systemu. Stosowanie globalnych okien dialogowych nie wymaga przygotowywania specjalnie plików zasobów w interfejsie UI S60 co sprawia że łatwo jest nimi zarządzać z poziomu kodu. Kod z listingów należy przerobić tak żeby działało w aplikacji HelloWorld z trzeciego rozdziału książki albo samodzielnie wstawić do kodu aplikacji GUI wygenerowanej przez Carbide. Autor omawia 5 klas okien dialogowych. Klasa CAknGlobalConfirmationQuery służy do wyświetlania okna dialogowego wyboru logicznego. Klasa CAknGlobalListQuery służy do wyświetlania listy wyboru. Klasa CAknGlobalMsgQuery może wyświetlić długi komunikat bo zawiera pasek przewijania. Klasa CAknGlobalNote wyświetla krótkie komunikaty z odpowiednią kategorią ikon, Natomiast klasa CAknGlobalProgressDialog pokazuje pasek postępu. Aczkolwiek trudno wymyślić sensowną aplikację bazującą na tym to jednak bardzo mogą się przydać przy wyświetlaniu komunikatów wysyłanych przez biblioteki dll, bądź przez aplikacje działające w tle. Najbardziej praktyczny rozdział z tej książki to rozdział o tworzeniu bibliotek dll. Tak naprawdę tworzenie bibliotek dll jest podstawą programowania na Symbianie, do takiego wniosku doszedłem podczas lektury tej całej książki. Są 2 rodzaje bibliotek ładowane statycznie i ładowane dynamicznie. W większości przypadków ładowanie statycznie jest najlepszym rozwiązaniem, ponieważ działa razem z aplikacją. Brak biblioteki powoduje, że aplikacja nie uruchomi się. Przykładem biblioteki statycznej jest Qt. Natomiast gdy istotna jest szybkość i wydajność to warto pomyśleć nad ładowaniem biblioteki polimorficznej do pamięci RAM. Bardzo ciekawie autor pokazał na listingach sposoby tworzenia takich bibliotek i kompilowania tego z linii poleceń. W listingach można zauważyć, że tak naprawdę programowanie na Symbiana w C++ wymaga znajomości wielu makr które w pewien sposób tworzą jakby nakładkę na język C++. Ostatni rozdział opisuje stosowanie podstawowych makr. Właściwie odebrałem wrażenie, że Ci którzy znają się na programowaniu w C++ mogliby rozpocząć od lektury tego rozdziału. Makra _DEBUG wskazują kompilatorowi że ten fragment kodu ma zostać skompilowany dla wersji debugującej. Makro EKA2 ma sens jak tworzy się wersje dla starszych wersji Symbiana. Bardzo użyteczne są __FUNCTION__ czy G_STRLOC makra które służą informowaniu o działaniu programu. Inne użyteczne makra to makra zapobiegające wyciekom pamięci, do których należy grupa makr rozpoczynających się od __UHEAP. Dobrze napisany kod na Symbiana to kod z makrami asercji. Makra które rozpoczynają się od __ASSERT pozawalają już na poziomie kodu sprawdzać wykonanie pewnych założeń i w razie czego wywołać panikę. Obecnie tą rolę zaczynają spełniać testy jednostkowe, które nie są częścią API Symbiana.

wtorek, 22 grudnia 2009

QML i Declarative UI

Tworzenie interesów użytkownika to bardzo trudne zadanie, szczególnie jak tworzy się tak jak strony internetowe. Zazwyczaj tworzy się jakiś framework UI i kompiluje się do jakiejś postaci binarnej. Na przykład piszesz kod w ActionScript 3, ale do opisu UI używasz składni MXML a skompiluje się to do postaci binarnego SWF . Piszesz kod interfejsu w XAML ale i tak efektem końcowym kompilacji jest plik wykonywalny.
Tworzenie interfejsu strony internetowej polega na pisaniu odpowiednich skryptów JavaScript i kodów CSS oraz HTML. Zaletą takiego podejścia jest to że można dynamicznie zmieniać zawartość interfejsu. Czy przeniesienie takiego mechanizmu do tworzenia aplikacji komputerowych i na komórki pozwoli na szybsze tworzenie efektywnego interfejsu użytkownika?

Jak można zauważyć duża popularność języków opisów deklaratywnego pozwoliło na oddzielenie prac nad wyglądem aplikacji od jej logiki. XAML czy MXML są językami deklaratywnymi które są potem przekształcane w odpowiedni kod do kompilacji. Natomiast próbą przeniesienia mechanizmu obsługi interfejsu aplikacji tak jak działa strona internetowa czy poprzez parsowanie i kompilację kodu skryptowego dzięki mechanizmowi JIT. Od dłuższego czasu Qt Nokia pracuje nad Qt Declarative UI. Jest to biblioteka która pozwala przy pomocy języka deklarytywnego QML bazującego na CSS3 i skryptów JavaScript budować layout aplikacji.

Ściągamy ftp://ftp.trolltech.com/qml/qt-4.6.0-declarative.zip
Wypakowujemy to w e:\qt-4.6.0-declarative
Otwieraramy QtCreatora 4.6 i importujemy plik declarative.pro następnie go otwieramy i na koncu kodu dodajemy

*-g++*: CONFIG += create_prl

Potem otwieram camand prompt który ustawia MinGW
wchodzę na e:\qt-4.6.0-declarative\src\declarative
i generuję pliki makefile

qmake

następnie generuje binaria dla wersji release i debug

mingw32-make all

pozostaje potem jeszcze przegranie plików

mingw32-make install kopiuje tylko wersję debug

E:\qt-4.6.0-declarative\src\declarative\.obj\QtDeclaratived4.dll
do E:\qt-everywhere-opensource-src-4.6.0\bin\QtDeclaratived4.dll
E:\qt-4.6.0-declarative\src\declarative\.obj\libQtDeclaratived4.a
do E:\qt-everywhere-opensource-src-4.6.0\lib\libQtDeclaratived.a

a także sami skopiujemy wersję release
E:\qt-4.6.0-declarative\src\declarative\.obj\QtDeclarative4.dll
do E:\qt-everywhere-opensource-src-4.6.0\bin\QtDeclarative4.dll
E:\qt-4.6.0-declarative\src\declarative\.obj\libQtDeclarative4.a
do E:\qt-everywhere-opensource-src-4.6.0\lib\libQtDeclarative.a
E:\qt-4.6.0-declarative\src\declarative\.obj\QtDeclarative.prl
do E:\qt-everywhere-opensource-src-4.6.0\lib\QtDeclarative.prl
E:\qt-4.6.0-declarative\src\declarative\.obj\QtDeclaratived.prl
do E:\qt-everywhere-opensource-src-4.6.0\lib\QtDeclaratived.prl

Na koniec potrzebne jest przekazanie plików nagłówkowych. Zaznaczamy poniższy kod i wklejamy do w oknie konsoli.

xcopy /E /Y ..\..\include\QtDeclarative %QTDIR%\include\QtDeclarative

Następnym krokiem będzie skompilowanie narzędzia interpertacji kodu QML czyli pliku qmlviewer.exe

W okno konsoli wpisujemy

cd ..\..\tools\qmlviewer

następnie

qmake

a potem w celu wygenerowania pliku qmlviewer.exe wpisujemy

mingw32-make release

Następnie kopiujemy plik E:\qt-4.6.0-declarative\bin\qmlviewer.exe tam gdzie mamy plik QtDeclarative4.dll czyli do E:\qt-everywhere-opensource-src-4.6.0\bin\qmlviewer.exe

Potem możemy otworzyć nowy projekt QML w QtCreatorze kliknąc w zakładkę Projekt oraz wskazać ścieżkę dla qmlviewer.exe czyli E:\qt-everywhere-opensource-src-4.6.0\bin\qmlviewer.exe

Mając już przygotowane Declarative zainstalowane API
warto przejrzeć przykłady z
E:\qt-4.6.0-declarative\examples\declarative

Jedyne wprowadzenie do Declarative UI to strona
oraz dokumentacja
Wygląda na to że w przyszłości będziemy tworzyć aplikacje QML na komórki z Symbianem
co widać na przykładzie kodów New Qt APIs Technology Preview 2 - Mobility Project
(instrukcja do tego jak to zainstalować jest na wiki i na forum)

Kiedy Ci ludzie odpoczną? Ciekawy jestem czy uda mi się skompilować qmlviewer w XM 5800.

czwartek, 10 grudnia 2009

Polskie środowisko programistów Symbiana

Rola Symbiana jako platformy programistycznej w Polsce została zauważona już dość dawno. Niektóre polskie firmy współpracują z Symbianem od samego początku.

Programowanie w systemie operacyjnym Symbian często jest traktowane jako coś bardzo elitarnego, co powodowało że lepiej było zrobić otoczkę tajemniczości ze względu na liczne umowy NDA czy zakazu pracy w konkurencji. Pośrednio powoduje to, że dotarcie do osób zajmujących się programowaniem na Symbiana nie jest takie łatwe. Odtąd kiedy pojawiły się portale społecznościowe to część programistów pozakładała sobie profile zawodowe. Pozwoliło prześledzić kariery tych ludzi. Najciekawsze będzie to w jakich firmach pracują. Daje to dość interesujący obraz tego jak szybko rozwija się społeczność Symbiana w Polsce.

Comarch w Krakowie i w Łodzi ma dział zajmujący się rozwijaniem technologi mobilnych na Symbiana. Bardzo aktywnie włącza się w prace rozwojowe badawcze nad rozwojem Symbiana. Silne inwestuje w edukację uniwersytecką czego przykładem jest inwestowanie w pracowników i w studentów. Warto zobaczyć kod źródłowy projektu 2 gier autorstwa Jerzy Chałupskiego i Pawła Piotrowicza. Bardzo często realizują odpowiednie zadania z zakresu programowania na Symbiana dla Nokii w metodyce Scrum. Pracownicy Comarchu, którzy mają dobre doświadczenie z programowaniem na Symbiana: Krzysztof Sołtysik (ASD), Krystian Jasiński (ASD), Maciej Sufa (ASD), Michał Czerwiec (ASD), Dominik Frankowski, Piotr Mądry, Grzegorz Gustof (ASD), Adrian Cichoń, Łukasz Sromek, Przemyslaw Jacak , Marcin Szymański, Grzegorz Wąchocki (ASD), Jerzy Suzanowicz

Psiloc to firma, która specjalizuje się od bardzo długiego czasu w tworzeniu oprogramowania na Symbiana. Program który jest wizytówką tej firmy to WorldTraveler. Programiści w tej firmie programują na Symbiana od samego początku tej platformy: Maciej Gawroński, Sławomir Baranowski, Jarosław Pelczar, Tomasz Polański, Maciej Kujałowicz.

Mobica to brytyjska firma, która ma 2 oddziały w Polsce: w Warszawie i w Łodzi. Wyspecjalizowała się w konsultacjach dla rynku telekomunikacyjnego na różne platformy programistyczne z preferencją programowania na Symbiana. Ludzie, którzy znają się na programowaniu na Symbiana to: Rafał Jańczyk, Grzegorz Kapusta Joanna Zolopa, Paweł Jankowski.

eLeader to lubelska firma wyspecjalizowana w tworzeniu oprogramowania biznesowego na Symbiana. Głównym ich priorytetem jest tworzenie oprogramowania dla bankowości mobilnej. Osoby które znają się na programowaniu na Symbiana to: Tomasz Włodzimierz Smutek i Karol Pawlik.

Fancyfon kolejna brytyjska firma która ma centrum rozwojowe badawcze w Otominie pod Gdańskiem. Mają też kilka produktów na Symbiana. Według mnie najciekawszy jest produkt MoDo czyli system pozwalający na pracę dziennikarzy w terenie za pomocą komórki. Jednak osobą odpowiedzialną za rozwój produktów opartych na Symbianie jest Bartosz Leoszewski.

Tieto międzynarodowy koncern IT działający głównie w technologiach programistycznych na urządzenia mobilne. Intensywnie rozwijają outsourcing na rzecz wielu firm. W Polsce mają swoje siedziby w Szczecinie i we Wrocławiu. Główni programiści od Symbiana w tej firmie to Piotr Staniszewski (ASD), Dariusz Rosołek (ASD), Piotr Orzechowski (ASD), Piotr Żabiński

BLStream ma siedzibę w Szczecinie i studio w Bydgoszczy oraz placówki we Wrocławiu i w Warszawie. Firma bardziej wyspecjalizowała się w tworzeniu prototypów na Symbiana i na inne platformy mobilne. Najbardziej znany opensourcowy projekt tej firmy to Open Video Hub Za kod źródłowy tego projektu odpowiada Sebastian Jędruszkiewicz Pracownicy którzy znają się na programowaniu na Symbiana to: Tomasz Dubik, Piotr Szmyt, Konrad Słowiński (ASD), Magdalena Mostek , Paweł Gala (ASD), Rafał Kocisz.

Teleca - szwedzka firma mająca oddział w Polsce w Łodzi. Głownie specjalizują się w pisaniu niskopoziomowych rozwiązań dla Symbiana, czyli głównie tutaj chodzi o przeprogramowanie systemu Symbian pod kątem określonych mikroprocesorów i układów scalonych. Większość programistów prowadzi też badania na poziomie akademickim: Piotr Gawroński, Bartłomiej Świercz (ASD), Oskar Kamiński (ASD), Maurycy Mikos.

Opera we Wrocławiu i w Warszawie tworzy wersję mobilną Opera Mobile. W Polsce z programistów Symbiana biorą przy tym udział m.in. Maciej Kasprzyk, Michał Zajączkowski, Łukasz Lipski, Damian Trelka

Programiści Symbiana są też potrzebni w centrach badawczo rozwojowych przy wdrażaniu nowych zastosowań telekomunikacyjnych u producentów urządzeń. W warszawskim Samsung Electronics Polska Sp. z o.o. pracuje m.in Michał Lipiński (ASD). Dla Motorola Polska Electronics Sp. z o. o. pracuje Piotr Dziewoński. Natomiast w Nokia Siemens Networks programowaniem na Symbiana znają się Justyna Żmuda i Bartłomiej Prędki .

Cybercom to firma, która ma oddziały w Warszawie i w Łodzi specjalizuje się w realizowaniu zadań dla firm telekomunikacyjnych dostarczając im rozwiązania z zakresu wykorzystania infrastruktury internetowej dla komórek z Symbianem. Pracownicy, którzy programują pod Symbianem to: Marek Bartosik (ASD), Konrad Marek Zapalowicz (ASD), Tomasz Kuczera, Robert Kowalski (ASD), Sławomir Firlej.

SMT Software to wrocławska firma która ma w swojej ofercie tworzenie oprogramowania mobilnego dla zarządzania flotą transportową i oprogramowaniem logistycznym. W tej firmie głównymi specjalistami od Symbiana są Jacek Munko, Roman Ludwicki Radosław Puścian, Tomasz Hołodniak.

Polidea to mała warszawska firma z duzym potencjałem rozwojowym dla technologii mobilnych, aktywnie intensywnie rozwijają cross-platform technologii mobilnych. Twórcy tej firmy mieli okazję programować na Symbiana: Jakub Lipiński i Piotr Wach. Przykładem ich współpracy jest kod źródłowy biblioteki s60-json-library.

W GG Network S.A. gdzie za rozwój mobilnej wersji Gadu-Gadu na Symbiana odpowiada Alexey Shabalovskiy

Od całkiem niedawna na studiach w Polsce na niektórych uczelniach można już poważnie postudiować programowanie na Symbiana duża zasługa tutaj Comarchu, który inwestuje w program edukacyjny na AGH od 2007 roku. Przykładowy plan zajęć z 2008 roku.Obecnie zajęcia prowadzi Jacek Danda. Natomiast za praktyki studenckie dla programistów Symbiana w Comarchu odpowiada Grzegorz Wąchocki. W 2009 roku rozpoczęły się intensywne prace nad stworzeniem platformy edukacyjnej MoTeCo do edukacji nad programowaniem Symbiana w ramach europejskiego programu Leonardo da Vinci.

Teleca też współpracuje z politechniką Łódzką tworząc projekt edukacyjny od 2008 roku zwany Akademią Symbiana. Jest to program studiów podyplomowych na których też przygotowuje się do egzaminów ASD. Warto zatrzymać się na tym programie prowadzonym przez Bartłomieja Świercza.

W Warszawie powstała raczej oddolną inicjatywa zwana Akademią Inżyniera "Szlif" ponieważ ma być coraz większe zainteresowanie tworzeniem aplikacji na urządzenia mobilne nie tylko na Symbiana ale i też na inne platformy programistyczne dla urządzeń mobilnych.

W Szczecinie firma BLStream podpisała umowę z Zachodniopomorskim Uniwersytetem Technologicznym o współpracy. Pozwoli to na lepsze kształcenie studentów w programowaniu na Symbiana.

Warto też zwrócić uwagę na inicjatywę Rafała Kocisza, który na łamach czasopisma Software Developer`s Journal napisał cykl artykułów o programowaniu na Symbiana pod tytułem "Programowanie gier dla Symbian OS" (Szkielet aplikacji w 09/08, Budujemy grę w 11/08, Rozwijamy grę w 12/08, Efekty specjalne w 1/09) Problem w tym, że nie można dostać się do listingów powiązanych z tymi artykułami.

16 grudnia 2009 wydawnictwo Helion wydało pozycję Symbian S60. Programowanie urządzeń mobilnych autorstwa Pawła Gali. Książka też ma kod źródłowy.

poniedziałek, 7 grudnia 2009

Debugowanie aplikacji Symbiana w komórce.

Bardzo ważną cechą w pracy programisty jest umiejętność używania debugera, tak żeby można było na bieżąco sprawdzać działanie programu. W środowisku Carbide.C++ można sprawdzać działanie programu na 2 sposoby: w emulatorze i na komórce. Najbardziej polecam sprawdzanie działanie programu bezpośrednio w komórce podczas gdy Carbide.C++ będzie informować o procesie debugowania.

Najpierw trzeba w swojej komórce zainstalować program App TRK którzy będzie przesyłał informacje do Carbide.C++ . Trzeba zwrócić uwagę na to, żeby pobrać wersję która będzie zgodna z komórką którą będziemy debugować aplikację. Na przykład dla 5800 XM pobieramy s60_5_0_app_trk_3_1_2.sisx.

Instalujemy App TRK w komórce (najczęściej za pomocą Nokia PC Suite). Komórka ma być połaczona kablem USB. Uruchamiamy App TRK w komórce. Wybieramy lewym softem menu Opcje -> Setting. Pojawi się wybór Connect to ustawiamy na USB. Komórka jest podłączona kablem USB to z Opcje wybieramy Connect. Pojawi się na wyświetlaczu komunikat Status Connected Connection:USB.

Uruchamiamy Carbide C++. Importujemy projekt E:\S60\devices\S60_5th_Edition_SDK_v1.0\S60CppExamples\helloworldbasic
Podczas wyboru SDK wybieramy Phone Debug (GCCE) [S60_5th_Edition_SDK_v1.0]. Po zaiportowaniu widzimy że mamy aktywny projekt Z menu Carbide.C++ wybieramy Project -> Properties. Pojawi się okno Properties for helloworldbasic. Z węzła Carbide.C++ wybieramy Build Configurations. Widzimy aktywną konfigurację na Phone Debug (GCCE) [S60_5th_Edition_SDK_v1.0]. W zakładce "SIS Builder" klikamy w Add. Pojawi się okno SIS Propories Z PKG File wybieramy sis\helloworldbasic_gcce.pkg. Upewniamy się że mamy zaznaczone Self sign sis file Klikamy w OK. Potem w przycisk Apply a następnie w OK. Więc już projekt mamy przygotowany do kompilacji.
Zanim weźmiemy się do kompilacji trzeba będzie zmienić w pliku sis\helloworldbasic_gcce.pkg
..\..\..\epoc32\release\gcce\urel\HelloWorldBasic.exe na ..\..\..\epoc32\release\gcce\udeb\HelloWorldBasic.exe
Zresztą pliki z SDK i tak muszą wymagać odpowiedniego przygotowania skryptów do instalacji. Po prostu trzeba wskazać gdzie kompilator umieścił wersję debugowaną.

Kompilację wykonuje się prosto. Z menu Carbide wybieram Project -> Build Project. Obserwujemy w oknie konsoli (Window -> Show View -> Console) komunikaty podczas kompilacji.

Następnie otwieramy plik src/helloworldbasicappui.cpp i przy linii 140 dla kodu
case EHelloWorldBasicCommand1:
stawiamy czujkę

Następnie z menu Run -> Debug As -> Debug Symbian OS Application. Może sie pojawić okno
"Application TRK Launch Configuration" > "Next" wybieramy połączenie USB Klikamy w Next to wstedy pojawi się USB Setting. Sprawdzamy czy Serial Port jest w liście rozwijanej nazwa komórki, w moim przypadku jest to COM7 Nokia 5800 XpressMusic USB Z listy rozwijanej Service OS wybieramy S60 5.0.0 Klikamy w Initiate Service testing i sprawdzamy czy doszło do połączenia. Pojawi się komunikat że mamy poprawna wersje zainstalowaną.

Z menu Run -> Debug powoduje otwarcie obszaru roboczego poświęconego debugowaniem. Carbide .C++ dokonuje kompilacji, pakowania w plik instalacyjny oraz instaluje w komórce i uruchamia w komórce. Gdy w uruchomionym programie w komórce uruchomię w menu to program zatrzyma się a w debugerze pokaże to że program zatrzymał się tam gdzie była postawiona czujka.
W obszarze roboczym debugowania w zakładce Debug warto używać przycisku StepOver (F6) pozwala to na prześledzenie krok po kroku działania programu. Natomiast w zakładce Variables śledzimy jak zachowują się zmienne. A dla odważnych polecam zakładkę Dissasembly, żeby nauczyć się asemblera ARM.

QtCreator 1.3 też ma możliwość pracy z App TRK. Upewniamy się że App TRK jest w komórce uruchomiony na USB. Uruchamiamy QtCreatora. w menu Narzędzia -> Opcje... uruchomi się okno Opcje. Wchodzimy w węzeł SDK S60 i sprawdzamy jakie mamy zainstalowane SDKi i czy są przypisane do odpowiedniego SDK Qt4.6

A więcej to można obejrzeć na tym filmie z Youtube

Hinduska impreza #fndc09

Nokia zorganizowała dla Hindusów imprezę programistyczną Forum Nokia Developer Conference - mogę na bieżąco śledzić informacje dzięki Twiterowi pierwszy raz mam wrażenie że to narzędzie staje się tak silnym narzędziem marketingu wirusowego którego jeszcze nie widziałem w ciągu minuty dostawałem kilkanaście wpisów z tej konferencji, tak jak bym był tam na żywo. Gdybym jeszcze na żywo ogladał przekaz multimedialny to byłby hit. Drugi aspekt że prezentacje muszą być profesjonalnie przygotowane z efektami interaktywną prezentacją - w przeciwnym razie trzeba liczyć sie z porażką i dezaprobatą wobec technologii.

Bardzo ciekawe są moje spostrzeżenia.
Silna promocja technologii widgetów wraz z ograniczeniami: nie można pobierać plików i jak nie można uruchamiać midletów. Bardzo dobrze przyjęto bibliotekę Qt pomimo braków czyli dostępu do API niskopoziomowego ( z powodu security) oraz instalatora poprzez OTA. Podstawą budowania aplikacji na Symbiana ma być OpenC/C++ a warto tworzyć aplikacje już w Qt. Tworzenie aplikacji na Symbiana ma opierać się na IDE takich jak Carbide.C++, Aptana oraz QtCreator. "Rezygnacja" z rozwoju midletów Java Mobile - nikt nie chce o tym pisać ani inwestować co powoduje niezadowolenie cześci programistów którzy postawili na tworzenie na masowo aplikacji na S40 i braku rozwoju usług SMSowych. Ponad przeciętne zainteresowanie programowaniem na Maemo. Wątpliwości programistów czy poznawać Sybmian C++ skoro maja uczyć się Qt który ma 12 modułów i ponad 700 klas API. W mniemaniu niektórych programistów wyszedł show marketingowy a myśleli, że czegoś się nauczą. Też był konkurs na który wysłano ponad 110 aplikacji.

BlueHome, rozwijany przez Binu i Irene z Excel Technologies oparty jest na Pythonie dla Symbiana, głównie użytkownikami mają być niepełnosprawni i niewidzący i używa układu scalonego który jest kontrolerem.
Srinivasan V z firmy Indiagames Ltd skoncentrował się na możliwościach grafiki 3D w komórach Nokii w prezentacji o możliwościach OpenGL ES 2.0. Maemo w N900 używa układu scalonego PowerVR SGX W tej firmie stworzono silnik ICE3D i pokazali to na przykładzie gry do baseballa na N900 w Maemo. Ponieważ N900 ma czujniki ruchu to sprawia że otwierają się nowe możliwosci w programowaniu gier. Ta gra miała 15 fps on 800x480 . Problem jest taki że jest nie wiele jest komórek z wsparciem ze strony procesorów grafiki. Są też problemy z poszczególnymi wersjami pomiędzy OpenGL ES, Open GL ES 1.1 a tą najnowszą OpenGL ES 2,0 ze wsparciem shaderów.
Prezentacja "Innovation in Mobile Applications" była prowadzona przez by Ankur Srivastav MobiMonster. Ta firma koncentruje się na tworzeniu middleware czyli niskopoziomowych silników dla aplikacji mobilnych na styku z częścią sprzętową czyli tworzą mechanizmy silników dla sms/mms, stosy telekomunikacyjne: GPS/GPRS, szyfrowanie rozmów. Jego główną ideą jest to innowacja w muzyce gdzie użytkownicy mogliby też tworzyć muzykę w komórkach i dzielić się nią. Sukces polega na tym, że potrafisz dzięki programowaniu coś stworzyć dla innych z pasją
Mr. Vijay z Interchange Solutions pracuje nad aplikacjami bazującymi na lokalizacji i zaprezentował Trackut Aplikacji dzięki której użytkownicy otrzymują informację o tym gdzie są.Opiera się to na oprogramowaniu GPSWatch i mapach OVI. Mają już 1.7 mln uzytkowników i dziennie rejestruje się ponad 300 użytkowników.
Amit z BIZense technologies zrobił prezentację o programiku w FlashLite Justdial dla FlashLite 2 i Flashlite 3, Flash Player 10 dla urządzeń mobilnych pojawi się w przyszłym roku. Justdial będzie zawierał integrację z OviMaps.
Fajnie że można spotkać sporo hinduskich programistów i geeków na Twiterze, którzy na żywo informowali o przebiegu konferencji: @uma_kanth @subbu16 @s0h4m @dhempe @ashwinbhatks, @tsuvik, @slakshmikanth, @jain_rajesh, @Deepaksegaran, @im2amit, @phoenicks, @vkvraju, @mynokiaworld, @pramodxyle.

czwartek, 3 grudnia 2009

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.

środa, 2 grudnia 2009

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.