Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01291 014561 13625921 na godz. na dobę w sumie
Programowanie aplikacji dla urządzeń mobilnych z systemem Windows Mobile - książka
Programowanie aplikacji dla urządzeń mobilnych z systemem Windows Mobile - książka
Autor: , Liczba stron: 400
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2631-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie mobilne >> windows mobile
Porównaj ceny (książka, ebook, audiobook).

Zaprojektuj nowe aplikacje dla urządzeń mobilnych

Urządzenia przenośne, począwszy od telefonów komórkowych, a skończywszy na GPS-ach i kieszonkowych odtwarzaczach wideo, są dziś niezwykle popularne. Wiele z nich łączy w sobie tak przeróżne funkcje, że można je nazwać minikomputerami. Nic dziwnego, że pracują pod kontrolą uniwersalnego systemu operacyjnego, zdolnego obsłużyć wiele różnych aplikacji, który bez kłopotu można przenieść z jednego urządzenia na drugie. Podobna kompatybilność samych aplikacji gwarantuje możliwość ich wielokrotnego wykorzystania w różnych typach urządzeń, a użytkownikom zapewnia komfort błyskawicznego opanowania obsługi nowego telefonu czy aparatu fotograficznego.

W książce 'Programowanie aplikacji dla urządzeń mobilnych i systemu Windows Mobile ' omówione zostało projektowanie aplikacji napisanych w języku C# dla urządzeń działających pod kontrolą systemu Windows Mobile. Znajdziesz tu wszystkie aspekty pracy nad takim programem: począwszy od warunków środowiska programistycznego i uruchomieniowego, przez pisanie i testowanie kodu (z wyszczególnieniem elementów właściwych aplikacjom projektowanym dla platformy .NET Compact), aż po przechowywanie danych w plikach XML czy bazie SQL Server Compact. Dowiesz się także nieco więcej o wykorzystywaniu w urządzeniach przenośnych grafiki 3D.

Zagwarantuj uniwersalność swoich aplikacji - buduj je dla systemu Windows Mobile

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Idź do • Spis treści • Przykładowy rozdział Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2010 Programowanie aplikacji dla urz¹dzeñ mobilnych z systemem Windows Mobile Autorzy: Jacek Matulewski, Bartosz Turowski ISBN: 978-83-246-2631-1 Format: 158235, stron: 400 Zaprojektuj nowe aplikacje dla urz¹dzeñ mobilnych • Œrodowisko Visual Studio i szkic projektu • Wykorzystanie jêzyka C# i platformy .NET Compact • Zastosowanie grafiki trójwymiarowej z mobilnym Direct3D Urz¹dzenia przenoœne, pocz¹wszy od telefonów komórkowych, a skoñczywszy na GPS-ach i kieszonkowych odtwarzaczach wideo, s¹ dziœ niezwykle popularne. Wiele z nich ³¹czy w sobie tak przeró¿ne funkcje, ¿e mo¿na je nazwaæ minikomputerami. Nic dziwnego, ¿e pracuj¹ pod kontrol¹ uniwersalnego systemu operacyjnego, zdolnego obs³u¿yæ wiele ró¿nych aplikacji, który bez k³opotu mo¿na przenieœæ z jednego urz¹dzenia na drugie. Podobna kompatybilnoœæ samych aplikacji gwarantuje mo¿liwoœæ ich wielokrotnego wykorzystania w ró¿nych typach urz¹dzeñ, a u¿ytkownikom zapewnia komfort b³yskawicznego opanowania obs³ugi nowego telefonu czy aparatu fotograficznego. W ksi¹¿ce „Programowanie aplikacji dla urz¹dzeñ mobilnych i systemu Windows Mobile” omówione zosta³o projektowanie aplikacji napisanych w jêzyku C# dla urz¹dzeñ dzia³aj¹cych pod kontrol¹ systemu Windows Mobile. Znajdziesz tu wszystkie aspekty pracy nad takim programem: pocz¹wszy od warunków œrodowiska programistycznego i uruchomieniowego, przez pisanie i testowanie kodu (z wyszczególnieniem elementów w³aœciwych aplikacjom projektowanym dla platformy .NET Compact), a¿ po przechowywanie danych w plikach XML czy bazie SQL Server Compact. Dowiesz siê tak¿e nieco wiêcej o wykorzystywaniu w urz¹dzeniach przenoœnych grafiki 3D. • Œrodowisko programistyczne Visual Studio i emulatory • Tworzenie, zapisywanie i wczytywanie projektu • Uruchomienie aplikacji na rzeczywistym urz¹dzeniu • Jêzyk C# i praktyka projektowania aplikacji dla platformy .NET Compact • Projektowanie kontrolek i kontrolki charakterystyczne dla platformy .NET Compact • Studium przypadku – gra Reversi • Obs³uga podstawowych funkcji telefonu i programu Outlook • Detekcja stanu urz¹dzenia przenoœnego i dodatkowe funkcje urz¹dzeñ przenoœnych • Przechowywanie danych w SQL Server Compact i plikach XML • Grafika trójwymiarowa z mobilnym Direct3D • Instalacja Windows Mobile 6 Professional SDK Zagwarantuj uniwersalnoœæ swoich aplikacji – buduj je dla systemu Windows Mobile Spis treĈci Wstöp .............................................................................................. 9 Rozdziaä 1. Przygotowania ................................................................................ 11 ĝrodowisko programistyczne Visual Studio ................................................................... 11 Emulatory ....................................................................................................................... 12 Urządzenie przenoĞne ..................................................................................................... 15 Remote File Viewer i Remote Registry Editor ............................................................... 15 MyMobiler ...................................................................................................................... 18 Windows Mobile SDK ................................................................................................... 18 Kilka sáów o Windows Mobile ....................................................................................... 19 Rozdziaä 2. Pierwsze kroki ............................................................................... 21 Tworzenie i zapisywanie projektu .................................................................................. 21 Rzut oka na Ğrodowisko .................................................................................................. 24 Korzystanie z kontrolek do projektowania interfejsu aplikacji ....................................... 26 Zapisywanie i wczytywanie projektu .............................................................................. 27 Analiza kodu aplikacji .................................................................................................... 28 ElastycznoĞü interfejsu aplikacji ..................................................................................... 33 Metody zdarzeniowe ....................................................................................................... 35 Metoda zdarzeniowa reagująca na zmianĊ pozycji suwaka ...................................... 35 Testowanie metody zdarzeniowej ............................................................................ 36 Przypisywanie istniejącej metody do zdarzeĔ komponentów ................................... 39 Edycja metody zdarzeniowej .................................................................................... 40 Modyfikowanie wáasnoĞci komponentów ................................................................ 40 Wywoáywanie metody zdarzeniowej z poziomu kodu ............................................. 41 Uruchomienie aplikacji na rzeczywistym urządzeniu ..................................................... 42 Jözyk C# ........................................................................................ 45 Platforma .NET .............................................................................................................. 45 Cele platformy .NET ................................................................................................ 45 ĝrodowisko uruchomieniowe ................................................................................... 46 Kod poĞredni i podwójna kompilacja ....................................................................... 47 Nowe nazwy i skróty ................................................................................................ 47 Podstawowe typy danych ............................................................................................... 48 Deklaracja i zmiana wartoĞci zmiennej .................................................................... 48 Typy liczbowe oraz znakowy ................................................................................... 49 OkreĞlanie typu zmiennej przy inicjacji (typ var) ..................................................... 51 Operatory ................................................................................................................. 51 Rozdziaä 3. 4 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile Konwersje typów podstawowych ............................................................................. 53 Operatory is i as ....................................................................................................... 54 àaĔcuchy .................................................................................................................. 55 Typ wyliczeniowy .................................................................................................... 58 Delegacje i zdarzenia ................................................................................................ 59 WyraĪenia lambda .................................................................................................... 60 Typy wartoĞciowe i referencyjne .................................................................................... 62 Nullable .................................................................................................................... 63 Pudeákowanie ........................................................................................................... 64 Sterowanie przepáywem ................................................................................................. 64 Instrukcja warunkowa if..else ................................................................................... 64 Instrukcja wyboru switch ......................................................................................... 65 PĊtle .......................................................................................................................... 66 Zwracanie wartoĞci przez argument metody .................................................................. 67 Wyjątki ........................................................................................................................... 68 Dyrektywy preprocesora ................................................................................................. 71 Kompilacja warunkowa — ostrzeĪenia .................................................................... 71 Definiowanie staáych preprocesora .......................................................................... 72 Bloki ......................................................................................................................... 73 Atrybuty ......................................................................................................................... 73 Kolekcje ......................................................................................................................... 74 „Zwykáe” tablice ...................................................................................................... 74 PĊtla foreach ............................................................................................................. 76 Sortowanie ............................................................................................................... 78 Kolekcja List ............................................................................................................ 79 Kolekcja SortedList i inne ........................................................................................ 81 Tablice jako argumenty funkcji oraz metody z nieokreĞloną liczbą argumentów .... 81 Projektowanie typów ...................................................................................................... 82 Przykáad struktury (Ulamek) .................................................................................... 83 Nowa forma inicjacji obiektów i tablic .................................................................... 92 Implementacja interfejsu (na przykáadzie IComparable) .......................................... 92 Definiowanie typów parametrycznych ..................................................................... 94 Rozszerzenia .......................................................................................................... 101 Typy anonimowe .................................................................................................... 102 Zapytania LINQ na przykáadzie kolekcji ...................................................................... 103 Pobieranie danych (filtrowanie i sortowanie) ......................................................... 106 Najprostsza prezentacja pobranych danych ............................................................ 106 Kalkulacje .............................................................................................................. 106 Wybór elementu ..................................................................................................... 107 Testowanie danych ................................................................................................. 107 Prezentacja w grupach ............................................................................................ 107 àączenie zbiorów danych ....................................................................................... 108 àączenie danych z róĪnych Ĩródeá w zapytaniu LINQ — operator join ................. 109 MoĪliwoĞü modyfikacji danych Ĩródáa ................................................................... 109 Rozdziaä 4. Praktyka projektowania aplikacji dla platformy .NET Compact ....... 111 Rysowanie na ekranie ................................................................................................... 112 Obsáuga rysika ........................................................................................................ 113 Menu ...................................................................................................................... 115 Zmiana orientacji ekranu ........................................................................................ 118 Zamykanie i minimalizowanie aplikacji ................................................................. 118 Reakcja aplikacji na próbĊ zamkniĊcia okna .......................................................... 119 Okno dialogowe wyboru pliku ............................................................................... 121 Spis treĈci 5 Notatnik ........................................................................................................................ 124 Projektowanie interfejsu aplikacji .......................................................................... 124 Menu ...................................................................................................................... 125 Edycja ..................................................................................................................... 127 Menu kontekstowe ................................................................................................. 130 Okna dialogowe i pliki tekstowe ............................................................................ 131 Zamykanie aplikacji ............................................................................................... 136 Opcje widoku ......................................................................................................... 138 Drzewo katalogów ........................................................................................................ 138 Rozdziaä 5. Projektowanie kontrolek ............................................................... 147 Projekt kontrolki i budowa interfejsu ........................................................................... 147 WáasnoĞci ..................................................................................................................... 150 Aplikacja testująca ........................................................................................................ 150 Zdarzenia ...................................................................................................................... 152 Dodanie kontrolki do podokna Toolbox ....................................................................... 154 Rozdziaä 6. Studium przypadku — gra Reversi ................................................ 157 Tworzenie Ğrodowiska do testowania klasy .................................................................. 158 Pola, metody i wáasnoĞci. Zakres dostĊpnoĞci .............................................................. 160 Konstruktor klasy ......................................................................................................... 162 Interfejs aplikacji testującej .......................................................................................... 162 Implementacja zasad gry .............................................................................................. 165 Metody zdarzeniowe ..................................................................................................... 169 Elastyczny interfejs ...................................................................................................... 172 Korzystanie z zasobów ................................................................................................. 183 Wykrywanie szczególnych sytuacji w grze .................................................................. 183 Metoda sprawdzająca, czy gracz moĪe wykonaü ruch ........................................... 186 Warunki zakoĔczenia gry i wyáonienie zwyciĊzcy ................................................. 187 Indeksatory ................................................................................................................... 190 Menu ............................................................................................................................. 191 Dziedziczenie ............................................................................................................... 193 Jak nauczyü komputer graü w grĊ Reversi? .................................................................. 194 Metoda proponująca najlepszy ruch ....................................................................... 195 PodpowiedĨ i ruch wykonywany przez komputer .................................................. 197 Gra z komputerem .................................................................................................. 199 OpóĨnienie ruchu komputera ................................................................................. 200 Uzupeánienie menu ................................................................................................. 201 Co dalej? ....................................................................................................................... 202 Rozdziaä 7. Kontrolki charakterystyczne dla platformy .NET Compact .............. 203 InputPanel ..................................................................................................................... 203 Notification ................................................................................................................... 205 HardwareButton ........................................................................................................... 208 Rozdziaä 8. Obsäuga podstawowych funkcji telefonu i programu Outlook .......... 211 Cellular Emulator ......................................................................................................... 211 Podáączanie emulatora urządzenia przenoĞnego do programu Cellular Emulator .. 212 Kontakty Outlook ......................................................................................................... 213 Tworzenie aplikacji wyĞwietlającej listĊ kontaktów .............................................. 214 Tworzenie przykáadowych kontaktów .................................................................... 215 Edycja nowego kontaktu ........................................................................................ 216 Inicjowanie poáączeĔ telefonicznych ............................................................................ 218 Wysyáanie krótkich wiadomoĞci tekstowych (SMS) .................................................... 220 Przygotowanie projektu aplikacji sáuĪącej do wysyáania wiadomoĞci SMS ........... 221 6 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile Wybór adresata i wysáanie wiadomoĞci SMS ......................................................... 222 Numer telefonu w parametrach uruchomienia aplikacji ......................................... 224 Korzystanie z aplikacji wysyáającej SMS-y jak z okna dialogowego ..................... 226 Wysyáanie poczty elektronicznej .................................................................................. 228 Metoda wybierająca adres e-mail z listy kontaktów ............................................... 228 Wybór zaáącznika, komponowanie i wysyáanie listu e-mail ................................... 229 Korzystanie z aplikacji wysyáającej listy jak z okna dialogowego ......................... 232 Przechwytywanie wiadomoĞci SMS ............................................................................. 234 Tworzenie aplikacji przechwytującej wiadomoĞci ................................................. 234 Trwaáe monitorowanie wiadomoĞci ....................................................................... 237 Kalendarz i zadania ...................................................................................................... 239 Lista zadaĔ i terminów zapisanych w kalendarzu ................................................... 239 Dodawanie nowych terminów i zadaĔ .................................................................... 240 Rozdziaä 9. Detekcja stanu urzñdzenia przenoĈnego ........................................ 243 Wykrywanie dodatkowych urządzeĔ ............................................................................ 243 Bateria .......................................................................................................................... 247 Reakcja na zmianĊ stanu urządzenia ............................................................................. 248 Reakcja z uruchomieniem aplikacji .............................................................................. 250 Stan telefonu i poáączenia przychodzące ...................................................................... 256 Rozdziaä 10. Dodatkowe funkcje urzñdzeþ przenoĈnych ..................................... 261 Aparat fotograficzny i kamera ...................................................................................... 261 Obsáuga wbudowanego aparatu fotograficznego .................................................... 262 Wybór obrazu za pomocą okna dialogowego SelectPictureDialog ........................ 265 Film ........................................................................................................................ 266 GPS ............................................................................................................................... 267 Przygotowanie biblioteki ........................................................................................ 267 WyĞwietlanie informacji z moduáu GPS ................................................................ 268 Instalacja i uruchomienie aplikacji FakeGPS na emulatorze urządzenia przenoĞnego ............................................................... 270 Akcelerometr ................................................................................................................ 273 Rozdziaä 11. Przechowywanie danych w SQL Server Compact ............................ 277 Minimum wiedzy o SQL .............................................................................................. 277 Select ...................................................................................................................... 278 Insert ...................................................................................................................... 278 Delete ..................................................................................................................... 279 Update .................................................................................................................... 279 ADO.NET ..................................................................................................................... 279 Projekt aplikacji z doáączoną bazą danych ............................................................. 279 Konfiguracja komponentu DataSet ........................................................................ 281 Podgląd danych udostĊpnianych przez komponent DataSet ................................... 285 Prezentacja danych w siatce DataGridView ........................................................... 285 Projektowanie formularzy prezentujących pojedyncze rekordy ............................. 287 Sortowanie ............................................................................................................. 289 Filtrowanie ............................................................................................................. 290 Odczytywanie z poziomu kodu wartoĞci przechowywanych w komórkach ........... 290 Aktualizacja zmodyfikowanych danych ................................................................. 291 LINQ to DataSet ........................................................................................................... 294 Zapytanie ................................................................................................................ 294 Korzystanie z rozszerzeĔ LINQ ............................................................................. 295 DowolnoĞü sortowania i filtrowania pobieranych danych ...................................... 295 Spis treĈci 7 Rozdziaä 12. Przechowywanie danych w plikach XML (LINQ to XML) ................. 297 Tworzenie pliku XML za pomocą klas XDocument i XElement ................................. 298 Pobieranie wartoĞci z elementów o znanej pozycji w drzewie ..................................... 301 Przenoszenie danych z kolekcji do pliku XML ............................................................ 303 Przenoszenie danych z bazy danych (komponentu DataSet) do pliku XML ................ 304 Tabele w plikach XML. Zapytania LINQ ..................................................................... 306 Modyfikacja pliku XML ............................................................................................... 307 Serializacja obiektów do pliku XML ............................................................................ 308 Serializacja obiektu do pliku XML ........................................................................ 308 Deserializacja obiektu z pliku XML ....................................................................... 310 Rozdziaä 13. Grafika trójwymiarowa z mobilnym Direct3D .................................. 311 Szablon projektu aplikacji korzystającej z Direct3D .................................................... 312 Rysowanie trójkąta ....................................................................................................... 314 Trzy macierze ............................................................................................................... 317 Kamera i perspektywa ............................................................................................ 317 Poruszanie trójkątem za pomocą rysika ................................................................. 320 Obracanie trójkąta .................................................................................................. 323 Zmiana orientacji ekranu .............................................................................................. 325 Dygresja: sprzĊĪenie kamery z akcelerometrem ........................................................... 326 SzeĞcian ........................................................................................................................ 328 Teksturowanie .............................................................................................................. 331 OĞwietlenie ................................................................................................................... 335 Rozdziaä 14. Internet w aplikacjach mobilnych .................................................. 341 Poáączenie z internetem ................................................................................................ 341 Podáączanie emulatora urządzenia przenoĞnego do internetu ................................. 342 Internetowy táumacz ..................................................................................................... 344 Korzystanie z usáug sieciowych (web services) ............................................................ 348 Sposób pierwszy ..................................................................................................... 349 Sposób drugi ........................................................................................................... 351 Tworzenie wáasnej usáugi sieciowej ............................................................................. 353 FakeServer, czyli prawie serwer ................................................................................... 358 Dodatek A Instalacja Windows Mobile 6 Professional SDK ............................. 361 Dodatek B Przygotowywanie pakietów instalacyjnych aplikacji ....................... 365 Tworzenie projektu instalatora ..................................................................................... 365 Wybór plików ............................................................................................................... 367 Katalogi specjalne. Tworzenie skrótów ........................................................................ 368 Plik CAB ...................................................................................................................... 369 Instalacja ....................................................................................................................... 369 Instalatory platformy .NET i bazy danych SQL Server Compact ................................. 372 Skorowidz .................................................................................... 373 Rozdziaä 8. Obsäuga podstawowych funkcji telefonu i programu Outlook W tym rozdziale opiszĊ, jak z poziomu aplikacji moĪna uĪywaü funkcji urządzenia prze- noĞnego charakterystycznych dla telefonu komórkowego. Za ich obsáugĊ odpowiadają klasy doáączane do platformy .NET Compact, których nie znajdziemy w jej peánej wersji1. Jednak zanim do tego przejdziemy, poáączymy emulator urządzenia przenoĞnego z pro- gramem Cellular Emulator imitującym fikcyjną sieü komórkową. To umoĪliwi darmowe testowanie projektowanych aplikacji. Cellular Emulator Program Cellular Emulator dostarczany jest razem z Windows Mobile 6 SDK (zob. dodatek A). Jest to emulator sieci komórkowej wspóápracujący z emulatorami urządzeĔ przenoĞnych dostĊpnych w Visual Studio. Pozwala na inicjowanie poáączeĔ z emula- torem telefonu oraz Ğledzenie poáączeĔ wychodzących. Za jego pomocą moĪna równieĪ wysyáaü na emulowane urządzenie wiadomoĞci SMS (ang. Short Message Service), jak i odbieraü wiadomoĞci wysáane z emulatora. MoĪemy teĪ zmieniaü i nadzorowaü parametry sieci oraz komendy AT (polecenia sterujące pozwalające na komunikacjĊ miĊdzy komputerem i modemem lub, jak w tym przypadku, miĊdzy urządzeniem prze- noĞnym i siecią komórkową). Jednym sáowem, Cellular Emulator tworzy wirtualne Ğrodowisko sieci komórkowej wokóá emulowanego urządzenia. 1 Oznacza to m.in., Īe w przeciwieĔstwie do projektów opisywanych w rozdziaáach 2. – 6. aplikacji korzystających z tych specyficznych klas w ogóle nie bĊdziemy mogli uruchomiü na komputerze PC. 212 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile Podäñczanie emulatora urzñdzenia przenoĈnego do programu Cellular Emulator 1. Otwieramy program Cellular Emulator (dostĊpny z menu Start/Wszystkie programy/Windows Mobile 6 SDK/Tools/) i odczytujemy nazwĊ portu szeregowego w lewym dolnym rogu okna programu (np. COM4, por. rysunek 8.1). Rysunek 8.1. àączenie emulatora urządzenia z programem Cellular Emulator 2. Mapujemy ten port w emulatorze. W tym celu: a) Uruchamiamy Visual Studio, a nastĊpnie z menu Tools wybieramy polecenie Connect to Device…. Pojawi siĊ okno dialogowe, w którym wskazujemy Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 213 emulator urządzenia przenoĞnego o nazwie Windows Mobile 6 Professional Emulator (wersje Classic nie áączą siĊ z siecią komórkową). Klikamy przycisk Connect. b) Po uruchomieniu emulatora z jego menu File wybieramy polecenie Configure…, a nastĊpnie na zakáadce Peripherals w polu Serial port 0 wpisujemy nazwĊ portu szeregowego odczytanego z programu Cellular Emulator (np. COM4, rysunek 8.1) i klikamy OK. c) Pojawi siĊ komunikat o áączeniu z nowym urządzeniem, ale dopiero ponowne uruchomienie systemu Windows na emulatorze spowoduje zalogowanie do fikcyjnej sieci komórkowej. MoĪemy to wymusiü, wybierając z menu File emulatora polecenie Reset/Soft. Po restarcie systemu emulator urządzenia przenoĞnego powinien siĊ zalogowaü do emulowanej sieci, co sygnalizuje ikona widoczna na pasku tytuáu w emulowanym urzą- dzeniu (rysunek 8.2). JeĞli zamykając program emulatora urządzenia, zapiszemy jego stan, to ustawienia portu szeregowego zostaną równieĪ zapisane, co oszczĊdzi nam pracy przy kolejnym uruchomieniu. Przed ponownym wáączeniem emulatora naleĪy oczywiĞcie pamiĊtaü o uruchomieniu programu Cellular Emulator. Rysunek 8.2. Emulator „widzi” sieü komórkową Kontakty Outlook W kaĪdym telefonie mamy dostĊp do zbioru kontaktów. W najprostszym przypadku ograniczają siĊ one tylko do nazwy i numeru telefonu. W systemach Windows Mobile są one jednak znacznie bardziej rozbudowane; za ich obsáugĊ odpowiedzialna jest 214 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile mobilna wersja programu Outlook. MoĪliwy jest dostĊp do kontaktów — zarówno odczyt, jak i edycja — z poziomu platformy .NET Compact. Pozwalają na to klasy z przestrzeni nazw Microsoft.WindowsMobile.PocketOutlook. Tworzenie aplikacji wyĈwietlajñcej listö kontaktów Zacznijmy od stworzenia aplikacji typu Smart Device wyĞwietlającej wszystkie pola w ksiąĪce kontaktów: 1. W Ğrodowisku Visual Studio tworzymy nowy projekt aplikacji dla urządzenia przenoĞnego na platformĊ Windows Mobile 6 Professional i .NET Compact Framework Version 3.5. Projekt ów nazwijmy Kontakty. 2. Z podokna Toolbox wybieramy siatkĊ DataGrid, umieszczamy ją na formie, a nastĊpnie, korzystając z podokna Properties, ustawiamy jej wáasnoĞü Dock na wartoĞü Fill. 3. Doáączmy do projektu referencjĊ do biblioteki DLL zawierającej klasy pozwalające na korzystanie z moĪliwoĞci programu Outlook na urządzeniu przenoĞnym. W tym celu w menu Project wybieramy Add Reference…, a nastĊpnie na zakáadce .NET wybieramy bibliotekĊ Microsoft.WindowsMobile.PocketOutlook i klikamy OK. 4. Przechodzimy do edycji kodu (klawisz F7) i do zbioru deklaracji przestrzeni nazw na początku pliku Form1.cs dodajemy: using Microsoft.WindowsMobile.PocketOutlook; 5. W klasie formy Form1 definiujemy nowe pole reprezentujące sesjĊ programu Outlook: OutlookSession outlook = new OutlookSession(); 6. Natomiast do konstruktora klasy Form1 dodajemy instrukcjĊ wskazującą kolekcjĊ kontaktów dostĊpną w sesji programu Outlook jako Ĩródáo danych dla siatki dataGrid1: dataGrid1.DataSource = outlook.Contacts.Items; 7. Na pasku narzĊdzi Device z rozwijanej listy Target Device wybieramy Windows Mobile 6 Professional Emulator (emulator) lub Windows Mobile 6 Device (rzeczywiste urządzenie) i uruchamiamy aplikacjĊ, naciskając F5. W punkcie 3. dodaliĞmy referencjĊ do biblioteki PocketOutlook, która jest odpowie- dzialna za obsáugĊ programu Outlook dla urządzeĔ mobilnych, a tym samym za listĊ kontaktów, kalendarz, zapisywanie i wyĞwietlanie zadaĔ, wysyáanie i odbieranie wia- domoĞci SMS i pocztĊ elektroniczną, a zatem za wiĊkszoĞü funkcji inteligentnego tele- fonu. W tym rozdziale bĊdziemy z tej biblioteki korzystaü bardzo czĊsto. WiĊkszoĞü potrzebnych funkcjonalnoĞci zapewnia obiekt zdefiniowany w punkcie 5., tj. instancja klasy OutlookSession, reprezentująca uruchomioną instancjĊ aplikacji Outlook Mobile. Lista kontaktów dostĊpna jest poprzez pole Contacts tego obiektu, którego kolekcjĊ Items wskazaliĞmy jako Ĩródáo danych dla siatki dataGrid1 pokazywanej w oknie pro- jektowanej aplikacji. Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 215 Po uruchomieniu aplikacji na doáączonym rzeczywistym urządzeniu przenoĞnym powin- niĞmy zobaczyü tabelĊ zawierającą wszystkie zdefiniowane w nim kontakty programu Outlook2 (rysunek 8.3). Jednak jeĞli korzystamy z emulatora, to najpewniej ksiąĪka kontaktów jest pusta. MoĪemy oczywiĞcie wypeániü ją sami kilkoma kontaktami, ale moĪemy to równieĪ zrobiü z poziomu aplikacji. Tym wáaĞnie zajmiemy siĊ w kolejnym zadaniu. Rysunek 8.3. Lista kontaktów (w emulatorze jest oczywiĞcie pusta) Tworzenie przykäadowych kontaktów Utwórzmy w menu pozycjĊ odpowiedzialną za dodanie do ksiąĪki kilku przykáadowych kontaktów: 1. Otwórzmy menu Outlook, a w nim pozycjĊ Dodaj przykáadowe kontakty (menuItem2). 2. Klikając dwukrotnie nową pozycjĊ w podglądzie formy, stworzymy domyĞlną metodĊ zdarzeniową związaną ze zdarzeniem Click tej pozycji. Umieszczamy w niej kod widoczny na listingu 8.1. Listing 8.1. Dodawanie przykáadowych kontaktów private void menuItem2_Click(object sender, EventArgs e) { Contact kontakt = outlook.Contacts.Items.AddNew(); kontakt.FirstName = Jan ; 2 Inną sprawą jest odczytanie kontaktów zapisanych na karcie SIM. Jest to moĪliwe, choü Windows Mobile preferuje ich przechowywanie w bazie programu Outlook. Zadanie to uáatwiáby projekt Smart Device Framework (SDF) firmy OpenNETCF dostĊpny na stronie http://www.opennetcf.com/Products/ SmartDeviceFramework/tabid/65/Default.aspx. 216 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile kontakt.LastName = Kowalski ; kontakt.MobileTelephoneNumber = 7272024 ; kontakt.Email1Address = jankow@afero.pl ; kontakt.BusinessTelephoneNumber = 7272020 ; kontakt.Update(); kontakt = outlook.Contacts.Items.AddNew(); kontakt.FirstName = Bartosz ; kontakt.LastName = Turowski ; kontakt.Email1Address = tubartek@gmail.com ; kontakt.BusinessTelephoneNumber = 7272022 ; kontakt.Update(); kontakt = outlook.Contacts.Items.AddNew(); kontakt.FirstName = Jacek ; kontakt.LastName = Matulewski ; kontakt.Email1Address = jacek@fizyka.umk.pl ; kontakt.MobileTelephoneNumber = 7272021 ; kontakt.Update(); dataGrid1.Refresh(); } Numery telefonów uĔyte w powyĔszym przykäadzie nie sñ przypadkowe — rozpo- znawane sñ przez emulator sieci komórkowej. Przypisane sñ do nich róĔne reakcje programu Cellular Emulator (zob. pole Preset Number na rysunku 8.1, lewy). NastĊpnie uruchamiamy aplikacjĊ i z menu Outlook wybieramy polecenie, które do listy kontaktów powinno dodaü trzy nowe pozycje. MoĪemy to sprawdziü, korzystając z wbu- dowanego w Windows Mobile programu do obsáugi kontaktów (rysunek 8.4, lewy) lub z naszej aplikacji (rysunek 8.4, prawy). Metoda z listingu 8.1 dodaje do zbioru kontaktów trzy nowe. W kaĪdym z tych kon- taktów wypeániamy tylko kilka z wielu dostĊpnych pól: imiĊ, nazwisko, numer telefonu komórkowego i adres e-mail. Te pola wykorzystamy w trakcie dalszej pracy nad pro- jektem. Proponujö zapisaè stan emulatora po dodaniu przykäadowych kontaktów — przy- dadzñ siö nam podczas kolejnych èwiczeþ. Edycja nowego kontaktu Platforma .NET Compact nie ma specjalnego okna dialogowego pozwalającego na tworzenie nowych kontaktów z wpisywanymi przez uĪytkownika danymi. Z poziomu kodu moĪemy jednak utworzyü pusty kontakt, a nastĊpnie edytowaü go, wywoáując na rzecz reprezentującego go obiektu metodĊ ShowDialog. Spowoduje to wyĞwietlenie okna z podsumowaniem kontaktu, które w przypadku pustego kontaktu zawiera jedynie Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 217 Rysunek 8.4. Nowe kontakty Rysunek 8.5. Dodanie i edycja nowego kontaktu pozycjĊ Unnamed (rysunek 8.5, lewy). KlikniĊcie tej pozycji lub polecenia Edit w menu spowoduje przywoáanie edytora kontaktu widocznego na rysunku 8.5, prawy. Stwórzmy zatem w menu pozycjĊ, której wybranie spowoduje wywoáanie okna pozwa- lającego, choü w nie najbardziej elegancki sposób, na dodanie nowego kontaktu o para- metrach ustalanych przez uĪytkownika. MyĞlĊ jednak, Īe wáasny formularz i kod podobny do tego z listingu 8.1 w profesjonalnych zastosowaniach są lepszym rozwiązaniem. 218 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile 1. Do menu Outlook dodaj pozycjĊ Dodaj nowy kontakt (menuItem3). 2. Tworzymy domyĞlną metodĊ zdarzeniową do nowej pozycji menu i umieszczamy w niej kod widoczny na listingu 8.2. Listing 8.2. Dodanie dowolnego kontaktu private void menuItem3_Click(object sender, EventArgs e) { Contact kontakt = new Contact(); string orgFileAs = kontakt.FileAs; kontakt.ShowDialog(); if (kontakt.FileAs != orgFileAs) outlook.Contacts.Items.Add(kontakt); } Zgodnie z zapowiedzią w powyĪszej metodzie tworzymy nowy, „pusty” kontakt (instan- cja klasy Contact), a nastĊpnie wywoáujemy na jej rzecz metodĊ ShowDialog, co powo- duje wyĞwietlenie okna widocznego na rysunku 8.5, po lewej. JeĞli uĪytkownik zmieni nazwĊ kontaktu, zmieni siĊ teĪ zawartoĞü pola edycyjnego Zapisz jako w oknie dialo- gowym (odpowiada mu pole FileAs obiektu kontakt). Jest ono domyĞlnie tworzone na podstawie imienia i nazwiska dopisywanej osoby, czyli pól FirstName i LastName obiektu reprezentującego kontakt. W edytorze kontaktu prezentowane są one razem w jednym polu o nazwie Name. Z poziomu kodu moĔliwe jest równieĔ wywoäanie okna dialogowego pozwalajñcego na wyszukanie kontaktu w ksiñĔce kontaktów. Z tej moĔliwoĈci skorzystamy w dalszej czöĈci rozdziaäu, podczas opisywania funkcji zwiñzanych z wysyäaniem SMS-ów i e-maili. Inicjowanie poäñczeþ telefonicznych Aby zadzwoniü na wybrany numer telefonu, wystarczy tylko jedna linia kodu! Dodajmy zatem do aplikacji przygotowanej w poprzednim üwiczeniu metodĊ, która zainicjuje poáączenie po dwukrotnym klikniĊciu wybranego kontaktu. Za funkcje związane stricte z telefonem komórkowym odpowiadają klasy z przestrzeni nazw Microsoft.WindowsMobile.Telephony, w szczególnoĞci klasa Phone. Podobnie jak klasy pozwalające na obsáugĊ programu Outlook Mobile, takĪe te klasy zdefiniowane są w bibliotece DLL, którą trzeba dodaü do projektu. 1. W menu Project wybieramy Add Reference…. Gdy pojawi siĊ okno Add Reference, przechodzimy na zakáadkĊ .NET, zaznaczamy bibliotekĊ Microsoft.WindowsMobile.Telephony i klikamy przycisk OK. 2. Do zbioru deklaracji przestrzeni nazw na początku pliku Form1.cs dodajemy: using Microsoft.WindowsMobile.Telephony; Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 219 3. W gáównym menu okna, z prawej strony, umieszczamy podmenu o nazwie Telefon. W nim dodajemy polecenie Poáącz (menuItem5). 4. Tworzymy domyĞlną metodĊ zdarzeniową związaną ze zdarzeniem Click elementu Poáącz i uzupeániamy ją zgodnie z listingiem 8.3. Listing 8.3. Inicjacja poáączenia telefonicznego private void menuItem5_Click(object sender, EventArgs e) { new Phone().Talk( outlook.Contacts.Items[dataGrid1.CurrentCell.RowNumber]. ´MobileTelephoneNumber); } 5. MetodĊ tĊ moĪemy równieĪ związaü ze zdarzeniem dwukrotnego klikniĊcia siatki. Argumentem metody Phone.Talk jest numer telefonu, z którym chcemy siĊ poáączyü, zapisany w áaĔcuchu (typ string). Efekt jej wywoáania widoczny jest na rysunku 8.6. JeĪeli w argumencie przeĞlemy pusty ciąg znaków (np. gdy kontakt nie miaá przypi- sanego telefonu komórkowego), poáączenie nie zostanie zainicjowane i nie zostanie wyĞwietlony Īaden komunikat o báĊdzie. OczywiĞcie metoda moĪe uwzglĊdniaü taką sytuacjĊ, kiedy próbujemy wykonaü poáączenie z innymi telefonami, których numery zapisane są w danych kontaktu. Listing 8.4 prezentuje kod, w którym w przypadku braku telefonu komórkowego inicjowane jest poáączenie z telefonem sáuĪbowym, a dopiero gdy i tego nie ma, wyĞwietlany jest komunikat o báĊdzie. Rysunek 8.6. Wybieranie numeru po dwukrotnym klikniĊciu pozycji w liĞcie kontaktów 220 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile Listing 8.4. JeĪeli kontakt nie ma telefonu komórkowego, program sprawdzi, czy nie ma zapisanych innych numerów private void menuItem5_Click(object sender, EventArgs e) { Contact kontakt=outlook.Contacts.Items[dataGrid1.CurrentCell.RowNumber]; string numerTelefonu = kontakt.MobileTelephoneNumber; if (numerTelefonu == ) numerTelefonu = kontakt.BusinessTelephoneNumber; if (numerTelefonu != ) new Phone().Talk(numerTelefonu); else MessageBox.Show( Wybrany kontakt nie zawiera numeru telefonu komórkowego ´ani sđuľbowego ); } JeĔeli korzystamy z emulatora, próba inicjowania poäñczenia telefonicznego, jak i sama rozmowa sñ Ĉledzone przez emulator sieci komórkowej. Lista aktualnych poäñczeþ widoczna jest w polu Active Calls okna Cellular Emulator (rysunek 8.7). Wybrane poäñczenie moĔemy przerwaè, klikajñc przycisk Drop Call. Rysunek 8.7. Aktywne poáączenie wychodzące Wysyäanie krótkich wiadomoĈci tekstowych (SMS) Przygotujmy kolejną aplikacjĊ, za pomocą której bĊdziemy mogli tworzyü i wysyáaü wiadomoĞci SMS. Są to krótkie wiadomoĞci tekstowe (do 160 znaków) przesyáane w sie- ciach komórkowych i odczytywane przez wszystkie wspóáczeĞnie produkowane tele- fony komórkowe. Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 221 Przygotowanie projektu aplikacji säuĔñcej do wysyäania wiadomoĈci SMS 1. Do rozwiązania Kontakty dodajmy nowy projekt typu Device Application dla systemu Windows Mobile 6 Professional, korzystający z platformy .NET Compact Framework Version 3.5. Nazwijmy go SMS. 2. W menu Project wybieramy Add Reference…, po czym na zakáadce .NET otwartego okna wskazujemy bibliotekĊ Microsoft.WindowsMobile.PocketOutlook i klikamy OK. W taki sam sposób dodajemy równieĪ bibliotekĊ Microsoft.WindowsMobile.Forms. 3. Nowy projekt ustawiamy jako projekt startowy rozwiązania (menu Set as StartUp Project). 4. Do zbioru deklaracji przestrzeni nazw na początku pliku Form1.cs dodajemy: using Microsoft.WindowsMobile.PocketOutlook; using Microsoft.WindowsMobile.Forms; 5. W widoku projektowania (zakáadka Form1.cs [Design]) w palecie komponentów (podokno Toolbox) odnajdujemy pole edycyjne (TextBox) i umieszczamy na formie dwa takie komponenty — zgodnie ze wzorem na rysunku 8.8. ZmieĔmy ich nazwy (pole Name w podoknie wáasnoĞci) na, odpowiednio, adresatTextBox oraz tekstTextBox. Rysunek 8.8. Projekt interfejsu 6. NastĊpnie w podoknie Properties ustawiamy wáasnoĞci komponentu adresatTextBox: wáasnoĞü Enabled ustawiamy na False, ReadOnly na true, a zakotwiczenie (wáasnoĞü Anchor) na Top,Left,Right, co spowoduje zachowanie staáej odlegáoĞci pola edycyjnego od górnej i bocznych krawĊdzi formy takĪe podczas zmiany orientacji ekranu. 222 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile 7. W przypadku komponentu tekstTextBox ustawiamy: wáasnoĞü Multiline na True, ScrollBars na Both oraz zakotwiczenie Anchor na Top,Bottom,Left,Right, a nastĊpnie rozciągamy go na dostĊpnej powierzchni formy pod pierwszym polem edycyjnym (por. rysunek 8.8). 8. W podoknie Toolbox odnajdujemy komponent przycisku Button i umieszczamy go na formie. Zmieniamy jego nazwĊ na kontaktyButton. W podoknie Properties w polu odpowiadającym treĞci etykiety (wáasnoĞü Text) wpisujemy trzy kropki. Zakotwiczenie ustawiamy na Top,Right. W ten sposób komponent umieszczamy na górze formy, po prawej stronie komponentu adresatTextBox. 9. Na formie umieszczamy jeszcze dwa komponenty Label i zmieniamy ich wáasnoĞü Text na „Do:” oraz „WiadomoĞü:”. Ich poáoĪenie zmieniamy zgodnie ze wzorem z rysunku 8.8. 10. NastĊpnie tworzymy menu zgodnie ze wzorem widocznym na rysunku 8.8. Zmieniamy nazwy elementów menu odpowiednio na: wyslijMenuItem, opcjeMenuItem, potwierdzenieodbioruMenuItem, zakonczMenuItem. WáasnoĞü Enabled pozycji WyĞlij (wyslijMenuItem) ustawiamy na false. Aplikacja bĊdzie dziaáaáa w ten sposób, Īe za pomocą przycisku kontaktyButton wywo- áamy okno dialogowe wyboru kontaktu. Po wskazaniu kontaktu jego nazwĊ i numer telefonu wyĞwietlimy w polu edycyjnym adresatTextBox. Z kolei pole edycyjne wiadomoscTextBox pozwoli na wpisanie treĞci wiadomoĞci, którą moĪna bĊdzie nastĊp- nie wysáaü, klikając pozycjĊ menu z etykietą WyĞlij. BĊdziemy mieü takĪe moĪliwoĞü zaĪądania potwierdzenia odbioru wiadomoĞci, zaznaczając odpowiednią opcjĊ w menu. Wybór adresata i wysäanie wiadomoĈci SMS Stwórzmy teraz metody realizujące funkcje poszczególnych pozycji menu: 1. W klasie formy Form1 definiujemy pole: string numerTelefonuAdresata; 2. Tworzymy metodĊ zdarzeniową związaną ze zdarzeniem Click komponentu kontaktyButton, w której umieszczamy instrukcje z listingu 8.5. Listing 8.5. Wybór adresata wiadomoĞci w ksiąĪce kontaktów private void kontaktyButton_Click(object sender, EventArgs e) { ChooseContactDialog wybierzKontakt = new ChooseContactDialog(); wybierzKontakt.RequiredProperties = new ContactProperty[] {ContactProperty.Sms}; wybierzKontakt.Title = Wybierz adresata ; if (wybierzKontakt.ShowDialog() == DialogResult.OK) { numerTelefonuAdresata = wybierzKontakt.SelectedPropertyValue; adresatTextBox.Text = wybierzKontakt.SelectedContactName + + numerTelefonuAdresata + ; Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 223 wyslijMenuItem.Enabled = true; } } 3. NastĊpnie tworzymy metodĊ związaną ze zdarzeniem Click pozycji menu WyĞlij i uzupeániamy jej kod zgodnie z listingiem 8.6. Listing 8.6. Wysyáanie wiadomoĞci SMS private void wyslijMenuItem_Click(object sender, EventArgs e) { SmsMessage sms = new SmsMessage(numerTelefonuAdresata, tekstTextBox.Text); sms.RequestDeliveryReport = potwierdzenieOdbioruMenuItem.Checked; try { sms.Send(); MessageBox.Show( Wiadomoħè zostađa wysđana! ); } catch { MessageBox.Show( Nie udađo siú wysđaè wiadomoħci! ); return; } } 4. Jako ostatnie tworzymy dwie metody związane ze zdarzeniami Click pozycji menu Potwierdzenie odbioru oraz ZakoĔcz. Ich zawartoĞü uzupeániamy zgodnie ze wzorem na listingu 8.7. Listing 8.7. Zmiana opcji potwierdzenia odbioru oraz zakoĔczenie programu private void potwierdzenieOdbioruMenuItem_Click(object sender, EventArgs e) { potwierdzenieOdbioruMenuItem.Checked = !potwierdzenieOdbioruMenuItem.Checked; } private void zakonczMenuItem_Click(object sender, EventArgs e) { Close(); } Pierwsza linia kodu zaprezentowanego w punkcie 2. (listing 8.5) tworzy okno dialo- gowe typu ChooseContactDialog pozwalające na wybór kontaktu z listy kontaktów zapisanych w urządzeniu przenoĞnym. Okno to pochodzi z przestrzeni nazw Microsoft. ´WindowsMobile.Forms, którą naleĪy dodaü do sekcji instrukcji using. WyĞwietlamy przy tym tylko te kontakty, które umoĪliwiają wysyáanie wiadomoĞci SMS. NastĊpnie ustalamy tytuá okna dialogowego i je przywoáujemy, wywoáując metodĊ ShowDialog. JeĞli, korzystając z okna dialogowego, uĪytkownik wybraá adresata, wyĞwietlamy jego dane w polu edycyjnym adresatTextBox i odblokowujemy opcjĊ WyĞlij. W punkcie 3. przygotowaliĞmy metodĊ wysyáającą SMS. Jak widaü na listingu 8.6, tworzymy w tym celu obiekt typu SmsMessage (naleĪy do przestrzeni Microsoft.Windows 224 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile ´Mobile.PocketOutlook), przekazując do argumentów konstruktora numer wybranego wczeĞniej adresata wiadomoĞci (przechowywany w zmiennej numerTelefonuAdresata) oraz wpisaną do pola tekstowego tekstTekstBox treĞü wiadomoĞci. Zwróümy uwagĊ na drugą liniĊ ciaáa metody, w której w zaleĪnoĞci od stanu pozycji menu o etykiecie Potwierdzenie odbioru przeáączamy pole RequestDeliveryReport obiektu reprezentu- jącego wiadomoĞü SMS. Aplikacja wysyáająca SMS-y jest juĪ gotowa do testów. NaleĪy oczywiĞcie pamiĊtaü, Īe jej dziaáanie jest uzaleĪnione od obecnoĞci sieci komórkowej. Zatem do jej urucho- mienia na emulatorze konieczne jest poáączenie z programem Cellular Emulator. Ten ostatni pozwala monitorowaü SMS-y wysyáane przez emulator. SáuĪy do tego lista Receive from device (z ang. otrzymane z urządzenia) widoczna na zakáadce SMS (rysu- nek 8.9). PamiĊtajmy równieĪ, aby przed uruchomieniem aplikacji zmieniü w pasku narzĊdzi w rozwijanej liĞcie Target Device urządzenie lub emulator na taki, który zawiera telefon (a wiĊc np. Windows Mobile 6 Professional Emulator). Rysunek 8.9. Monitorowanie SMS-ów wysáanych z emulatora Numer telefonu w parametrach uruchomienia aplikacji Aby móc uĪyü aplikacji pozwalającej na redagowanie i wysyáanie SMS-ów jako apli- kacji pomocniczej, wykorzystywanej w innych aplikacjach, konieczne jest przekazy- wanie do niej informacji o adresacie. Najlepiej nadaje siĊ do tego numer telefonu, który w zasadzie moĪna traktowaü jak identyfikator kontaktu. Zmodyfikujmy powyĪszą apli- kacjĊ tak, aby mogáa sáuĪyü jako rodzaj okna dialogowego. 1. W klasie Form1 definiujemy nowe pole: bool zamknijPoWyslaniu = false; 2. Do tej klasy dodajemy równieĪ metodĊ z listingu 8.8. Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 225 Listing 8.8. W metodzie korzystamy z technologii LINQ, zatem wymaga ona platformy .NET Compact w wersji 3.5 public void sprawdzKontakt(string numerTelefonu) { if (numerTelefonu == null || numerTelefonu == ) return; OutlookSession outlook = new OutlookSession(); var kontakty = from Contact kontakt in outlook.Contacts.Items where kontakt.MobileTelephoneNumber==numerTelefonu select kontakt.FirstName + + kontakt.LastName + + ´kontakt.MobileTelephoneNumber + ; if (kontakty.Count() == 0) adresatTextBox.Text = numerTelefonu; else adresatTextBox.Text = kontakty.First string (); wyslijMenuItem.Enabled = true; zamknijPoWyslaniu = true; } 3. MetodĊ tĊ wywoáamy w zmodyfikowanym konstruktorze. ProszĊ zwróciü uwagĊ, Īe jednoczeĞnie konstruktor wyposaĪyliĞmy w argument typu string (listing 8.9). Listing 8.9. Dodajemy argument do konstruktora — w ten sposób przekazywaü bĊdziemy do formy argument linii komend public Form1(string numerTelefonuAdresata) { InitializeComponent(); this.numerTelefonuAdresata = numerTelefonuAdresata; sprawdzKontakt(numerTelefonuAdresata); } 4. Uzupeániamy metodĊ wysyáającą SMS tak, aby w razie powodzenia i odpowiedniej wartoĞci pola zamknijPoWyslaniu zamykaáa ona caáą aplikacjĊ (listing 8.10). Listing 8.10. JeĪeli aplikacja zostaáa uruchomiona jako „niby-okno dialogowe”, zostanie zamkniĊta tuĪ po wysáaniu SMS-a private void wyslijMenuItem_Click(object sender, EventArgs e) { SmsMessage sms = new SmsMessage(numerTelefonuAdresata, tekstTextBox.Text); sms.RequestDeliveryReport = potwierdzenieOdbioruMenuItem.Checked; try { sms.Send(); MessageBox.Show( Wiadomoħè zostađa wysđana! ); if (zamknijPoWyslaniu) Close(); } catch { MessageBox.Show( Nie udađo siú wysđaè wiadomoħci! ); return; } } 226 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile 5. I na koniec wczytujemy do edytora plik Program.cs, w którym odczytujemy pierwszy parametr linii komend i przekazujemy go do konstruktora klasy Form1 (listing 8.11). Listing 8.11. Przekazujemy argument linii komend do konstruktora formy using System; using System.Linq; using System.Collections.Generic; using System.Windows.Forms; namespace SMS { static class Program { /// summary /// The main entry point for the application. /// /summary [MTAThread] static void Main(string[] argumenty) { string numerTelefonuAdresata = ; if (argumenty.Count() 0) numerTelefonuAdresata = argumenty[0]; Application.Run(new Form1(numerTelefonuAdresata)); } } } 6. Aby przetestowaü dziaáanie aplikacji, otwórzmy ustawienia projektu SMS (menu Project, polecenie SMS Properties…) i na zakáadce Debug w polu Command line arguments wpiszmy numer 7272021, tj. fikcyjny numer przypisany do jednego z kontaktów (rysunek 8.10). 7. Po uruchomieniu powinniĞmy zobaczyü okno aplikacji z zapeánionym polem adresata. Korzystanie z aplikacji wysyäajñcej SMS-y jak z okna dialogowego 1. Usuwamy argumenty linii komend w ustawieniach projektu SMS (por. rysunek 8.10). 2. Zmieniamy projekt startowy rozwiązania z powrotem na projekt Kontakty. 3. Do projektu Kontakty dodajemy plik SMS.exe, który znajdziemy w podkatalogu SMS\bin\Debug. Zaznaczmy go w podoknie Solution Explorer i w podoknie Properties zmieĔmy jego wáasnoĞü Copy to Output Directory na Copy if newer. 4. W projekcie Kontakty, na zakáadce Form1.cs [Design], na podglądzie formy dodajemy do menu Telefon pozycjĊ SMS. Tworzymy jej domyĞlną metodĊ zdarzeniową i umieszczamy w niej kod widoczny na listingu 8.12. Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 227 Rysunek 8.10. Ustawianie argumentu wysyáanego do aplikacji uruchamianej w otoczeniu debugera Visual Studio Listing 8.12. Uruchamianie aplikacji SMS.exe z argumentem zawierającym numer telefonu static string katalogAplikacji { get { string katalog = System.IO.Path.GetDirectoryName(System.Reflection. ´Assembly.GetExecutingAssembly().GetName().CodeBase); if (katalog.StartsWith( file: )) katalog = katalog.Remove(0, 6); return katalog; } } private void menuItem6_Click(object sender, EventArgs e) { Contact kontakt=outlook.Contacts.Items[dataGrid1.CurrentCell.RowNumber]; string numerTelefonu = kontakt.MobileTelephoneNumber; if (numerTelefonu!= ) { string sciezkaDoPliku = System.IO.Path.Combine(katalogAplikacji, ´ SMS.exe ); System.Diagnostics.ProcessStartInfo psi = new ´System.Diagnostics.ProcessStartInfo(sciezkaDoPliku, numerTelefonu); System.Diagnostics.Process.Start(psi); } else MessageBox.Show( Wybrany kontakt nie zawiera numeru telefonu ´komórkowego ); } 228 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile Zwróèmy uwagö, Ĕe ĈcieĔka do pliku SMS.exe wyznaczana jest na podstawie katalogu aplikacji. Wykorzystujemy do tego wäasnoĈè katalogAplikacji, którñ zdefiniowaliĈmy w rozdziale 6. Po zmianie z punktu 2. naciĞniĊcie klawisza F5 spowoduje skompilowanie i urucho- mienie aplikacji Kontakty. W widocznej w jej oknie siatce moĪemy zaznaczyü kontakt i z menu Telefon wybraü polecenie SMS. Wówczas aplikacja wywoáa aplikacjĊ SMS z parametrem okreĞlającym numer telefonu komórkowego. Natomiast jeĪeli wybrany kontakt nie ma zapisanego numeru komórkowego, wyĞwietlony zostanie informujący o tym komunikat. Wysyäanie poczty elektronicznej Z perspektywy programisty platformy .NET Compact wysyáanie wiadomoĞci e-mail via Outlook jest bardzo podobne do wysyáania wiadomoĞci SMS, które równieĪ wysy- áane są za poĞrednictwem programu Outlook. Nie bĊdziemy zatem mieli z tym Īadnych problemów. Aby podkreĞliü owe podobieĔstwa, ograniczymy aplikacjĊ wysyáającą pocztĊ elektro- niczną w taki sposób, Īe list bĊdzie mógá mieü tylko jednego adresata. Jest to jednak ogra- niczenie doĞü sztuczne — w razie potrzeby Czytelnik moĪe je bez problemu usunąü. Metoda wybierajñca adres e-mail z listy kontaktów Do rozwiązania Kontakty dodajemy kolejny projekt o nazwie Email (pamiĊtajmy o wskazaniu platformy Windows Mobile 6 Professional). ZawartoĞü formy budujemy analogicznie do projektu SMS, moĪemy ją nawet po prostu skopiowaü (w widoku pro- jektowania wszystkie kontrolki okna moĪna zaznaczyü, naciskając kombinacjĊ klawiszy Ctrl+A)! Zbiór kontrolek uzupeánimy za chwilĊ o pole tekstowe, w którym wpiszemy tytuá listu, i rozwijaną listĊ pozwalającą na wybór konta. NastĊpnie dodajmy do projektu biblioteki DLL Microsoft.WindowsMobile.PocketOutlook.dll i Microsoft.WindowsMobile. Forms.dll. Dalej postĊpujemy identycznie, jak opisano w projekcie SMS, z wyjątkiem nazwy pola typu string, które zamiast numeTelefonuAdresata nazywamy teraz adres ´EmailAdresata. PostĊpujemy tak aĪ do momentu, w którym definiujemy metodĊ zda- rzeniową związaną ze zdarzeniem Click komponentu kontaktyButton. Jej nową wersjĊ, nieznacznie tylko róĪniącą siĊ od pierwowzoru, prezentuje listing 8.13. Listing 8.13. Wybór adresata wiadomoĞci w ksiąĪce kontaktów (szare táo wskazuje zmiany w kodzie wzglĊdem wersji dla projektu SMS) private void kontaktyButton_Click(object sender, EventArgs e) { ChooseContactDialog wybierzKontakt = new ChooseContactDialog(); wybierzKontakt.RequiredProperties = new ContactProperty[] ´{ContactProperty.AllEmail }; wybierzKontakt.Title = Wybierz adresata ; Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 229 wybierzKontakt.ChooseContactOnly = false; if (wybierzKontakt.ShowDialog() == DialogResult.OK) { adresEmailAdresata = wybierzKontakt.SelectedPropertyValue; adresatTextBox.Text = wybierzKontakt.SelectedContactName + + adresEmailAdresata + ; wyslijMenuItem.Enabled = true; } } Porównując listingi 8.13 i 8.5, widzimy jak niewiele jest zmian (zaznaczone zostaáy szarym táem). Obecnie wáasnoĞü RequiredProperties ustaliliĞmy tak, aby okno dialogowe wyboru kontaktu wyĞwietliáo tylko te kontakty, które mają wpisany adres e-mail. Oprócz tego poprzez ustawienie wáasnoĞci okna dialogowego o nazwie ChooseContactOnly na false dajemy moĪliwoĞü wyboru konkretnego adresu e-mail w przypadku, gdy z danym kontaktem związanych jest wiĊcej adresów poczty elektronicznej. Wybór zaäñcznika, komponowanie i wysyäanie listu e-mail Wróümy do projektowania okna pozwalającego na przygotowanie listu. ZawartoĞü okna skopiowana z projektu SMS nie pozwala na wybór konta poczty elektronicznej ani na wpisanie tytuáu. Musimy równieĪ umoĪliwiü wybór pliku zaáącznika wysyáanego wraz z listem. TĊ ostatnią moĪliwoĞü dodamy jednak nie do okna, które nie jest przecieĪ zbyt duĪe, a do menu. 1. W podoknie Toolbox zaznaczamy komponent okna dialogowego wyboru pliku OpenFileDialog i umieszczamy go na podglądzie formy, a nastĊpnie w edytorze wáasnoĞci (podokno Properties) czyĞcimy zawartoĞü pola przy wáasnoĞci FileName tego komponentu. Okna dialogowego uĪyjemy do wyboru pliku, który ma byü ewentualnie doáączony do wysyáanego listu. 2. W menu aplikacji usuwamy pozycjĊ Potwierdzenie odbioru (usuwamy takĪe związaną z nią metodĊ zdarzeniową) i zastĊpujemy ją pozycją Wybierz plik zaáącznika… (zmieniamy jej nazwĊ na zalacznikMenuItem), nastĊpnie tworzymy metodĊ związaną ze zdarzeniem Click dla tej opcji zgodnie z listingiem 8.14. Dodajemy równieĪ pozycjĊ UsuĔ zaáącznik, której metoda zdarzeniowa równieĪ widoczna jest na listingu 8.14. Listing 8.14. Wybór pliku zaáącznika private void zalacznikMenuItem_Click(object sender, EventArgs e) { if (openFileDialog1.ShowDialog() == DialogResult.OK) { tekstTextBox.Text = openFileDialog1.FileName; zalacznikMenuItem.Checked = true; } } private void usunZalacznikMenuItem_Click(object sender, EventArgs e) 230 Programowanie aplikacji dla urzñdzeþ mobilnych z systemem Windows Mobile { openFileDialog1.FileName = ; zalacznikMenuItem.Checked = false; } 3. W klasie formy Form1 definiujemy pole: OutlookSession outlook = new OutlookSession(); 4. Do formy dodajemy pole tekstowe TextBox (zmieĔmy jego nazwĊ na tytulTextBox) oraz etykietĊ o treĞci Tytuá (rysunek 8.11). Rysunek 8.11. Projekt interfejsu aplikacji do wysyáania poczty elektronicznej 5. Do formy dodajemy równieĪ rozwijaną listĊ ComboBox (kontaComboBox), której zawartoĞü wypeánimy dostĊpnymi kontami poczty elektronicznej. W tym celu w konstruktorze odczytujemy nazwy kont, których tablicĊ wskazujemy jako Ĩródáo danych rozwijanej listy (listing 8.15). Listing 8.15. Zapisywanie nazw kont poczty elektronicznej do rozwijanej listy public Form1() { InitializeComponent(); Rozdziaä 8. i Obsäuga podstawowych funkcji telefonu i programu Outlook 231 var konta = from EmailAccount konto in outlook.EmailAccounts select konto.Name; kontaComboBox.DataSource = konta.ToArray string (); } 6. NastĊpnie ze zdarzeniem Click pozycji
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie aplikacji dla urządzeń mobilnych z systemem Windows Mobile
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: