Blog Technologiczny ATENA » Bez kategorii http://blog.atena.pl JavaEE, AJAX, xHTML, RIA, JBoss Fri, 20 Jan 2012 11:18:46 +0000 en hourly 1 JavaFX 2 – aplikacja wielowątkowa http://blog.atena.pl/javafx-2-aplikacja-wielowatkowa http://blog.atena.pl/javafx-2-aplikacja-wielowatkowa#comments Fri, 20 Jan 2012 11:18:46 +0000 Marcin Garniewski http://blog.atena.pl/?p=1183 Kontynuując nasz wątek blogowy o JavaFX 2.0, chciałbym dziś zaprezentować kilka możliwości JavaFX. Głównym tematem jest oczywiście wielowątkowość, ale znajdzie się też miejsce na wiązanie danych pomiędzy warstwą danych a warstwą prezentacji, definiowanie akcji oraz pracę z biblioteką JavaFX z wykorzystaniem środowiska Maven.

Temat wielowątkowości, szczególnie w kontekście aplikacji typu „gruby klient”, nigdy nie był łatwy. Zapewnienie odpowiedniej synchronizacji, komunikacji oraz braku zakleszczeń może niejednego programistę przyprawić o zawrót głowy. Śmiało można śmiało powiedzieć, że JavaFX wprowadza nową jakość w tworzeniu tego typu aplikacji. Udogodnienia dostępne w wersji 2.0 dają wiele możliwości. W efekcie kod aplikacji oraz czas wykonania są znacznie krótsze w porównaniu do tworzenia bliźniaczej aplikacji w bibliotece SWING.

W JavaFX klasy i interfejsy związane z obsługą wielowątkowości znajdują się w pakiecie javafx.concurrent. Interfejs Worker jest implementowany przez pozostałe dwie klasy: Task i Service. Obiekt typu Worker wykonuje prace w jednym lub kilku równoległych wątkach. Stan jest w pełni obserwowalny i dostępny dla głównego wątku interfejsu GUI. Nie da się natomiast bezpośrednio modyfikować stanu interfejsu GUI. Próba taka kończy się wyjątkiem. Abstrakcyjna klasa Task służy do enkapsulacji pracy, jaka ma być wykonywana w danym wątku. Implementująca klasa musi wypełnić metodę call, która będzie wykonywana podczas uruchomienia wątku. Obiektu tej klasy nie można ponownie uruchomić. Ostatnią klasą jest Service, która – dla odmiany – da się użyć ponownie poprzez restart lub reset.

Z kodu tych wątków nie można bezpośrednio modyfikować stanu GUI. Wszystkie operacje komunikacji wykonuje za nas silnik JavaFX. Wystarczy powiązać (ang. bind) odpowiedni parametr z elementem graficznym. Domyślnie interfejs Worker oferuje nam całą listę parametrów związanych ze stanem wątku. Niektóre z nich to:

  • ReadOnlyStringProperty messageProperty()
  • ReadOnlyDoubleProperty progressProperty()
  • ReadOnlyBooleanProperty runningProperty()
  • ReadOnlyObjectProperty stateProperty()
  • ReadOnlyStringProperty titleProperty()
  • ReadOnlyDoubleProperty totalWorkProperty()

Można też oczywiście dodawać własne parametry. Przykładowo, aby powiązać parametr „message” z elementem wizualnym typu TextField, należy wykonać polecenie:

1
task.messageProperty().bind(textField.textProperty());

A następnie w kodzie wątku wywołać polecenie:

1
updateMessage("tekst do prezentacji");

Demonstracyjna aplikacja będzie uruchamiała wątki typu Task i Service. Każdy z nich będzie informował interfejs o postępie wykonania swojego zadania. Każdy wiersz w tabeli to jeden wątek. Pierwsza kolumna w tabeli będzie zawierała nazwę wątku nadaną przez maszynę wirtualną Javy. Druga kolumna będzie zawierała element typu ProgressBar, który będzie na bieżąco pokazywał stan zaawansowania wykonania danego wątku. W naszym przypadku wątek nie będzie nic robił oprócz ustawienia stanu postępu i przejścia w stan uśpienia. W docelowej aplikacji wątek taki może wykonywać dowolne zadanie, nie blokując jednocześnie GUI. Aplikację utworzyłem w edytorze IDE Eclipse, wykorzystująć środowisko Maven.

Przygotowanie środowiska i utworzenie nowego projektu

  1. Utworzenie projektu

    1
    mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=pl.atena.javafxblog -DartifactId=JavaFXBlog
  2. Dodanie plików konfiguracyjnych wymaganych przez Eclipse. Wchodzimy do katalogu JavaFXBlog i wykonujemy polecenie:

    1
    mvn eclipse:eclipse
  3. Modyfikacja pliku konfiguracyjnego pom.xml. W sekcji <dependencies> dodajemy zależność do biblioteki JavaFX2:

    1
    2
    3
    4
    5
    6
    7
            <dependency>
                <groupId>javafx</groupId>
                <artifactId>javafxrt</artifactId>
                <version>2.0.2</version>
                <scope>system</scope>
                <systemPath>C:/Program Files/Oracle/JavaFX 2.0 SDK/rt/lib/jfxrt.jar</systemPath>
            </dependency>

    Ścieżka do biblioteki jfxrt.jar w elemencie <systemPath> powinna odpowiadać lokalizacji tego pliku na naszym komputerze.

  4. Import projektu do środowiska Eclipse

    W aplikacji Eclipse wybieramy opcje File->Import…->Existing Projects into Workspace i wskazujemy katalog z projektem.

Kod aplikacji

Aplikacja składa się z dwóch elementów: tabeli i przycisku. Przykładowe ułożenie elementów może być wykonane w następujący sposób:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    public void start(Stage primaryStage) throws Exception {
        tableData = new TableView<Worker<Void>>();
        runTaskButton = new Button("Nowy wątek typu Task");
        runServiceButton = new Button("Nowy wątek typu Service");
       
        BorderPane rootGroup = new BorderPane();
        FlowPane paneFlow = new FlowPane();
        paneFlow.getChildren().addAll(runTaskButton, runServiceButton);
        paneFlow.setPadding(new Insets(10, 10, 10, 10));
        paneFlow.setHgap(10);
        paneFlow.setVgap(10);
        paneFlow.setAlignment(Pos.CENTER);
       
        rootGroup.setCenter(tableData);
        rootGroup.setBottom(paneFlow);

        Scene scene = new Scene(rootGroup, 800, 600);
        scene.setFill(Color.OLDLACE);
       
        primaryStage.setTitle("JavaFX Blog");
        primaryStage.setScene(scene);
       
       
        configTable();
        attachActions();
        bindData();
       
        primaryStage.show();
    }

Powiązanie tabeli z listą utworzonych wątków. Ważne jest, aby kolekcja przechowująca listę wątków była typu „ObservableList”

1
2
3
    private void bindData() {
        tableData.setItems(listThreads.getThreadList());
    }

gdzie obiekt threadList został utworzony w następujący sposób:

1
private final ObservableList<ThreadTask> threadList = FXCollections.observableArrayList();

W tabeli znajdują się dwie kolumny. Pierwsza będzie wyświetlać nazwę wątku, druga postęp wykonania zadania. Konfiguracja tabeli z dwiema kolumnami:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    private void configTable() {
        tableData.setEditable(false);
        TableColumn nameCol = new TableColumn("Nazwa wątku");
        nameCol.setCellValueFactory(
                new PropertyValueFactory<ThreadTask,Integer>("name") //1
            );
        nameCol.setPrefWidth(150);        
       
        TableColumn progressCol = new TableColumn("Postęp");
        progressCol.setCellValueFactory( new Callback<CellDataFeatures<ThreadTask, ProgressBar>, ObservableValue<ProgressBar>>() {
            @Override
            public ObservableValue<ProgressBar> call(CellDataFeatures<ThreadTask, ProgressBar> arg0) {
                ThreadTask task = arg0.getValue();
                ProgressBar bar = new ProgressBar();
                bar.setPrefWidth(630);
                bar.progressProperty().bind(task.progressProperty()); //2
                return new SimpleObjectProperty<ProgressBar>(bar);
            }
        });
        progressCol.setPrefWidth(630);
        tableData.getColumns().addAll(nameCol, progressCol);
    }

Dane w komórkach tabeli powiązane są z polami w klasie typu ThreadTask. W pierwszej kolumnie definiujemy odczytywanie danych z funkcji getName() — linia nr 1. Druga kolumna progressCol jest trochę bardziej skomplikowana. Umieszczony został w niej element typu ProgressBar. Powinien on wyświetlać aktualny stan wykonania zadania. Powiązanie to jest wykonane w linii nr 2.

Teraz najważniejszy element demonstracyjnej aplikacji: uruchomienie nowego wątku po wciśnięciu przycisku „Nowy wątek typu Task” lub „Nowy wątek typu Service”. Kod akcji uruchamiany po wciśnięciu przycisku:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    private void attachActions() {
        runTaskButton.setOnAction(new EventHandler<ActionEvent>() {
            public void handle(ActionEvent t) {
                ThreadTask task = new ThreadTask(); //1
                new Thread(task).start(); //2
                listThreads.getThreadList().add(task);
            }
        });
        runServiceButton.setOnAction(new EventHandler<ActionEvent>() {
            public void handle(ActionEvent t) {
                Service service = new ServiceTask(); //3
                service.setExecutor(executor); //4
                service.start(); //5
                listThreads.getThreadList().add(service); //6
            }
        });
    }

W linii nr 1 tworzymy nowy obiekt typu ThreadTask (kod poniżej). Implementuje on interfejs „Runnable” a więc można go uruchomić jak zwykły wątek javowy – linia nr 2. Obiekt klasy ServiceTask jest uruchamiany poprzez wywołanie metody „start()”, linia nr 5. Politykę zarządzania wątkami ustawia się metodą „setExecutor”. W linii nr 6 dodajemy wątek do listy wyświetlanej przez obiekt Table. Kod klasy ThreadTask:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class ThreadTask extends Task{
    private static int MAX = 100; // maksymalna wartość postępu
    private static int SLEEP_TIME = 200; // czas wstrzymania wątku w ms
    private String threadName;    // nazwa wątku
   
    /**
     * @return Nazwa wątku
     */
    public String getName() {
        return threadName;
    }
   
    /**
     * Wykonanie zadania
     * @see javafx.concurrent.Task#call()
     */
    @Override
    protected Object call() throws Exception {
        threadName = Thread.currentThread().getName();
       
        for (int i=1; i<=MAX; i++) {  // pętla od 1 do 100
            updateProgress(i, MAX);   // aktualizacja postępu pracy wątku
            Thread.sleep(SLEEP_TIME); // wstrzymanie czasu pracy wątku                    
        }      
        return null;
    }
}

Aktualizacja postępu wykonania jest ustawiana za pomocą metody updateProgress(int,int). Pierwszy argument to stan pracy, drugi wartość maksymalna.

Kod klasy ThreadService:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ThreadService extends Service<Void>{
   
    private ThreadTask task;
   
    public String getName() {
        return "[Service] " + task.getThreadName();
    }
   
    @Override
    protected Task createTask() {
        task = new ThreadTask();
        return task;
    }

}

Podsumowanie

Jak widać, programowanie wielowątkowe w JavaFX 2 jest dość łatwe. Po poznaniu mechanizmu tworzenia i uruchamiania wątków oraz komunikacji wątków z interfejsem javafx mamy pewność, że pisane przez nas programy będą stabilne i wydajne.

]]> http://blog.atena.pl/javafx-2-aplikacja-wielowatkowa/feed 0 Wstęp do Androida http://blog.atena.pl/wstep-do-androida http://blog.atena.pl/wstep-do-androida#comments Wed, 14 Dec 2011 07:13:07 +0000 Piotr Łabuński http://blog.atena.pl/?p=2004 Android jest obecnie najpopularniejszym systemem operacyjnym przeznaczonym dla urządzeń mobilnych. Według danych firmy Canalys w ostatnim kwartale 2010 roku Android osiągnął wynik 32,9 miliona sprzedanych telefonów, wyprzedzając Symbiana (31 mln) oraz pozostawiając w tyle iOS (16,2 mln). Od przejęcia w roku 2005 roku firmy Android Inc. rozwijany jest przez Google. Opiera się na jądrze Linuxa. Działa na zasadach wolnego oprogramowania (Apache License 2.0) – nie licząc linii 3.x przeznaczonej wyłącznie na tablety. Android udostępnia bardzo rozbudowane możliwości deweloperskie: bazę danych SQLite, WebKit, GPS, sensory, bibliotekę graficzną OpenGL ES, TTS i wiele innych. W tym artykule przedstawię podstawowe informacje dotyczące Androida oraz pokażę, jak zacząć swoją przygodę z programowaniem w ramach tej platformy.

Ważniejsze pojęcia

  • Activity – klasa, która odpowiada za stworzenie okna aplikacji. Zawiera takie metody jak onCreate (wywoływana w momencie inicjalizacji klasy) oraz inne metody reagujące na przejście klasy w inne stany cyklu życia, np. onPause, onStop, onResume i inne.
  • Layout – schemat określający rozmieszczenie elementów na ekranie.
  • Intent – klasa opisująca operację, którą mamy zamiar wykonać.
  • SDK (Software Development Kit) – zbiór narzędzi umożliwiający pisanie, uruchamianie oraz testowanie aplikacji w danej technologii – w naszym przypadku dla platformy Android.
  • NDK (Native Development Kit) – zbiór narzędzi umożliwiający pisanie aplikacji w języku C/C++ dla platformy Android.
  • ADT (Android Development Tools) – plugin umożliwiający pisanie aplikacji na Androida przy wykorzystaniu środowiska Eclipse.
  • AVD (Android Virtual Device) – emulator systemu Android umożliwiający uruchomienie plików .apk na komputerze.

Jak zacząć

Język programowania

Podstawowym językiem programowania dla tej platformy jest Java z ograniczonym API, dostosowana do potrzeb smartfonów i tabletów (Android SDK). Przy pomocy NDK (Native Development Kit) można również korzystać z języka C/C++, co może spowodować znaczne zwiększenie szybkości pracy aplikacji, np. w wypadku zaawansowanych operacji graficznych. NDK umożliwia pisanie mieszanych aplikacji Java/C/C++ jak również (od wersji r5) samodzielnych aplikacji C/C++.

Środowisko programistyczne

Do pisania aplikacji na urządzenia z systemem Android można wykorzystać takie IDE, jak Eclipse, NetBeans czy IntelliJ IDEA. W tym przykładzie skorzystamy z pierwszego z nich. Instalacja środowiska (oryginalna instrukcja pod adresem http://developer.android.com/sdk/installing.html):

1. Ściągamy i instalujemy JDK5 lub JDK6. Samo JRE jest niewystarczające.

2. Ściągamy i instalujemy Eclipse (for Java Developers, for Java EE Developers lub Classic w wersji 3.5.1 lub wyższej).

3. Ściągamy i instalujemy Android SDK.

4. Dodajemy komponent do SDK.

  • Włączamy „SDK Manager”.
  • Automatycznie zostaną wyszukane wszystkie aktualizacje.
  • Akceptujemy licencje paczek, które nas interesują i klikamy Install.


Wskazówka: Gdy łączymy się przez serwer Proxy, należy włączyć SDK Manager, wejść w Tools > Options… (w starszych wersjach SDK wchodzimy w Settings) i tam skonfigurować swoje połączenie.

5. Dodajemy AVD (Android Virtual Device).

  • Włączamy „SDK Manager”.
  • Wchodzimy w Tools > Manage AVDs…
  • Klikamy New.
  • W nowym oknie nadajemy nazwę nowemu AVD.
  • W polu Target wybieramy interesującą nas wersję API. Numer API określa minimalną wersję Androida, dla której aplikacja będzie działać poprawnie, np. API 7 określa wersję Androida 2.1. Kolejne platformy wersji 1.x i 2.x są kompatybilne wstecz.
  • Wybieramy rodzaj wyświetlacza w polu Skin oraz inne parametry sprzętowe w polu Hardware.
  • Możemy również zaznaczyć opcję Snapshot, która umożliwi szybsze włączanie się emulatora.
  • Klikamy Create AVD.


Wskazówka: Przy większych projektach lub wymagających dostępu do niektórych elementów sprzętowych korzystanie z emulatora może okazać się bardzo uciążliwe lub w ogóle niemożliwe. W takich przypadkach warto skorzystać z możliwości bezpośredniego instalowania/debugowania aplikacji w telefonie. Aby to zrobić, należy w ustawieniach telefonu wybrać opcję Aplikacje, zaznaczyć pole Nieznane źródła oraz w zakładce Dla programistów zaznaczyć Debugowanie USB. Następnie podłączamy telefon do komputera przy pomocy kabla USB. Aby sprawdzić, czy nasze urządzenie jest widziane przez Android Debug Bridge (ADB), należy w konsoli wywołać komendę adb devices. Powinna pojawić się lista podłączonych urządzeń z systemem Android oraz włączonych emulatorów. Jeżeli na tej liście znajduje się nasz telefon, możemy z poziomu Eclipse instalować, uruchamiać oraz debugować (przy pomocy DDMS) w nim nasze aplikacje.

6. Instalujemy ADT(Android Development Tools).

  • Włączamy Eclipse.
  • Wchodzimy w Help > Install New Software.
  • Klikamy Add.
  • Location: https://dl-ssl.google.com/android/eclipse/.
  • Klikamy Ok.
  • Zaznaczamy Developer Tools i klikamy Next.
  • Kolejny raz klikamy Next, następnie pojawią się warunki licencji, akceptujemy i klikamy Finish
  • Restartujemy Eclipsa.

Wskazówka: Gdy łączymy się przez serwer Proxy, należy włączyć Eclipse i wejść w Window > Preferences > General > Network Connections i tam skonfigurować swoje połączenie.

7. Konfiguracja ADT

  • Włączamy Eclipse.
  • Wchodzimy w Window > Preferences.
  • Wybieramy zakładkę Android.
  • Klikamy Browse i wybieramy miejsce, w którym zainstalowaliśmy Android SDK.
  • Klikamy Apply a następnie Ok.

konfiguracja AVD

Przykładowa aplikacja

Pierwszą aplikacją na telefony z systemem Android będzie prosty notatnik umożliwiający dodawanie, usuwanie oraz edytowanie notatek. Nasza aplikacja będzie składała się z dwóch layout’ów: jednego zawierającego listę naszych notatek i drugiego umożliwiającego dodawanie i edycję notatek. Nasze informacje będziemy przechowywać z bazie SQLite. Dodawanie notatek będzie wywoływane poprzez przycisk w wysuwanym menu, a edycja i usuwanie poprzez przyciski w menu kontekstowym wywoływanym przy naciśnięciu danej notatki.

Tworzenie nowego projektu

1. Włączamy Eclipse.

2. Wchodzimy w File > New > Android Project.

3. Nadajemy nazwę projektowi i klikamy Next.

4. Wybieramy interesującą nas wersję API i klikamy Next.


5. Podajemy nazwę naszej paczki i klikamy Finish.

6. Eclipse wygenerował nam nasz projekt, w którym znajdują się między innymi:

  • Folder src zawierający naszą paczkę oraz pierwszą klasę, do której powrócimy podczas pisania naszej pierwszej aplikacji.
  • Folder gen zawierający automatycznie wygenerowany plik R.java, którego nie należy modyfikować ręcznie. Klasa ta łączy zasoby graficzne z kodem Javy.
  • Folder bin, w którym będą się znajdować stworzone przez nas aplikacje oraz klasy po skompilowaniu.
  • Folder res zawierający nasze zasoby m. in. podfolder layout, w którym możemy w postaci plików xml zdefiniować wygląd interfejsów naszej aplikacji. Oczywiście można dodawać elementy w kodzie aplikacji analogicznie jak przy użyciu biblioteki Swing, jednak skorzystanie z plików xml jest o wiele wygodniejszą metodą. Dodatkowo Eclipse pozwala na automatyczne budowanie layoutów w postaci plików xml dzięki prostemu edytorowi graficznemu.
  • Plik AndroidManifest.xml jest to główny plik konfiguracyjny Androida zawierający m. in. nazwę paczki, minimalną wersję API, zezwolenia na dostęp do zasobów sprzętowych, zdefiniowane klasy Activity, Serwisy

Elementy aplikacji

1. Konfiguracja wyglądu

1.1. Konfiguracja poprzez xml

W Eclipsie w panelu Package Explorer klikamy prawym przyciskiem myszy na folder res/layout. Z menu wybieramy New -> Android XML File. Wprowadzamy nazwę nowego pliku – w naszym przypadku będzie to addnote. W tym miejscu możemy dodać elementy widoku, ale zrobimy to później, a więc klikamy Finish. Klikamy dwa razy na nowo powstały plik, przez co otwieramy graficzny interfejs pozwalający na dodawanie elementów do widoku.


Z panelu Form Widgets wybieramy Medium text i przeciągamy go na nasz ekran. Jego zawartość oraz id możemy ustalić, przechodząc do widoku xml (zakładka u dołu panelu). Analogicznie postępujemy z kolejnymi elementami. W edytorze graficznym możemy w zależności od wybranego layout’u (standardowo jest to LinearLayout) pozycjonować oraz zmieniać wielkość dodanych przez nas elementów. Po dodaniu wszystkich elementów wygenerowany plik xml powinien wyglądać tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:orientation="vertical" >

    <TextView
       android:id="@+id/textView1"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Title: "
       android:textAppearance="?android:attr/textAppearanceMedium" />

    <EditText
       android:id="@+id/editText1"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content" >

        <requestFocus />
    </EditText>

    <TextView
       android:id="@+id/textView2"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Text: "
       android:textAppearance="?android:attr/textAppearanceMedium" />


    <EditText
       android:id="@+id/editText2"
       android:layout_width="fill_parent"
       android:layout_height="wrap_content"
       android:layout_weight="0.88"
       android:inputType="textMultiLine" />

</LinearLayout>

Warto w tym miejscu podejrzeć plik R.java. W tym pliku wygenerował nam się fragment kodu przypisujący id naszych elementów pewne stałe.

1
2
3
4
        public static final int editText1=0x7f050001;
        public static final int editText2=0x7f050003;
        public static final int textView1=0x7f050000;
        public static final int textView2=0x7f050002;

Jak już wspomniałem wcześniej, nie należy samodzielnie modyfikować tego pliku. Wartości tych stałych nie mają dla nas większego znaczenia. Te wpisy demonstrują, w jaki sposób android łączy zasoby graficzne z kodem Javy.

1.2. Konfiguracja z poziomu javy

W przypadku widoku listy najprostszym sposobem jest zrobienie tego z poziomu javy. Zmieniamy klasę, z której dziedziczy klasa AtenaNotepadActivity z

1
public class AtenaNotepadActivity extends Activity

na

1
public class AtenaNotepadActivity extends ListActivity

Teraz wystarczy ustawić adapter wskazujący, co ma wyświetlać nasza lista. Robimy to poprzez:

1
2
this.setListAdapter(new ArrayAdapter<String>(this,
                    android.R.layout.simple_list_item_1,results));

gdzie results jest to ArrayList danych, które chcemy wyświetlić, a android.R.layout.simple_list_item_1 jest to stała określająca wygląd naszej listy.

2. Definiowanie napisów

Aby zdefiniować napisy, które wykorzystamy później w celu wyświetlenia ich na przyciskach naszych menu, wchodzimy w folder res naszego projektu. Następnie wybieramy katalog values i klikamy dwukrotnie na plik strings.xml. Klikamy Add, w kolejnym okienku wybieramy opcje String i klikamy OK. Następnie możemy nadać nazwę oraz wartość naszego stringa. Aby odwołać się do utworzonego napisu w kodzie wystarczy R.string.nazwa.

3. Stworzenie bazy danych oraz tablicy składającej się z 2 kolumn „Title” i „Text” .

  • Definiujemy nazwę bazy danych.
1
2
private final String DB_NAME = "AtenaNotepad";
private SQLiteDatabase baza = null;
  • Otwieramy (jeżeli istnieje) lub tworzymy bazę danych oraz tablicę Notepad poprzez metodę execSQL. Poniższy fragment kodu wstawiamy do metody onCreate, która zostaje wywołana w momencie startu naszej aplikacji.
1
2
3
4
5
6
7
try {
baza = this.openOrCreateDatabase(DB_NAME, MODE_PRIVATE, null);
baza.execSQL("CREATE TABLE IF NOT EXISTS Notepad (Title VARCHAR UNIQUE, Text VARCHAR)");
           
} catch (SQLException e) {
    e.printStackTrace();
}
  • Przykładowe zapytanie do bazy danych.
1
Cursor cursor = baza.rawQuery("SELECT Title FROM Notepad", null);

4. Wywołanie okna wprowadzania i edycji notatki.

1
2
Intent intent = new Intent(getApplicationContext(), AddNote.class);
startActivityForResult(intent, REQUEST_CODE);

5. Przekazywanie parametrów pomiędzy widokami.

1
2
3
4
5
6
7
intent = new Intent();
               
        intent.putExtra("Title", title.getText().toString());
        intent.putExtra("Text", text.getText().toString());
                 
        AddNote.this.setResult(RESULT_CODE, intent);                    
AddNote.this.finish();

6. Tworzenie oraz obsługa wysuwanego menu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        super.onCreateOptionsMenu(menu);
        menu.add(0, ADD_ID, 0, R.string.menu_add);
        return true;
}

@Override
    public boolean onMenuItemSelected(int featureId, MenuItem item) {
        switch(item.getItemId()) {
            case ADD_ID:
                addNote();
                return true;
        }

        return super.onMenuItemSelected(featureId, item);
    }

7. Naciskając Run, tworzymy plik apk jednocześnie odpalając go na emulatorze (jeżeli stworzyliśmy AVD) lub na urządzeniu.

Cały projekt można pobrać z: AtenaNotepad

Podsumowanie

Programowanie na platformę Android jest bardzo szerokim tematem m.in. ze względu na ilość dostępnych peryferii oraz bibliotek. Ten artykuł jest jedynie wstępem, w którym skupiłem się na przygotowaniu środowiska oraz stworzeniem pierwszego projektu. Przedstawiona aplikacja pokazuje wykorzystanie takich elementów, jak menu kontekstowe, widok listy, komunikacja pomiędzy widokami, wysuwane menu, obsługa bazy danych oraz tworzenie widoków poprzez pliki xml. Jeżeli ktoś chciałby zapoznać się z innymi możliwościami, zachęcam do przeanalizowania przykładów zawartych w folderze samples z katalogu, w którym zainstalowaliśmy SDK. Można je zaimportować do Eclipse poprzez wybranie opcji File->Import->Existing Project into Workspace. Działanie aplikacji demonstrujących możliwości poszczególnych API można również zaobserwować w emulatorze w folderze API Demos.

Materiały

]]> http://blog.atena.pl/wstep-do-androida/feed 9 Aplikacje mobilne w HTML5, Phonegap, jQueryMobile http://blog.atena.pl/aplikacje-mobilne-w-html5-phonegap-jquerymobile http://blog.atena.pl/aplikacje-mobilne-w-html5-phonegap-jquerymobile#comments Tue, 15 Nov 2011 09:12:08 +0000 Zbigniew Wysocki http://blog.atena.pl/?p=1855 Poszukiwanie sposobu na łatwe i szybkie wytwarzanie aplikacji mobilnych to nieustająca zabawa. Mnogość technologii, platform oraz frameworków wspomagających ten proces jest spora. Tym razem postanowiłem wziąć na tapetę HTML5. Pisanie w technologii JavaScript, HTML5, CSS3 wydaje się prostsze niż Objective-C, a już na pewno łatwiej tu o programistę z doświadczeniem. Czy ta technologia jest faktycznie użyteczna w świecie smartfonów i tabletów? Postaram się odpowiedzieć na to pytanie oraz opisać pomocnicze narzędzia.

HTML5

HTML5, jak dobrze wiadomo, jest następną wersją popularnego języka hyper text markup language (HTML). Pomyślano ją tak, aby ułatwiała pisanie nie tylko stron internetowych, ale również aplikacji pracujących nawet w trybie offline. Doszła możliwość rysowania nowych obiektów 2D canvas, obsługa plików wideo i audio oraz wiele innych. Nie będę zagłębiał się w wątek nowości HTML5, dla ciekawych poniżej znajduje się stosowny link do źródeł.
Bardziej interesuje mnie, jak zrobić w HTML5 aplikację. Aby działała poprawnie na urządzeniu mobilnym, wymagana jest przeglądarka wspierająca tę technologię. Obecnie całkiem dobrze radzi sobie z tym Opera, która jednak nie jest domyślną przeglądarką w smartfonach. Spośród dostarczonych przez daną platformę, wsparcie dla HTML5 wygląda już nieco gorzej w przypadku Androida, a sporo gorzej w przypadku Blackberry czy Windows Phone. Zapewne z czasem sytuacja ta będzie się poprawiać. Jeśli ktoś chciałby sprawdzić, na ile dobrze wspiera HTML5 jego własna przeglądarka, polecam ten test. Mój Galaxy S2 i9100 z Androidem 2.3.3 uzyskał wynik 128 na 160 punktów. Skoro przeglądarki różnią się znacząco od siebie w implementacji specyfikacji HTML5, łatwo sobie wyobrazić, jakie problemy spotkają nas przy kodowaniu. Odmienne zachowanie aplikacji w zależności od przeglądarki jest kłopotliwe w testowaniu i programowaniu, a więc kosztowne. A może da się jakoś raz napisać aplikację w HTML5, aby tak samo działała na różnych telefonach?

Phonegap i jQuery

Phongap – tak właśnie nazywa się framework ułatwiający nam okiełznanie HTML5 i skłonienie tej technologii do poprawnego działania na różnych telefonach. Pozwala na pisanie jednej aplikacji i wydanie jej w postaci oddzielnych paczek dedykowanych dla odpowiedniej platformy. Dostęp do API urządzenia odbywa się przez funkcje javascriptowe dostępne w pliku phonegap-1.1.0.js. Instrukcja jak napisać „Hello World!” i skonfigurować środowisko znajduje się tutaj http://phonegap.com/start#android. Podałem linka do Androida, gdyż w nim postanowiłem napisać prostą aplikację, aby zobaczyć, jak to wszystko wygląda w tak zwanym praniu. Aplikacja miała za zadanie automatycznie logować nas do sieci wewnętrznej wifi, gdy włączy się połączenie. Dodatkowo wyświetlać obecny status połączenia z siecią i na osobnej stronie umożliwić konfigurację, która byłaby na stałe zapamiętana w telefonie. Pisanie w samym HTML i JS czegoś więcej niż „Hello World!” jest dość żmudne. Zwłaszcza jeśli chcemy zapewnić estetyczny wygląd formularzy, układ strony itd. Ponieważ dobry programista to „leniwy” programista, postanowiłem poszukać gotowych bibliotek wspomagających pracę z JS na mobilne urządzenia. Skorzystałem z jQueryMobile, gdyż jQuery jest popularny i zawiera wiele przydatnych funkcji JS. Aby dodać go do naszego projektu, należy ściągnąć pliki z http://jquerymobile.com/download/ i zapisać w katalogu assets/www. Skoro mamy już wszystko, co nam potrzebne, zaczynamy!

Trochę kodu

Tworzymy stronkę index.html i w sekcji head dołączamy potrzebne pliki. W tym momencie najlepiej jest utworzyć plik lib.js na potrzeby własnych funkcji javascriptowych.

1
2
<script src="phonegap-1.1.0.js" type="text/javascript"></script> <script src="jquery-1.6.4.min.js"></script>
<script src="jquery.mobile-1.0rc2.js"></script> <script src="lib.js" type="text/javascript"></script>

Potrzebny będzie nam jeszcze dostęp do API Androida, aby wykryć połączenie z wifi oraz zapisanie lokalnie na telefonie ustawień aplikacji. Na zmiany połączenia z siecią możemy reagować poprzez funkcję nasłuchiwania odpowiednich zdarzeń.

1
2
document.addEventListener("offline", pgOffOnline, false);
document.addEventListener("online", pgOnOnline, false);

pgOffOnline i pgOnOnline to nazwy moich funkcji wywoływanych w momencie wystąpienia zdarzenia. Zapisanie danych w telefonie możliwe jest dzięki

1
localStorage.setItem(klucz, wartość);

Pozostało jeszcze napisać formularze w HTML i połączyć wszystko w jedną całość. Kod index.html i lib.js poniżej na stronie, a cała aplikacja, którą można zaimportować do Eclipse na dole w dziale linki.

index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<script src="phonegap-1.1.0.js" type="text/javascript"></script> <script src="jquery-1.6.4.min.js"></script>
<script src="jquery.mobile-1.0rc2.js"></script> <script src="lib.js" type="text/javascript"></script>

<script type="text/javascript">
    document.addEventListener("deviceready", onDeviceReady, false);
    function onDeviceReady() {
        document.addEventListener("offline", pgOffOnline, false);
        document.addEventListener("online", pgOnOnline, false);
        checkConnection();
    }
</script>
<div id="home">
<div>
<h1>Atena Wifi Connector</h1>
</div>
<div>

Twoje obecne polaczenie to :

<a href="#settings">Ustawienia</a>

</div>
</div>
<div id="settings">
<div>
<h1>Ustawienia</h1>
<div class="ui-body ui-body-b">
<fieldset> <legend>Zaloguj autmatycznie:</legend><input id="start" class="custom" name="start" type="checkbox" /> <label for="start">Tak</label></fieldset>
<div><label for="login">Login:</label> <input id="login" name="login" type="text" />
<label for="pass">Haslo:</label> <input id="pass" name="pass" type="password" /></div>
<button onclick="saveSettings();">Zapisz</button><button onclick="cancelSettings();">Anuluj</button>

</div>
</div>
<script type="text/javascript">
        $('#login').attr("value",getProperty(LOGIN_KEY,LOGIN_DEFAULT));
        $('#pass').attr("value",getProperty(PASSWORD_KEY,PASSWORD_DEFAULT));
        if(getProperty(STARTUPAPP_KEY,STARTUPAPP_DEFAULT)){
            $('#start').attr("checked","checked");
        }

</script>

</div>
lib.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
const PASSWORD_KEY = "password";
const LOGIN_KEY = "login";
const STARTUPAPP_KEY = "STARTUPAPP";

const PASSWORD_DEFAULT = "xx";
const LOGIN_DEFAULT = "xxx";
const STARTUPAPP_DEFAULT = true;

function connect2Wifi(){
var url = "https://1.1.1.1/login.html";
var login = getProperty(LOGIN_KEY,LOGIN_DEFAULT);
var pass  = getProperty(PASSWORD_KEY,PASSWORD_DEFAULT);
$.ajax({
type: 'post',
url: url,
data: {'buttonClicked':'4','err_flag':'0','err_msg':'0','info_flag':'0','info_msg':'','username':login,'password':pass},
success: function(data){
},
});

}

function checkConnection() {

var networkState = navigator.network.connection.type;

var states = {};
states[Connection.UNKNOWN] = 'Unknown connection';
states[Connection.ETHERNET] = 'Ethernet connection';
states[Connection.WIFI] = 'WiFi connection';
states[Connection.CELL_2G] = 'Cell 2G connection';
states[Connection.CELL_3G] = 'Cell 3G connection';
states[Connection.CELL_4G] = 'Cell 4G connection';
states[Connection.NONE] = 'No network connection';

setConnectionStatus(states[networkState]);

if(getProperty(STARTUPAPP_KEY,STARTUPAPP_DEFAULT)){
if (networkState == Connection.WIFI) {
connect2Wifi();
}
}

}

function saveSettings(){
setProperty(LOGIN_KEY,$('#login').attr("value"));
setProperty(PASSWORD_KEY,$('#pass').attr("value"));
setProperty(STARTUPAPP_KEY,$('#start').attr("value"));
$.mobile.changePage( "#home", { transition: "slideup"} );
}

function cancelSettings(){
$.mobile.changePage( "#home", { transition: "slideup"} );
}

function setConnectionStatus(status){
document.getElementById('status').innerHTML = status

}
function pgOnOnline() {
checkConnection();
}
function pgOffOnline() {
checkConnection();
}

function getProperty(name,defaultvalue){
var val =localStorage.getItem(name);
if(jQuery.isEmptyObject(val)){
return defaultvalue;
}else{
return val;
}
}
function setProperty(name,value){
try {
localStorage.setItem(name, value);
} catch (e) {
if (e == QUOTA_EXCEEDED_ERR) {
alert('Brak miejsca na zapisanie danych.');
}
}
}

Podsumowanie

Podsumowując, połączenie HTML5, Phonegapa z jQueryMobile wywołuje wrażenie jak najbardziej pozytywne. Nie było większych problemów czy błędów, które bym napotkał, mimo że jQuery jest jeszcze w wersji rc1. Dokumentacja do Phonegap jak i jQuery jest na bardzo dobrym poziomie – nic, tylko zacząć kodować. Zdecydowanie polecam to rozwiązanie, jeśli chcemy napisać prostą aplikację na różne telefony. Opanowanie HTML5 z JS jest znacznie szybsze, niż nauczenie się Javy dla Androida, Objective-C na iPhona itd. Ponadto możliwości, jakie udostępnia nam HTML5 pozwalają na stworzenie także rozbudowanych i zaawansowanych aplikacji. Dodatkowo Phonegap dostarcza nam środowisko do kompilowania aplikacji na różne platformy. Tak więc wystarczy napisać sam plik index.html, wrzucić na serwer i pobrać naszą skompilowaną aplikację dla danej platformy https://build.phonegap.com/

Linki

]]> http://blog.atena.pl/aplikacje-mobilne-w-html5-phonegap-jquerymobile/feed 0 Różnorodność mobilnych systemów operacyjnych – ograniczenie czy szansa? http://blog.atena.pl/roznorodnosc-mobilnych-systemow-operacyjnych-ograniczenie-czy-szansa http://blog.atena.pl/roznorodnosc-mobilnych-systemow-operacyjnych-ograniczenie-czy-szansa#comments Wed, 22 Jun 2011 08:22:45 +0000 Zbigniew Wysocki http://blog.atena.pl/?p=1348 Rynek urządzeń mobilnych jest zdecydowanie jednym z najszybciej rozwijających się na świecie, a co za tym idzie – także zapotrzebowanie na aplikacje jest ogromne. A wraz ze wzrostem możliwości i dostępności tego rynku, również jego oczekiwania będą coraz większe. Mówiąc wprost, prędzej czy później firmy IT będą musiały rozpocząć prace nad tego typu aplikacjami, aby sprostać wymaganiom rynku. Jednak każdy, kto wytwarzał aplikacje mobilne lub zastanawiał się nad tym, zapewne zdaje sobie sprawę z trudności związanych z różnorodnością obecnych telefonów oraz tempem pojawiania się nowych modeli. Popularne od lat API Javy czy Symbiana także nie jest przyjazne dla programisty. Czy jednak tak jest ciągle? Co zmieniło się w ostatnich latach? Jak ten rynek będzie wyglądał za parę lat? Na jakie problemy można natrafić podczas prowadzenia projektu? Wybrałem się na wykład pod tytułem „Różnorodność mobilnych systemów operacyjnych – ograniczenie czy szansa” w ramach tegorocznej konferencji InfoShare z nadzieją, iż Łukasz Korzeniowski z firmy FancyFon S.A pomoże mi w znalezieniu odpowiedzi na te pytania.

Opis prezentacji

Podczas prezentacji Łukasz Korzeniowski skupił się na porównaniu czasu pisania aplikacji na różne platformy telefonów komórkowych oraz podsumowaniu co zaskoczyło twórców i z czym mieli największe problemy. Przedstawił także obecne trendy i przyszłe prognozy popularności telefonów. Nie zostały poruszone szczegółowe różnice platform w oferowanych możliwościach. Wszystkie wnioski, jakie zostały przekazane przez prowadzącego, pochodzą z realnego projektu Pakk wykonanego na zlecenie węgierskiego klienta Vodafone. Ważne jest też, że do każdego typu telefonu został przydzielony programista z doświadczeniem w pracy z daną platformą.

Obecne dane

Oto, jak przedstawia się procentowy udział platformy na rynku urządzeń mobilnych za pierwszy kwartał 2011 roku:

Platforma 2011 Market Share
Android 39.5%
BlackBerry 14.9%
iOS 15.7%
Symbian 20.9%
WindowsMobile 5.5%
Others 3.5%

Według danych od Vodafhone wśród czołowych czterdziestu modeli telefonów występują:

  • Java: 42%
  • Symbian: 26%
  • Android: 32%

Podsumowanie platform

Java

Zalety
  • Stosunkowo krótki czas wytworzenia
  • Powszechny język programowania
Problemy:
  • API nie działające zgodnie ze specyfikacją
  • rozmiar aplikacji
  • zróżnicowanie wielkości ekranu
  • zróżnicowanie możliwości przeglądarki
  • różna reprezentacja obiektów (np. kontakt)
  • wysoki koszt testów
  • problem z konfiguracją APN (Nokia) oraz uprawnień aplikacji – negatywny wpływ na wrażenia użytkownika!!!

Android

Zalety:
  • wielozadaniowy system operacyjny – można więcej
  • duża swoboda aplikacji (szeroki dostęp do systemu)
  • popularny język programowania
  • szybkość tworzenia aplikacji
  • automatyczna dostępność aplikacji na tablety
Problemy:
  • różnice w zachowaniu API na różnych modelach telefonów (raczej incydentalne)
  • pewne nienaruszalne założenia (np. sposób instalacji aplikacji) – ograniczenie możliwości
  • nie najlepsza dokumentacja

Symbian

Zalety:
  • API pozwalające na dostęp do każdego elementu systemu
  • w nowych telefonach możliwość tworzenia aplikacji w Qt
Problemy:
  • dużo wyższa pracochłonność niż na innych platformach (bez użycia Qt)
  • archaiczny język i środowisko programistyczne
  • ukryte API
  • skomplikowany system podpisów
  • „sztuczki i kruczki” zarówno w systemie jak i w środowisku
  • zróżnicowanie między wersjami Symbiana
  • zróżnicowanie między urządzeniami

iPhone

Zalety:
  • niewielka liczba urządzeń i wersji systemu
  • szybki development
  • „błyszczący” interfejs użytkownika
  • automatyczna dostępność aplikacji dla iPad
Wady:
  • nietypowy język programowania
  • konieczność posiadania sprzętu Apple
  • ograniczone API do dostępu do elementów systemu (np. skrzynka SMS)

Czas napisania aplikacji

Platforma Czas
Java półtora miesiąca
Symbian ponad dwa i bez paru funkcjonalności
Android miesiąc
iOS trzy tygodnie

Wnioski

Ważne jest, aby podczas podpisywania umowy ograniczyć ilość telefonów docelowych na których zapewniamy poprawność naszej aplikacji. Mnogość modeli na rynku może znacząco wpłynąć na ryzyko przekroczenia budżetu i czasu naszego projektu. Należy testować aplikację na konkretnych telefonach, a nie tylko symulatorach, co również pozwoli skrócić czas wykrycia nieprawidłowości w działaniu aplikacji.
W związku z popularyzacją smartphonów i osłabianiem się pozycji Symbiana na rynku, powinno się w miarę możliwości zrezygnować z supportu dla tej drugiej platformy. Po za tym sprawił on najwięcej problemów w projekcie i zajął najwięcej czasu. W przypadku iPhona powinno się zastanowić, na ile nasza aplikacja może być popularna na iStore, gdyż w przypadku napisania pierwszej koszty wejścia na ten rynek, są dość wysoki. Niestety niezbędny jest zakup: iPhone, iMac i licencji developerskiej pozwalającej na publikowanie aplikacji w iStore. Kolejną rzeczą, która wymaga zastanowienia , jest fakt, że w powyższym przedsięwzięciu nie używano praktycznie żadnego współdzielenia kodu między platformami. Rozwiązaniem tego problemu może być użycie jednego z frameworków:

Z powyższej listy do prostego interfejsu bez „fajerwerków” wybrałbym zdecydowanie PhoneGap. Dzięki użyciu HTML5 i javascript (powszechnie znanych technologi) jest on bardzo prosty w użyciu dla programisty. Zarazem zapewnia API pozwalające na tworzenie dowolnych aplikacji, można odwoływać się również do native API. Gdyby pojawiły się problemy, możemy liczyć na wsparcie rozwijającej się społeczności wokół tego projektu. Natomiast jeśli miałaby to być gra lub inna aplikacja wymagająca więcej od telefonu, warto rozważyć użycie OpenGL. Projekt ten jest wiodącym pod względem renderingu 3D. Więcej informacji o frameworkach można znaleźć na stronach podanych powyżej. Dodatkowe wiadomości można również zaczerpnąć z prezentacji Łukasz Korzeniowskiego dostępnej tutaj.



]]> http://blog.atena.pl/roznorodnosc-mobilnych-systemow-operacyjnych-ograniczenie-czy-szansa/feed 0 Czy Clojure da się lubić? http://blog.atena.pl/czy-clojure-da-sie-lubic http://blog.atena.pl/czy-clojure-da-sie-lubic#comments Tue, 07 Jun 2011 11:37:37 +0000 Marcin Garniewski http://blog.atena.pl/?p=1281 Po prezentacji Jacka Laskowskiego „Programowanie funkcjonalne funkcyjnie z Clojure praktycznie” na Infoshare 2011 wychodziliśmy z mieszanymi uczuciami. Powtarzał się pogląd o niedosycie informacji o tym nowym (dla mnie) języku. Korzystając z rozbudzonej ciekawości poznawczej, postanowiłem przyjrzeć się bliżej temu nawiasowemu językowi .

Powtarzając za Wikipedią, głównymi cechami języka są:

  • kompilowany do kodu bajtowego JVM (ang. Java Virtual Machine, wirtualna maszyna Javy);
  • pełna kompatybilność z Javą: Clojure natywnie wywołuje metody Javy i na odwrót;
  • możliwość pracy w trybie interaktywnym REPL (ang. read-eval-print loop, pętla wczytaj-wykonaj-wypisz);
  • domknięcia z naciskiem na rekurencję;
  • bogata biblioteka stałych struktur danych;
  • silne wsparcie dla współbieżności w postaci transakcyjnej pamięci (ang. Software Transactional Memory – STM) i systemu agentów.

Środowisko deweloperskie

Zacznijmy od instalacji środowiska pracy. Istnieją odpowiednie pluginy do większości popularnych IDE. Osobiście preferuję środowisko Eclipse, a więc do niego zainstalowałem plugin Counterclock. Po instalacji pluginu mamy między innymi funkcjonalność podpowiadania składni oraz okno REPL. REPL służy do dynamicznego programowania (o tym za chwilę).
Dodatkowo proponuję zainstalować środowisko Leiningen. Jest to środowisko uruchomieniowe Clojure — odpowiednik Maven w Javie. Sposób instalacji opisany jest na stronie projektu. Sprowadza się do pobrania aplikacji, rozpakowania pliku w katalogu docelowym i dodania ścieżki do zmiennej systemowej PATH. Następnie wydajemy polecenie lein self-install i to już wszystko. Lein automatycznie ściąga wszystkie niezbędne pakiety. Mała uwaga dotycząca sytuacji, w której jesteśmy za proxy. W pliku lein.bat dodajemy wiersze:

1
2
set http_proxy=http://server_proxy:port
set https_proxy=http://server_proxy:port

oraz modyfikujemy poniższy wiersz z:

1
set HTTP_CLIENT=wget --no-check-certificate -O

na:

1
set HTTP_CLIENT=wget --proxy-user=domena+login --proxy-password=hasło --no-check-certificate -O

Rozwiązuje nam to problem proxy.

Po instalacji otrzymujemy dostęp do interfejsu shellowego, w którym dostępnych jest wiele przydatnych akcji:

Dostępne są opcje rozwiązujące zależności (deps), kompilujące (compile) oraz oczywiście budujące (jar). Jednak jedną z najciekawszych funkcji jest możliwość rozszerzania funkcjonalności lein przez system pluginów. Jeden z nich to plugin generujący strukturę plików dla edytora Eclipse.
A więc po kolei:

  • tworzymy nowy projekt Clojure, wpisując polecenie lein new HelloWorldProject:
  • edytujemy wygenerowany plik D:\temp\HelloWorldProject\project\core.clj:
    1
    2
    3
    4
    5
    6
    7
    (defproject HelloWorldProject "1.0.0-SNAPSHOT"
    :description "FIXME: write description"
    :dependencies [[org.clojure/clojure "1.2.1"]]
    :dev-dependencies [
    [lein-eclipse "1.0.0"|lein-eclipse "1.0.0"]
    ]
    )
  • wydajemy polecenie lein deps — zostanie automagiczne ściągnięty plugin
  • wydajemy polecenie lein eclipse — zostają wygenerowane pliki .classpath i .project:
  • w Eclipsie importujemy project: File->Import…I gotowe! Projekt jest przygotowany do edycji w Eclipsie. Możemy rozpocząć programowanie.

    Składnia języka

Nie da się ukryć, że pierwszy kontakt ze składnią języka jest małym szokiem dla deweloperów Javy czy też C#. Za to programiści Lispa będą się czuć jak ryby w wodzie. Z tego właśnie języka pochodzi składnia języka. Najprościej rzecz ujmując, szablon wygląda następująco:

1
(polecenie argument argument)

Garść przykładów:

1
2
3
(println "Hello World"); — bez komentarza
(* 3 3); — wynik 9
(def zmienna (+ 2 (* 4 5))) — definicja zmiennej

Myślę, że nie ma sensu mnożyć tutaj przykładów, gdyż składnia jest bardzo szeroka, a jeszcze szersza jest baza tutoriali, przykładów oraz blogów na sieci. Ciekawsze propozycje zamieściłem na końcu tego artykułu w sekcji „Zasoby w sieci”.

Uruchomienie skryptu

Jest kilka możliwości uruchomienia skryptu. Wszystkie opierają się na rozwiązaniu REPL, czyli dynamicznym programowaniu. Daje ona np. możliwość ingerowania w kod działającej (nawet produkcyjnie) aplikacji. Potencjalnie możliwości są ogromne. Technicznie najprościej jest z poziomu Eclipsa wybrać edytowany skrypt *.clj i wydać komendę „Run”. Zostanie uruchomiona konsola REPL, kod skryptu zostanie załadowany i uruchomiony. Od tego momentu mamy dostęp do konsoli, w której możemy kontynuować kodowanie. Dynamiczność takiego programowania najłatwiej przedstawić na aplikacji swingowej. Poniższy kod uruchomi aplikację okienkową, w której podczas działania zmienimy rozmiar okna. To naprawdę działa, proszę sprawdzić!

  • import klasy JFrame
    1
    (import (javax.swing JFrame))
  • przypisanie do zmiennej f nowego obiektu klasy JFrame
    1
    (def f (JFrame. "Mój frame"));
  • uruchomienie metod pack i show na obiekcie f:
    1
    (doto f .pack .show)

    Efekt:

    A teraz uwaga! Program działa, a my w tym czasie zmienimy rozmiar okna:

    1
    (.setSize f 100 100)

    I oto wynik:

    Mała rzecz, a cieszy :) .

    Podsumowanie

Siłą języka Clojure jest kompilacja do bajtkodu Javy. Dzięki temu może być wykorzystany w istniejących systemach jako zewnętrzna biblioteka. Inaczej mówiąc, Clojure nie oferuje nic więcej niż daje język Java. Za to udostępnia rozwiązania, których napisanie „ręcznie” w Javie zajęłoby wiele czasu i sprawiłoby niemały kłopot. Nie wspomniałem tu nic o wielowątkowości, która jest najsilniejszą stroną tego języka. Jest to podobno idealny język do pisania wielowątkowych aplikacji. Temat jest na tyle szeroki, że w celu jego omówienia można by napisać kolejny artykuł.

Zasoby w sieci

http://clojure.org/ — strona domowa
http://clojure.pl — polska strona domowa
http://java.ociweb.com/mark/clojure/article.html — świetny opis języka
http://clojars.org/ — baza danych o bibliotekach w Clojure
http://en.wikibooks.org/wiki/Clojure_Programming — wikibook o Clojure
http://www.learningclojure.com/
http://pramode.net/clojure/
http://www.clojureblog.pl/
http://loufranco.com/blog/files/category-20-days-of-clojure.html — 20 dni z Clojure

]]> http://blog.atena.pl/czy-clojure-da-sie-lubic/feed 2 PRAKTYCZNY ENVERS http://blog.atena.pl/praktyczny-envers http://blog.atena.pl/praktyczny-envers#comments Fri, 20 Aug 2010 07:00:10 +0000 Mateusz Mrozewski http://blog.atena.pl/?p=1028 Envers jest dodatkiem do Hibernate’a pozwalającym na automatyczne zapisywanie historii zmian encji (audytu). Envers używa pojęcia rewizji – co oznacza, że każda zmiana dowolnej (audytowalnej) encji tworzy nową rewizję. Nowy rekord jest zapisany do tabeli, a na podstawie starego zostaje utworzona rewizja i zapisana do dodatkowej tabeli wraz z poprzednimi wartościami.

Konfiguracja

W ramach podstawowej niezbędnej konfiguracji należy dodać następujące właściwości do pliku persistence.xml lub hibernate.cfg.xml:

<property name=”hibernate.ejb.event.post-insert” value=”org.hibernate.ejb.event.EJB3PostInsertEventListener,org.hibernate.envers.event.AuditEventListener” />
<property name=”hibernate.ejb.event.post-update” value=”org.hibernate.ejb.event.EJB3PostUpdateEventListener,org.hibernate.envers.event.AuditEventListener” />
<property name=”hibernate.ejb.event.post-delete” value=”org.hibernate.ejb.event.EJB3PostDeleteEventListener,org.hibernate.envers.event.AuditEventListener” />
<property name=”hibernate.ejb.event.pre-collection-update” value=”org.hibernate.envers.event.AuditEventListener” />
<property name=”hibernate.ejb.event.pre-collection-remove” value=”org.hibernate.envers.event.AuditEventListener” />
<property name=”hibernate.ejb.event.post-collection-recreate” value=”org.hibernate.envers.event.AuditEventListener” />

Konfigurujemy w ten sposób listenery , które sprawdzają, czy zmieniły się jakieś audytowalne encje i czy należy zachować historię zmian tych encji.

Kolejnym krokiem jest już oznaczenie encji adnotacją @Audited. Jeśli adnotację umieścimy na poziomie klasy, wszystkie pola będą wersjonowane. Możemy również adnotację umieścić na poziomie pól klasy, aby wersjonować tylko wybrane.

Przykład użycia

Po umieszczeniu konfiguracji opisanej w kroku wyżej użycie Envers’a sprowadza się do dodania odpowiednich adnotacji.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Entity
@Audited
public class Item {
    @Id
    private int id;

    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

I to tak naprawdę wszystko z rzeczy specyficznych dla Envers. Użycie encji w innym zakresie jest tak standardowe, jak w przypadku JPA lub Hibernate i w zasadzie niczym się od nich nie różni.

Przechowywanie rewizji

Dla każdej adnotowanej encji zostanie utworzona dodatkowa tabela przechowująca audyt. Dla naszej encji z podanego przykładu powstanie podstawowa tabela:

1
2
3
4
5
CREATE TABLE ITEM
(
ID decimal(10) PRIMARY KEY NOT NULL,
NAME varchar2(1020)
);

Oraz dodatkowa tabela do przechowywania audytu:

1
2
3
4
5
6
7
8
CREATE TABLE ITEM_AUD
(
ID decimal(10) NOT NULL,
REV decimal(10) NOT NULL,
REVTYPE decimal(3),
NAME varchar2(1020),
CONSTRAINT SYS_C006187 PRIMARY KEY (ID,REV)
);

Dodatkowo doszły nam następujące pola:

  • REV – oznacza numer rewizji;
  • REVTYPE – typ zmiany; możliwe wartości: 0 – wstawienie rekordu, 1 – modyfikacja rekordu, 2 – usunięcie rekordu.

Najnowszy rekord w tabeli audytu będzie miał wartości o jedną wersję wstecz względem wartości w aktualnej tabeli. Jeśli natomiast rekord zostanie usunięty, nie znajdziemy go już w tabeli podstawowej, a najświeższy wpis będzie miał wartości ustawione na <null> i typ rewizji 2.

Numery rewizji są wspólne dla wszystkich encji. Oznacza to, że jeśli najpierw zmienimy encję A, otrzyma ona rewizję 1, dopiero potem zmienimy encję B, która otrzyma rewizję 2 (oczywiście obie będą posiadały oddzielne tabele audytu).

Encja rewizji i zapis dodatkowych danych

Oprócz zapisywania historii zmian danej encji możemy dla każdej rewizji zapisać dodatkowe informacje. Służy do tego encja rewizji – jest to standardowa encja z dodatkową adnotacją oraz dodatkowymi polami, jakie chcemy zapisać. Przykładowo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Entity
@RevisionEntity(MyRevisionListener.class)
public class MyRevisionEntity extends DefaultRevisionEntity {
    private static final long serialVersionUID = -78999006241889798L;
    private String username;
   
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

Klasa DefaultRevisionEntity jest dostarczana wraz z Envers i deklaruje dwa podstawowe pola: id oraz timestamp. Do tego możemy dołożyć dodatkowe informacje, które chcemy zapisać, np. nazwę użytkownika. Wykonuje się to w listenerze wskazanym przez adnotację @RevisionEntity:

1
2
3
4
5
6
7
8
public class MyRevisionListener implements RevisionListener {

    public void newRevision(Object revisionEntity) {
        MyRevisionEntity entity = (MyRevisionEntity) revisionEntity;
        entity.setUsername("NAZWA UŻYTKOWNIKA");
    }

}

Dla przykładowej encji rewizji zostanie utworzona następująca tabela:

1
2
3
4
5
6
CREATE TABLE MYREVISIONENTITY
(
ID decimal(10) PRIMARY KEY NOT NULL,
TIMESTAMP decimal(19) NOT NULL,
USERNAME varchar2(1020)
);

Teraz przy utworzeniu nowej rewizji dowolnej audytowanej encji zostanie utworzony nowy wpis w tej tabeli z danymi uzupełnionymi według naszego listenera.

Odpytywanie o rewizje

Envers dostarcza klasy użytkowe pozwalające na odpytywanie o stan rewizji poszczególnych encji. Klasa AuditReaderFactory pozwala nam na pobranie instancji AuditReader w zależności od tego, czy operujemy na EntityManager z JPA czy też na Session z Hibernate.

AuditReader pozwala na budowanie zapytań implementujących interfejs AuditReader. Służy on do budowania zapytań w sposób podobny jak w przypadku Hibernate Criteria. Pytać możemy na dwa sposoby:

  • o encję w konkretnej rewizji,
  • o rewizje, w których encje się zmieniły.

Przykład zapytania o konkretną rewizję:

1
2
3
4
5
6
7
int revision = 1;
AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Item.class, revision);

List items = query.addOrder(AuditEntity.property("name").desc())
    .setFirstResult(4)
    .setMaxResults(2)
    .getResultList();

Przykład zapytania o rewizje, w których zmieniała się encja:

1
2
3
4
5
6
int revision = 1;
Number revision = (Number) getAuditReader().createQuery()
    .forRevisionsOfEntity(Item.class, false, true)
    .setProjection(AuditEntity.revisionNumber().min())
    .add(AuditEntity.id().eq(entityId))
    .getSingleResult();

Wnioski

Jak widać, Envers pozwala na łatwe wdrożenie historii zmian bez specjalnego nakładu pracy i praktycznie transparentnie dla istniejącego modelu. Warto też wspomnieć, że Envers stał się już częścią dystrybucji Hibernate’a (od wersji 3.5), co dodatkowo świadczy o jego użyteczności i jakości.

Źródła

Strona główna projektu: http://jboss.org/envers
Dokumentacja: http://docs.jboss.org/envers/docs/index.html

]]> http://blog.atena.pl/praktyczny-envers/feed 0 SUMI jako metoda badania jakości oprogramowania http://blog.atena.pl/sumi-jako-metoda-badania-jakosci-oprogramowania http://blog.atena.pl/sumi-jako-metoda-badania-jakosci-oprogramowania#comments Fri, 09 Oct 2009 09:58:43 +0000 Bartosz Żukowski http://blog.atena.pl/?p=781 Wdrażanie systemów informatycznych w przedsiębiorstwach powinno przyczyniać się do zwiększenia ich zysków. Nie kupuje się nowych technologii w pogoni za nowoczesnością, lecz traktuje je jak inwestycje w biznes. Menedżerowie liczą, że poniesione nakłady zwrócą się, wpływając na wzrost efektywności pracy firmy. Pozytywny efekt wdrożenia systemu powinien być widoczny w wynikach finansowych, a tę informację otrzymamy dopiero po pewnym czasie. Ważne jest zatem monitorowanie wydajności, rozpoznawanie trendów i reagowanie z wyprzedzeniem. Jednym z elementów pozwalających ocenić efektywność jest satysfakcja użytkowników końcowych. Właśnie w celu jej pomiaru opracowano metodę SUMI (Software Usability Measurement Inventory).

SUMI powstało na uniwersytecie Cork w Irlandii. Grupa ekspertów w dziedzinie oprogramowania stale rozwija tę metodę od ponad 15 lat. Jej celem jest badanie głównych czynników wpływających na użyteczność oprogramowania, mierzenie wydajności w połączeniu z satysfakcją z pracy. Metoda ta zdobyła popularność i jest powszechnie stosowana. Dzięki niej możemy mierzyć zadowolenie pracowników z używania nowego systemu.

SUMI opiera się na badaniu ankietowym w sześciu obszarach mających decydujący wpływ na wydajność pracy. Badane obszary to:

  1. współpraca – łatwości współpracy i komunikacji pomiędzy użytkownikami;
  2. dostęp do danych – tworzenie zestawień, raportów, wyszukiwanie informacji, wymiana informacji;
  3. elastyczność – obsługa nietypowych problemów i zadań, możliwości wprowadzania modyfikacji;
  4. użyteczność – łatwość obsługi, komfort pracy;
  5. znajomość – nauka obsługi, intuicyjność rozwiązań;
  6. wydajność transakcyjna – szybkość i niezawodność, wykonywanie powtarzalnych zadań.

Badanie polega na wypełnieniu ankiet przez użytkowników systemu. Pytania w poszczególnych obszarach tworzone są w oparciu o scenariusze użycia, które odzwierciedlają realną pracę z systemem. Muszą one odpowiadać uprawnieniom i zakresom obowiązków użytkowników.

Przykład pytań ze znajomości obsługi:

  1. Czy do pracy z systemem X konieczne jest przeszkolenie?

a)      zdecydowanie tak

b)      tak

c)      raczej tak

d)      raczej nie

e)      nie

f)        zdecydowanie nie

  1. Czy podczas pracy zdarza się, że nie wiesz, który przycisk należy nacisnąć?

a)      zdecydowanie nie

b)      nie

c)      raczej nie

d)      raczej tak

e)      tak

f)        zdecydowanie tak

Wszystkie pytania są oceniane w tej samej kilkupunktowej skali, np. od 1 do 6. Dla każdego obszaru wyciągamy średnią ocenę. Konieczne jest przyjęcie dla wszystkich pytań jednakowych warunków, w których zawsze 6 to najlepsza odpowiedź. Ocena całego produktu powstaje przez średnią ważoną ze wszystkich obszarów.

Wyniki z badania pokazują, które obszary wymagają ulepszeń, a z których użytkownicy są zadowoleni.

Przykładowe wyniki dla obszarów:

- współpraca 4,5

- dostęp do danych 4,8

- elastyczność 5,2

- użyteczność 3,8

- znajomość 2,8

- wydajność transakcyjna 3,9

Z przykładu można wyciągnąć wniosek, że aplikacja ma pewnie duże możliwości, lecz jest trudna w użyciu i użytkownicy potrzebują dużo czasu, aby móc z niej korzystać. Może to uniemożliwić zbieranie korzyści z wdrożenia, mimo że wszystkie funkcjonalności zostały zaimplementowane.

Przykład ten, choć uproszczony, ma za zadanie przedstawić ogólną zasadę. Badanie to jest o tyle interesujące, że w określonym zakresie można je przeprowadzać na prototypach i reprezentatywnej grupie użytkowników już w trakcie procesu wytwarzania. Metoda SUMI jest idealnym uzupełnieniem testów funkcjonalnych.

]]> http://blog.atena.pl/sumi-jako-metoda-badania-jakosci-oprogramowania/feed 0