Программирование мобильных телефонов на Java
         

С этой главы начинается непосредственно



С этой главы начинается непосредственно описание работы с кодом. Специфика Java 2 ME приложений несколько своеобразна, но совсем несложная. Достаточно разобраться в общей модели построения программ и все сразу станет понятно.

В предыдущих двух главах вашему вниманию были представлены две среды программирования мобильных приложений и большое количество разнообразных телефонных эмуляторов. Полностью был разобран весь процесс установки этих средств, а так же режимы создания, компиляции кода и просмотр получившегося приложения на эмуляторе. Выберите себе понравившуюся среду разработки или работайте с теми средствами, к которым привыкли. Мы больше не будем отвлекаться на процесс написания кода, компиляции и запуска приложения на эмуляторе. Предшествующие две главы дали исчерпывающую информацию по этому поводу.

Мидлет



Приложение, написанное для мобильного телефона, может состоять из различного количества классов. Одни классы, отвечают за загрузку ресурсов, другие за обработку данных, третьи выполняют еще какие-то дополнительные функции, как программист вы вправе выбирать любую удобную для вас модель построения программы. В итоге, созданные вами классы, объединенные в одно целое, будут составлять одну программу или приложение. Все приложения, сформированные для работы в среде Java мобильных телефонов, носят название мидлет. Мидлет -это программа, написанная для мобильного телефона с использованием платформы Java 2 ME. Определять количество классов программы привилегия программиста, но среди всех классов одной программы существует один основной класс, с которого начинается работа всей программы. Этот основной класс мидлета, сердце приложения, он наследуется от класса javax.microedition.midlet. MI Diet. В этом классе описывается код, отвечающий за управление процессом создания интерфейса пользователя, объявления набора данных необходимых для работы всего приложения, создаются объекты имеющихся классов, и что самое главное, он является отправной точкой в работе приложения. Такой класс в Java 2 ME носит название основной класс мидлета.

Рабочие функции, выполняемые этим классом, практически идентичны методу main (). Помните запись, с которой начинался рабочий процесс приложений написанных на Java 2 SE: 

public static void main ( String[] args )



На мобильных устройствах аналогичные действия возложены на подкласс класса MIDlet, производящий управление рабочим процессом всего приложения. В дополнение к основному классу, может создаваться ряд классов необходимых для реализации поставленной перед вами задачи. Также имеется возможность собирать несколько мидлетов в один архив. Такая комплектация программ или мидлетов помещенных в один JAR-файл носит название MIDlet suite (набор мидлетов).

В главе 2, когда объяснялась работа в среде Sun ONE Studio 4 Mobile Edition и J2ME Wireless Toolkit 2.1, в частности момент создания проекта Demo, был сформирован простейший код мидлета с названием HelloMIDlet. Этот код был сгенерирован автоматически Sun ONE Studio 4 Mobile Edition, он очень простой и дает хорошую возможность разобраться в структуре мидлета. Посмотрите на листинг 5.1, где приведен код примера HelloMIDlet проекта Demo, созданный в главе 2. 
/** Листинг 5.1 Класс HelloMIDlet.java

*/

 import javax.microedition.midlet.*;

import javax.microedition.lcdui.*;

 public class HelloMIDlet extends MIDlet implements CommandListener

 {

 private Command exitCommand;

 private Display mydisplay;

    public HelloMIDlet()

    {

 mydisplay = Display.getDisplay(this);

exitCommand = new Command("Выход", Command.EXIT, 1);

    }

 public void startApp() {

TextBox t = new TextBox("

", "Строка текста", 256, 0);

 t.addCommand(exitCommand);

 t.setCommandListener(this);

 mydisplay.setCurrent(t);

  }

 public void pauseApp() {  }

 public void destroyApp(boolean unconditional) { }

 public void commandAction(Command c, Displayable s)

{

 if (c == exitCommand)

 {

 destroyApp(false);

notifyDestroyed();

 }

 }

}

Первое, что бросается в глаза при детальном рассмотрении кода мидлета - это три метода: startApp (), pauseApp () и destroyApp (). Программисты, которые знакомы с аплетами, найдут явное сходство в структуре мидлета и аплета, даже названия в некоторой степени схожие. В аплете также имеются подобные методы: start (), stop () и destroy (). Можно сказать, что основной класс мидлета - это некий симбиоз аплета и метода main(), играющего основную и управляющую роль в приложении для мобильных устройств. Создавая свои классы и реализуя их код, вы должны возложить основные рабочие функции на основной класс мидлета. На рис. 5.1 показан принцип работы мобильных приложений.


Рис. 5.1. Принцип работы приложения

Сейчас мы вкратце разберем код примера HelloMIDlet проекта Demo, а потом перейдем к более детальному анализу схемы работы приложений в Java 2 ME. Первые две строки кода из листинга 5.1 - это библиотеки импорта. 

import javax.microedition.midlet.*;

import javax.microedition. Icdui.*;

В этих строках происходит импорт двух пакетов платформы Java 2 ME. Первый пакет javax.microedition.midlet.* содержит класс MIDlet, с помощью которого происходит связь с MIDP. Каждый код создающий основной класс мидлета обязан импортировать этот пакет. Второй пакет содержит классы, позволяющие создавать пользовательский интерфейс приложения. В следующей главе будут подробно рассмотрены все классы пользовательского интерфейса. Импорт двух пакетов дает возможность задействовать все имеющиеся в этих пакетах интерфейсы, классы, методы и константы, необходимые для работы всего создаваемого приложения. Следующая строка кода: 

public class HelloMIDlet extends MIDlet implements

CommandListener

создает основной класс мидлета, наследуемый от суперкласса MIDlet, реализуя при этом методы startApp(), pauseApp() и destroyApp(). Также задействуется интерфейс CommandListener, необходимый для обработки событий происходящих в приложении при помощи метода commandAction(). Далее идут две строки создающие объекты классов Command и Display. 

private Command exitCommand;

private Display mydisplay;

С помощью переменной exitCommand осуществляется выход из приложения посредством метода commandAction (). Переменная mydisplay будет представлять дисплей телефона при помощи абстрактного класса Display, играющего роль диспетчера телефонных экранов. В конструкторе класса HelloMIDlet инициализируются объекты exitCommand и mydisplay. 

public HelloMIDlet()

{

mydisplay = Display.getDisplay(this);

exitCommand = new Command("Выход",Command.EXIT, 2);

}

В конструкторе класса HelloMIDlet, переменная mydisplay получает ссылку на объект Display при помощи метода getDisplay (). Давайте разберемся эти действия подробно. Вы наверно заметили, что объект Display явно не создается при помощи ключевого слова new. Если быть совсем точным, вы просто не можете этого сделать. Объект класса Display создается автоматически с помощью сервисов телефона для каждого мидлета. Класс Display играет роль диспетчера телефонных экранов, на которые проецируется в итоге все то, что вы будете видеть на дисплее телефона. В телефоне существует всего один основной экран и поэтому в отдельный промежуток времени может быть отражен только один экран, за который отвечает класс Display. С помощью метода getDisplay (), основной класс мидлета получает ссылку на класс Display и содержит ее в переменной mydisplay. В последствии, для того чтобы отразить содержимое текущего дисплея, необходимо воспользоваться методом setCurrent (), например следующим образом: 

mydisplay.setCurrent();

Вторая и последняя строка кода в конструкторе класса HelloMIDlet () создает экземпляр класса Command и инициализирует созданный ранее объект exitCommand. Класс Command создает набор информации или набор команд, которые можно отобразить на экране телефона для обработки событий полученных от пользователя. На основе определенного набора команд с помощью интерфейса CommandListener происходит обработка фактических действий пользователя. Посмотрите на рис. 5.2, где на дисплее показана команда Выход, расположенная под экранной клавишей телефона.


Рис. 5.2. Команда выхода из программы

Такая схема отображения различных команд реализована на всех без исключения мобильных телефонах. Единственное, что может изменяться- это способ отображения этих команд. У некоторых производителей мобильных телефонов команды располагаются под экранными клавишами, а у других, ряд команд формируется в виде меню.

Класс Command имеет два конструктора с тремя и четырьмя параметрами. В примере был использован конструктор из трех параметров, посмотрим, как выглядит прототип конструктора класса Command: 

public Command( String label, int commandType, int priority )


Параметры конструктора класса Command:
 label - это переменная типа String, содержащая метку в виде простого текста. В примере использовалась команда Выход. Эта строка текста может находиться под кнопками дисплея, либо в виде элемента меню. Обычно команда - это короткое слово. Если необходимо использовать длинное слово, то нужно вызвать конструктор класса Command с четырьмя параметрами;  commandType - тип команды соответствующей выбранным действиям. Имеются команды BACK, CANCEL, EXIT, HELP, ITEM, SCREEN, STOP.  BACK - возврат к предыдущему экрану;  CANCEL - отмена произведенных действий;  EXIT - выход из приложения;  HELP - вызов справки;  ITEM - обычно используется для работы с классом Choice, и производит выбор элемента из группы элементов;  SCREEN - представление нового экрана;  STOP - остановка выполняемых действий.  priority - это приоритет, назначенный для данной команды относительно других команд, имеющихся на дисплее. Приоритет задается целым числом, где более низкое число указывает на более высокое значение.
За конструктором класса HelloMIDlet () следует ключевой метод основного класса мидлета startApp (). 

public void startApp()

 {

TextBox t=new TextBox("HelloMIDlet","Текст",256,0);

t.addCommand(exitCommand);

t.setCommandListener (this) ;

mydisplay.setCurrent(t) ;

 }


Метод startApp() вводит приложение в активное состояние и является своего рода входной точкой для всей программы. В рассматриваемом примере для вывода текста на экран используется класс TextBox. Чтобы разобраться, как это происходит, необходимо рассмотреть конструктор класса TextBox: 

public TextBox (String title,

 String text,

int naxSize,

int constraints)


Параметры конструктора класса TextBox:
 title - это титл или основное название, размещенное в верхней части дисплея;  text - текст, выводящийся непосредственно на экран. Текст, выводимый на экран можно редактировать и даже не выводить вовсе, выставив значение этого параметра в значение null;  maxSize - максимальное количество символов выводимого на экран текста;  constraints - с помощью этого параметра можно производить специальные ограничения, но пока рекомендую выставить параметр в 0.
То есть, создав объект класса TextBox, вы задаете область экрана, в которой существует свое название и количество выводимых символов. В следующих двух строках кода: 

t.addCommand(exitCommand) ;

 t.setCommandListener(this) ;


сначала добавляется команда Выход, к текущему экрану телефона представленному классом TextBox, а затем с помощью метода setCommandListener () устанавливается обработка событий для этой команды Выход, используя метод интерфейса GoimandListener . Самая последняя строка кода: 

mydi splay. setCurrent (t);


отражает текущую информацию на экране. Этот метод подобен кнопке Обновить в Internet Explorer. Вызывая каждый раз метод setCurrent (), вы будете обновлять информацию на дисплее телефона. Следующий метод в примере: 

public void pauseAppf)


Тело этого метода пока отсутствует, но с его помощью можно поместить мидлет в состояние паузы и освободить часть используемых ресурсов приложения. Дальше идет метод destroyApp (), освобождающий захваченные мидлетом ресурсы и удаляющий сам мидлет из памяти, то есть закрывает работу приложения. И самый последний метод основного класса мидлета conimandAction () интерфейса CommandListener обрабатывает назначенные события. 

public void commandAction(Command c, Displayable s)

 {

if (c ==? exitCommand)

{

destroyApp(false);

notifyDestroyed();

}

 }


По сути, этот метод является обработчиком событий приложения для всех имеющихся команд. В нашем примере происходит обработка команды Выход. После чего происходит освобождение всех захваченных ресурсов и мидлет выгружается из памяти с помощью методов destroyApp() и notifyDestroyed(). Рассмотрев вкратце общую модель работы мидлета, давайте разберем более подробно процесс работы приложений, а также жизненный цикл всей программы.

Модель работы мидлета



После успешной компиляции примера HelloMIDlet и запуска на любом понравившемся вам эмуляторе, на дисплее эмулятора в верхнем левом углу появится надпись HelloMIDlet. В нашем случае мидлет всего один, ни возможна ситуация когда будет несколько мидлетов, то есть MIDlet suite (набор мидлетов), тогда сервис телефона автоматически создаст меню выстроив все имеющиеся мидлеты друг под другом, предоставляя возможность в выборе программы. Но это не значит, что после того, как вы войдете в ваше приложение, сервис телефона и далее будет так же создавать за вас меню. Нет, действия по структуризации приложения, созданию списков и меню лежит на плечах программиста. На рис. 5.3 изображено Меню телефона с набором различных программ.

Для того чтобы запустить программу на эмуляторе, необходимо нажать кнопку Select (выбор), после чего вы попадаете непосредственно в рабочий цикл приложения. После нажатия клавиши Select, то есть подачи команды активизации приложения, в мидлете происходит поиск метода startApp(), который является начальной и входной точкой всех программ. И уже в методе startApp () идет обработка соответствующего программного кода и как следствие, выполнение работы приложения. Конечно, код находящийся до метода startApp (): объекты, конструктор и так далее, так же инициализируются, но активизация рабочего процесса мидлета происходит с вызовом метода startApp ().


Рис. 5.3. Меню в телефоне

В рассматриваемом примере мы воспользовались классом TextBox, который создает область для вывода текста. В связи с этим, на экране появится текстовая строка, изначально прописанная в программном коде в параметре text конструктора класса TextBox. Этот . текст на дисплее можно отредактировать как угодно, воспользовавшись клавишами эмулятора телефона. В нижнем левом углу экрана, вы увидите надпись Выход. Нажав на клавишу телефона под этой надписью, вы автоматически выйдете из программы. При нажатии подэкранной клавиши Выход, происходит запуск метода commandAction (), реакция которого на команду ' Выход, равносильна обработке событий для переменной exitCommand. Обработка события в данном случае подразумевает вызов двух методов - destroyApp () и notifyDestroyed(), благодаря которым происходит обнуление ссылок, если таковые имеются, и выгрузка мидлета и всего приложения из памяти телефона, возвращая- вас в меню телефона, откуда производился запуск рассматриваемой программы. В итоге весь жизненный цикл работы приложения сводится к периоду активизации программы до выхода из нее. На рис. 5.4 показана общая модель работы мидлета.


Рис. 5.4. Модель работы мидлета

Основной класс мидлета - это своего рода мотор всего приложения, тогда как функциональную часть лучше разбить на необходимое количество классов. Конечно, возможна интеграция всего программного кода приложения в код основного класса мидлета, но, во-первых, это непрофессионально, а во-вторых, это просто неудобно. Хорошо если вы пишете совсем маленькое приложение подобно нашему примеру, но когда речь идет о более серьезном программном продукте, надо разработать четкую структуру классов, продумать общую модель взаимодействия и в конечном итоге написать код приложения. При рассмотрении примеров этой и следующей главы мы будем пока использовать основной класс мидлета, формируя в этом классе дополнительные объекты рассматриваемых классов платформы Java 2 ME, для того чтобы не путаться в большом количестве исходных файлов. Но, начиная с главы 7, перейдем к профессиональной модели построения приложений.

Пользовательский интерфейс



Когда мы рассматривали механизм работы примера из листинга 5.1, я думаю, вы подметили некий поэкранный принцип отображения информации на дисплее. Первый экран показывал список доступных приложений, после выбора одного из них вы попадали на экран этого приложения. Нажав кнопку Выход, происходило возвращение к экрану выбора. В Java 2 ME программах такая схема поэкранного отображения информации является основной. Если вы никогда не обращали на это внимания при работе со своим телефоном, то самое время взять его и пощелкать джойстиком. В приложениях для мобильных телефонов основанных на экранах в Java 2 ME отсутствуют окна и фреймы в отличие от Java 2 SE. Телефоны ограничены в системных ресурсах и разнообразная красивая роскошь, к сожалению не позволительна для этих маленьких устройств. Поэтому при создании конечного продукта стоит с особой тщательностью продумывать основные составляющие будущего приложения. Основываясь на поэкранном отображении информации, необходимо создавать интуитивно понятную структуру приложения, образуя при этом четкую экранную навигацию. Если пользователь заблудится в вашей программе, он просто удалит ее из памяти телефона и никогда к ней больше не вернется, а вы потеряете потенциального покупателя.

Как уже отмечалось, экран телефона представлен классом Display. Каждый мидлет может иметь только один объект класса Display, возвращаемый мидлету при помощи метода getDisplay (), определяя тем самым текущий дисплей телефона для мидлета.

Платформа Java 2 ME обладает пакетом javax.microedition.lcdui, включающим в себя классы для работы с пользовательским интерфейсом UI (user interface). Большое количество классов, входящих в этот пакет, будут подробно рассматриваться в следующей главе. Самым главным классом пользовательского интерфейса является класс Displayable. С основы абстрактного класса Displayable происходит построение основной части графического интерфейса приложения. На рис. 5.5 показана структура пользовательского интерфейса пакета javax.microedition.lcdui.


Рис. 5.5. Структура пользовательского интерфейса

От класса диспетчера Display зависит, какой из классов Displayable будет отображен на экране. В свою очередь только один класс Displayable может быть единовременно показан на экране. То есть, объект класса TextBox, грубо говоря, существует в своем экране, объект класса List - в своем и оба объекта не могут существовать вместе на одном экране, определяя тем самым правило поэкранного отражения информации на дисплее телефона.

Далее в иерархии структуры пользовательского интерфейса, показанного с помощью рис. 5.5, идут два абстрактных класса: Screen и Canvas. На этой стадии происходит разделение классов пользовательского интерфейса на высокоуровневый класс, назначенный классу Screen и всей его дальнейшей иерархии наследования и низкоуровневый класс Canvas. Оба класса создают структуру интерфейсов, разделенную на высокоуровневый и низкоуровневый пользовательский интерфейсы.

Высокоуровневый интерфейс содержит средства для работы с пользовательским интерфейсом, созданные на основе классов шаблонов, использование которых приводит к построению жестко заданного интерфейса. Например, задействованный в исходном коде HelloMIDlet проекта Demo класс TextBox, не может никаким образом изменить экран телефона. Экран представленный классом TextBox - это текстовый контейнер, в котором можно осуществлять вывод, удаление и редакцию текста и не более того. То есть классы высокоуровневого интерфейса - это жестко заданная модель отображения пользовательского интерфейса на экране телефона, с помощью которых программист организует навигацию, списки, меню, текстовые контейнеры, группы выбираемых элементов и так далее.

Низкоуровневый интерфейс предоставляет графические средства для рисования на экране различных графических элементов и обработку команд, посылаемых с клавиш телефона. Низкоуровневый интерфейс позволяет рисовать на экране телефона, добавляя тем самым в приложение красивые графические элементы в виде таблицы, изображений, полей, заставок и так далее. Такое разделение классов существует сугубо в теоретическом виде и ничто вам не мешает комбинировать элементы обоих интерфейсов в одной программе, создавая красивое интерактивное приложение.

На рис. 5.5 была дана часть пакета javax.microedition.lcdui.*, потому что классы Canvas и GameCanvas будут подробно рассматриваться соответственно в главах 7 и 8. Рассмотрим некоторые характеристики классов Alert, TextBox, Form и List представляющие высокоуровневый интерфейс:
 Alert - предоставляет возможность в создании уведомлений или сообщений об ошибках в виде отдельных экранов;  TextBox - массив данных содержащий текстовую информацию с возможностью ее редакции;  Form - экранный контейнер, в котором можно разместить различные элементы интерфейса с помощью дополнительных подклассов класса Item;  List - список элементов, позволяющий производить выбор различных операций.

Переход с экрана на экран



Прежде чем мы приступим к изучению основ перехода в приложении с одного экрана на другой, хочу обозначить стоящие перед нами задачи в рассмотрении средств по созданию пользовательского интерфейса. Сейчас вы имеете некоторое представление о модели работы программ для мобильных телефонов. Далее вы изучите основной способ перехода от экрана к экрану внутри приложения на простом примере. Потом код несколько усложнится и будет показан механизм навигации в программах на Java 2 ME. И уже в главе 6 будут изучены все классы пользовательского интерфейса для создания действительно красивых программ. Сейчас мы идем от простого к сложному и я хочу предложить вам новый пример кода, на основе которого будет изучена схема перехода с одного экрана на другой. Попутно мы задействуем все четыре высокоуровневых класса TextBox, Form, List и Alert.

Прежде чем коснуться непосредственно программирования любого приложения, нужно уделить внимание теоретической части создаваемой программы. Лично я, когда разрабатываю некую программу для мобильного телефона, беру чистый листок бумаги, карандаш и рисую предполагаемый набор экранов, указывая на связь между ними с помощью стрелочек. Это, конечно, не язык UML, но достаточно просто и эффективно. На рис. 5.6 даются все четыре дисплея и связь между ними.


Рис. 5.6. Переход с экрана на экран

Идея этого показательного примера очень проста. Первым делом после входа в приложение вы попадаете в класс Form, являющимся неким контейнером для элементов пользовательского интерфейса. В этом примере классы Form, List, TextBox и Alert не задействованы в полном объеме, а только показывают информативную надпись названия класса. После попадания на экран представленного классом Form, появятся две кнопки: выхода из программы и переход на следующий экран представленный классом TextBox. После перехода с экрана представленного классом Form в TextBox, на экране появится две кнопки: выход из приложения и переход. Кнопка перехода приведет вас на экран представленный классом List, дав аналогичную возможность выбора перехода. Выбрав переход на экран представленный класс Alert, вы увидите на некоторое время экран с надписью Alert и автоматически возвратитесь в List. По своей специфики класс Alert предназначен для сообщения информации об ошибке или исключительной ситуации, этим объясняются и соответствующие действия этого класса. Приступим к написанию кода этого примера. Первым делом импортируем две библиотеки: 

import javax.microedition.midlet.*;

import javax.microedition.Icdui.*.


Затем создаем класс Perexod, наследуемый от класса MIDlet. 

public class Perexod extends MIDlet implements

CommandListener


Теперь необходимо создать объекты класса Command. Объект exitMidlet нужен для выхода из программы. Код, реализующий это событие аналогичен коду из предыдущего примера, рассмотренного в листинге 5.1. И еще три объекта будут служить для перехода от экрана к экрану: 

private Command exitMidlet;

private Command perexodTextBox;

private Command perexodList;

private Command,perexodAlert;

private Display mydisplay;


Названия этих объектов достаточно информативны и в объяснении не нуждаются. Далее очередь подошла к конструктору класса Perexod. Первым делом сохраним ссылку на Display в переменной mydisplay: 

mydisplay = Display.getDisplay(this);


Следующим шагом создадим два объекта класса Command, один для выхода из программы, другой для перехода на экран представленный классом TextBox. 

exitMidlet = new Command("Выход",Command.EXIT,1);

perexodTextBox = new Command("Перейти",Command.SCREEN,2);


Создание этих объектов в конструкторе - не обязательное условие. Просто я основывался на предыдущем примере и оставил примерную структуру приложения для понимания. На самом деле все четыре объекта класса Command можно было инициализировать еще при их объявлении .в начале класса MainMidlet, что более читабельно. Следующим кодом за конструктором идет метод startАрр (), внутри которого создается объект класса Form. Добавим при помощи метода addCommand () команду Выход - это выход из приложения и команду Переход - это переход на экран представленный классом TextBox. 'Назначим обработчик событий классу Form методом setCommandListener () и присоединим объект myform класса Form к текущему дисплею при помощи метода setCurrent(). 

public void startApp()

{

Form myform = new Рогт("Это объект класса Form");

myform.addCommand(exitMidlet);

myform.addCommand(perexodTextBox);

 myform.setCommandListener(this);

 // отражает текущий экран

mydisplay.setCurrent(myform); }


Когда вы запустите программу или войдете в рабочий цикл мидлета, то автоматически инициализируются объекты классов и конструктор класса Perexod, а работа программы начнется с вызова метода startApp (). Теперь необходимо назначить соответствующие действия клавишам перехода в методе commandAction () интерфейса CommandListener для обработки пользовательских команд. Переход по кнопке Выход вам уже знаком из предыдущего примера, поэтому оставим все почти без изменения, за исключением информационной команды exitMidlet. 

if (с == exitMidlet)

 {

destroyApp(false);

notifyDestroyed();

}


А теперь вплотную займемся командой Перейти. Что от нас требуется? В момент запуска программы мы попадаем на экран представленный классом Form посредством команды perexodTextBox, а требуется прейти на экран представленный классом TextBox. Для создания обработчика событий команды Перейти нужно сформировать объект класса TextBox, позаботиться о следующей кнопке перехода perexodList для перехода на экран, представленый классом List, добавить команду Выход для выхода из программы и команду Перейти. Осталось добавить обработчик событий и присоединить созданный TextBox к текущему экрану. Смотрим, что у нас получилось: 

if (с == perexodTextBox)

{

TextBox tb = new TextBox("TextBox", "Текст", 256, 0);

perexodList = new Command("Перейти", Command.SCREEN, 2)*;

tb.addCommand(exitMidlet);

tb.addCommand(perexodList);

tb.setCommandLi'stener (this) ;

Display.getDisplay(this).setCurrent(tb);

}


Обратите внимание на последнюю строку кода в теле условного оператора: 

Display.getDisplay.(this) . setCurrent (tb) ;


В данном случае присоединяется созданный объект tb класса TextBox к текущему экрану. Мы говорим о смене экранов для создания четкого и информативного пользовательского интерфейса, на самом деле смены экранов в буквальном смысле не происходит. Существует только один дисплей, назначенный для класса Displey, который отвечает за то, что будет нарисовано на экране телефона, а именно, какой из объектов Displayable. Только один объект Displayable может быть отображен за один раз на экране. То есть существует всего один физический дисплей, к которому присоединяются необходимые объекты классов пользовательского интерфейса через обработку событий. Имеющийся экран просто постоянно перерисовывается, отображая тот или иной объект востребованного класса, а иначе говоря, к текущему дисплею присоединяется объект класса, создавая иллюзию смены экранов. Системные ресурсы телефонов пока малы, поэтому приходится идти на такие хитрости.

Затем в рассматриваемом примере необходимо перейти на экран представленный классом List. Поскольку мы имеем аналогичные требования к экземпляру этого класса, то обработка событий и создание класса List будут идентичными классу TextBox. 

if (с == perexodList)

 {

List mylist = new List("List", List.IMPLICIT);

perexodAlert = new Command("Перейти", Command.SCREEN, 2);

mylist.addCommand(exitMidlet);

mylist.addCoiranand(perexodAlert);

mylist.setCommandListener(this);

Display.getDisplay(this).setCurrent(mylist);

}


Позаботившись о переходе на экран представленный классом Alert и о выходе из приложения, можно создать код для объекта Alert, который впоследствии можно присоединить к текущему экрану. Класс Alert несколько специфичен, это вам станет понятно как только вы откроете окно, отвечающее за отображение объекта. Попробуйте после компиляции рассмотренного примера сделать для Alert команду Выход, и посмотрите, что получится. Теперь соединим рассмотренный код в одно целое, получив готовую программу, представленную в листинге 5.2. Пример также можно найти на прилагаемом к книге компакт-диске в папке \Code\Listing5_2\src. 

/**

Листинг 5.2

Переход с экрана на экран

*/

// подключаем пакеты

import javax.microedition.midlet.*;

import javax.microedition..lcdui. *;

// создаем класс Perexod

public class Perexod extends MIDlet implements

CommandListener

{

// команда выход из программы

 private Command exitMidlet;

// команда перехода в программе

 private Command perexodTextBox;

private Command perexodList;

 private Command perexodAlert;

// дисплей

private Display mydisplay;

// конструктор класса

 Perexod public Perexod()

 {

mydisplay = Display.getDisplay(this);

// выход из приложения

exitMidlet = new Command("Выход", Command.EXIT, 1);

// переход

TextBox

perexodTextBox = new Command("Перейти", Command.SCREEN, 2);

}

// входная точка всей программы

 public void startApp()

{

// создаем объект класса Form

Form myform = new Form("Это объект класса Form");

// добавляем команду выхода из программы

myform.addCommandfexitMidlet);

// добавляем команду перехода в TextBox

myform.addCommand(perexodTextBox);

// устанавливаем обработчик событий для команд объекта

класса Form

myform.setCommandListener(this);

// отражаем текущий экран

mydisplay.setCurrent(myform);

 }

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

// обработчик событий в программе

public void commandAction(Command c, Displayable d)

{

// обработка команды выход

if (с == exitMidlet)

{

destroyApp(false);

notifyDestroyed();

}

// обработка команды перехода в TextBox

 if (с == perexodTextBox)

{

TextBox tb = new TextBox("TextBox", "Текст", 256, 0);

perexodList = new Command("Перейти",Coramand.SCREEN, 2);

tb.addCommand(exitMidlet);

tb.addCommand(perexodList);

tb.setCommandListener(this);

Display.getDisplay(this).setCurrent(tb);

 }

// обработка команды перехода в List

 if (с == perexodList)

{

List mylist = new List("List", List.IMPLICIT);

perexodAlert = new Command("Перейти", Command.SCREEN, 2);

mylist.addCommand(exitMidlet);

mylist.addCommand(perexodAlert);

mylist.setCommandListener(this);

Display.getDisplay(this).setCurrent(mylist);

 }

// обработка команды перехода в Alert

 if (с == perexodAlert)

{

Alert myalert = new Alert("Alert","Текст",null,null);

Display.getDisplay(this).setCurrent(myalert);

}

}

}


После компиляции примера пройдите по всей программе и убедитесь, что вам понятна общая идея и принцип работы смены экранов, на которых строятся все приложения в Java 2 ME.

Навигация



Рассмотренный пример из листинга 5.2 раскрыл суть перехода с одного экрана на другой. Как вы заметили, принцип смены экраны довольно прост - достаточно добавить необходимую команду с помощью метода addCommand (), установить обработчик событий для этого экрана и создать код в методе commandAction () , адекватно реагирующий на заданные действия.

Познакомившись с моделью смены экранов и закрепив свои знания на практике, можно переходить к более осмысленной навигации в приложении. В предыдущем примере происходила последовательная смена экранов без возможности возврата либо перехода на необходимый экран. Такая структура хороша для изучения, но абсолютно не годится для серьезного приложения. Телефоны различных марок имеют собственные механизмы перехода, предоставляемые операционной системой или прошивкой мобильного телефона. Механизм, использованный в Java 2 ME для приложений созданных на этом языке, предоставляет не менее мощные, а главное, простые средства для навигации в программе. Самый простой и, как мне кажется, эффективный способ - это использовать автоматически созданное меню при помощи сервиса телефона. Когда вы добавляете к заданному экрану с присоединенным к нему объектом Displayable команды обработки в виде двух подэкранных клавиш, вы имеете всего два видимых варианта клавиш -слева и справа. Как только вы добавите с помощью функции addCommand () более двух команд, сервис телефона автоматически создаст на правой или левой подэкранной клавише телефона (в зависимости от марки производителя), выпадающее меню. При нажатии клавиши, отвечающей за меню, появится меню, отображающее полный список имеющихся команд. На рис. 5.7 изображено контекстное меню, созданное эмулятором телефона среды программирования J2ME Wireless Toolkit 2.1.


Рис. 5.7. Автоматически созданное меню

Задав нужные команды для конкретного объекта Displayable, и создав код их обработки, вы получаете отличный механизм навигации. Но это не единственный способ перехода с экрана на экран. Каждый из четырех классов Form, List, TextBox и Alert имеет свои встроенные средства для создания списков, меню, таблиц, полей, загрузки изображений и так далее. При знакомстве с каждым из классов мы обязательно рассмотрим имеющиеся возможности. А пока давайте разберем механизм автоматического создания меню и обработки имеющихся команд.

Итак, к каждому из задействованных классов нам надо добавить набор команд для перехода на нужный экран и обработать, а точнее, создать код, реагирующий на назначенные команды. Рис. 5.8 живописно изображает и отчасти решает поставленную перед нами задачу.

Теперь сосредоточимся на одном из вариантов программного кода, решающего проблему с навигацией. Первым делом создадим класс, назвав его Navigator. 

public class Navigator extends MIDlet

 implements CommandListener



Рис. 5.8. Схема перехода с экрана на экран

В исходном коде до строк вызова конструктора класса Navigator, добавим объект, содержащий команду Выход.

private Command exitMidlet = new Command("Выход", Command.EXIT, 1);

Потом необходимо создать четыре объекта для каждого из задействованных классов Form, TextBox, List и Alert, Созданные объекты будут отвечать за обработку команд перехода на экран, представленные соответствующими классами. 

private Command perexodTextBox = new Command("В TextBox",
Command. SCREEN, 2) ;

private Command perexodList = new CommandC'B List",
Command.SCREEN, 2);

private Command perexodAlert = new CommandC'B Alert",
Command.SCREEN, 2) ;

private Command perexodForm = new CommandC'B Form",
Command.SCREEN, 2) ;


Информативные названия всех объектов понятны, но, естественно, выбранные мною названия ни к чему вас не обязывают. Созданные объекты являются объектами класса Command, отвечающего за создание команд, которые в последствии можно определить для каждого из классов Form, TextBox, List и Alert. Позже, в коде мидлета, мы будем задавать соответствующие блоки обработки событий непосредственно в методе commandAction () при помощи оператора if и созданных объектов.

Теперь нам нужно объявить и инициализировать объекты четырех классов Form, TextBox, List и Alert. 

private Form my form = new Рогт.("Это объект класса Form") ;

private List

mylist = new List("Это объект класса List", List.IMPLICIT);

private TextBox

mytextbox = new TextBox("Это TextBox", "Текст", 256, 0);

private Alert

myalert = new Alert("Это Alert","Alert исчезнет",null,null);

 private Display mydisplay;


В конструкторе класса Navigator происходит инициализация объекта 

mydisplay.

public Navigator()

{

mydisplay = Display.getDisplay(this);

}


Следующая наша задача - это реализация метода startApp (). Сейчас необходимо решить какой из классов будет первым появляться на экране и добавить к нему команды перехода в другие классы, а также команду выхода из приложения. В предыдущем примере первым появлялся класс Form. Его и определим как основной объект, в который попадет пользователь, запускающий приложение. 

public void startApp()

{

myform.addCommand(exitMidlet);

myform.addCommand(perexbdTextBox);

myform.addCommand(perexodList);

myform.addCommand(perexodAlert);

myform.setCommandListener(this);

mydisplay.setCurrent(myform); }


Последняя строка метода startApp() отображает объект myform на дисплее со всеми имеющимися командами. Как уже говорилось, командам, которым не хватит телефонных клавиш, будет автоматически создано свое собственное меню.

После того как вы попадете в основное окно приложения, которое мы определили для объекта myform, над левой или правой подэкранной клавишей появится команда выхода из приложения и команда Menu. При нажатии на клавишу Menu, на экране телефона появится всплывающее Меню с добавленными ранее командами перехода на экраны, представленные классами TextBox, List и Alert.

Следующей нашей задачей является написание кода для обработки событий созданных команд в методе commandAction (). Код, обрабатывающий команду Выход из приложения, идентичен коду из примера в листинге 5.2 и в большинстве рассматриваемых впоследствии примеров останется таковым. Дальнейшие действия состоят в обработке команды перехода на экран, представленный классом TextBox. 

if (с == perexodTextBox)

{

mytextbox.addCommand(exitMidlet);

mytextbox.addCommand(perexodForm);

mytextbox.addCommand(perexodList);

mytextbox.addCommand(perexodAlert);

mytextbox.setCommandListener(this);

mydisplay.setCurrent(mytextbox);

 }


Сразу после того, как пользователь попадет на экран, представленный классам Form, и в контекстном меню выберет команду Перейти в TextBox, произойдет обработка блока команд perexodTextBox. Добавляются все команды к объекту mytextbox, устанавливается обработчик событий и в итоге отображается текущий экран, содержащий все созданные компоненты объекта mytextbox. Точно так же как и на экране с объектом myform существует меню перехода и кнопка выхода.

Обработка событий для объекта mylist происходит с помощью команды perexodList и аналогично рассмотренному коду для объекта mytextbox. С той лишь разницей, что используются соответствующие команды для объекта mylist. В итоге листинг 5.3 связывает все разрозненные фрагменты кода этого подраздела, собирая воедино очень простую и в то же время, мощную программу отличной системы навигации. 

/ * *

Листинг 5.3

Навигация в приложении

*/

import javax.microedition.midlet.*;

import javax.microedition.Icdui.*;

public class Navigator extends MIDlet implements

CommandListener

{

// команда выхода из приложения

private Command

exitMidlet = new Command("Выход", Command.EXIT, 1);

// команда перехода в TextBox

private Command

perexodTextBox = new Command("B TextBox", Command.SCREEN, 2);

// команда перехода в List

private Command

perexodList = new Command("B List", Command.SCREEN, 2);

 // команда перехода в Alert

private Command

perexodAlert = new Command("B Alert", Command.SCREEN, 2);

 // команда перехода в Form

private Command perexodForm= new Command("B Form",
Command.SCREEN, 2);

// объект класса Form

private Form myform = new Form("Это объект класса Form");

// объект класса List

private List

mylist = new List("Этообъект класса List",
List.IMPLICIT);

// объект класса TextBox

private TextBox

mytextbox = new TextBox("Это TextBox",
"Текст", 256, 0);

// объект класса Alert

private Alert

myalert = new Alert("Это Alert","Alert
исчезнет",null,null);

// объект mydisplay представляет экран телефона

private Display mydisplay;

public Navigator()

{

mydisplay = Display.getDisplay(this);

}

public void startApp()

{

// добавить команды перехода в Form

myform.addCommand(exitMidlet);

myform.addCommand(perexodTextBox);

myform.addCommand(perexodList);

myform.addCommand(perexodAlert);

У/ установка обработчика событий для Form

myform.setCommandListener (this);

// отразить текущий дисплей

mydisplay.setCurrent(myform);

}

public void pauseApp() {}

public void destroyApp(boolean unconditional) {}

public void commandAction(Command c, Displayable d)

 {

// выход из приложения

if (с = = exitMidlet)

{

destroyApp(false);

notifyDestroyed();

}

// переход в TextBox

if (с == perexodTextBox)

{

mytextbox.addCommand(exitMidlet);

mytextbox.addCommand(perexodForm);

mytextbox.addCommand(perexodList);

mytextbox.addCommand(perexodAlert);

mytextbox.setCommandListener(this);

mydisplay.setCurrent(mytextbox);

}

// переход в List

if (c == perexodList)

{

mylist.addCommand(exitMidlet);

mylist.addCommand(perexodForm);

mylist.addCommand(perexodAlert);

mylist.addCommand(perexodTextBox);

mylist.setCommandListener(this);

mydisplay.setCurrent(mylist);

}

// переход в Alert

if (c == perexodAlert)

{

mydisplay.setCurrent(myalert);

 }

// переход в Form

if (c == perexodForm) mydisplay.setCurrent(myform);

}

}


В следующей главе будут изучаться классы высокоуровневого интерфейса, с помощью которых создаются списки, группы элементов, текстовые поля и множество других элементов пользовательского интерфейса.