czwartek, 17 lutego 2011

Klasa Command i interfejs CommandListener

Kontynuując nasz pierwszy midlet dodajmy do niego komendę umożliwiającą wyjście z aplikacji.

public class MojMidlet extends MIDlet {
    private Display display;
    private Form form;
    private Command exitCommand = new Command("Wyjdz", Command.EXIT, 1);

    public void startApp() {
        form = new Form("Jakis tekst");
        form.append("Pierwszy MIDlet");
        form.addCommand(exitCommand);
        
        display = Display.getDisplay(this);
        display.setCurrent(form);
    }
    ...

Oczywiście musimy zadeklarować obiekt klasy Command której konstruktor ma następującą składnię
                  Command(String Etykieta, int TypKomendy, int Priorytet)


Pamiętajmy o zaimportowaniu klasy wciskając CTRL+SHIFT+I (Fix Imports).


Następnie dodajemy komendę do istniejącej juz formy używając metody addCommand(Command komenda) i po uruchomieniu naszego midletu zobaczymy komendę "Wyjdź" która... nie działa.

Tutaj z pomocą idzie interfejs CommandListener, który nasz midlet musi implementować

public class MojMidlet extends MIDlet implements CommandListener {
    private Display display;
...


CommandListener posiada tylko jedną metodę która obsługuje naszą komendę , więc dopiszmy ją na końcu naszego kodu

    public void destroyApp(boolean unconditional) {
    }
    
    public void commandAction(Command c, Displayable d) {
        if (c == exitCommand) {
            destroyApp(false);
            notifyDestroyed();
        }            
    }


Widzimy, że spełnienie warunku (c == exitCommand) owocuje zakończeniem midletu. Oczywiście posiadając tylko jedną komendę warunek bedzie zawsze spełniony.


Ostatnim krokiem będzie dodanie instrukcji setCommandListener do naszego programu w metodzie startApp() bez której commandAction nie zostałaby wywołana.

    public void startApp() {
        form = new Form("Jakis tekst");
        form.append("Pierwszy MIDlet");
        form.addCommand(exitCommand);
        form.setCommandListener(this);

...


Można teraz smiało uruchomić midlet i sprawdzić poprawność działania naszej komendy.


Dodajmy jeszcze dwie komendy napiszCommand dodającą na ekranie tekst i czyscCommand, po której wciśnieciu nasza forma zostanie wyczyszczona. Zasada jest identyczna jak w przypadku exitCommand

  private Command exitCommand = new Command("Wyjdz", Command.EXIT, 1);
  private Command dodajCommand = new Command("DodajTxt", Command.OK, 1);
  private Command czyscCommand = new Command("Czysc", Command.OK, 1);

  public void startApp() {
      form = new Form("Jakis tekst");
      form.append("Pierwszy MIDlet");
      form.addCommand(dodajCommand);
      form.addCommand(czyscCommand);
      form.addCommand(exitCommand);        
      form.setCommandListener(this);

...

Zostaje nam tylko zmodifikować commandAction o dodane komendy

public void commandAction(Command c, Displayable d) {
        if (c == exitCommand) {
            destroyApp(false);
            notifyDestroyed();
        } else if (c == dodajCommand) {
            form.append("Dodany tekst\n");
        } else if (c == czyscCommand) {            
            form.deleteAll();
        }
    }

Metoda deleteAll() klasy Form usuwa wszystkie rzeczy umieszczone na danej formie, w tym przypadku wpisane teksty.

Kompletny kod naszego midletu i wynik działani powinien wyglądać następująco:




import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.*;


public class MojMidlet extends MIDlet implements CommandListener {
    private Display display;
    private Form form;
    private Command exitCommand = new Command("Wyjdz", Command.EXIT, 1);
    private Command dodajCommand = new Command("DodajTxt", Command.OK, 1);
    private Command czyscCommand = new Command("Czysc", Command.OK, 1);


    public void startApp() {
        form = new Form("Jakis tekst");
        form.append("Pierwszy MIDlet");
        
        form.addCommand(dodajCommand);
        form.addCommand(czyscCommand);
        form.addCommand(exitCommand);    
        
        form.setCommandListener(this);
        
        display = Display.getDisplay(this);
        display.setCurrent(form);
    }


    public void pauseApp() {
    }


    public void destroyApp(boolean unconditional) {
    }


    public void commandAction(Command c, Displayable d) {
        if (c == exitCommand) {
            destroyApp(false);
            notifyDestroyed();
        } else if (c == dodajCommand) {
            form.append("Dodany tekst\n");
        } else if (c == czyscCommand) {            
            form.deleteAll();
        }
    }
}








Linki

Zbiór stron traktujących o Javie:

Dokumentacja Oracle, czyli wszystkie dostępne w Javie klasy i metody, tutaj dla microedition
Kurs pisania prostej gry na telefon
Olbrzymi zbiór kodów źródłowych nietylko z Javy
Następna gra w J2ME
Tutoriale z Javy
Ciekawy kurs, a właściwie ksiażka
O programowaniu obiektowym na stronie Uniwersytetu Warszwskiego


Narazie tyle, ale postaram sie aktualizować ten post o nowe ciekawe strony.

środa, 16 lutego 2011

Pierwszy midlet

Utwórzmy nowy dostosowany do naszych potrzeb projekt w NetBeans

Wybieramy New Project z menu File a następnie zaznaczmy kategorie zgodne z rysunkiem poniżej


Klikamy Next > i wpisujemy nazwę naszego projektu np. MojPierwszyMidlet oraz odznaczamy opcje Create Hello MIDlet.


Możemy zakończyć tworzenie projektu klikając Finish i pominąć w tym MIDlecie wybór profilu i konfiguracji urządzenia. Terminy CLDC oraz MIDP wyjaśnie w następnych postach. Narazie skupmy się na szkielecie prostego MIDlet-u.

Utworzyliśmy więc nowy projekt, który jak widać w panelu Projects umieszczonym po lewej stronie nie ma jeszcze pliku z kodem źródłowym


Dodajmy teraz nowy MIDlet do naszego projektu. Menu File , New File i wybieramy opcje jak poniżej


Po kliknięciu Next > wpisujemy nazwę naszego midletu np MojMidlet. Pole Package na tym etapie możemy zostawić puste. Kończymy dodawanie pliku przyciskiem Finish.
Naszym oczom powinien ukazać się ten oto szkielet midletu

import javax.microedition.midlet.*;

/**
 * @author Lukasz
 */

public class MojMidlet extends MIDlet {

    public void startApp() {
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}

Nasza klasa MojMidlet dziedziczy po klasie MIDlet i musi nadpisywać (przesłaniać) jej abstrakcyjne metody:

startApp() - ustawia stan midletu na aktywny, tłumacząc niedosłownie uruchamia nasz midlet
pauseApp() - pauzuje nasz midlet np. w przypadku rozmowy przychodzącej
destroyApp(boolean unconditional)kończy działanie działanie midletu

Dodajmy trochę kodu tak aby nasz midlet wyświetlał na ekranie tekst "Pierwszy MIDlet". Umówmy się że nowo dodane linie będą pogrubione

import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.*;

public class MojMidlet extends MIDlet {
    private Display display;
    private Form form;

    public void startApp() {
        form = new Form(null);
        form.append("Pierwszy MIDlet");
        display = Display.getDisplay(this);
        display.setCurrent(form);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }
}


Zanim omówię co zrobiliśmy możemy uruchomić midlet wybierając Run Main Project z menu Run lub klikając ikonę uruchamiania na pasku narzędzi.

Uwaga do pierwszych lini 
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;

NetBeans umożliwia automatyczne importowanie potrzebnych nam klas za pomocą opcji Fix Imports z menu Source, wiec zamiast wpisywania ścieżek możemy użyć skrótu opcji Ctrl+Shift+I po ówczesnym zadeklarowaniu zmiennej referencyjnej do obiektu danej klasy (Form czy Display)

Wróćmy do naszego kodu. Mamy tu obiekt klasy Display, której używamy do wyświetlania na ekranie obiektów klas dziedziczących po klasie Displayable. W naszym przypadku jest to obiekt klasy Form, której konstruktor Form(null) tworzy pustą formę wyświetlaną później na ekranie. Gdybyśmy zmienili wywołanie konstruktora na

form = new Form("Jakis tekst");
efekt różniłby się o etykietę formy widoczną u góry ekranu



Metoda append("Pierwszy MIDlet") klasy Form umieszcza wpisany tekst na formie i wreszcie display.setCurrent(form) wyświetla naszą formę na ekranie.

Tak więc napisaliśmy pierwszy midlet posiadający jedna zasadniczą wadę - brak możliwości wyjścia z programu. Do poczytania o komendach wyjścia i nietylko oraz paru nowych rzeczach zapraszam do następnego posta.


Wstęp

Witam wszystkich którzy jakimś cudem tutaj dotarli i chcieliby nauczyć się czegoś o tworzeniu prostych (w przyszłości być może bardziej zaawansowanych) aplikacji na urządzenia mobline. Zakładam że każdy z czytelników zna podstawy programowania w Javie, jeśli nie zachęcam do nauki.
Nie opisuje tu sposobów instalacji programów na telefonach gdyż służą do tego aplikacje dostarczane z telefonami lub dostępne na stronach producentów.
Pliki *.jar tworzone prze NetBeans po kompilacji znajdują się domyślnie w:

KatalogProjektowNetBeans\DanyProjekt\dist\DanyProjekt.jar

Jednym z powodów błędu podczas instatlacji może być niezgodność ustawionego profilu (wersji MIDP) podczas tworzenia projektu. Możemy go łatwo zmienić wchodząc w menu Run > Set Project Configuration > Customize.

Tyle wstępu, zajmijmy się czymś konkretnym.

Do pisania kodu, kompilacji i emulowania utworzonych programów używał będę aplikacji NetBeans, której darmową wersję (w dniu dzisiejszym 6.9.1) można pobrać z

http://netbeans.org/downloads/

Oczywiście interesuje nas opcja wspierająca technologie Java ME więc taką ściągamy, instalujemy i możemy przejść do pisania pierwszego midletu.

Będę wdzieczny za zostawianie opinii zarówno tych dobrych jak i przeciwnych.