Из особенностей: PyGTK (hildonize for Nokia N900), само-модифицируемый код, что бы не возиться с конфиг-файлами.

( Читать дальше )

Я предсказывал, что 2010 год принесет на рынок смартфонов большие перемены. Я предсказывал, что ситуация будет весьма изменчивой. Я предсказывал, что в уже начавшуюся гонку вступят новые игроки. И еще я предсказывал, что битва будет жестокой. Ну что ж, жертвы уже есть: первой стал Palm. Я предполагал, что они не переживут этот год, и то, что в апреле эта марка была продана, демонстрирует, как накаляется ситуация. Итак, я дал свой прогноз на текущий год. Теперь мы получили данные от ведущих производителей и можем составить отчет о ситуации на рынке смартфонов в 1 квартале. Я использовал средние цифры суммарных продаж смартфонов за квартал по отраслевым аналитическим отчетам, получив общий объем продаж в 54,5 млн. штук.

( Читать дальше )

Как отправить смс в эмулятор?

Самый простой способ это сделать - использовать Eclipse с плагином ADT.
1. Запускаем Eclipse.
2. Переходим в режим DDMS, для этого открываем в меню Window->Open Perspective->Other… и там выбираем DDMS

3. Запускаем эмулятор:
- либо из папки где у вас установлен сдк, например, путь_к_сдк-tools-emulator
- или запустив свой проект в эмуляторе

4. В Eclipse, в режиме DDMS выбираем эмулятор из списка (нужно кликнуть по нему):

5. Чуть ниже выбора эмулятора, находится окно отправки смс.

здесь указываем номер звонящего (от кого придет смс), выбираем режим SMS и указываем текст сообщения. Что бы отправить нажимаем Send.

6. Открываем окно с эмулятором и видим наше отправленное смс.

Как отправить смс из эмулятора (или программы) и получить его в другом эмуляторе?

1. Для этого нам понадобится еще один эмулятор. Запускаем его: путь_к_сдк-tools-emulator.exe. Таким образом у нас должно быть открыто два эмулятора и Eclipse.

2. В Eclipse должны быть видны оба эмулятора:

Цифры рядом с emulator - это порт на котором работает эмулятор, он же и будет номером телефона.

3. Например мы хотим отправить смс из emulator-5554 на emulator-5556. Для этого открываем emulator-5554 и запускаем программу для отправки смс - Messaging.

4. Выбираем New message и создаем новую смс. В качестве Incoming number указываем номер эмулятора которому хотим отправит, в нашем случае 5556. И указываем текст сообщения.

Далее нажимаем кнопку отправить.

6. Открываем эмулятор 5556 и видим наше сообщение:

Таким образом, мы видим, что пришло сообщение от эмулятора 5554 с текстом: Hello from emulator 5554 to 5556

Уровень сложности:  средний

Содержание:

• Введение
• Сенсорные возможности Android
• Пример работы с датчиком
• Применение MediaRecorder
• Android как измерительная платформа
• Заключение
• Загрузка
• Ресурсы
• Об авторе

Введение

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

Какое приложение лучше построить, чтобы задействовать аппаратные возможности устройства на платформе Android? Подойдет любое, в котором требуются электронные глаза и уши. На ум приходит электронная няня, система безопасности или даже сейсмограф. Хотя с метафизической точки зрения одновременно присутствовать в двух местах невозможно, Android может предложить некоторые практические способы преодоления этого ограничения. В рамках этой статьи под Android-устройством понимается не просто "мобильный телефон", а установленное в определенном месте устройство с беспроводным соединением с сетью, таким как EDGE или Wi-Fi. Загрузите исходный код примера приложения для этой статьи.

В начало

Сенсорные возможности Android

Один из приятных аспектов работы с платформой Android заключается в возможности получить доступ к некоторым полезным компонентам самого устройства. До сих пор разработчиков мобильных устройств разочаровывала невозможность доступа к их внутреннему оборудованию. Хотя между вами и металлом все же остается прослойка Java-среды Android, команда разработчиков Android вывела многие возможности аппаратуры на поверхность. А так как это платформа с открытым исходным кодом, можно засучить рукава и написать собственный код для решения своих задач.

Загрузите SDK Android, если вы этого еще не сделали. Рекомендуем также изучить содержимое пакета android.hardware и следить за примерами этой статьи. Пакет android.media package содержит классы, которые предоставляют разработчикам новые полезные функции.

Ниже описаны некоторые аппаратно-ориентированные функции, содержащиеся в SDK Android.

Таблица 1. Аппаратно-ориентированные функции SDK Android

android.hardware.Camera

android.hardware.SensorManager

SensorManager

android.hardware.SensorListener

android.media.MediaRecorder

android.FaceDetector

java.util.Date

java.util.Timer

java.util.TimerTask

java.util.Date

java.util.Timer

java.util.TimerTask

Android.hardware.SensorManager содержит несколько констант, которые характеризуют различные аспекты системы датчиков Android, в том числе:

Центром сенсорных приложений служит интерфейс

SensorListener

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

registerListener

SensorManager

SensorListener

Помните, что не каждое устройство Android поддерживает тот или иной датчик, указанный в SDK. Если на конкретном устройстве тот или иной датчик отсутствует, ваше приложение должно обрабатывать эту ситуацию аккуратно.

В начало

Пример работы с датчиком

Этот пример приложения просто следит за изменениями значений датчиков ориентации и акселерометра (исходный код приведен в разделе Загрузки). При изменении значений датчиков они отображаются на экране в виджете

TextView

Рисунок 1. Мониторинг ускорения и ориентации

Приложение создано в среде Eclipse с плагином Android Developer Tools. (Более подробную информацию о разработке Android-приложений с помощью Eclipse см. в разделе Ресурсы.) В листинге 1 приведен код этого приложения.

Листинг 1. IBMEyes.java

package com.msi.ibm.eyes;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import android.hardware.SensorManager;
import android.hardware.SensorListener;
public class IBMEyes extends Activity implements SensorListener {
    final String tag = "IBMEyes";
    SensorManager sm = null;
    TextView xViewA = null;
    TextView yViewA = null;
    TextView zViewA = null;
    TextView xViewO = null;
    TextView yViewO = null;
    TextView zViewO = null;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       // get reference to SensorManager
        sm = (SensorManager) getSystemService(SENSOR_SERVICE);
        setContentView(R.layout.main);
        xViewA = (TextView) findViewById(R.id.xbox);
        yViewA = (TextView) findViewById(R.id.ybox);
        zViewA = (TextView) findViewById(R.id.zbox);
        xViewO = (TextView) findViewById(R.id.xboxo);
        yViewO = (TextView) findViewById(R.id.yboxo);
        zViewO = (TextView) findViewById(R.id.zboxo);
    }
    public void onSensorChanged(int sensor, float[] values) {
        synchronized (this) {
            Log.d(tag, "onSensorChanged: " + sensor + ", x: " + 
values[0] + ", y: " + values[1] + ", z: " + values[2]);
            if (sensor == SensorManager.SENSOR_ORIENTATION) {
                xViewO.setText("Orientation X: " + values[0]);
                yViewO.setText("Orientation Y: " + values[1]);
                zViewO.setText("Orientation Z: " + values[2]);
            }
            if (sensor == SensorManager.SENSOR_ACCELEROMETER) {
                xViewA.setText("Accel X: " + values[0]);
                yViewA.setText("Accel Y: " + values[1]);
                zViewA.setText("Accel Z: " + values[2]);
            }            
        }
    }

    public void onAccuracyChanged(int sensor, int accuracy) {
    	Log.d(tag,"onAccuracyChanged: " + sensor + ", accuracy: " + accuracy);
    }
    @Override
    protected void onResume() {
        super.onResume();
      // register this class as a listener for the orientation and accelerometer sensors
        sm.registerListener(this, 
                SensorManager.SENSOR_ORIENTATION |SensorManager.SENSOR_ACCELEROMETER,
                SensorManager.SENSOR_DELAY_NORMAL);
    }

    @Override
    protected void onStop() {
        // unregister listener
        sm.unregisterListener(this);
        super.onStop();
    }    
}

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

Метод действия

onCreate

SensorManager

onCreate

TextView

Метод

onResume()

SensorManager

registerListener

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

unregisterListener

SensorManager

SensorListener

При вызове обоих методов

registerListener

unregisterListener

this

implements

SensorListener

registerListener

unregisterListener

SensorListener

onSensorChange

onAccuracyChanged

onAccuracyChanged

Кажется, что метод

onSensorChanged

Теперь, когда мы рассмотрели подсистему датчиков, в следующем разделе приведем пример кода, который записывает звук на телефон Android. Этот пример работает на устройстве для разработчиков Dev1.

В начало

Применение MediaRecorder

Пакет Android.media содержит классы для взаимодействия с мультимедийной подсистемой. Класс

android.media.MediaRecorder

MediaRecorder

В листинге 2 приведен код для записи звука на устройство Android. Этот код не включает элементы пользовательского интерфейса приложения (полный исходный код см. в разделе загрузок).

Листинг 2. Запись аудиофрагмента

MediaRecorder mrec ;
File audiofile = null;
private static final String TAG="SoundRecordingDemo";
protected void startRecording() throws IOException 
{
   mrec.setAudioSource(MediaRecorder.AudioSource.MIC);
   mrec.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
   mrec.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
   if (mSampleFile == null) 
   {
       File sampleDir = Environment.getExternalStorageDirectory();
       try 
       { 
          audiofile = File.createTempFile("ibm", ".3gp", sampleDir);
       }
       catch (IOException e) 
       {
           Log.e(TAG,"sdcard access error");
           return;
       }
   }
   mrec.setOutputFile(audiofile.getAbsolutePath());
   mrec.prepare();
   mrec.start();
}
protected void stopRecording() 
{
   mrec.stop();
   mrec.release();
   processaudiofile(audiofile.getAbsolutePath());
}
protected void processaudiofile() 
{
   ContentValues values = new ContentValues(3);
   long current = System.currentTimeMillis();
   values.put(MediaStore.Audio.Media.TITLE, "audio" + audiofile.getName());
   values.put(MediaStore.Audio.Media.DATE_ADDED, (int) (current / 1000));
   values.put(MediaStore.Audio.Media.MIME_TYPE, "audio/3gpp");
   values.put(MediaStore.Audio.Media.DATA, audiofile.getAbsolutePath());
   ContentResolver contentResolver = getContentResolver();

   Uri base = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
   Uri newUri = contentResolver.insert(base, values);

   sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, newUri));
}

В методе

startRecording

MediaRecorder

Аудиофайл хранится не во внутренней памяти, а на отдельной карте.

External.getExternalStorageDirectory()

MediaRecorder

setOutputFile

Вызов метода

prepare

MediaRecorder

start

stop

MediaRecorder

Когда аудиофрагмент записан, можно выполнить несколько действий:

В примере кода метод

processaudiofile

Intent

И последнее замечание об этом фрагменте кода: сразу после создания он не будет записывать аудио. Вы увидите созданный файл, но не услышите звука. Нужно добавить разрешение в файл AndroidManifest.xml:

<uses-permission android:name="android.permission.RECORD_AUDIO"></uses-permission>

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

В начало

Android как измерительная платформа

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

Рисунок 2. Блок-схема Android-ориентированной системы датчиков

Это очень гибкая архитектура; логику приложения можно распределять между локальным Android-устройством и серверными ресурсами, которые могут подключаться к более крупным базам данных и вычислительным мощностям. Например, аудиотрек, записанный на локальном Android-устройстве, можно отправить методом

POST

В начало

Заключение

Из этой статьи вы получили первое представление о работе с датчиками Android. Приведенные примеры приложений определяют ориентацию и ускорение, а также взаимодействуют со средствами звукозаписи с использованием класса

MediaRecorder

В начало

Загрузка

Ресурсы

Научиться

• Оригинал статьи (EN).
   
• "Разработка приложений для Android с помощью Eclipse."
   
• Сайт для разработчиков Android предлагает документацию, загрузки, блоги и многое другое.
   
• Спонсор Android: Open Handset Alliance - группа из 47 компаний, специализирующихся на ИТ и мобильной связи, которые поставили перед собой цель ускорить внедрение инноваций в сфере мобильной телефонии и предложить потребителям еще более широкие возможности, низкие цены и лучшее качество связи.
   
• Прочтите книгу Unlocking Android, чтобы углубить свои знания (EN).
   
• Подробнее о Dalvik Virtual Machine.
   
• Видеоруководства по устройству Dalvik VM на YouTube.
   
• Unlocking Android: A Developer's Guide — руководство с практическими рекомендациями по ОС Android и инструментам разработки (EN).
   
• Интервью и дискуссии разработчиков ПО в подкастах на developerWorks.(EN)
   
• Чтобы оставаться в курсе новостей, посещайте раздел технических мероприятий и Web-трансляций на developerWorks.(EN)
   
• Следите за developerWorks по Твиттеру.(EN)
   
• Следите за предстоящими конференциями, выставками, Web-трансляциями и другими мероприятиями во всем мире, которые могут заинтересовать разработчиков открытого ПО IBM.(EN)
   
• Посетите раздел открытого ПО developerWorks, содержащий богатую справочную информацию, инструменты и новости по проектам, которые помогают в разработке технологий с открытым исходным кодом и их использовании с продуктами IBM.(EN)
   
• Узнавайте о технологиях IBM и возможностях продуктов IBM и Open Source и учитесь работать с ними с помощью бесплатных демонстраций по требованию на developerWorks.(EN)
   

Получить продукты и технологии

• Загрузите SDK Android.
   
• Загрузите последнюю версию IDE Eclipse.
   
• Используйте в своем следующем проекте Open Source-разработки ознакомительное ПО IBM, которое можно загрузить через Интернет или заказать на DVD.(EN)
   
• Загрузите ознакомительные версии продуктов IBM или попробуйте онлайновые версии IBM SOA Sandbox и попрактикуйтесь в работе с инструментами разработки приложений и продуктами промежуточного уровня семейств DB2®, Lotus®, Rational®, Tivoli® и WebSphere®.(EN)
   

Обсудить

• Примите участие в обсуждении материала на форуме developerWorks.
   
• Принимайте участие в блогах developerWorks и в жизни сообщества developerWorks.(EN)
   

Об авторе

В начало

Уровень сложности:  простой

Содержание:

• Введение
• History
• Платформа Android
• Архитектура приложений
• Необходимые инструменты
• Создание простого приложения
• Заключение
• Загрузка
• Ресурсы
• Об авторе

Введение

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

Сегодня многие сетевые или поддерживающие сеть устройства работают на том или ином варианте ядра Linux. Это солидная платформа: недорогая в развертывании и поддержке и хорошо принимаемая благодаря удобному подходу к развертыванию. Пользовательский интерфейс таких устройств зачастую основан на HTML и может просматриваться с помощью браузера для РС или Mac. Но не всяким устройством нужно управлять посредством компьютера. Рассмотрим обычные бытовые приборы, такие, как плита, микроволновая печь или хлебопечка. Что если у ваших бытовых приборов была бы ОС Android и цветной сенсорный экран? Будь у плиты интерфейс Android, автор и сам, возможно, смог бы что-нибудь приготовить.

Из этой стати вы узнаете о платформе Android и о том, как ее можно использовать для мобильных и стационарных приложений. Мы установим SDK Android и создадим простую программу. Загрузите исходный код примера приложения для этой статьи.

В начало

Краткая история Android

Платформа Android является продуктом группы Open Handset Alliance, ставящей себе целью создание более совершенного мобильного телефона. Эта группа во главе с Google включает операторов мобильных сетей, производителей телефонов и компонентов, разработчиков программных решений и поставщиков услуг, а также маркетинговые компании. С точки зрения разработки программного обеспечения Android находится в самом центре мира открытого ПО.

Первым выпущенным на рынок телефоном на платформе Android стало устройство G1 производства HTC, которое распространяла T-Mobile. Это устройство появилось почти через год после того, как о нем пошли слухи, и единственным инструментом разработки программ для него были постепенно совершенствуемые последовательные выпуски SDK. Накануне выпуска G1 команда Android представила SDK v1.0, и начали появляться приложения для новой платформы.

Чтобы стимулировать инновации, Google спонсировала два «Конкурса разработчиков для Android», победители которых получили миллионы долларов. Через несколько месяцев после выхода G1 открылся сайт Android Market, откуда пользователи могли загружать приложения прямо в свой телефон. Всего за полтора года новая мобильная платформа вышла на арену.

В начало

Платформа Android

По широте возможностей платформа Android не уступает операционным системам настольных ПК. Это многоуровневая среда на основе ядра Linux с богатыми функциональными возможностями. В подсистему пользовательского интерфейса входят:

Android содержит встраиваемый браузер на базе WebKit - того же механизма с открытым исходным кодом, который лежит в основе браузера Safari мобильного телефона iPhone.

Android обладает широким спектром возможностей подключения, охватывающим Wi-Fi, Bluetooth и протоколы передачи данных через сотовую сеть (GPRS, EDGE, 3G и др.). Популярным приемом в приложениях для Android является ссылка на Google Maps для отображения адреса непосредственно в приложении.В стек программного обеспечения Android входит и поддержка сервисов, основанных на определении местоположения (например, GPS), и акселерометров, хотя не все устройства на этой платформе оснащены необходимым оборудованием. Есть также поддержка видеокамеры.

Исторически двумя областями, где мобильные приложения отставали от своих настольных собратьев, были графика/мультимедиа и способы хранения данных. Android решает проблему графики благодаря встроенной поддержке 2-D и 3-D графики, включая библиотеку OpenGL. Задача хранения данных упрощается благодаря наличию в платформе Android популярной базы данных с открытым исходным кодом SQLite. На рисунке 1 показана упрощенная схема уровней программного обеспечения Android.

Рисунок 1. Уровни программного обеспечения Android

В начало

Архитектура приложений

Как уже говорилось, Android работает поверх ядра Linux. Android-приложения пишутся на языке программирования Java и выполняются в виртуальной машине (VM). Важно отметить, что виртуальная машина – это не JVM, как можно было бы ожидать, а открытая технология Dalvik Virtual Machine. Каждое приложение Android запускается внутри экземпляра Dalvik VM, который, в свою очередь заключен в пределах управляемого ядром Linux процесса, как показано на рисунке 2.

Рисунок 2. Dalvik VM

Android-приложение содержит элементы одного или нескольких перечисленных ниже типов:

Приложение для Android развертывается на устройстве вместе с файлом AndroidManifest.xml. Этот файл содержит необходимую информацию о конфигурации, которая позволяет правильно установить приложение на устройстве. Он включает также необходимые имена классов и типы событий, которые может обрабатывать приложение, и разрешения, требуемые для его работы. Так, если приложению нужен доступ к сети – например, чтобы загрузить файл, - соответствующее разрешение должно быть явно указано в файле манифеста. Это конкретное разрешение могут иметь многие приложения. Такая защита путем декларирования помогает уменьшить вероятность повреждения устройства по вине некорректно написанного приложения.

В следующем разделе рассматривается среда разработки, необходимая для создания Android-приложений.

В начало

Необходимые инструменты

Самый простой способ приступить к разработке приложений для Android - это загрузить SDK Android и Eclipse IDE (см. Ресурсы). Разработку Android-приложений можно вести на платформах Microsoft® Windows®, Mac OS X или Linux.

В этой статье предполагается, что вы используете Eclipse IDE и плагин Android Developer Tools для Eclipse. Android-приложения пишутся на языке Java, но компилируются и выполняются в Dalvik VM (не в виртуальной машине Java). Кодирование на языке Java в рамках Eclipse – интуитивно понятный процесс; Eclipse предоставляет богатую среду Java, включая контекстно-зависимую справку и подсказки к коду. Когда ваш Java-код будет безошибочно скомпилирован, Android Developer Tools сам позаботится о том, чтобы приложение был надлежащим образом упаковано, в том числе снабдит его файлом AndroidManifest.xml.

Android-приложение можно написать и без Eclipse и плагина Android Developer Tools, но для этого нужно хорошо разбираться в Android SDK.

Android SDK распространяется в виде файла ZIP, который распаковывается в папку на жестком диске. Так как вышло несколько обновлений SDK, мы рекомендуем вам поддерживать среду разработки в порядке, чтобы можно было легко переключаться между разными установками SDK. В SDK входят:

Android-приложения могут работать как на реальном устройстве, так и на эмуляторе Android, который прилагается к SDK Android. На рисунке 3 показан главный экран эмулятора Android.

Рисунок 3. Эмулятор Android

Отладочный мост Android

Утилита

adb

adb

Рисунок 4. Применение команды оболочки

adb

В рамках этой консоли можно:

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

В следующем разделе мы создадим простое приложение для Android.

В начало

Создание простого приложения

Этот раздел содержит краткий обзор процесса создания Android-приложения. Наш пример приложения предельно прост: это несколько видоизмененное приложение «Hello Android». Мы добавим незначительные изменения, чтобы сделать цвет фона экрана белым – тогда телефон можно будет использовать в качестве фонарика. Не очень оригинально, но как пример полезно. Загрузите весь исходный код.

Чтобы создать приложение в Eclipse, выберите File > New > Android project, что приведет к запуску мастера нового проекта Android (рисунок 5).

Рисунок 5. Мастер нового проекта Android

Теперь создадим простое приложение с одним действием, а также макет пользовательского интерфейса, который будет храниться в папке main.xml. Макет содержит текстовый элемент, который мы заменим на Android FlashLight (фонарик Android). Этот простой макет приведен в листинге 1.

Листинг 1. Макет Flashlight

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@color/all_white">
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="@string/hello" android:textColor="@color/all_black" 
   android:gravity="center_horizontal"/>
</LinearLayout>

Создайте пару ресурсов цвета в strings.xml (листинг 2).

Листинг 2. Цвет в strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Android FlashLight</string>
    <string name="app_name">FlashLight</string>
    <color name="all_white">#FFFFFF</color>
    <color name="all_black">#000000</color>
</resources>

Цвет фона основного экрана определяется как

all_white

all_white

Макет содержит одно поле

TextView

gravity

Приложение содержит исходный файл Java с именем FlashLight.java, как показано в листинге 3.

Листинг 3. Flashlight.java

package com.msi.flashlight;
import android.app.Activity;
import android.os.Bundle;
public class FlashLight extends Activity {
    /** Called when the activity is first created. */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Код создается непосредственно в мастере новых проектов:

Запуск приложения приводит к отображению белого экрана с черным текстом (рисунок 6).

Рисунок 6. Белый экран фонарика

Настройка файла AndroidManifest.xml для приложения FlashLight показана в листинге 4.

Листинг 4. AndroidManifest.xml для приложения FlashLight

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.msi.flashlight"
      android:versionCode="1"
      android:versionName="1.0.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".FlashLight"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Этот файл создается автоматически плагином Android Developer Tools для Eclipse. Вам не нужно ничего делать.

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

В начало

Заключение

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

В начало

Загрузка

        Исходный код FlashLight (zip, 24 Кб)

Ресурсы

Научиться

• Оригинал статьи (EN).
   
• Open Handset Alliance - группа из 47 компаний, специализирующихся на ИТ и мобильной связи, которые поставили перед собой цель ускорить внедрение инноваций в сфере мобильной телефонии и предложить потребителям еще более широкие возможности, меньшие цены и лучшее качество связи. Сообща они разработали Android, первую полную, открытую и бесплатную платформу мобильной телефонии.(EN)
   
• Сайт для разработчиков Android содержит документацию, загрузки, блоги и многое другое. (EN)
   
• Подробнее о Dalvik Virtual Machine.(EN)
   
• Видеоруководства по устройству Dalvik VM на YouTube.(EN)
   
• Unlocking Android: A Developer's Guide - руководство с практическими рекомендациями по ОС Android и инструментам разработки.(EN)
   
• Интервью и дискуссии разработчиков ПО в подкастах на developerWorks.(EN)
   
• Чтобы оставаться в курсе новостей, посещайте раздел технических событий и Web-кастов на developerWorks.(EN)
   
• Следите за developerWorks по Твиттеру.(EN)
   
• Следите за предстоящими конференциями, выставками, Web-кастами и другими мероприятиями во всем мире, которые могут заинтересовать разработчиков открытого ПО IBM.(EN)
   
• Посетите раздел открытого ПО developerWorks, содержащий богатую справочную информацию, инструменты и новости по проектам, которые помогают в разработке технологий с открытым исходным кодом и их использовании с продуктами IBM.(EN)
   
• Узнавайте о технологиях и возможностях продуктов IBM и open source и учитесь работать с ними с помощью бесплатных демонстраций по требованию на developerWorks.(EN)
   

Получить продукты и технологии

• Загрузите Android SDK.(EN)
   
• Получите последнюю версию Eclipse IDE. (EN)
   
• Используйте в своем следующем проекте Open Source-разработки ознакомительное ПО IBM, которое можно загрзить через Интернет или заказать на DVD.(EN)
   
• Загрузите ознакомительные версии продуктов IBM или попробуйте онлайновые версии в IBM SOA Sandbox и попрактикуйтесь в работе с инструментами разработки приложений и продуктами промежуточного уровня семейств DB2®, Lotus®, Rational®, Tivoli® и WebSphere®.(EN)
   

Обсудить

• Примите участие в обсуждении материала на форуме developerWorks.
   
• Примите участие в блогах developerWorks и в жизни сообщества developerWorks.(EN)
   

Об авторе

В начало

Источник: megadarja.blogspot.com

Вот мы и добрались до конца. Осталось сделать только главное меню приложения, а также сделать игре настройки (собственно, меню только для того и нужно, чтобы было откуда настройки вызывать). Ну первое мы еще с прошлой статьи умеем, так что особых сложностей быть не должно. А вот второе следует рассмотреть подробнее. Итак, приступим.

Окно приветствия

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

На нашей форме приветствия будет какая-нибудь картинка и три кнопки: "Начать игру", "Настройки" и "Выход". Картинку в формате png, которую мы назовем

start.png

strings.xml

<resources>
    <string name="app_name">PingPong</string>

    <string name="start_title">Start Game</string>
    <string name="settings_title">Settings</string>
    <string name="exit_title">Exit</string>

Тогда разметка для новой формы будет выглядеть так:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="bottom"
    android:background="@drawable/start"
    android:padding="8dip">

    <Button android:id="@+id/StartButton"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:textStyle="bold"
        android:text="@string/start_title" />

    <Button android:id="@+id/SettingsButton"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:textStyle="bold"
        android:text="@string/settings_title" />

    <Button android:id="@+id/ExitButton"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:textStyle="bold"
        android:text="@string/exit_title" />
</LinearLayout>

Фоновое изображение можно задать экрану с помощью полезного свойства

android:background

Добавим соответствующий этой разметке класс

StartScreen.java

public class StartScreen extends Activity implements OnClickListener
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.start);

        // Кнопка "Start"
        Button startButton = (Button)findViewById(R.id.StartButton);
        startButton.setOnClickListener(this);

        // Кнопка "Exit"
        Button exitButton = (Button)findViewById(R.id.ExitButton);
        exitButton.setOnClickListener(this);

        // Кнопка "Settings"
        Button settingsButton = (Button)findViewById(R.id.SettingsButton);
        settingsButton.setOnClickListener(this);
    }

    /** Обработка нажатия кнопок */
    public void onClick(View v)
    {
        switch (v.getId())
        {
            case R.id.StartButton:
            {
                Intent intent = new Intent();
                intent.setClass(this, GameScreen.class);
                startActivity(intent);
                break;
            }

            case R.id.SettingsButton:
            {
                break;
            }

            case R.id.ExitButton:
                finish();
                break;

            default:
                break;
        }
    }
}

По нажатию на кнопку Start происходит переход на экран с игрой. Обратите внимание, что

StartScreen

StartScreen

Осталось только зарегистрировать эту форму в приложении и сделать ее главной. Для этого идем в

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.android.pingpong"
      android:versionCode="1"
      android:versionName="1.0.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".GameScreen"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" /> 
                <category android:name="android.intent.category.SAMPLE_CODE" /> 
            </intent-filter>
        </activity>

        <activity android:name=".StartScreen">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Теперь приложение начинается с

StartScreen

Настройки

Я сделаю в настройках два параметра — максимальное количество очков и сложность. Сложность игры будем менять, варьируя скорость мячика и ракеток.

Сама форма с настройками делается достаточно просто. Есть специальный наследник класса

Activity

PreferenceActivity

Разметка

Разметка для формы с настройками выглядит несколько необычно:

<?xml version="1.0" encoding="UTF-8"?>
<PreferenceScreen
        xmlns:android="http://schemas.android.com/apk/res/android" >
    <PreferenceCategory
        android:title="@string/prefs_title">

        <ListPreference android:key="@string/pref_difficulty"
            android:title="@string/difficulty_title"
            android:entries="@array/difficulty"
            android:entryValues="@array/difficulty"
            android:defaultValue="1"
           />

        <EditTextPreference android:key="@string/pref_max_score"
             android:title="@string/score_title"
             android:defaultValue="10"
             />
    </PreferenceCategory>
</PreferenceScreen>

Настолько необычно, что, если поместить этот XML в папку layout, eclipse начнет ругаться, что не может разрезолвить такие классы. Собственно, это не просто разметка: там также содержатся ключи настроек и значения по умолчанию. Поэтому мы создадим отдельную папку xml, и поместим этот файл туда. А теперь обо всем по порядку.

PreferenceCategory

Ну,

PreferenceScreen

PreferenceCategory

А можно обойтись без групп:

PreferenceScreen

Какие можно сделать настройки

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

Preference

android:title

Заголовок настройки или контейнера настроек.

android:summary

Краткое описание. Проще говоря, это то, что пишется под заголовком мелким шрифтом.

android:defaultValue

Значение по умолчанию

android:key

Ключ, с которым данная настройка будет храниться и с которым можно будет к ней обращаться.

android:dependency

Задает зависимость от другого контрола. Например, можно поставить эдитору зависимость от флажка, и тогда, если флажок не установлен, но эдитор будет неактивен.

Ну и еще кое-что. Рассмотрим некоторые конкретные виды настроек.

CheckBoxPreference

Вот такой флажок:

EditTextPreference

Редактор текста.

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

ListPreference

Своеобразная реализация Dropdown-а. Хотя, на телефоне наверно и вправду так удобнее.

На этом контроле хотелось бы остановиться подробнее. А конкретнее, рассказать, откуда он, собственно, берет элементы списка. А берет он их из ресурсов с помощью таких атрибутов.

android:entries

Здесь хранится ссылка на ресурс, в котором хранятся отображаемые элементы списка. Все значения, которые хочется вынести в ресурсы, хранятся в папке values. До сих пор там была только одна XML-ка —

strings.xml

. Но теперь надо добавить еще одну — arrays.xml. И добавить в узел

resources

следующее:

<string-array name="performance">
    <item>Best performance</item>
    <item>Normal performance and appearance</item>
    <item>Best appearance</item>
</string-array>

После этого можно смело указывать в

android:entries

этот ресурс, список будет загружен.

Кстати говоря, в

item

-ах может быть не непосредственно строка, а ссылка на строку в

strings.xml

. Например, в нашем случае будет так (разумеется, стоит добавить соответствующие значения в

strings.xml

):

res/values/arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="difficulty">
        <item>@string/difficulty_easy</item>
        <item>@string/difficulty_normal</item>
        <item>@string/difficulty_hard</item>
    </string-array>
</resources>

android:entryValues

Список действительных значений. Также ссылка на ресурс, и задавать можно так же. Если кодов будет меньше, чем значений, приложение будет валиться с исключением. Если больше — не будет. В нашем случае можно в entries и entryValues смело задавать одно и то же, но бывает, когда имеет смысл их разделять.

А еще мне никак не удалось победить у

ListPreference

adnroid:defaultValue

RingtonePreference

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

Класс формы

Класс для формы с настройками будет выглядеть так:

public class SettingsScreen extends PreferenceActivity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        // Настройки и их разметка загружаются из XML-файла
        addPreferencesFromResource(R.xml.preferences);
    }
}

Кстати, настройки необязательно загружать из XML-ки, можно добавлять все эти настройки прямо в коде конструктора. В сэмплах, которые идут с Android SDK, такие примеры есть.

Добавляем в

StartScreen

SettingsScreen

AndroidManifest.xml

GameScreen

Не знаю, кому как, а мне нравится, когда рядом с названием опции написано ее значение. Но как это сделать автоматически, я так и не нашла, пришлось все делать руками, используя для этого поле

summary

OnPreferenceChange

public class SettingsScreen extends PreferenceActivity
          implements Preference.OnPreferenceChangeListener
{
    /* Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        // Load the preferences from an XML resource
        addPreferencesFromResource(R.xml.preferences);

        ListPreference difficulty = 
                                (ListPreference)this.findPreference("pref_difficulty");
        difficulty.setSummary(difficulty.getEntry());
        difficulty.setOnPreferenceChangeListener(this);

        EditTextPreference maxScore = 
                      (EditTextPreference)this.findPreference("pref_max_score");
        maxScore.setSummary(maxScore.getText());
        maxScore.setOnPreferenceChangeListener(this);

Думаю, все понятно без слов. Теперь мы видим такую картину:

И, если мы будем менять настройки, изменения сразу же будут отображаться в

summary

Использование настроек в других формах

Ну все, настройки мы сделали, они как-то сами где-то сохранились. Теперь возникла необходимость их прочитать и что-нибудь с ними сделать. Читать и делать мы будем в классе

GameManager

SharedPreferences

public GameManager(SurfaceHolder surfaceHolder, Context context)
{
    ...

    // стили для рисования игрового поля
    ...

    // игровые объекты
    ...

    // применение настроек
    SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);

    String difficulty = settings.getString(res.getString(R.string.pref_difficulty),
                                                   res.getString(R.string.difficulty_normal));
    setDifficulty(difficulty);

    int maxScore = Integer.parseInt(settings.getString(
                                          res.getString(R.string.pref_max_score), "10"));
    setMaxScore(maxScore);

Метод

setDifficulty

SharedPreferences

getString

getInt

getBoolean

android:key

getString

мне так и не удалось.

Заключение

Итак, мануал закончен. Получился он огромным, но при этом собственно про андроид оказалось не так уж и много, что самое-то обидное :( Спасибо, если кто дочитал до конца. Буду рада услышать любые мнения.

Отдельное спасибо xeye и std.denis

А вот и все исходники

Источник: megadarja.blogspot.com

В этой части мы напишем обработку выигрышей-проигрышей, реализуем подсчет очков, а также сделаем, чтобы игру можно было ставить на паузу. Собственно, пауза тут несколько не в тему, но девать ее некуда, так что сделаем ее в этой части.

Обработка проигрыша

Помнится, мы заводили в классе

Racquet

mScore

Итак, в начале игры количество очков у обоих игроков пусто. Когда игрок не успевает отбить мяч, его противнику засчитывается очко, мячик и ракетки возвращаются на исходные позиции. Игра продолжается, пока какой-нибудь из игроков не наберет N очков. N мы пока что объявим константой, а в следующей части вынесем в настройки.

Проверка проигрыша должна осуществляться также в методе

updateObjects()

GameManager

private void updateObjects()
{
    ...

    // проверка проигрыша
    if (mBall.getBottom() < mThem.getBottom())
    {
        mUs.incScore();
        reset();
    }

    if (mBall.getTop() > mUs.getTop())
    {
        mThem.incScore();
        reset();
    }

Racquet.incScore()

/** Увеличить количество очков игрока */
public void incScore()
{
    mScore++;
}

GameManager.reset()

private void reset()
{
    // ставим мячик в центр
    mBall.setCenterX(mField.centerX());
    mBall.setCenterY(mField.centerY());
    // задаем ему новый случайный угол
    mBall.resetAngle();

    // ставим ракетки в центр
    mUs.setCenterX(mField.centerX());
    mThem.setCenterX(mField.centerX());

    // делаем паузу
    try
    {
        sleep(LOSE_PAUSE);
    }
    catch (InterruptedException iex)
    {
    }
}

LOSE_PAUSE

GameManager

resetAngle()

Ball

/** Задает новое случайное значение угла */
public void resetAngle()
{
    mAngle = getRandomAngle();
}

Если теперь запустить приложение, то увидим, что, если упустить мячик, то он никуда не улетит, а через некоторое время восстановится в центре. А про очки пока ничего сказать нельзя, потому что они нигде не выводятся. Что ж, будем выводить.

Вывод количества очков

Вывод текста на экран производится с помощью метода

drawText(String text, float x, float y, Paint paint)

Paint

GameManager

mPaint

Paint

private Paint mScorePaint;

Инициализировать его в конструкторе:

public GameManager(SurfaceHolder surfaceHolder, Context context)
{
    mSurfaceHolder = surfaceHolder;
    Resources res = context.getResources();
    mRunning = false;

    // стили для рисования игрового поля
    mPaint = new Paint();
    mPaint.setColor(Color.BLUE);
    mPaint.setStrokeWidth(2);
    mPaint.setStyle(Style.STROKE);

    // стили для вывода счета
    mScorePaint = new Paint();
    mScorePaint.setTextSize(20);
    mScorePaint.setStrokeWidth(1);
    mScorePaint.setStyle(Style.FILL);
    mScorePaint.setTextAlign(Paint.Align.CENTER);

А непосредственно вывод счета игры производится в методе, где происходит вся отрисовка текущей игровой ситуации —

refreshCanvas

private void refreshCanvas(Canvas canvas)
{
    // вывод фонового изображения
    canvas.drawBitmap(mBackground, 0, 0, null);

    // рисуем игровое поле
    canvas.drawRect(mField, mPaint);

    // рисуем игровые объекты
    mBall.draw(canvas);
    mUs.draw(canvas);
    mThem.draw(canvas);

    // вывод счета
    mScorePaint.setColor(Color.RED);
    canvas.drawText(String.valueOf(mThem.getScore()),
                mField.centerX(), mField.top - 10, mScorePaint);
    mScorePaint.setColor(Color.GREEN);
    canvas.drawText(String.valueOf(mUs.getScore()),
         mField.centerX(), mField.bottom + 25, mScorePaint);

Правда, совсем уж без изменения стиля не обошлось. Наши очки мы рисуем зелёным, а очки противника — красным. Запустив, увидим примерно такую картину:

Использование пользовательских шрифтов

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

В нашем проекте есть такая папка assets, там хранятся такие ресурсы, как TrueType-шрифты, возможно, какие-то большие тексты и т.д.. Основное отличие их от ресурсов, которые хранятся в папке

res

res

R

AssetManager

Итак, создадим в папке

assets

Mini.ttf

mScorePaint

mScorePaint.setTypeface(Typeface.createFromAsset(context.getAssets(), "fonts/Mini.ttf"));

context.getAssets()

AssetManager

Неприятность

И всё бы хорошо, но теперь время от времени стали возникать ситуации, когда в начале игры у одного из игроков выводится не 0 очков, а 1. Я так понимаю, что проблемы возникают в самом начале программы, перед

initPositions

updateObjects

GameManager

mInitialized

false

initPositions

true

run

public void run()
{
    while (mRunning)
    {
        Canvas canvas = null;
        try
        {
            // подготовка Canvas-а
            canvas = mSurfaceHolder.lockCanvas();
            synchronized (mSurfaceHolder)
            {

                if (mInitialized)
                {

Теперь гарантированно не будет происходить никаких проверок, пока не будут инициализированы координаты игровых объектов. Проблема решена.

Обработка окончания игры

Прежде всего, нам следует завести в

GameManager

/** Максимальное число очков, до которого идет игра */
private static int mMaxScore = 5;

public static void setMaxScore(int value)
{
    mMaxScore = value;
}

Саму проверка на окончание игры можно поместить как в метод

updateObjects()

run()

updateObjects()

/** Обновление состояния игровых объектов */
private void updateObjects()
{
    // Обновление состояния игровых объектов
    ...

    // обработка столкновений
    ...

    // проверка проигрыша
    ...

    // проверка окончания игры
    if (mUs.getScore() == mMaxScore  mThem.getScore() == mMaxScore)
    {
        this.mRunning = false;
    }

Напомню, что метод

run

public void run()
{
    while (mRunning)
    {
        // обновление и отрисовка объектов
    }
}

То есть, когда

mRunning

false

run()

public void run()
{
    while (mRunning)
    {
        // обновление и отрисовка объектов
    }
    // рисование GameOver
    ...
}

А теперь разберемся, как это рисование может выглядеть. Как известно, при рисовании мы лочим Canvas, рисуем, и затем разлочиваем. При этом еще нужно отловить возможные исключения. Получается куча кода, которая появляется при каждом рисовании и сильно загромождает текст программы. Естественно, хочется вынести все это в метод-обертку и передавать туда ссылку на функцию, осуществляющую собственно рисование. На C# это выглядело бы так:

delegate void DrawFunction(Canvas canvas);

private void draw(DrawFunction something)
{
    Canvas canvas = null;
    try
    {
        canvas = mSurfaceHolder.lockCanvas();
        synchronized (mSurfaceHolder)
        {
            something(canvas);
        }
    }
    }
    catch (Exception e) { }
    finally
    {
        if (canvas != null)
        {
            mSurfaceHolder.unlockCanvasAndPost(canvas);
        }
    }
}

Но здесь нам не C#, здесь климат иной, и делегатов нет. Однако, как мне подсказал товарищ xeye, подобный код можно написать. Итак, добавим в

GameManager

private interface DrawHelper
{
    void draw(Canvas canvas);
}

И такой метод, куда мы вынесем всю работу по подготовке canvas-а:

private void draw(DrawHelper helper)
{
    Canvas canvas = null;
    try
    {
        // подготовка Canvas-а
        canvas = mSurfaceHolder.lockCanvas();
        synchronized (mSurfaceHolder)
        {
            if (mInitialized)
            {
                helper.draw(canvas);
            }
        }
    }
    catch (Exception e) { }
    finally
    {
        if (canvas != null)
        {
            mSurfaceHolder.unlockCanvasAndPost(canvas);
        }
    }
}

Теперь можно завести конкретные реализации

DrawHelper

/** Хелпер для перерисовки экрана */
private DrawHelper mDrawScreen;

/** Хелпер для рисования результата игры*/
private DrawHelper mDrawGameover;

Инициализирую в конструкторе таким образом:

public GameManager(SurfaceHolder surfaceHolder, Context context)
{
    ...
   
    // функция для рисования экрана
    mDrawScreen = new DrawHelper()
    {
        public void draw(Canvas canvas)
        {
            refreshCanvas(canvas);
        }
    };

    // функция для рисования результатов игры
    mDrawGameover = new DrawHelper()
    {
        public void draw(Canvas canvas)
        {
            // Вывели последнее состояние игры
            refreshCanvas(canvas);
           
            // смотрим, кто выиграл и выводим соответствующее сообщение
            String message = "";
            if (mUs.getScore() > mThem.getScore())
            {
                mScorePaint.setColor(Color.GREEN);
                message = "You won";
            }
            else
            {
                mScorePaint.setColor(Color.RED);
                message = "You lost";
            }
            mScorePaint.setTextSize(30);
            canvas.drawText(message, mField.centerX(), mField.centerY(), mScorePaint);
        }
    };
}

После этого метод

run()

/** Действия, выполняемые в потоке */
public void run()
{
    while (mRunning)
    {
        if (mInitialized)
        {
            updateObjects(); // обновляем объекты
            draw(mDrawScreen);
        }
    }
    draw(mDrawGameover);
}

И сразу результат:

Пауза

Тут совсем кратко. Объявим в классе

GameManager

/** Стоит ли приложение на паузе */
private boolean mPaused;

Если приложение на паузе, поток работает "вхолостую", т.е. состояния объектов не меняются и вообще ничего не происходит. Это значит, в методе

run()

public void run()
{
    while (mRunning)
    {

        if (mPaused) continue;

Будем ставить приложение на паузу, если нажата средняя клавиша джойстика:

public boolean doKeyDown(int keyCode)
{
    switch (keyCode)
    {
        case KeyEvent.KEYCODE_DPAD_LEFT:
        case KeyEvent.KEYCODE_A:
            mUs.setDirection(GameObject.DIR_LEFT);
            return true;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
        case KeyEvent.KEYCODE_D:
            mUs.setDirection(GameObject.DIR_RIGHT);
            return true;

        case KeyEvent.KEYCODE_DPAD_CENTER:
            mPaused = !mPaused;
            draw(mDrawPause);
            return true;

mDrawPause

Итак

У нас уже совсем готовая игра. Можно играть, выигрывать, проигрывать, ставить на паузу.

Исходники примера

Источник: megadarja.blogspot.com

В этой статье мы рассмотрим две темы: управление игровыми объектами и их взаимодействие. Мячик у нас уже летает, осталось сделать, чтобы он отражался от стен и ракеток; также стоит реализовать управление нижней ракетки игроком, а верхней — неким алгоритмом. Итак, приступим.

Движение мячика

Для начала добавим в

GameObject

/** Верхняя граница объекта */
public int getTop() { return mPoint.y; }

/** Нижняя граница объекта */
public int getBottom() { return mPoint.y + mHeight; }

/** Левая граница объекта */
public int getLeft() { return mPoint.x; }

/** Правая граница объекта */
public int getRight() { return mPoint.x + mWidth; }

/** Центральная точка объекта */
public Point getCenter() { return new Point(mPoint.x + mWidth / 2, mPoint.y + mHeight / 2); }

/** Высота объекта */
public int getHeight() { return mHeight; }

/** Ширина объекта */
public int getWidth() { return mWidth; }

/** @return Прямоугольник, ограничивающий объект */
public Rect getRect() { return mImage.getBounds(); }

/** Проверяет, пересекаются ли два игровых объекта */
public static boolean intersects(GameObject obj1, GameObject obj2)
{
    return Rect.intersects(obj1.getRect(), obj2.getRect());
}

Игровые объекты ничего не знают ни о друг друге, ни об игровом поле, поэтому все столкновения будут обрабатываться GameManager-ом. Итак, рассмотрим сначала такую ситуацию:

Итак, наш мячик был в некотором состоянии A, потом, пройдя расстояние

mSpeed

Расчет координат при столкновении

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

Вычисление нового направления движения

Рассмотрим варианты столкновения. Пусть ? — угол, под которым движется мячик, а ? — угол, получившийся после столкновения. Посмотрим, как ? зависит от ? в различных случаях:

	Значения ?	Столкновение с вертикалью		Столкновение с горизонталью
1	0 < ? < ? / 2		? = ? ? ?		? = 2? ? ?
2	? / 2 < ? < ?		? = ? ? ?		? = 2? ? ?
3	? < ? < 3? / 2		? = 3? ? ?		? = 2? ? ?
4	3? / 2 < ? < 2?		? = 3? ? ?		? = 2? ? ?

Выяснив всй это, можно добавить в класс

Ball

/** Отражение мячика от вертикали */
public void reflectVertical()
{
    if (mAngle > 0 && mAngle < PI)
        mAngle = PI - mAngle;
    else
        mAngle = 3 * PI - mAngle;
}

/** Отражение мячика от горизонтали */
public void reflectHorizontal()
{
    mAngle = 2 * PI - mAngle;
}

Обновление же в

GameManager

private void updateObjects()
{
    mBall.update();
    mUs.update();
    mThem.update();

    // проверка столкновения мячика с вертикальными стенами
     if (mBall.getLeft() <= mField.left)
     {
      mBall.setLeft(mField.left + Math.abs(mField.left - mBall.getLeft()));
      mBall.reflectVertical();
     }
     else if (mBall.getRight() >= mField.right)
     {
      mBall.setRight(mField.right - Math.abs(mField.right - mBall.getRight()));
      mBall.reflectVertical();
     }

    // проверка столкновения мячика с горизонтальными стенами
     if (mBall.getTop() <= mField.top)
     {
      mBall.setTop(mField.top + Math.abs(mField.top - mBall.getTop()));
      mBall.reflectHorizontal();
     }
     else if (mBall.getBottom() >= mField.bottom)
     {
      mBall.setBottom(mField.bottom - Math.abs(mField.bottom - mBall.getBottom()));
      mBall.reflectHorizontal();
     }
}

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

Управление ракеткой

Перемещать ракетку можно двумя способами. Первый — отлавливать нажатие кнопок вправо и влево, и при нажатии смещать ракетку в нужную сторону. Однако, как показала практика, такой способ не очень хорош, так как ракетка двигается резко и подтормаживает при первом нажатии. Более прогрессивным способом оказался другой: при нажатии клавиши назначать ракетке соответствующий Direction, а при отпускании обнулять его. А в методе

updateObjects

Итак, теперь надо бы написать код для обработки нажатия клавиш. Вообще, нажатие клавиш ловит View, и для обработки нужно перегрузить функции

onKeyDown

onKeyUp

GameManager

GameView

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)
{
    return mGameManager.doKeyDown(keyCode);
}

@Override
public boolean onKeyUp(int keyCode, KeyEvent event)
{
    return mGameManager.doKeyUp(keyCode);
}

А в

GameManager

doKeyDown

doKeyUp

/**
 * Обработка нажатия кнопки
 * @param keyCode Код нажатой кнопки
 * @return Было ли обработано нажатие
 */
public boolean doKeyDown(int keyCode)
{
    switch (keyCode)
    {
        case KeyEvent.KEYCODE_DPAD_LEFT:
            mUs.setDirection(GameObject.DIR_LEFT);
            return true;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            mUs.setDirection(GameObject.DIR_RIGHT);
            return true;
        default:
            return false;
    }
}
/**
 * Обработка отпускания кнопки
 * @param keyCode Код кнопки
 * @return Было ли обработано действие
 */
public boolean doKeyUp(int keyCode)
{
    if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT ||
        keyCode == KeyEvent.KEYCODE_DPAD_RIGHT)
    {
        mUs.setDirection(GameObject.DIR_NONE);
        return true;
    }
    return false;
}

GameView

добавить одну строчку:

public GameView(Context context, AttributeSet attrs)
{
    super(context, attrs);

    // подписываемся на события Surface
    mSurfaceHolder = getHolder();
    mSurfaceHolder.addCallback(this);

    mGameManager = new GameManager(mSurfaceHolder, context);

    setFocusable(true);

Теперь все работает, ракетка управляется.

Искусственный интеллект для противника

У компьютера логика будет простая: по возможности не допускать, чтобы мячик выходил за пределы ракетки. Если мячик окажется правее ракетки, ракетка едет направо, если левее — налево. Реализуем всю эту логику в методе

moveAI()

GameManager

private void moveAI()
{
    if (mThem.getLeft() > mBall.getRight())
        mThem.setDirection(GameObject.DIR_LEFT);
    else if (mThem.getRight() < mBall.getLeft())
        mThem.setDirection(GameObject.DIR_RIGHT);
    mThem.update();
}

А

GameManager.updateObjects()

private void updateObjects()
{
    mBall.update();
    mUs.update();

    moveAI();

Еще пара доработок

Ракетки выходят за пределы экрана

Собственно, никто им этого делать не запрещает. Напишем в

GameManager

private void placeInBounds(Racquet r)
{
    if (r.getLeft() < mField.left)
        r.setLeft(mField.left);
    else if (r.getRight() > mField.right)
        r.setRight(mField.right);
}

А в

GameManager.updateObjects()

private void updateObjects()
{
    mBall.update();
    mUs.update();
    moveAI();

    // чтобы ракетки не выходили за пределы поля
    placeInBounds(mUs);
    placeInBounds(mThem);

Теперь все стало хорошо, ракетки не выходят за пределы поля.

Столкновение мячика с ракетками

Сейчас у нас мячик летает, отражаясь от стен, а хотелось бы, чтобы он летал, отражаясь только от вертикальных стен и от ракеток. Убираем из

GameManager.updateObjects()

private void updateObjects()
{
    // Обновление положений объектов
    ...

    // Обработка столкновений с вертикальными стенами
    ...

    // проверка столкновений мячика с ракетками
    if (GameObject.intersects(mBall, mUs))
     {
      mBall.setBottom(mUs.getBottom() - Math.abs(mUs.getBottom() - mBall.getBottom()));
      mBall.reflectHorizontal();
     }
     else if (GameObject.intersects(mBall, mThem))
     {
      mBall.setTop(mThem.getTop() + Math.abs(mThem.getTop() - mBall.getTop()));
      mBall.reflectHorizontal();
     }

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

Итак

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

Исходники для этой части

Источник: megadarja.blogspot.com

Добавим в нашу игру экшена. Как известно, в пинг-понге три действующих лица: мячик и две ракетки. Имеет смысл реализовать соответствующие классы —

Ball

Racquet

GameObject

У всех игровых объектов есть:

• mPoint

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

• mImage

  — изображение объекта. Изображения обычно берутся из ресурсов приложения — /res/drawable

• mHeight

  ,

  mWidth

  — размеры изображения объекта. Вынесены как поля класса только для того, чтобы не загромождать код всякими

  mImage.getIntrinsicHeight()

  и

  mImage.getIntrinsicWidth()

• mSpeed

  — скорость перемещения объекта (фактически, на сколько перемещается объект за один шаг)

Кроме того, все игровые классы умеют рисовать себя на указанном Canvas-е (метод

draw

update

updatePoint

updatePoint

В класс

Ball

mAngle

Racquet

mDirection

mScore

Реализации классов

GameObject

public abstract class GameObject
{
    // Константы для направлений
    public final int DIR_LEFT = -1;
    public final int DIR_RIGHT = 1;
    public final int DIR_NONE = 0;

    /** Координаты опорной точки */
    protected Point mPoint;

    /** Высота изображения */
    protected int mHeight;

    /** Ширина изображения */
    protected int mWidth;

    /** Изображение */
    private Drawable mImage;

    /** Скорость */
    protected int mSpeed;

    /**
     * Конструктор
     * @param image Изображение, которое будет обозначать данный объект
     */
    public GameObject(Drawable image)
    {
        mImage = image;
        mPoint = new Point(0, 0);
        mWidth = image.getIntrinsicWidth();
        mHeight = image.getIntrinsicHeight();
    }

    /** Перемещение опорной точки */
    protected abstract void updatePoint();

    /** Перемещение объекта */
    public void update()
    {
        updatePoint();
        mImage.setBounds(mPoint.x, mPoint.y, mPoint.x + mWidth, mPoint.y + mHeight);
    }

    /** Отрисовка объекта */
    public void draw(Canvas canvas)
    {
        mImage.draw(canvas);
    }
    /** Задает левую границу объекта */
    public void setLeft(int value) { mPoint.x = value; }

    /** Задает правую границу объекта */
    public void setRight(int value) { mPoint.x = value - mWidth; }

    /** Задает верхнюю границу объекта */
    public void setTop(int value) { mPoint.y = value; }

    /** Задает нижнюю границу объекта */
    public void setBottom(int value) { mPoint.y = value - mHeight; }

    /** Задает абсциссу центра объекта */
    public void setCenterX(int value) { mPoint.x = value - mHeight / 2; }

    /** Задает левую ординату центра объекта */
    public void setCenterY(int value) { mPoint.y = value - mWidth / 2; }
}

Ball

public class Ball extends GameObject
{
    private static final int DEFAULT_SPEED = 3;
    private static final int PI = 180;

    /** Угол, который составляет направление полета шарика с осью Ox */
    private int mAngle;

    /**
     * @see com.android.pingpong.objects.GameObject#GameObject(Drawable)
     */
    public Ball(Drawable image)
    {
        super(image);

        mSpeed = DEFAULT_SPEED; // задали скорость по умолчанию
        mAngle = getRandomAngle(); // задали случайный начальный угол
    }

    /**
     * @see com.android.pingpong.objects.GameObject#updatePoint()
     */
    @Override
    protected void updatePoint()
    {
        double angle = Math.toRadians(mAngle);

        mPoint.x += (int)Math.round(mSpeed * Math.cos(angle));
        mPoint.y -= (int)Math.round(mSpeed * Math.sin(angle));
    }

    /** Генерация случайного угла в промежутке [95, 110]U[275,290] */
    private int getRandomAngle()
    {
        Random rnd = new Random(System.currentTimeMillis());

        return rnd.nextInt(1) * PI + PI / 2 + rnd.nextInt(15) + 5;
    }
}

Racquet

public class Racquet extends GameObject
{
    private static final int DEFAULT_SPEED = 3;

    /** Количество заработанных очков */
    private int mScore;

    /** Направление движения */
    private int mDirection;

    /** Задание направления движения*/
    private void setDirection(int direction)
    {
        mDirection = direction;
    }

    /**
     * @see com.android.pingpong.objects.GameObject#GameObject(Drawable)
     */
    public Racquet(Drawable image)
    {
        super(image);

        mDirection = DIR_NONE; // Направление по умолчанию - нет
        mScore = 0; // Очков пока не заработали
        mSpeed = DEFAULT_SPEED; // Задали скорость по умолчанию
    }

    /**
     * @see com.android.pingpong.objects.GameObject#updatePoint()
     */
    @Override
    protected void updatePoint()
    {
        // двигаем ракетку по оси Ox в соответствующую сторону
        mPoint.x += mDirection * mSpeed;
    }
}

Отображение игровых объектов

Рисуем картинки

Ну вроде классы наши готовы, можно теперь их использовать в программе. Но сначала надо нарисовать картинки, для наших объектов. Картинки должны быть в png. У меня получилось так:

	Мячик
	Наша ракетка
	Pакетка противника

Берем все это счастье, и кидаем в /res/drawable, где у нас хранятся всякие такие ресурсы.

Создаем игровые объекты

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

GameManager

/** Ресурсы приложения */
private Resources mRes;

/** Мячик */
private Ball mBall;

/** Ракетка, управляемая игроком */
private Racquet mUs;

/** Ракетка, управляемая компьютером*/
private Racquet mThem;

В конструкторе инициализируем их:

public GameManager(SurfaceHolder surfaceHolder, Context context)
{
    mSurfaceHolder = surfaceHolder;
    mRunning = false;

    // инициализация стилей рисования
    mPaint = new Paint();
    mPaint.setColor(Color.BLUE);
    mPaint.setStrokeWidth(2);
    mPaint.setStyle(Style.STROKE);

    Resources res = context.getResources();

    mField = new Rect();
    mBall = new Ball(res.getDrawable(R.drawable.ball));
    mUs = new Racquet(res.getDrawable(R.drawable.us));
    mThem = new Racquet(res.getDrawable(R.drawable.them));

Расставляем их по местам

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

initPositions()

public void initPositions(int screenHeight, int screenWidth)
{
    int left = (screenWidth - FIELD_WIDTH) / 2;
    int top = (screenHeight - FIELD_HEIGHT) / 2;

    mField.set(left, top, left + FIELD_WIDTH, top + FIELD_HEIGHT);

    // мячик ставится в центр поля
    mBall.setCenterX(mField.centerX());
    mBall.setCenterY(mField.centerY());

    // ракетка игрока - снизу по центру
    mUs.setCenterX(mField.centerX());
    mUs.setBottom(mField.bottom);

    // ракетка компьютера - сверху по центру
    mThem.setCenterX(mField.centerX());
    mThem.setTop(mField.top);

Заставляем их что-то делать

Итак, объекты мы создали, теперь надо заставить их что-то делать. Понятно, что все изменения должны происходить в цикле, который работает в методе

run()

/** Обновление объектов на экране */
private void refreshCanvas(Canvas canvas)
{
    // рисуем игровое поле
    canvas.drawRect(mField, mPaint);

    // рисуем игровые объекты
    mBall.draw(canvas);
    mUs.draw(canvas);
    mThem.draw(canvas);
}

/** Обновление состояния игровых объектов */
private void updateObjects()
{
    mBall.update();
    mUs.update();
    mThem.update();
}

А в методе

run()

public void run()
{
    while (mRunning)
    {
        Canvas canvas = null;
        try
        {
            // подготовка Canvas-а
            canvas = mSurfaceHolder.lockCanvas();
            synchronized (mSurfaceHolder)
            {

                updateObjects(); // обновляем объекты
                refreshCanvas(canvas); // обновляем экран
                sleep(20);

Ну все, вроде сделали, можно запускать. Ракетки не двигаются, потому что ими пока никто не управляет, а вот шарик вполне себе летает. Правда, оставляет при этом за собой шлейф:

Делаем фон

Это всё из-за того, что мы не очищаем экран перед очередной отрисовкой. А очищать экран это тоже не так-то просто. Ничего вроде

canvas.clear()

refreshCanvas

Итак, заводим поле:

/** Фон */
private Bitmap mBackground;

Инициализируем его в

initPositions

public void initPositions(int screenHeight, int screenWidth)
{
    int left = (screenWidth - FIELD_WIDTH) / 2;
    int top = (screenHeight - FIELD_HEIGHT) / 2;

    mField.set(left, top, left + FIELD_WIDTH, top + FIELD_HEIGHT);

    mBackground = Bitmap.createBitmap(screenWidth, screenHeight, Bitmap.Config.RGB_565);

И отрисовываем в

refreshCanvas

private void refreshCanvas(Canvas canvas)
{

    // вывод фонового изображения
    canvas.drawBitmap(mBackground, 0, 0, null);

И получаем примерно вот такую картину:

Итак

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

Исходники примера

Android является программным стеком для мобильных устройств, в том числе операционной системы, промежуточного программного обеспечения и основных приложений. Он разрабатывается группой Open Handset Alliance, включающей в себя более 30 мобильных компаний и технологий. Android был создан “с нуля”, чтобы позволить разработчикам создавать конкурентоспособные мобильные приложения, использующие все возможности мобильного телефона. Разработчики могут создавать приложения для платформы с помощью SDK Android.

С чего же начать?

Ссылки:

1. Java Development Kit (JDK) (~72MB)
2. Eclipse Classic (~151MB)
3. Android SDK (~94MB)
4. ADT его установим через Eclipse

Замечание: даже если у вас 64 битная ОС, устанавливать нужно только 32х битный JDK

Установка

1. Устанавливаем Java Development Kit (JDK), ничего не обычного там нет. Ставим все по умолчанию.
2. Распаковываем Eclipse Classic в c:eclipse
3. Распаковываем Android SDK в папку c:eclipse

Должно выглядеть как на картинке ниже:

Настройка Eclipse

1. Запускаем Eclipse и выбираем в меню: Help > Software Updates->Find and Install…

2. Выбираем Search for new features to install и нажимаем Next >

3. В появившемся окне нажимаем кнопку New Remote Site…
Добавляем источник для Android Development Tools: https://dl-ssl.google.com/android/eclipse/

Нажимаем OK. Проверяем что наш источник выбран , нажимаем Finish. Начнется поиск доступных плагинов, еще раз выделяем плагин для установки, далее, соглашаемся с лицензией, Finish-> Install All.

4. Указываем Eclipse путь к установленному SDK:

В меню Window->Preferences… В разделе Android указываем путь к SDK:

После выбора должно быть что то вида:

Нажимаем OK

На этом установка и настройка готова. Можно приступать к созданию программ для Android.

Основная информация по Android может быть найдена на официальном сайте: code.google.com/android