Часть 2. Просмотр анимации

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

Содержание

1. Просмотр анимации
   a. Просмотр анимации (в составе набора или без)
   b. Просмотр анимации в XML
   c. Настраиваемая анимация

Просмотр анимации

Следующие способы создания анимации применяются в представлениях. Это может быть стандартное представление API Android или собственный настраиваемый класс представления. Обратите внимание, что при этом изменится только место отрисовки представления на экране, а не его фактическое расположение. Например, кнопка будет перемещаться по экрану, но область кнопки, поддерживающая нажатие указателем мыши, не будет перемещаться вместе с изображением. Это ограничение можно обойти, написав собственную настраиваемую анимацию и обновляя свойства вместо применения к объекту матрицы преобразований. Анимации представлений также используют реализацию интерфейса AnimationListener, чтобы можно было применять обратные вызовы вместо класса AnimationListenerAdapter, используемого в анимации свойств (в этом случае пришлось бы использовать все его методы, даже если они и не нужны).

a. Просмотр анимации (в составе набора или без)

Анимацию можно вкладывать в многоуровневую структуру или объединять в наборы. Это позволяет запустить одним вызовом просмотр сразу нескольких анимаций или их последовательности. Для вкладывания анимаций нужно задать значение true для параметра .setFillAfter, чтобы представление осталось в том состоянии, в котором оно было в конце первой анимации, а не возвращалось к начальной точке перед запуском следующей анимации. В приведенной здесь реализации мы делаем одну и ту же анимацию дважды, но во второй раз запускаем ее «задом наперед», задав значение 1 для счетчика повторов и значение reverse для режима повтора. Можно было бы и вложить эти анимации, но в данном случае описываемый подход предпочтительнее. Можно использовать повтор в обратном направлении для некоторых анимаций свойств, описанных в первой части; мы этого не сделали, чтобы не возникло путаницы с описываемыми здесь методиками. TranslateAnimation и другие анимации представлений отличаются тем, что используемые ими значения не являются абсолютными: величины изменений применяются в начале и в конце анимации. Поэтому мы сначала используем значение 0, чтобы оставаться на месте в начале анимации; а к ее концу нужно сдвинуться наполовину влево, поэтому используем значение x/2.

public void doViewAnimation(){
     TranslateAnimation transTo= new TranslateAnimation(0, -mLittleChef.getX()/2, 0, 0);
     transTo.setRepeatCount(1);
     transTo.setRepeatMode(Animation.REVERSE);
     transTo.setAnimationListener(new Animation.AnimationListener(){
           @Override
           public void onAnimationEnd(Animation animation) {
                simpleLock=  false;
           }
          @Override
          public void onAnimationStart(Animation animation) {
               // TODO Auto-generated method stub
	 }
          @Override
          public void onAnimationRepeat(Animation animation) {
              // TODO Auto-generated method stub
           }
 });
     transTo.setInterpolator(new LinearInterpolator());
     transTo.setDuration(mShortAnimationDuration/2);
     mLittleChef.startAnimation(transTo);
}
Метод set анимации представления:

public void doViewAnimationSet(){
     TranslateAnimation transTo= new TranslateAnimation(0, -mLittleChef.getX()/2, 0, 0);
     TranslateAnimation transBack= new TranslateAnimation(0, mLittleChef.getX()/2, 0, 0);
     transTo.setDuration(mShortAnimationDuration/2);
     transBack.setDuration(mShortAnimationDuration/2);
     transTo.setStartOffset(0);
     transBack.setStartOffset(transTo.getDuration());
     AnimationSet transSet= new AnimationSet(true);
     transSet.setInterpolator(new LinearInterpolator());
     transSet.addAnimation(transTo);
     transSet.addAnimation(transBack);
     transSet.setAnimationListener(new AnimationListener(){
          @Override
          public void onAnimationEnd(Animation animation) {
               simpleLock= false;
          }

          @Override
          public void onAnimationStart(Animation animation) {
               //  TODO Auto-generated method stub
           }

          @Override
          public void onAnimationRepeat(Animation animation) {
               //  TODO Auto-generated method stub
          }
     });
     mLittleChef.startAnimation(transSet);
     //another way to start your set animation:
     //set.setTarget(mLittleChef);
    //set.start();
     }

b. Просмотр анимации с помощью XML

Также можно задать параметры анимации в XML-файле в папке res/anim. У этого подхода есть такие же недостатки, как у анимации объектов в XML, описанной в первой части этой серии: значения являются статическими, что затрудняет адаптацию к разным размерам экрана. Тем не менее, для анимации преобразований мы используем toXDelta, что дает нам возможность использовать значения, оканчивающиеся на % (процент от собственного значения) или на %p (процент от родительского значения). Это повышает удобство.

public void doViewAnimationXML(){
     Animation trans = AnimationUtils.loadAnimation(getActivity(), R.anim.view_animation);
     trans.setRepeatCount(1);
     trans.setRepeatMode(Animation.REVERSE);
     trans.setAnimationListener(new AnimationListener(){
          @Override
          public void onAnimationEnd(Animation animation) {
               simpleLock= false;
          }

          @Override
          public void onAnimationRepeat(Animation animation) {
               // TODO Auto-generated method stub
          }

          @Override
          public void onAnimationStart(Animation animation) {
               // TODO Auto-generated method stub
          }
     });
     mLittleChef.startAnimation(trans);
}

Файл view_animation.xml в res/anim-xhdpi:

<?xml version="1.0" encoding="utf-8"?><translate xmlns:android="http://schemas.android.com/apk/res/android"
     android:duration="2000"
     android:fromXDelta="0"
     android:toXDelta="-15%p"
     android:interpolator="@android:anim/linear_interpolator"
/>

c. Настраиваемая анимация

Как было упомянуто в общем описании, для перемещения фактического представления (а не просто места отрисовки) можно создать собственную настраиваемую анимацию. Для этого мы переопределяем метод applyTransformation и используем setX для обновления значения с учетом интерполяции.

public void doCustomAnimation(){
     final Float startingPoint= mLittleChef.getX();
     Animation animation = new Animation()
          {
          @Override
          protected void applyTransformation(float interpolatedTime, Transformation t) {
               mLittleChef.setX(startingPoint - (int)(startingPoint/2 * interpolatedTime));
	          }

      };

     animation.setAnimationListener(new AnimationListener(){
           @Override
           public void onAnimationEnd(Animation animation) {
               simpleLock= false;
           }
          @Override
          public void  onAnimationRepeat(Animation animation) {
               // TODO Auto-generated method stub
          }
          @Override
          public void onAnimationStart(Animation animation) {
               // TODO Auto-generated method stub

	  });

          animation.setInterpolator(new LinearInterpolator());
          animation.setRepeatCount(1);
          animation.setRepeatMode(Animation.REVERSE);
          animation.setDuration(mShortAnimationDuration/2);
          mLittleChef.startAnimation(animation);
}

Заключение

Анимации представлений позволяют анимировать преобразование различных свойств представлений. Их можно определить индивидуально, в наборе или отдельно в XML-файле. Дальнейшие выпуски этой серии посвящены отображаемым объектам и полотну.

Справочные материалы

http://developer.android.com/guide/topics/graphics/index.html

Часть 1, посвященная свойствам анимаций

https://software.intel.com/en-us/articles/2d-animation-for-android-series-comparing-and-contrasting-different-ways-of-doing-the-same

Об авторе

Уитни Фостер (Whitney Foster) — инженер по программному обеспечению в подразделении Software Solutions Group корпорации Intel. Она занимается поддержкой крупномасштабных проектов, посвященных приложениям Android.

*Прочие наименования и товарные знаки могут быть собственностью третьих лиц.
**Пример исходного кода распространяется на условиях лицензионного соглашения корпорации Intel на использование образцов исходного кода.

Введение

Sikuli — это визуальная технология и простой способ автоматизации и тестирования графических пользовательских интерфейсов с помощью снимков экрана. Проект Sikuliбыл изначально создан в группе дизайна пользовательских интерфейсов в Массачусетском технологическом институте в качестве исследовательского проекта с открытым исходным кодом. Первый выпуск Sikuli содержит Sikuli Script — визуальный API сценариев для Python, а также Sikuli IDE — интегрированную среду разработки для создания визуальных сценариев. Sikuli Script автоматизирует все, что вы видите на экране, без поддержки внутренних API. Поэтому можно управлять веб-страницами, приложениями под управлением Windows*/Linux*/Mac* OS X и даже приложениями для Android*, запущенными с помощью виртуальных компьютерных сетей (VNC).

TДля настройки сервера VNC на устройствах с Android существует несколько приложений. Я могу запустить сервер VNC в Android и использовать средство просмотра VNC на компьютере с Windows, но вместо этого я предпочитаю использовать приложение MyPhoneExplorerдля Android, а затем запустить программу Sikuli на ПК. В результате на моем рабочем столе появляется домашний экран Android.

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

Установка среды разработки Sikuli

Прежде всего, для установки Sikuli нужно выполнить некоторые особые действия. Я опишу процесс установки в Windows.

На официальном сайте, вы найдете 32-разрядную версию Sikuli. Не беспокойтесь, если у вас 64-разрядная версия Windows (для 64-разрядных систем запускайте Sikuli-IDE-w.bat, а не Sikuli-IDE.exe), программа будет работать.

Перед установкой Sikuli необходимо установить Java Runtime Environment (JRE) и удалить все прежние версии Sikuli.

1. Загрузите и установите Sikuli: Sikuli-X-1.0rc3 (r905)-win32.exe. После завершения установки в вашей системе должна появиться папка Sikuli X.
2. Важно! Пока не приступайте к использованию Sikuli X, поскольку это решение содержит ошибки. Загрузите ZIP-файл Sikuli X r930, содержащий важные исправления ошибок.
3. Откройте загруженный ZIP-файл и найдите в нем папку SIKULI-IDE.
4. Скопируйте содержимое SIKULI-IDE в Sikuli X. Цель этого действия — замена файлов, связанных с r905 (версия с ошибками), на файлы r930с исправленными ошибками.

Запустите Android в Windows

Я использую Lenovo K900 для тестирования игр. В частности, я покажу, как удобно проверить игру Angry Birds* на этом устройстве. Подключим устройство к Windows с помощью MyPhoneExplorer.

1. Установите MyPhoneExplorer на устройство Android и на ПК.
2. Подключите Lenovo K900 с помощью USB [File -> Settings -> connect via USB Cable].
3. Запустите MyPhoneExplorer в Windows.
4. Extras -> Control Phone/Load screenshot -> установите флажок refresh automatically

Рисунок 1.  Lenovo K900 с программой MyPhoneExplorer.

Теперь можно управлять устройством Android с ПК.

Создание бота игры Angry Birds на устройстве Android

Запустите редактор Sikuli IDEв Windows.

Рисунок 2.  Sikuli IDE.

Затем откройте приложение Angry Birds.

Рисунок 3. Angry Birds на Lenovo K900.

Нажмите кнопку с белым треугольником, чтобы запустить игру. Команда Click()служит для нажатия на любые графические объекты. Инструкция Sleep()включает ожидание обновления сцены.

У нас получился следующий код:

click("1400666128574.png")
sleep(20)

Нажмите кнопку с белым треугольником (изображение этой кнопки — 1400666128574.png), затем ждите изменения сцены в течение 20 секунд.

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

Рисунок 4. Lenovo K900: 1 уровень игры Angry Birds.

if (exists("1400672718307.png")):
    click("1400672718307.png")
    sleep(20)

Этот фрагмент кода проверяет, отображается ли кнопка на экране.

Теперь покажем, как запускать птицу. Для этого я использую команду dragDrop (img1, img2):

dragDrop("1400171376311.png", "1400253224137.png")

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

click("1400666128574.png")
sleep(20)
click("1400666165817.png")
sleep(20)
click("1400666191490.png")
sleep(60)
if (exists("1400672718307.png")):
    click("1400672718307.png")
    sleep(20)
dragDrop("1400171376311.png", "1400253224137.png")
sleep(60)
click("KQY.png")

На следующем снимке экрана показано, как этот код отображается в среде разработки Sikuli IDE.

Рисунок 5. Код в среде разработки Sikuli.

Теперь мы можем использовать этот сценарий для проверки первого уровня игры Angry Birds. Можно проверять любые приложения столь же просто.

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

Виталий Калинин работает в отделе Software & Service Group корпорации Intel. Он учится в аспирантуре Нижегородского государственного университета им. Лобачевского на экономическом факультете. Его специальность — прикладная математика и информатика в экономике. Среди его интересов — мобильные технологии, разработка игр для ПК и смартфонов.

Ресурсы и статьи по теме:

• Создание приложений HTML5 для Google Play
• Как привлечь внимание к своему приложению в Google Play, часть первая
• Как привлечь внимание к своему приложению в Google Play, часть вторая
• Развертывание приложений в Google Play

Примечания

ИНФОРМАЦИЯ В ДАННОМ ДОКУМЕНТЕ ПРИВЕДЕНА ТОЛЬКО В ОТНОШЕНИИ ПРОДУКТОВ INTEL. ДАННЫЙ ДОКУМЕНТ НЕ ПРЕДОСТАВЛЯЕТ ЯВНОЙ ИЛИ ПОДРАЗУМЕВАЕМОЙ ЛИЦЕНЗИИ, ЛИШЕНИЯ ПРАВА ВОЗРАЖЕНИЯ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ. КРОМЕ СЛУЧАЕВ, УКАЗАННЫХ В УСЛОВИЯХ И ПРАВИЛАХ ПРОДАЖИ ТАКИХ ПРОДУКТОВ, INTEL НЕ НЕСЕТ НИКАКОЙ ОТВЕТСТВЕННОСТИ И ОТКАЗЫВАЕТСЯ ОТ ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ ГАРАНТИЙ В ОТНОШЕНИИ ПРОДАЖИ И/ИЛИ ИСПОЛЬЗОВАНИЯ СВОИХ ПРОДУКТОВ, ВКЛЮЧАЯ ОТВЕТСТВЕННОСТЬ ИЛИ ГАРАНТИИ ОТНОСИТЕЛЬНО ИХ ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ, ОБЕСПЕЧЕНИЯ ПРИБЫЛИ ИЛИ НАРУШЕНИЯ КАКИХ-ЛИБО ПАТЕНТОВ, АВТОРСКИХ ПРАВ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ.

КРОМЕ СЛУЧАЕВ, СОГЛАСОВАННЫХ INTEL В ПИСЬМЕННОЙ ФОРМЕ, ПРОДУКТЫ INTEL НЕ ПРЕДНАЗНАЧЕНЫ ДЛЯ ИСПОЛЬЗОВАНИЯ В СИТУАЦИЯХ, КОГДА ИХ НЕИСПРАВНОСТЬ МОЖЕТ ПРИВЕСТИ К ТРАВМАМ ИЛИ ЛЕТАЛЬНОМУ ИСХОДУ.

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

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

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

Перед размещением заказа получите последние версии спецификаций в региональном офисе продаж Intel или у местного дистрибьютора.

Копии документов с порядковым номером, ссылки на которые содержатся в этом документе, а также другую литературу Intel можно получить, позвонив по телефону 1-800-548-4725 либо на сайте: http://www.intel.com/design/literature.htm

Программное обеспечение и нагрузки, использованные в тестах производительности, могли быть оптимизированы для достижения высокой производительности на микропроцессорах Intel. Тесты производительности, такие как SYSmark* и MobileMark*, проводятся на определенных компьютерных системах, компонентах, программах, операциях и функциях. Любые изменения любого из этих элементов могут привести к изменению результатов. При выборе приобретаемых продуктов следует обращаться к другой информации и тестам производительности, в том числе к тестам производительности определенного продукта в сочетании с другими продуктами.

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

Intel и эмблема Intel являются товарными знаками корпорации Intel в США и в других странах.

Copyright © 2014 Intel Corporation.Все права защищены.

*Other names and brands may be claimed as the property of others.

Отказ от ответственности

Содержание

1. Введение

2. Необходимые условия

3. Настройка
      3.1 Декодер
      3.2 RenderScript

4. Запуск декодера

5. Применение эффекта RenderScript

6. Обработка цветов

7. Заключение

Введение

В этой статье мы покажем, как использовать классы Android Media и Android RenderScript для применения эффектов к декодированному видео. Для упрощения в статье описывается только воспроизведение видео; воспроизведение звука не рассматривается. Существует два рабочих потока: поток декодера и поток RenderScript.

Поток декодера делает следующее:
1.    Декодирует поток данных и помещает декодированные изображения в декодированный буфер. 
2.    Копирует только что декодированный кадр в расположение Renderscript.

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

Необходимые условия

Для воспроизведения API Android требуется опыт разработки приложений для Android. Дополнительные сведения о Media Decoder и RenderScript см. в следующих статьях.

1. Android BasicMediaDecoder - The Android Sample BasicMediaDecoder sample -      
    http://developer.android.com/samples/BasicMediaDecoder/index.html

2. Android BasicRenderScript - The Android Sample BasicRenderScript sample -  
    http://developer.android.com/samples/BasicRenderScript/index.html

3. Intel INDE Code Sample - Getting Started with RenderScript  
    https://software.intel.com/en-us/articles/renderscript-basic-sample-for-android-os

Настройка

Декодер

Вот фрагмент кода для настройки декодера. Дополнительные сведения см. в разделе класс Android MediaExtractor.

// Get the media file
String MediaPath = Environment.getExternalStorageDirectory().getPath() + "/Movies/test4.mp4";
// Create a Uri which parses the given encoded URI string
Uri uri = Uri.parse(MediaPath);

try
{
	// Set the Data Source for the MediaExtractor
	mMediaExtractor.setDataSource(this, uri, null);
	// Get The number of tracks
	int numTracks = mMediaExtractor.getTrackCount();

	for( int i=0; i < numTracks; i++ )
	{
		mMediaExtractor.unselectTrack(i);
	}

	for( int i=0; i < numTracks; i++ )
	{
		// Get the type of the track
		MediaFormat format = mMediaExtractor.getTrackFormat(i);
		String mimeType = format.getString(MediaFormat.KEY_MIME);

		if(mimeType.contains("video"))
		{
			// For a Video Track, get Media Format
			// Frame width and height
			mVideoWidth = format.getInteger(MediaFormat.KEY_WIDTH);
	        	mVideoHeight = format.getInteger(MediaFormat.KEY_HEIGHT);
	        	// Buffer Width and Height
	        mBufferWidth = mVideoWidth;
	        // make sure that the buffer height is a multiple of 16
	        mBufferHeight = mVideoHeight + (mVideoHeight%16);

	        // Initialize RenderScript See Section 3
	        initRenderScript();

	        // Creade a Decoder
			mDecoder = MediaCodec.createDecoderByType(mimeType);
			// Configure the decoder
			mDecoder.configure(format,	// Media Format from the stream
					null, 				// set surface to send decoded frames to buffers
					null,				// no Crypto
					0);					// flags
			if(mDecoder != null)
			{

				// Select this track
				mMediaExtractor.selectTrack(i);
				// start the decoder
				mDecoder.start();

				// query input and output buffers
		        mInputBuffers = mDecoder.getInputBuffers();
		        mOutputBuffers = mDecoder.getOutputBuffers();

		        // allocate byte buffer to temporarily hold decoded frame, input to renderscript
		        // 3/2 because the decoder outputs NV12 which has 12bits per pixel
		        mLocalOutputBuffers = new byte[mBufferWidth*mBufferHeight*3/2];


				break;
			}
		}
		else
		{
			// Handle this condition
		}
	}
}
catch (IOException e)
{
	e.printStackTrace();
}

RenderScript

Вот фрагмент кода для настройки RenderScript. Дополнительные сведения см. в разделе Android Renderscript.

  // Create RenderScript Context
    mRS = RenderScript.create(this);

    // Load RenderScript
    mScript = new ScriptC_process(mRS);

    // Create Allocations for reading into and out of Script
    // Input Allocation
    // Create a new Pixel Element of type YUV
    Element elemYUV = Element.createPixel(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.PIXEL_YUV);

    // Create a new (Type).Builder object of type elemYUV
    Type.Builder TypeYUV = new Type.Builder(mRS, elemYUV);

    // Set YUV format to NV21. The Decoder Outputs NV21 Surfaces
    TypeYUV.setYuvFormat(ImageFormat.NV21);

    // Create an Allocation
    mAllocationYUV = Allocation.createTyped(mRS,TypeYUV.setX(mVideoWidth).setY(mVideoHeight).create(),
    // Allocation Type Allocation.MipmapControl.MIPMAP_NONE, // No MIPMAP
Allocation.USAGE_SCRIPT);// Allocation will be used by a script

    // Output Allocation
    // Create a new Pixel Element of type RGBA
    Element elemOUT = Element.createPixel(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.PIXEL_RGBA);

     // Create a new (Type).Builder object of type elemOUT
     Type.Builder TypeOUT = new Type.Builder(mRS, elemOUT);

     // create an Allocation
     mAllocationOUT = Allocation.createTyped(mRS,
     TypeOUT.setX(mVideoWidth).setY(mVideoHeight).create(),   // Allocation Type
Allocation.MipmapControl.MIPMAP_NONE,    // No MIPMAP
Allocation.USAGE_SCRIPT|                 // will be used by a script
Allocation.USAGE_IO_OUTPUT);             // will be used as a SurfaceTexture producer

    // Associate the Surface with output allocation
    // Get the Surface Texture
    SurfaceTexture surfaceTexture = mPlaybackView.getSurfaceTexture();

    if(surfaceTexture != null)
    {
    // Create a new surface
    Surface surface = new Surface(surfaceTexture);
    if(surface != null)
    {
   // set allocation surface
   mAllocationOUT.setSurface(surface);
    }
    }
    // Set the Input Allocation
    mScript.set_gIn(mAllocationYUV);

Запуск декодера

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

Перед вызовом codec.releaseOutputBuffer(outputBufferIndex, ...) выполните следующие действия:

1. Получите декодированный буфер
2. Скопируйте его в расположение
3. Создайте новый поток для применения эффекта RenderScript

// decoded buffer size
int bufsize = mOutputBuffers[index].capacity();

// get the decode buffer
mOutputBuffers[index].get(mLocalOutputBuffers, 0, bufsize);

// copy to input Allocation
mAllocationYUV.copyFrom(mLocalOutputBuffers);

// rewind the ByteBuffer so that the pointer can be back to 0
mOutputBuffers[index].rewind();

// start a new thread for applying RenderScript effect
new ProcessData().execute();

// release outputbuffer back to the decoder
mDecoder.releaseOutputBuffer(index, render); 

Применение эффекта RenderScript

Вот фрагмент кода для потока RenderScript. Дополнительные сведения о потоке UI см. в разделе AsyncTask.

private class ProcessData extends AsyncTask<byte[], Void, Boolean>
{
@Override
	protected Boolean doInBackground(byte[]... args)
        {
        	// Apply the Renderscript YUV_to_RGB + greyscale effect
        	mScript.forEach_yuvToRgb_greyscale(mAllocationYUV, mAllocationOUT);
        	// Send the output allocation to surfacetexture
        	mAllocationOUT.ioSend();

            return true;
        }
    }

Обработка цветов

rs_allocation gIn;

void yuvToRgb_greyscale(const uchar *v_in, uchar4 *v_out, uint32_t x, uint32_t y) {
    uchar yp = rsGetElementAtYuv_uchar_Y(gIn , x, y) & 0xFF;

    uchar4 res4;
    res4.r = yp;
    res4.g = yp;
    res4.b = yp;
    res4.a = 0xFF;

    *v_out = res4;
}

Заключение

Платформа Android Multimedia Framework предоставляет высокоуровневый API для использования аппаратной поддержки мультимедиа. Обработка видео является весьма ресурсоемкой нагрузкой, и Renderscript предоставляет платформу для распараллеливания этой нагрузки.  В приведенной выше статье описывается метод, позволяющий платформе Android Multimedia Framework взаимодействовать с Renderscript для применения эффектов постобработки к декодированному видео.

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

Security Enhancements for Android (SEAndroid)

В операционной системе Android версии 4.4 (Kitkat) появились новые возможности. Наиболее важной среди новых возможностей является способность интегрировать SEAndroid в принудительном режиме, то есть помещать все права доступа ко всем компонентам Android под контроль SEAndroid.

Что такое SEAndroid? SEAndroid означает Security Enhancements for Android (расширенные функции безопасности для Android). Это решение безопасности для Android, выявляющее и устраняющее важные уязвимости. Изначально целью проекта было использование функций SELinux в системе Android для ограничения ущерба, связанного с работой дефектных или вредоносных приложений, и обеспечения разделения между приложениями. Затем область проекта была расширена. Теперь SEAndroid — это целая платформа для реализации обязательного управления доступом (MAC) SELinux и промежуточного обязательного управления доступом (MMAC) на платформе Android.

Следует разъяснить некоторые понятия, связанные с SEAndroid:

• Security-Enhanced Linux* (SELinux) — это реализация принудительного управления доступом с помощью модулей безопасности Linux (LSM, Linux Security Modules) в ядре Linux на основе принципа наименьших возможных прав. Это не дистрибутив Linux, а набор модификаций, которые можно применять к операционным системам, подобным UNIX*, таким как Linux и BSD.
• Избирательное управление доступом (DAC, Discretionary Access Control) — это стандартная модель безопасности в Linux. В этой модели права доступа зависят от личности пользователя и от принадлежности объектов.
• Обязательное управление доступом (MAC, Mandatory Access Control) ограничивает права доступа для субъектов (процессов) и объектов (файлов, сокетов, устройств и пр.).

SELinux не изменяет существующие средства безопасности в среде Linux; вместо этого SELinux расширяет модель безопасности, добавляя обязательное управление доступом (т. е. в среде SELinux применяются и MAC, и DAC).

SEAndroid расширяет возможности системы Android, добавляя поддержку SELinux в ядро и пользовательское пространство для выполнения следующих задач:

• Ограничение привилегированных демонов для защиты от неверного использования и ограничения возможного ущерба
• Применение «песочницы», изоляция приложений друг от друга и от системы
• Предотвращение повышения прав приложениями
• Управление привилегиями приложений при установке и выполнении с помощью ММАС
• Централизованная политика с возможностью анализа

Более того, в Android 4.4 платформа SEAndroid работает в принудительном режиме вместо нефункционального отключенного режима или разрешительного режима (в котором только выдаются уведомления). Это означает, что все недопустимые операции будут запрещены в среде выполнения Android.

Политика SEAndroid

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

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

TКонтекст безопасности SEAndroid в целом совместим с SELinux. Ниже описаны четыре его составные части: пользователь, роль, тип и уровень, например u: object_r: system_data_file: s0:

• Пользователь: контекст безопасности первого столбца в SEAndroid — пользователь, он обозначается как u.
• Роль: во втором столбце указывается роль в SEAndroid: это соответственно r и object_r.
• Тип: в третьем столбце SEAndroid определяет 139 различных типов политик, таких как устройство, процесс, файловая система, сеть, IPC и так далее.
• Уровень безопасности: четвертый столбец предназначен для многоуровневой безопасности (расширение MLS), которая представляет собой механизм доступа с добавлением контекста безопасности и конфиденциальности формата [: список категорий] [- конфиденциальность [: список категорий]], например s0 - s15: c0 - c1023, причем категория может не требоваться для текущей версии Android. Сочетание конфиденциальности и категории определяет текущий уровень безопасности, числовые значения задаются для низшего и высшего уровней безопасности. Параметры в этом столбце используются при проверке ограничений MLS: 15 — это наибольшая конфиденциальность, а 1023 — наивысшая категория. Этот диапазон параметров можно задать в Android.mk.

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

Источники политики SEAndroid находятся в папке external/sepolicy.

Политика состоит из исходных файлов, используемых для создания файла политики ядра SELinux, а также конфигураций file_contexts, property_contexts, seapp_contexts и mac_permissions.xml.

• Конфигурация file_contexts используется для маркировки файлов во время сборки (например, системный раздел) и во время выполнения (например, узлы устройства, файлы сокетов служб, папки /data, созданные init.rc, и пр.).
• Конфигурация property_contexts указывает контекст безопасности свойств Android для проверки разрешений.
• Конфигурация seapp_contexts используется для маркировки процессов приложения и каталогов пакета приложения.
• Конфигурация mac_permissions.xml — это политика MMAC.

Политики, действующие для устройства, находятся в папке device/<поставщик>/<устройство>.

• Такую политику можно задать, указав переменные BOARD_SEPOLICY_DIRS, BOARD_SEPOLICY_UNION и BOARD_SEPOLICY_REPLACE в файле BoardConfig.mk, находящемся в папке device/<поставщик>/<устройство> или vendor/<поставщик>/<устройство>. Например, файл конфигурации для планшета FFRD8 на базе процессора Intel® Atom (Bay Trail) находится в папке /device/intel/baytrail/BoardConfig.mk.
• Пример см. в файле device/intel/baytrail/BoardConfig.mk, где эти переменные заданы в соответствии с файлами политики для устройств в device/intel/baytrail/sepolicy.
• Документацию по политикам для устройств см. в файле external/sepolicy/README.

Изменение политики SEAndroid

Файлы политики SEAndroid находятся в папке /external/sepolicy. Можно изменить эти файлы и увидеть, что произойдет при применении измененной политики. Соблюдайте осторожность при изменении файлов политики, поскольку из-за неверной конфигурации может произойти зависание всей системы при загрузке. Ниже приведен пример:

Шаг 1. Проверка перед изменениями

Сначала нужно проверить файл /device/intel/baytrail/BoardConfig.mk. Используется следующая конфигурация sepolicy:

BOARD_SEPOLICY_DIRS :=

device/intel/baytrail/sepolicy

BOARD_SEPOLICY_UNION :=

file_contexts

seapp_contexts

file.te

genfs_contexts

fs_use

device.te

healthd.te

app.te

untrusted_app.te

surfaceflinger.te

vold.te

ecryptfs.te

zygote.te

netd.te

BOARD_SEPOLICY_DIRS определяет каталог, в котором находятся файлы политики для определенного устройства. BOARD_SEPOLICY_UNION — итоговая конфигурация политики, сочетающая файлы общей политики и файлы политики для определенного устройства. При сборке Android компилятор проверит наличие конфликтов между разными политиками. Если применяется BOARD_SEPOLICY_ REPLACE, это означает, что политики устройства заменят общие политики.

Во-вторых, нужно открыть файл /external/sepolicy/untrusted_app.te и убедиться в наличии в нем следующих строк:

Allow untrusted_app shell_data_file:file rw_file_perms

Allow untrusted_app shell_data_file:dir r_dir_perms

Два перечисленных выше элемента политики предоставляют недоверенным приложениям (обычным, а не системным приложениям) возможность чтения и записи файлов, а также чтения каталогов с типом shell_data_file в среде выполнения. Параметр shell_data_file указывает на любой файл в /data/local/tmp/ в среде выполнения, заданный в /external/sepolicy/file_contexts в среде разработки следующим образом:

/data/local/tmp(/.*)? u:object_r:shell_data_file:s0

Перечисленные выше разрешения обладают определенными ограничениями. Если в /data/local/tmp/ существуют файлы и папки, то недоверенные приложения могут читать и записывать эти файлы, входить в эти папки. Но создавать собственные файлы и папки в /data/local/tmp/ недоверенные приложения не могут. Только системные приложения или службы могут создавать файлы и папки для недоверенных приложений. Если нужно предоставить недоверенным приложениям больше разрешений, можно применить изменения, описанные на шаге 2.

Шаг 2. Добавьте новые элементы политики

Теперь нужно отредактировать файл /device/intel/baytrail/sepolicy/untrusted_app.te, добавив две следующие строки в конце файла:

Allow untrusted_app shell_data_file:file create_file_perms

Allow untrusted_app shell_data_file:dir create_dir_perms

Эти два элемента предоставляют разрешения недоверенным приложениям на создание файлов и папок в /data/local/tmp/ в среде выполнения. Они задаются в /external/sepolicy/file_contexts в следующей среде разработки:

/data/local/tmp(/.*)? u:object_r:shell_data_file:s0

Базовые разрешения для файлов и папок определяются в /external/sepolicy/global_macros:

define(`x_file_perms', `{ getattr execute execute_no_trans }')

define(`r_file_perms', `{ getattr open read ioctl lock }')

define(`w_file_perms', `{ open append write }')

define(`rx_file_perms', `{ r_file_perms x_file_perms }')

define(`ra_file_perms', `{ r_file_perms append }')

define(`rw_file_perms', `{ r_file_perms w_file_perms }')

define(`rwx_file_perms', `{ rw_file_perms x_file_perms }')

define(`link_file_perms', `{ getattr link unlink rename }')

define(`create_file_perms', `{ create setattr rw_file_perms link_file_perms }')

define(`r_dir_perms', `{ open getattr read search ioctl }')

define(`w_dir_perms', `{ open search write add_name remove_name }')

define(`ra_dir_perms', `{ r_dir_perms add_name write }')

define(`rw_dir_perms', `{ r_dir_perms w_dir_perms }')

define(`create_dir_perms', `{ create reparent rmdir setattr rw_dir_perms link_file_perms }')

Мы видим, что разрешения, например, файловая операция { getattr open read ioctl lock }, такие же, как функции файловых операций в реальной файловой системе.

И наконец, нужно пересобрать дерево исходного кода Android и передать новый образ на устройство FFRD8 с процессором Bay Trail.

Проверка политики SEAndroid

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

Мы можем создать новый файл и новую папку: нужно войти в папку /data/local/tmp/ и создать внутри нее новую папку и новый файл. (На стандартном устройстве FFRD8 создание нового файла и нового каталога запрещено.) Результат применения измененной политики показан на приведенном ниже рисунке. Слева показано воздействие исходных политик, а справа — измененных:

Рисунок 1.Сравнение файловых разрешений между обычными и измененными политиками.

Заключение

В этой статье описывается принцип работы политики SEAndroid и приводится пример добавления новой политики в набор политик SEAndroid на платформе с процессором Intel Atom (Bay Trail). Эта статья поможет разработчикам устройств, заинтересованным в создании настраиваемых версий SEAndroid, лучше понимать механизм политик SEAndroid.

Об авторе

Лянь Чжань (Liang Z. Zhang) — инженер по разработке приложений в подразделении Developer Relations Division в китайском представительстве корпорации Intel. Лянь Чжань отвечает за поддержку технологий безопасности на базе платформ Intel.

Примечания

ИНФОРМАЦИЯ В ДАННОМ ДОКУМЕНТЕ ПРИВЕДЕНА ТОЛЬКО В ОТНОШЕНИИ ПРОДУКТОВ INTEL. ДАННЫЙ ДОКУМЕНТ НЕ ПРЕДОСТАВЛЯЕТ ЯВНОЙ ИЛИ ПОДРАЗУМЕВАЕМОЙ ЛИЦЕНЗИИ, ЛИШЕНИЯ ПРАВА ВОЗРАЖЕНИЯ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ. КРОМЕ СЛУЧАЕВ, УКАЗАННЫХ В УСЛОВИЯХ И ПРАВИЛАХ ПРОДАЖИ ТАКИХ ПРОДУКТОВ, INTEL НЕ НЕСЕТ НИКАКОЙ ОТВЕТСТВЕННОСТИ И ОТКАЗЫВАЕТСЯ ОТ ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ ГАРАНТИЙ В ОТНОШЕНИИ ПРОДАЖИ И/ИЛИ ИСПОЛЬЗОВАНИЯ СВОИХ ПРОДУКТОВ, ВКЛЮЧАЯ ОТВЕТСТВЕННОСТЬ ИЛИ ГАРАНТИИ ОТНОСИТЕЛЬНО ИХ ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ, ОБЕСПЕЧЕНИЯ ПРИБЫЛИ ИЛИ НАРУШЕНИЯ КАКИХ-ЛИБО ПАТЕНТОВ, АВТОРСКИХ ПРАВ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ.

КРОМЕ СЛУЧАЕВ, СОГЛАСОВАННЫХ INTEL В ПИСЬМЕННОЙ ФОРМЕ, ПРОДУКТЫ INTEL НЕ ПРЕДНАЗНАЧЕНЫ ДЛЯ ИСПОЛЬЗОВАНИЯ В СИТУАЦИЯХ, КОГДА ИХ НЕИСПРАВНОСТЬ МОЖЕТ ПРИВЕСТИ К ТРАВМАМ ИЛИ ЛЕТАЛЬНОМУ ИСХОДУ.

Корпорация Intel оставляет за собой право вносить изменения в технические характеристики и описания своих продуктов без предварительного уведомления. Проектировщики не должны полагаться на отсутствующие характеристики, а также характеристики с пометками «зарезервировано» или «не определено». Эти характеристики резервируются Intel для будущего использования, поэтому отсутствие конфликтов совместимости для них не гарантируется. Информация в данном документе может быть изменена без предварительного уведомления. Не используйте эту информацию в окончательном варианте дизайна.

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

Перед размещением заказа получите последние версии спецификаций в региональном офисе продаж Intel или у местного дистрибьютора.

Копии документов с порядковым номером, ссылки на которые приведены в этом документе или в другой документации Intel, можно получить, обратившись по телефону 1-800-548-4725, или на сайте: http://www.intel.com/design/literature.htm

Программное обеспечение и нагрузки, использованные в тестах производительности, могли быть оптимизированы для достижения высокой производительности на микропроцессорах Intel. Тесты производительности, такие как SYSmark* и MobileMark*, проводятся на определенных компьютерных системах, компонентах, программах, операциях и функциях. Любые изменения любого из этих элементов могут привести к изменению результатов. При выборе приобретаемых продуктов следует обращаться к другой информации и тестам производительности, в том числе к тестам производительности определенного продукта в сочетании с другими продуктами.

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

Использование событий наблюдения за производительностью внеядерных компонентов платформы Rangeley

В этой статье рассматриваются события наблюдения за производительностью платформы «система на кристалле» Rangeley. Введение в наблюдение за производительностью внеядерных компонентов платформ «система на кристалле» см. в статье:

• • Руководство по наблюдению за производительностью внеядерных компонентов платформы «система на кристалле» Silvermont

Введение в платформу Rangeley с архитектурой «система на кристалле»

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

Доступные группы

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

UNC_SOC_Memory_DDR_BW

Группа UNC_VISA_Memory_DDR_BW предоставляет счетчики для вычисления пропускной способности всей памяти с точки зрения контроллера памяти «системы на кристалле». События можно разделить на запросы по каждому каналу, включая запросы размером 32 и 64 байта. Эти события не предоставляют информации о том, какой агент потребляет больше памяти, но это наиболее точный способ определения фактической используемой пропускной способности памяти.

Количество каналов памяти на платформе Rangeley зависит от конкретной модели: может быть либо один, либо два канала. Если существует только один канал, все счетчики, связанные со вторым каналом, будут выдавать нулевые значения. Дополнительные сведения об архитектуре каналов памяти: http://en.wikipedia.org/wiki/Multi-channel_memory_architecture.

Группы UNC_VISA_MEMORY_DDR0_BW и UNC_VISA_MEMORY_DDR1_BW являются подмножествами этой группы, они собирают данные только для каналов памяти 0 и 1.

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

В приведенной ниже таблице перечислены события, содержащиеся в группе UNC_VISA_Memory_BW.

Анализ результатов

Пропускную способность в МБ/с можно вычислить для перечисленных выше 64-байтовых событий следующим образом:

Формула метрики событий: количество_событий/отрезок_в_секундах*64 байт/1000000 байт = МБ/с

Для 32-байтовых событий замените 64 байта на 32:

Формула метрики событий: количество_событий/отрезок_в_секундах*32 байт/1000000 байт = МБ/с

События можно суммировать для получения нужных метрик, например:

• суммарная пропускная способность памяти = сумма всех событий, МБ/с
• суммарная пропускная способность чтения = сумма всех событий чтения, МБ/с
• пропускная способность канала 0 = сумма событий канала 0, МБ/с

Известное поведение

1. Если платформа не имеет двух каналов, показатели счетчика второго канала будут нулевыми.

UNC_SOC_DDR_Self_Refresh

Группа UNC_VISA_DDR_Self_Refresh содержит счетчики для аппаратных событий самообновления памяти. Самообновление представляет состояние пониженного потребления электроэнергии, его можно использовать для оптимизации электропитания «системы на кристалле» и приложений.

В приведенной ниже таблице перечислены события, содержащиеся в группе UNC_VISA_DDR_Self_Refresh.

Анализ результатов

Формула метрики событий: (количество_событий/(базовая_частота_SoC /базовая_частота_DDR))*100 = резидентность самообновления DDR

Известное поведение

1. Если платформа не имеет двух каналов, показатели счетчика второго канала будут нулевыми
2. Счетчики 0,1 могут быть запущены на другой исходной частоте, нежели счетчик 2

UNC_SOC_All_Reqs

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

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

Для точного измерения пропускной способности с разделением по чтению и записи следует использовать метрику пропускной способности по агентам для одного или двух агентов одновременно.

Анализ результатов

Формула метрики событий:

• количество_событий/отрезок_в_секундах *64 байт/1000000 байт = оцениваемая пропускная способность агента, МБ/с
• суммарное_количество_событий/отрезок_в_секундах *64 байта/1000000 байт = оцениваемая пропускная способность памяти DDR, МБ/с

Известное поведение

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

UNC_SOC_Module0_BW

Группа UNC_VISA_Module0_BW предоставляет счетчики для вычисления пропускной способности модуля 0 процессора с точки зрения системного агента. События можно разделить по типам запросов.

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

Анализ результатов

Пропускную способность чтения и записи можно вычислить для 32- и 64-байтовых событий, но вычисление событий затруднено, поскольку у них неизвестен объем полезной нагрузки. Также следует понимать, что частичные события для этой группы представляют собой сумму 64-байтовых, 32-байтовых и частичных запросов. Это частичное событие также можно рассматривать как сумму всех запросов чтения или записи.

Формула метрики событий:

• частичные_запросы - 32_байтные_запросы - 64_байтные_запросы = фактическое количество частичных запросов
• (Mod0_Read32B_количество * 32_байта / отрезок_в_секундах) + (Mod0_Read64B_количество * 64_байта / отрезок_в_секундах) = чтение, МБ/с
• (Mod0_Write32B_количество * 32_байта / отрезок_в_секундах) + (Mod0_Write64B_количество * 64_байта / отрезок_в_секундах) = запись, МБ/с

Известное поведение

1. Счетчик частичных событий модулей 0, 1, 2 и 3 включает 32-байтовые, 64-байтовые и частичные запросы. Его можно считать суммарным счетчиком запросов.

UNC_SOC_ModuleX_BW,

Группы UNC_VISA_Module1_BW, UNC_VISA_Module2_BW и UNC_VISA_Module3_BW идентичны группе UNC_VISA_Module0_BW с тем лишь исключением, что они подсчитывают события в соответствующих модулях процессора (модули 1, 2 и 3).

UNC_SOC_Module0_1_BW

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

На приведенном ниже рисунке показан отслеживаемый поток трафика для UNC_VISA_Module0_1_BW.

UNC_SOC_Module0_1_Snoops

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

UNC_VISA_Module2_3_Snoops идентичен счетчику UNC_VISA_Module0_1, но подсчи-тывает количество запросов и ответов отслеживания для модулей процессора 2 и 3. UNC_VISA_Module0_1_2_3_Snoops собирает данные отслеживания одновременно для всех четырех модулей процессора, но не включает тактовый счетчик «системы на кристалле».

Анализ результатов

Анализ результатов отслеживания зависит от модели использования.

Известное поведение

1. Показатели счетчиков отслеживания подсчитываются для всего процессорного модуля без возможности разделения по каждому ядру.

UNC_SOC_LowSpeedPF_BW

Группа UNC_VISA_LowSpeedPF_BW содержит события для определения пропускной способности структуры низкоскоростной периферии и представляет совокупную пропускную способность для всех подключаемых компонентов южного кластера: USB, SATA и Ethernet.

Анализ результатов

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

Формула метрики событий:

• (LowspeedPF_Read32B_количество * 32_байта / отрезок_в_секундах) + (LowspeedPF_Read64B_количество * 64_байтов / отрезок_в_секундах) = чтение, МБ/с
• (LowspeedPF_Read32B_количество * 32_байта / отрезок_в_секундах) + (LowspeedPF_Read64B_количество * 64_байта / отрезок_в_секундах) = запись, МБ/с

Известное поведение

1. Нет.

UNC_SOC_HighSpeedPF_BW

Группа UNC_VISA_HighSpeedPF_BW содержит события для определения пропускной способности структуры высокоскоростной периферии и представляет совокупную пропускную способность для всех подключаемых высокоскоростных компонентов. Эта группа идентична группе UNC_VISA_LowSpeed_BW по конфигурации счетчиков событий и по метрикам анализа. Имена событий изменены с LowSpeedPF на HighSpeedPF.

Download PDF

Введение

На рынке электроники доступен широчайший ассортимент устройств Android* с различными версиями ОС и разным оборудованием. В результате поставщикам интернет-видео приходится сталкиваться с определенными трудностями при распространении своих видеоматериалов. Поскольку уже в ближайшем будущем устройства с Android 4.1 и более поздней версии будут преобладать на рынке, в этой статье рассказывается о том, как интегрировать FFmpegв MediaCodec для поддержки различных форматов видео, а также о том, как создать аппаратный декодер для Android на базе платформ Intel® Atom™.

Базовые сведения

Для управления воспроизведением звука и видео Google создал проигрыватель MediaPlayer. Однако функциональность MediaPlayer ограничена ввиду поддержки всего трех форматов мультимедиа: mp4, 3gpp и mkv (начиная с Android 4.0). При этом большинство поставщиков интернет-видео используют другие форматы, такие как FLV и т. д. Для воспроизведения неподдерживаемых форматов и сохранения совместимости с как можно большим количеством доступных на рынке устройств Android разработчики интернет-видео применяют FFmpeg в качестве предпочитаемого программного декодера. Существует и другое решение: некоторые разработчики интегрируют OpenMAX* (хорошо известный стандарт в отрасли мультимедиа) для доступа к низкоуровневому аппаратному декодеру на устройствах с Android 2.3, кодек для поддержки устройств с Android 4.0 и класс MediaCodec для поддержки устройств с Android 4.1 и более поздних версий. Им приходилось покупать большинство самых популярных на рынке устройств с Android для тестирования. Но и в этом случае все равно оставались проблемы совместимости, поэтому приходилось использовать FFmpeg в качестве резервного решения.

Анализ решения FFmpeg с MediaCodec

FFmpeg [1] — это ведущая платформа мультимедиа, способная декодировать, кодировать, перекодировать, распаковывать, передавать потоком, фильтровать и воспроизводить практически любое содержимое, созданное человеком и компьютерами. FFmpeg также может выполнять разбор потока видео.

Класс MediaCodec впервые появился в Android 4.1, он основан на API Java* и предоставляет интерфейс для доступа к низкоуровневым системным кодекам; это могут быть либо аппаратные кодеки, либо, в случае со звуком, программные кодеки с высоким уровнем оптимизации. Использование MediaCodec помогает добиться ощутимого прироста производительности и экономии электроэнергии.

Помимо форматов mp4, 3gpp и mkv, поддерживаемых в Android MediaPlayer напрямую, многие другие популярные форматы видео, такие как flv, mov, rm, rmvb и пр., не имеют встроенной поддержки. Для этих неподдерживаемых форматов поставщики интернет-видео обычно используют FFmpeg в качестве программного декодера, из-за чего возрастает нагрузка на ЦП и потребление электроэнергии.

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

Решение показано на следующей схеме.

Рисунок 1..Интеграция FFmpeg с решением MediaCodec.

В этом решении FFmpeg распаковывает контейнер с видео как необработанные видеоданные и аудиоданные на уровне собственного кода. Затем необработанное видео передается в API MediaCodec на уровне Java для аппаратного декодера. Звуковые данные декодируются напрямую в FFmpeg, на это не тратится слишком много ресурсов ЦП. И наконец, FFmpeg синхронизирует звук и видео по штампу времени.

Это решение поддерживает некоторые другие популярные форматы видео, которые не поддерживаются в MediaPlayer, и независимые поставщики интернет-видео считают его полезным.

Сборка FFmpeg для Android на платформе x86

FFmpeg поддерживает Android начиная с выпуска 2.1, но пакет FFmpeg не имел сценария сборки для Android на платформе x86. Ниже приведены действия для сборки FFmpeg для Android на платформе x86:

1. На веб-сайте FFmpeg загрузите последнюю версию FFmpeg — ffmpeg-2.2.4.tar.bz2 [2].
2. Скопируйте пакет FFmpeg на компьютер с Ubuntu* и извлеките содержимое пакета с помощью следующей команды tar:

   wangsy@ubuntu:~/Desktop$  tar  xvf  ffmpeg-2.2.4.tar.bz2

3. Задайте среду ANDROID_NDK_HOME с помощью команды export:

   export  ANDROID_NDK_HOME= $ ANDROID_NDK_HOME :/~/android-ndk-r9c

4. Скопируйте следующий файл конфигурации в папку ~/ffmpeg-2.2.4 и добавьте права на исполнение:

   wangsy@ubuntu:~/Desktop$  cp  config_build_x86.sh  ~/ffmpeg-2.2.4
   wangsy@ubuntu:~/Desktop$  sudo chmod  a+x  ~/ffmpeg-2.2.4/config_build_x86.sh

5. Запустите сценарий конфигурации и соберите программу с помощью команд make и make instal:

   wangsy@ubuntu:~/Desktop/ffmpeg-2.2.4$  make
   wangsy@ubuntu:~/Desktop/ffmpeg-2.2.4$  make install

Созданные LIB-файлы Android для x86 находятся в папке ~/Desktop/ffmpeg-2.2.4/android/x86/lib$.

Разработчики могут скопировать эти библиотеки для разработки. Поскольку компилятор ассемблера YASM [3] и потоковые расширения Intel® SIMD (Intel® SSE) [4] включены в config_build_x86.sh, созданные LIB-файлы Android для x86 оптимизированы для очень высокой производительности на платформах Intel Atom под управлением Android.

Интеграция API Java MediaCodec из уровня собственного кода FFmpeg

Класс MediaCodec можно использовать для доступа к низкоуровневому медиакодеку, то есть к компонентам кодирования и декодирования. Его можно без труда вызвать из уровня Java. Но в этом решении FFmpeg распаковывает необработанные видеоданные на уровне собственного кода, поэтому необходимо разбирать функции MediaCodec из этого уровня и передавать необработанные видеоданные этим API.

Демонстрационный код: доступ к классу MediaCodec из уровня собственного кода:

struct classname
{
    const char *name;
    int offset;
};
static const struct classname classes[] = {
    { "android/media/MediaCodecList", OFF(media_codec_list_class) },
    { "android/media/MediaCodec", OFF(media_codec_class) },
    { "android/media/MediaFormat", OFF(media_format_class) },
    { "android/media/MediaFormat", OFF(media_format_class) },
    { "android/media/MediaCodec$BufferInfo", OFF(buffer_info_class) },
    { "java/nio/ByteBuffer", OFF(byte_buffer_class) },
    { NULL, 0 },
};
JNIEnv* env = NULL;
    ATTACH_THREAD;

    for (int i = 0; classes[i].name; i++) {
        *(jclass*)((uint8_t*)p_sys + classes[i].offset) =
            (*env)->FindClass(env, classes[i].name);

        if ((*env)->ExceptionOccurred(env)) {
            msg_Warn(p_dec, "Unable to find class %s", classes[i].name);
            (*env)->ExceptionClear(env);
            goto error;
        }
    }

Демонстрационный код: доступ к функциям MediaCodec из уровня собственного кода:

struct member
{
    const char *name;
    const char *sig;
    const char *class;
    int offset;
    int type;
};
static const struct member members[] = {
    { "toString", "()Ljava/lang/String;", "java/lang/Object", OFF(tostring), METHOD },

    { "getCodecCount", "()I", "android/media/MediaCodecList", OFF(get_codec_count), STATIC_METHOD },
    { "getCodecInfoAt", "(I)Landroid/media/MediaCodecInfo;", "android/media/MediaCodecList", OFF(get_codec_info_at), STATIC_METHOD },

    { "isEncoder", "()Z", "android/media/MediaCodecInfo", OFF(is_encoder), METHOD },
    { "getSupportedTypes", "()[Ljava/lang/String;", "android/media/MediaCodecInfo", OFF(get_supported_types), METHOD },
    { "getName", "()Ljava/lang/String;", "android/media/MediaCodecInfo", OFF(get_name), METHOD },

    { "createByCodecName", "(Ljava/lang/String;)Landroid/media/MediaCodec;", "android/media/MediaCodec", OFF(create_by_codec_name), STATIC_METHOD },
    { "configure", "(Landroid/media/MediaFormat;Landroid/view/Surface;Landroid/media/MediaCrypto;I)V", "android/media/MediaCodec", OFF(configure), METHOD },
    { "start", "()V", "android/media/MediaCodec", OFF(start), METHOD },
    { "stop", "()V", "android/media/MediaCodec", OFF(stop), METHOD },
    { "flush", "()V", "android/media/MediaCodec", OFF(flush), METHOD },
    { "release", "()V", "android/media/MediaCodec", OFF(release), METHOD },
    { "getOutputFormat", "()Landroid/media/MediaFormat;", "android/media/MediaCodec", OFF(get_output_format), METHOD },
    { "getInputBuffers", "()[Ljava/nio/ByteBuffer;", "android/media/MediaCodec", OFF(get_input_buffers), METHOD },
    { "getOutputBuffers", "()[Ljava/nio/ByteBuffer;", "android/media/MediaCodec", OFF(get_output_buffers), METHOD },
    { "dequeueInputBuffer", "(J)I", "android/media/MediaCodec", OFF(dequeue_input_buffer), METHOD },
    { "dequeueOutputBuffer", "(Landroid/media/MediaCodec$BufferInfo;J)I", "android/media/MediaCodec", OFF(dequeue_output_buffer), METHOD },
    { "queueInputBuffer", "(IIIJI)V", "android/media/MediaCodec", OFF(queue_input_buffer), METHOD },
    { "releaseOutputBuffer", "(IZ)V", "android/media/MediaCodec", OFF(release_output_buffer), METHOD },

    { "createVideoFormat", "(Ljava/lang/String;II)Landroid/media/MediaFormat;", "android/media/MediaFormat", OFF(create_video_format), STATIC_METHOD },
    { "setInteger", "(Ljava/lang/String;I)V", "android/media/MediaFormat", OFF(set_integer), METHOD },
    { "getInteger", "(Ljava/lang/String;)I", "android/media/MediaFormat", OFF(get_integer), METHOD },
    { "setByteBuffer", "(Ljava/lang/String;Ljava/nio/ByteBuffer;)V", "android/media/MediaFormat", OFF(set_bytebuffer), METHOD },

    { "<init>", "()V", "android/media/MediaCodec$BufferInfo", OFF(buffer_info_ctor), METHOD },
    { "size", "I", "android/media/MediaCodec$BufferInfo", OFF(size_field), FIELD },
    { "offset", "I", "android/media/MediaCodec$BufferInfo", OFF(offset_field), FIELD },
    { "presentationTimeUs", "J", "android/media/MediaCodec$BufferInfo", OFF(pts_field), FIELD },

    { "allocateDirect", "(I)Ljava/nio/ByteBuffer;", "java/nio/ByteBuffer", OFF(allocate_direct), STATIC_METHOD },
    { "limit", "(I)Ljava/nio/Buffer;", "java/nio/ByteBuffer", OFF(limit), METHOD },

    { NULL, NULL, NULL, 0, 0 },
};

JNIEnv* env = NULL;
jclass last_class;
    for (int i = 0; members[i].name; i++) {
        if (i == 0 || strcmp(members[i].class, members[i - 1].class))
            last_class = (*env)->FindClass(env, members[i].class);

        if ((*env)->ExceptionOccurred(env)) {
            msg_Warn(p_dec, "Unable to find class %s", members[i].class);
            (*env)->ExceptionClear(env);
            goto error;
        }

С помощью описанного выше метода разработчики могут разобрать класс и функции MediaCodec из уровня собственного кода. Дополнительные сведения об использовании см. по адресу http://developer.android.com/reference/android/media/MediaCodec.html. 

Заключение

Метод оптимизации Intel был создан для помощи разработчикам в интеграции FFmpeg с MediaCodec: при этом поддерживаются самые разные форматы видео, а платформы Intel Atom под управлением Android получают аппаратный декодер.

Статьи по теме

Высококачественное сжатие видео: интеграция решения H.265/HEVC для платформ на базе Intel® Atom™ — Аndroid*:  https://software.intel.com/en-us/android/articles/high-quality-video-compression-integrating-an-h265hevc-solution-for-intel-atom-based-android-platforms

Аппаратный кодек Android* — MediaCodec: https://software.intel.com/en-us/android/articles/android-hardware-codec-mediacodec

Справочные материалы

[1] FFmpeg: http://www.ffmpeg.org/index.html

[2] Загрузка FFmpeg: http://www.ffmpeg.org/olddownload.html

[3] Проект Yasm Modular Assembler: http://yasm.tortall.net/

[4] Потоковые расширения Intel® SIMD (Intel® SSE): https://software.intel.com/en-us/articles/performance-tools-for-software-developers-intel-compiler-options-for-sse-generation-and-processor-specific-optimizations.

Об авторе

Сонью Вань (Songyue Wang) — старший инженер по разработке приложений в отделе Intel® Software and Solutions Group (SSG), в подразделении Developer Relations Division, в составе группы Intel® Atom™ Processor Mobile Enabling Team. Сонью отвечает за поддержку приложений для Android на устройствах с процессорами Intel Atom. Среди его основных задач — оптимизация производительности мультимедиа на платформе Bay Trail, тесное сотрудничество с популярными поставщиками видео в КНР для поддержки кодировщика и декодера H.265/HEVC, а также реализация функциональности Intel® Wireless Display в решениях Android для платформ x86.

Аннотация

Разработчики и ранее использовали имитатор Android* на базе Intel^® Hardware Accelerated Execution Manager (Intel^® HAXM) для разработки приложений Android*, но при тестировании приложений, использующих API Google, действовал ряд ограничений. В состав пакета Android SDK недавно был добавлен системный образ API Google на базе x86. В этой статье описывается установка, настройка и тестирование эмулятора на базе HAXM с API Google. Мы создадим приложение, чтобы продемонстрировать использование API Google и тестирование их в имитаторе на базе HAXM.

Contents

• Аннотация
• Обзор
• Установите последнюю версию образа API Google для x86
• Создайте конфигурацию виртуального устройства Android (AVD) и проведите тестирование
• Установите пакет SDK служб Google Play
• Создайте образец приложения для тестирования API Google в имитаторе на базе архитектуры x86
• Заключение
• Об авторе

Обзор

Имитатор Android Intel HAXM работает очень быстро, так как использует аппаратно ускоренную виртуализацию. Разработчики получат ощутимый прирост производительности работы на таких этапах создания приложений, как разработка, отладка и тестирование. До сих пор не было возможности тестировать приложения Android, использующие API Google, поскольку не было образов имитатора API Google на базе x86.

Теперь стандартные образы имитатора x86 Google API доступны в составе Android SDK. В приведенной ниже статье на сайте Intel Developer Zone подробно описывается создание и настройка AVD для запуска образа API Google x86.

https://software.intel.com/en-us/blogs/2014/03/06/now-available-android-sdk-x86-system-image-with-google-apis

TВ разделе комментариев сообщили о нескольких проблемах. В некоторых системах происходит сбой приложений Google (например, Карт Google), использующих технологии OpenGL, если установить флажок Use Host GPU для образа имитатора. Возможно, эту проблему удастся решить, отключив имитацию GPU.

Установите последнюю версию образа API Google для x86

Недавно была выпущена обновленная версия образа с исправленными ошибками (v5). Выберите и установите образ, как показано ниже.

Рисунок 1. Образ API Google x86 в пакете Android SDK

Создайте конфигурацию виртуального устройства Android (AVD) и проведите тестирование

Создайте конфигурацию виртуального устройства Android для вашего профиля целевого устройства. На следующем снимке экрана показана конфигурация AVD для профиля устройства Nexus 4. Обратите внимание на параметр Target: выбрана система x86 c API Google, уровень API 19.

Рисунок 2. Выбор нужного целевого устройства для конфигурации AVD.

Запустите образ имитатора. В окне Starting Android Emulator появится сообщение HAX is working and emulator runs in fast mode (НАХ работает, имитатор запущен в быстром режиме), если HAXM успешно используется.

Рисунок 3. HAXM успешно используется.

После загрузки образа имитатора Android на экране приложений должны появиться некоторые стандартные приложения Google, такие как Карты и «Настройки Google». См. следующий снимок экрана.

Рисунок 4. Образ API Google x86 с приложениями Google

Щелкните Карты Google, чтобы проверить правильность работы вашего образа х86 API Google на базе HAXM.

Если Карты не отображаются должным образом, проверьте наличие сетевого подключения у имитатора: запустите любой веб-браузер и попробуйте открыть в нем любой веб-сайт. По умолчанию имитатор должен автоматически получить доступ к сети и подключение к Интернету (если ваша система подключена к Интернету). Применение прокси-сервера может в некоторых случаях привести к проблемам с сетевым подключением имитатора.

http://developer.android.com/tools/help/emulator.html

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

На следующем снимке экрана показано приложение Карты Google, запущенное в имитаторе Android на базе Intel HAXM. Используется созданная ранее конфигурация AVD (x86_19g).

Рисунок 5. Приложение Карты Google в образе API Google x86.

Установите пакет SDK служб Google Play

Перед использованием API Google в нашем приложении Android сначала нужно загрузить пакет Google Play Services SDK в составе Android SDK Manager.

Подробные инструкции по установке см. в следующей статье.

http://developer.android.com/google/play-services/setup.html

Ниже показан снимок экрана Android SDK Manager, где для установки выбраны службы Google Play. Этот компонент находится в разделе Extras.

Рисунок 6. Установите службы Google Play с помощью Android SDK Manager.

На более высоком уровне API Google зависят от двух основных компонентов:

• Службы Google Play, выполняемой в качестве фоновой системной службы в ОС Android. Она автоматически обновляется из магазина Google Play, как любой другой пакет APK.
• Клиентской библиотеки, представляющей собой тонкую оболочку API с однородным интерфейсом. Она входит в состав пакета Google Play Services SDK, который мы загрузили ранее. Разработчикам необходимо использовать в своих приложениях нужную, самую последнюю версию.

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

http://developer.android.com/google/play-services/index.html

Создание образца приложения для тестирования API Google в имитаторе на базе архитектуры x86

Теперь создадим простое приложение, чтобы попробовать в работе API Google в образе Android x86 с HAXM.

Для создания образца приложения используется Android Studio. Щелкните File -> New Project, чтобы создать простое приложение с одиночным основным действием. Поскольку наш образ x86 Google API использует API уровня 19, убедитесь, что этот уровень задан в настройках Compile и Target. На следующем снимке экрана показаны все параметры, заданные для нашего образца приложения.

Рисунок 7. Создание приложения по умолчанию в Android Studio с правильными уровнями API для образа x86 Google API.

Скомпилируйте приложение и запустите его в созданной ранее конфигурации AVD (x86_19g). По умолчанию в приложении будет отображаться сообщение hello world.

Теперь добавим в приложение клиентскую библиотеку службы Google Play. Это удобнее сделать в проекте Android Studio. Нужно всего лишь отредактировать файл build.gradle в модуле нашего приложения (но не файл build.gradle основного проекта). Добавьте ссылку на последнюю версию служб Google Play в разделе зависимостей, как показано в следующем фрагменте кода.

apply plugin: 'android'

android {
    compileSdkVersion 19
    buildToolsVersion "19.1.0"

    defaultConfig {
        packageName "com.gapisample.app"
        minSdkVersion 15
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            runProguard false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.google.android.gms:play-services:4.4.52'
}

Фрагмент кода 1 ++

Подробные сведения см. в справочной документации: http://developer.android.com/google/play-services/setup.html

Службы Google Play и клиентская библиотека предоставляют доступ к нескольким API Google, включая Карты, Drive, Location, Google+, Ads и другие.

Для нашего тестового образца приложения используем API Android Карт Google. Для доступа к API Android Карт Google нам нужен ключ API. Следуйте инструкции, приведенной в следующей справочной статье, для создания ключа API: https://developers.google.com/maps/documentation/android/start#obtain_a_google_maps_api_key

Получив ключ API, измените манифест приложения, чтобы добавить этот ключ API: замените текст (), выделенный зеленым цветом, на ваш ключ API.

Прочие добавления в манифест приложения: версия службы Google Play, а также, в зависимости от использованных API, требуемые разрешения.

Для Карт Google требуются по крайней мере следующие разрешения: internet, network_state и external_storage. Подробное объяснение см. по адресу https://developers.google.com/maps/documentation/android/start#specify_app_settings_in_the_application_manifest for a detailed explanation.

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

<?xml version=”1.0” encoding=”utf-8”?><manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.gapisample.app"><uses-feature android:glEsVersion="0x00020000" android:required="true"/><uses-permission android:name="android.permission.INTERNET"/><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/><uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/><application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme"><activity
            android:name=".MainActivity"
            android:label="@string/app_name"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter></activity><meta-data android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" /><meta-data android:name="com.google.android.maps.v2.API_KEY"
            android:value="<ADD YOUR KEY>"/></application></manifest>

Фрагмент кода 2 ++

Теперь у нас есть доступ к API Google и возможность вызова объектов Карт Google.

https://developers.google.com/maps/documentation/android/map

Чтобы просто вызвать Карты Google, можно просто использовать MapFragment и заменить наш код hello world на него. Измените содержимое файла activity_main.xml по умолчанию на следующий фрагмент кода согласно инструкциям, указанным на странице https://developers.google.com/maps/documentation/android/start#add_a_map

<?xml version="1.0" encoding="utf-8"?><fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/map"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:name="com.google.android.gms.maps.MapFragment"/>

Фрагмент кода 3 ++

Скомпилируйте приложение и запустите его на имитаторе. Теперь вместо сообщения hello world все пространство должно быть занято элементом MapFragment, отображающим базовые карты Google с элементами управления по умолчанию.

Рисунок 8. Действующий API Карт Google, протестированный в имитаторе Android на базе HAXM с помощью нашего образца приложения.

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

Заключение

В этой статье описывается установка и настройка системного образа API Google на базе x86 в имитаторе Android на базе HAXM. Также описана настройка пакета Google Play Service SDK и создание простого приложения для тестирования API Google в имитаторе.

Об авторе

Ашок Эмани (Ashok Emani) работает инженером по программному обеспечению в отделе Intel Software and Services Group. В настоящее время он занимается проектами по масштабированию систем на основе процессоров Intel® Atom™.

++Пример исходного кода распространяется на условиях лицензионного соглашения корпорации Intel на использование образцов исходного кода OBL (совместимого с MS-LPL).

Intel(R) Cilk^TM Plus — это набор языковых расширений для компилятора Intel(R), помогающий легко и быстро применять распараллеливание и векторизацию для кода C/C++. Для ознакомления с базовыми сведениями о Cilk Plus см. главную страницу этого решения.

Intel Cilk Plus: https://software.intel.com/en-us/intel-cilk-plus

Открытый исходный код Cilk Plus: http://www.cilkplus.org/

Цель этой статьи — описание поддержки Cilk Plus в компиляторе Intel C/C++ для Android. Я расскажу о том, как использовать Cilk Plus для повышения производительности ваших приложений в Android.

Три простых ключевых слова:

Intel Cilk Plus содержит 3 простых ключевых слова, помогающих быстро сделать ваше приложение многопоточным. Это ключевые слова cilk_spawn, cilk_sync и cilk_for, но ими возможности Cilk Plus не ограничиваются. Для использования Cilk Plus необходимо слинковать исполняемую библиотеку Cilk (libcilkrts.so).

Использование Cilk Plus в проекте Android NDK
1. Сначала нужно собрать ваш проект в компиляторе Intel. Нужно добавить приведенный ниже код в файл jni/Application.mk (если такого файла нет, его нужно создать):

NDK_TOOLCHAIN = x86-icc
APP_ABI = x86

2. Добавьте подходящую STL в файл Application.mk вашего проекта

APP_STL:=stlport_shared
OR
APP_STL:=gnustl_static
OR
APP_STL:=gnustl_shared

Примечания. После задания STL компилятор Intel автоматически слинкуется с выполняемым модулем Cilk Plus. Если не добавить STL, при сборке кода может появиться много ошибок компоновки вида «ссылка не определена».

3. Загрузка выполняемых библиотек в коде Java

System.loadLibrary("gnustl_shared");
System.loadLibrary("cilkrts");
System.loadLibrary("yourJNILib");
OR
System.loadLibrary("stlport_shared");
System.loadLibrary("cilkrts");
System.loadLibrary("yourJNILib");

Где yourJNILib — имя вашей библиотеки JNI. Примечание. В последней версии Android исправлена проблема зависимости loadLibrary. В прежних версиях Android при использовании System.loadLibrary, если libyourJNILib.so зависит от libcilkrts.so, а libcilkrts.so зависит от libgnustl_shared.so, необходимо загружать их, как показано выше. Но при тестировании моего приложения выяснилось, что в последней версии Android эта проблема исправлена, зависимые библиотеки загружаются автоматически и нужно загрузить только вашу библиотеку JNI для приведенного выше кода (нужна только одна строка для загрузки yourJNILib).

4. Использование Cilk Plus в коде C/C++
Теперь можно использовать Cilk Plus в вашем коде. В качестве примера возьмем вычисление последовательности Фибоначчи. Ниже приведены две реализации этого алгоритма:

int fib(int n) {
	if (n == 0 || n == 1)
		return n;
	int x = fib(n - 1);
	int y = fib(n - 2);
	return x + y;
}

#include <cilk/cilk.h>
int fib_cilk(int n) {
	if (n == 0 || n == 1)
		return n;
	int x = cilk_spawn
	fib_cilk(n - 1);
	int y = fib_cilk(n - 2);
	cilk_sync;
	return x + y;
}

Для использования Cilk Plus необходимо включить заголовки. Для трех простых ключевых слов достаточно включить cilk/cilk.h. Назначение cilk_spawn — создание новой ветви (которое можно рассматривать как задачу Cilk Plus), Cilk Plus будет автоматически управлять фактическими рабочими потоками (которые можно рассматривать как физические потоки), а выполняемый модуль будет сопоставлять ветви с рабочими потоками (количество рабочих потоков по умолчанию совпадает с количеством ядер процессора). 

Примечание. В приведенном выше случае код легко понять так: «существует 2 потока, один для выполнения fib_cilk(n-1), а другой для выполнения всего остального кода, т. е. для продолжения кода fib_cilk(n-2)».

Назначение cilk_sync — синхронизация, то есть ожидание завершения всех рабочих потоков, затем продолжение выполнения. Разумеется, для вычисления fib нужно дождаться fib(n-1) и fib(n-2), а затем продолжить выполнение.

Результаты тестирования:

Результаты тестирования таковы: работа кода без Cilk Plus занимает 2831 мс, а код с Cilk Plus работает 10 315 мс. Почему при использовании Cilk Plus код стал работать медленнее? В чем тогда был смысл написания этой статьи?

5. Оптимизация нагрузки

В приведенном выше примере каждый раз при вычислении fib(N) у нас есть два рабочих потока, выполняющих fib(N-1) и fib(N-2). Но если значение N очень маленькое (например, N = 3), то нагрузка fib(N-1) и fib(N-2) будет маленькой, а издержки на создание рабочих потоков и переключение контекста между потоками резко снизят производительность. Такая ситуация возникает постоянно, поэтому издержки будут возникать многократно, а производительность будет намного ниже, чем у кода, не использующего Cilk Plus.

Как решить эту проблему? Нужно пользоваться последовательной обработкой при небольших значениях N. Например:

int fib_cilk_optimize(int n) {
	if (n == 0 || n == 1)
		return n;
	if (n < 20) {
		int x = fib(n - 1);
		int y = fib(n - 2);
		return x + y;
	} else {
		int x = cilk_spawn
		fib_cilk_optimize(n - 1);
		int y = fib_cilk_optimize(n - 2);
		cilk_sync;
		return x + y;
	}
}

Теперь потоки Cilk будут использоваться только для нагрузок, где N >= 20. Результаты тестирования для измененного кода Cilk таковы:

Вот график для приведенных выше результатов:

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

Прочие ресурсы:

https://software.intel.com/en-us/android/articles/using-advanced-intelr-c-compiler-features-for-android-applications

Тестовое устройство: Dell Venue 8 (2 ядра, 4 потока в режиме гиперпоточности) (сведения о том, как получить версию образа этого устройства, предназначенную для разработчиков, см. по адресу http://software.intel.com/en-us/android/articles/mobile-development-kit-for-android

Эта статья применима к следующему:
Продукты: Intel(R) INDE; INTEL(R) System Studio
ОС/платформы разработки: Windows (IA-32, Intel(R) 64), Linux* (IA32, Intel(R) 64)
Целевые ОС/платформы: Android* (IA-32)

Download sample code

Введение

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

Для создания этого приложения пришлось решить три проблемы:

1. Как написать код, чтобы пользователь мог манипулировать трехмерной поверхностью, и при этом на ней не останавливалось воспроизведение видео?
2. Используемый по умолчанию класс MediaPlayer в Android хорошо работает с функциями воспроизведения, но с его помощью невозможно получить данные видеоизображения и отобразить их каким-то другим способом.
3. Как создать графический компонент для отображения видеоданных?

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

Возможности

Приложение обладает следующими возможностями:

1. 1. Пользователь может выбрать видеофайл из локальной библиотеки мультимедиа.
2. 2. Приложение работает и при вертикальной, и при горизонтальной ориентации экрана. Воспроизведение видео не прерывается при изменении ориентации.
3. 3. Поддерживаются три режима воспроизведения.
   1. Режим по умолчанию. Это режим обычного воспроизведения. Видеофайл воспроизводится точно так же, как в любом проигрывателе мультимедиа.
   2. Произвольное вращение. Поверхность видео вращается произвольным образом вокруг горизонтальной и вертикальной осей. Также переключается цвет между обычным и красноватым.
   3. Управляемое вращение. Пользователь с помощью касаний может поворачивать и крутить поверхность вправо и влево с различной скоростью.
   4. Если приложение переводится в фоновый режим или закрывается, текущие видеоклипы можно сохранить и затем воспроизвести при повторной активации приложения.

Примечание: Управление видеосеансом отсутствует: пользователь не может остановить видео, перемотать его вперед или назад. Если приложение переводится в фоновый режим или останавливается, видео можно вновь воспроизвести только с начала.

Модель использования

Начало воспроизведения видеоклипов

Приложение само по себе не содержит видеофайлов. Пользователь может выбрать любой видеофайл, поддерживаемый платформой Android. Рекомендуется использовать видеоклипы, закодированные с помощью кодека H.264AVC в контейнере MPEG-4, поскольку именно этот формат тестировался при разработке. При первом запуске приложения появится экран выбора файлов (см. снимок экрана на предыдущей странице).

В окне выбора файла на экране появляются указания. После выбора видеоклипа начинается воспроизведение.
Примечание: Иногда перед началом воспроизведения видео проходит определенное время (около 5—10 секунд).

Выбор другого режима

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

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

Произвольное вращение

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

Управляемое вращение

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

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

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

TКомпонент воспроизведения видео содержит два потока. Поток обработчика видео использует класс MediaCodec. Этот класс впервые появился в версии Android JellyBean (API 16). Он предоставляет доступ к низкоуровневому API платформы мультимедиа Android, поэтому можно управлять воспроизведением на уровне кадров. В каждом кадре видео графический компонент может содержать данные изображения и изменять способ отображения.

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

Графический компонент расширяет класс GLSurfaceView: в этот класс встроен измененный класс отрисовки. Класс отображения реализует интерфейс Renderer для выполнения алгоритма отрисовки OpenGL. Этот алгоритм реализует трехмерный эффект вращения на поверхности текстуры, а также изменяет режим, включая различные алгоритмы на основе действий пользователя.

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

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

Процесс декодирования MediaCodec работает в темпе видеокадров; функция отрисовки в графическом компоненте работает в темпе графических кадров. Поэтому функции обоих компонентов требуется синхронизировать при доступе к кадровому буферу.

Ссылки по теме и ресурсы:

• Перенос игр OpenGL* на устройства Android* с процессорами Intel Atom
• Пример кода Android* MediaPlayer для архитектуры Intel®
• Трехмерные игры на графической платформе процессоров Intel
• Intel Android* Developer Zone

Дополнительные сведения о средствах Intel для разработчиков Android см. на сайте Intel® Developer Zone for Android.

Об авторе

Марк Лю (Mark Liu) работает в подразделении Intel Ultra-Mobile Group инженером по программному обеспечению и занимается разработкой платформы проверки кода для устройств под управлением Android. Он также участвовал в нескольких проектах Android в Intel Ultra-Mobile Group, включая смартфоны и планшеты. Значительная часть его работы связана с воспроизведением мультимедиа, видеоконференциями и отладкой производительности программных пакетов.

После вступления в группу программной поддержки процессоров Intel® Atom™ в составе подразделения Intel Software and Services Group он работал на нескольких горизонтальных направлениях, включая разработку образцов мультимедиаприложений для Android, оптимизацию систем для мультимедиаплатформы Windows* 8 и создание документации по написанию мультимедиаприложений.

Крис Киркпатрик (Chris Kirkpatrick) — инженер по программному обеспечению в отделе Intel Software and Services Group. Он поддерживает графические решения Intel в группе Visual & Interactive Computing Engineering. Он является бакалавром компьютерных наук в Университете штата Орегон.

Юридическое уведомление

1 Общие сведения  

2 Установка Intel® INDE

      2.1 Требования к системе

      2.2 Шаг 1: установка центра Intel INDE

      2.3 Шаг 2: установка среды

      2.4 Шаг 3: установка компонентов Intel INDE

3 Использование бета-версии Intel INDE

      3.1 Тестирование приложений

4 Удаление бета-версии Intel INDE

5 Устранение неполадок при установке

1   Общие сведения

Intel® Integrated Native Developer Experience (Intel® INDE) — это межплатформенный пакет разработки, содержащий ряд компонентов, средств и библиотек Intel, позволяющих разработчикам создавать собственные приложения для Android-устройств с процессорами Intel® и задействовать определенные возможности в устройствах с процессорами ARM*. В этой статье описываются действия по поиску и установке компонентов INDE.

2    Установка Intel® INDE

Выполните следующие действия для установки Intel INDE:

Для выполнения шагов 1 и 2 может потребоваться от 15 до 45 минут (в зависимости от скорости подключения к Интернету). Длительность третьего шага зависит от набора устанавливаемых компонентов.

Можно открыть центр Intel INDE в любое время для получения уведомлений об обновлении компонентов.  

2.1    Требования к системе

Требования к системе для установки Intel INDE:

• 64-разрядная операционная система Microsoft* Windows* 7, Windows 8 или Windows 8.1
• 4 GB RAM
• 6 GB свободного места на жестком диске

2.2    Шаг 1: установка центра Intel INDE

Чтобы установить центр Intel INDE, управляющий дальнейшими действиями по установке, выполните следующие действия:

1. Перейдите по адресу http://software.intel.com/en-us/intel-inde для загрузки этого продукта.
2. Зарегистрируйте учетную запись Intel® Developer Zoneчтобы продолжить установку.
3. После завершения регистрации вы получите электронное письмо с информацией о лицензировании.
4. В полученном электронном письме щелкните ссылку Intel® Software Development Products Registration Center.Сохраните это электронное письмо для дальнейшего использования.
5. В папке с загруженными файлами дважды щелкните IntelHubSetup.exe, чтобы запустить программу установки.
6. По завершении программы установки запустите продукт. На экране появится список всех компонентов Intel INDE:

2.3    Шаг 2: установка среды

Перед установкой всех прочих компонентов Intel INDE необходимо установить компоненты среды.

Среда включает следующие компоненты:

• Google Android* SDKдля Java
• Android* NDKдля C++
• Android* Design
• Apache ANT*

Кроме того, при установке среды реализуется интеграция в следующие среды разработки

• Microsoft Visual Studio*
  •   Условия: Visual Studio 2012 или более поздней версии (выпуск Pro или Ultimate)
  •   Дополнительно:  подключаемые модули vs-android. Для этих подключаемых модулей требуется JDK 8)
• Eclipse* (в составе пакета Android* ADT, устанавливаемого с платформой Intel INDE)
• Android Studio* (в составе платформы Intel INDE)

Для установки среды выполните следующие действия:

1. Нажмите кнопку Установить в поле Environment Setup в окне центра Intel INDE. Появится мастер установки
2. В окне Suite выберите один из трех вариантов IDE и нажмите кнопку Далее. В окне Options отображаются средства, выбранные по умолчанию.
3. Снимите выбор с уже установленных компонентов. Если выбран компонент Intel HAXM, вы увидите, что уже задано рекомендуемое ограничение ОЗУ. Это ограничение можно изменить при необходимости. Нажмите кнопку Далее.
4. Примите условия лицензионных соглашений и нажмите кнопку Далее.
5. В окне Destination можно принять место установки по умолчанию или указать другую папку для установки средств Android.
6. Если пакет Java JDK уже установлен, примите отображаемую папку установки по умолчанию. Если пакет JDK не установлен, его можно установить из JDK 8и указать новую папку.
7. Нажмите кнопку Далее, чтобы отобразить окно готовности к установке, в котором будут перечислены выбранные для установки компоненты. Можно вернуться назад и изменить набор устанавливаемых компонентов.
8. Нажмите кнопку Далее, чтобы начать установку выбранных компонентов.
9. Появится страница завершения установки с уведомлением о том, что установка среды успешно завершена.

В центре Intel INDE в разделе Environment Setup появится значение Установлено:

Перейдите в папку ..\INDE\Framework\*, чтобы найти средства Android.

2.4    Шаг 3: установка компонентов Intel INDE

После установки центра Intel INDE и среды можно установить все остальные компоненты Intel INDE.

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

3   Использование бета-версии Intel INDE

Вот некоторые задачи, которые можно выполнять с помощью Intel INDE.

3.1    Тестирование приложений

Тестировать приложения можно следующими способами:

1. Программная эмуляция (эмуляторы доступны в Android SDK)
2. Программная эмуляция с аппаратным ускорением. При установке среды можно установить компонент Intel® Hardware Accelerated Execution Manager (Intel® HAXM), представляющий собой гипервизор для ускорения эмуляции приложений Android на компьютере (для его использования необходимо, чтобы в BIOS была включена технология виртуализации Intel®¹).
3. Непосредственное тестирование на устройстве с Android*, подключенном к компьютеру через USB, с помощью ADB.

4   Удаление бета-версии Intel INDE

Чтобы удалить бета-версию Intel INDE, выполните следующие действия:

1. Найдите значок бета-версии Intel® Integrated Native Developer Experience на панели управления и щелкните его правой кнопкой мыши, чтобы удалить центр Intel INDE. При этом компоненты Intel INDE не будут удалены.
2. Найдите значок Environment Setup на панели управления и щелкните его правой кнопкой мыши, чтобы удалить. При этом будут удалены компонент Intel HAXM и прочие средства Android, которые были установлены при установке среды Intel INDE.
3. Найдите какой-либо компонент Intel INDE на панели управления и щелкните его правой кнопкой мыши, чтобы удалить. Повторите эти действия для всех компонентов Intel INDE. 
    

5   Устранение неполадок при установке

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

Download PDF

Введение

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

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

• определение изменения режима ввода (сенсорный экран или клавиатура и мышь);
• предсказание режима (планшетный режим или режим ноутбука);
• отображение соответствующего пользовательского интерфейса

Типоразмеры устройств и их использование

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

В них используется сенсорный ввод на основе распознавания рукописного ввода или экранной сенсорной клавиатуры (впрочем, можно подключить и обычную внешнюю клавиатуру). Планшеты исключительно компактны и легки, их очень удобно носить с собой. Тем не менее по вычислительной мощности планшеты существенно уступают ноутбукам; функциональность планшетов как вычислительных устройств в значительной мере ограниченна. Планшеты прекрасно подходят для обычных пользователей Интернета, которые, главным образом, читают новости и просматривают популярные веб-сайты, играют в несложные игры или же смотрят телепередачи и кинофильмы в поездках. Кроме того, планшетами довольно часто пользуются представители творческих профессий, такие как дизайнеры и создатели музыки. [1]

Проблема двух устройств

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

Рисунок 1. Evolution of Computing Devices

Типы устройств-трансформеров

Существует несколько типов трансформеров. У некоторых из них экран вращается на шарнире, у других складывается на 180°, а у некоторых полностью отстыковывается. Во всех случаях есть одна важная общая черта — возможность быстро и без нарушения работы перейти из режима ноутбука в режим планшета и обратно. Итак, вот эти два режима: планшет (физическая клавиатура в этом режиме отсутствует или не используется, а основным средством ввода является сенсорный экран) и ноутбук (основные средства ввода — клавиатура, мышь, сенсорная панель).

Рисунок 2.Некоторые типы трансформеров, доступных на рынке в настоящее время.

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

Адаптация трансформеров для игр

Все игры можно разделить на две категории: (1) традиционные игры для ПК, для управления которыми используется мышь, клавиатура или игровые контроллеры; (2) игры для мобильных устройств с сенсорным управлением. Поскольку на трансформерах можно запускать и те, и другие игры, важно понять, как игра будет адаптироваться при изменении пользователем режима работы устройства. Это может произойти в любой момент, даже в процессе игры.

Особенности трансформеров как игровой платформы

Сенсорный режим

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

Устройство пользовательского интерфейса

Любой сенсорный пользовательский интерфейс должен соответствовать правилам проектирования игр для планшетов. Например, важно, чтобы сенсорные кнопки были достаточно крупными и имели промежутки между собой в соответствии со средним размером пальца взрослого человека. Кроме того, важно, чтобы кнопки и формы немедленно реагировали на пользовательский ввод. Помните, что, когда устройство находится в режиме планшета, весьма высока вероятность, что пользователь держит устройство двумя руками. Если спроектировать элементы управления так, чтобы они находились рядом с местами, за которые обычно пользователи держат устройство, игра будет удобной в использовании: пользователю не потребуется удерживать устройство одной рукой, чтобы другой нажать на кнопку в середине экрана. [2]

Рисунок 3. См. http://msdn.microsoft.com/en-us/library/windows/apps/hh465415.aspx

Гладкое изменение пользовательского интерфейса

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

Например, в игре Defense Grid: The Awakening такой переход реализован очень удобно. [3]Когда игра обнаруживает сенсорный ввод, она отображает планшетный интерфейс. Пользовательский интерфейс содержит расположенный у правого края экрана столбец, в котором удобно выбирать кнопки, находящуюся рядом кнопку настроек и игрового меню, а также кнопку быстрой прокрутки в левом нижнем углу экрана. Элементы пользовательского интерфейса расположены рядом с местами, за которые пользователь держит планшет, как показано выше. Когда игра обнаруживает ввод с клавиатуры, мыши или сенсорной панели, элементы сенсорного интерфейса исчезают, отображается указатель мыши. Благодаря этому переключение между состояниями происходит очень естественным и ненавязчивым образом.

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

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

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

GetSystemMetrics - это API Windows для опроса состояния устройства. [4]Соответствующие метрики - SM_CONVERTIBLESLATEMODEи SM_SYSTEMDOCKED. Опрос SM_CONVERTIBLESLATEMODEпозволяет определить режим работы устройства (режим планшета или режим ноутбука). [5]

	bool bSlateMode = (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0);

При изменении этой метрики системы она отправляет сообщение WM_SETTINGCHANGEсо значением “ConvertibleSlateMode” в разделе LPARAM.

case WM_SETTINGCHANGE:
	if(wcscmp(TEXT("ConvertibleSlateMode"), (TCHAR *) lParam) == 0)
NotifySlateModeChange();
	break;

Помните, что в некоторых системах эта функциональность может быть недоступна. Не существует простого способа определения этой функциональности API приложением. Это означает, что вызов GetSystemMetrics()может вернуть неверное состояние. На старых устройствах вызов может вернуть значение 0, указывающее на режим планшета, тогда как на самом деле устройство при этом будет работать в режиме ноутбука.

Сообщение WM_SETTINGCHANGEсо значением LPARAMConvertibleSlateMode или SystemDockMode будет разослано, только если эта функция поддерживается. Если игра обнаруживает эти сообщения, она может правильно предоставить пользователю нужный интерфейс. Поскольку эта функция поддерживается не во всех случаях, важно переключать интерфейс на основе изменения пользовательского ввода (сенсорный ввод или ввод с клавиатуры).

Экранная клавиатура

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

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

Рисунок 6.Экранная клавиатура с фиксированным размером и расположением.	Рисунок 7.Экранная клавиатура, размер и расположение которой можно изменять .

В следующем примере кода показано, как вызвать экранную клавиатуру Windows в игре DirectX: https://software.intel.com/en-us/blogs/2013/06/11/touch-keyboard-access-for-windows-8-desktop-apps [6]Для этого подхода требуется, чтобы игра была запущена в режиме развернутого на весь экран окна без рамки. Множество игр для настольных ПК создаются для монопольного полноэкранного режима. Это затрудняет использование встроенных клавиатур: либо вызванная клавиатура останется скрытой, либо она появится на экране, но заставит выйти игру из полноэкранного режима. Переход в полноэкранный монопольный режим и из этого режима связан с получением и высвобождением значительного объема ресурсов, а также с проблемой изменения размера окон. Как правило, это серьезные затруднения, совершенно излишние для обработки клавиатурного ввода. В решении, показанном в этом примере, игра запускается не в монопольном полноэкранном режиме, а в развернутом на весь экран окне без рамки. Преимущество такого подхода состоит в том, что появляющаяся на экране клавиатура никак не мешает игре: просто экран игры сдвигается на один уровень вниз в наборе z-уровней глубины. Игра продолжает выполняться в фоновом режиме, чтобы обрабатывать ввод с клавиатуры, и автоматически снова получает фокус после закрытия клавиатуры.

Автоматический поворот/блокировка ориентации

Все трансформеры оборудованы различными датчиками. Это позволяет воспользоваться функцией автоматического поворота. В планшетном режиме устройство может использоваться в книжной или в альбомной ориентации. Если включен автоматический поворот, игра на основе DirectX потеряет свое устройство D3D, ей потребуется заново создать новое устройство с новым разрешением изображения (с учетом изменения ориентации). Например, разрешение экрана может измениться с 1600x900 на 900x1600. Для полноэкранных игр это нежелательно. В приложениях для современного интерфейса Windows эту проблему несложно устранить: достаточно указать параметры ориентации в манифесте приложения. Для игр с классическим интерфейсом можно получить эту функциональность путем прямого отслеживания и вызова экспортированной функции в user32.dll. Эту функцию можно будет использовать для отключения автоматического поворота в настройках ориентации игры. [7]

typedef enum ORIENTATION_PREFERENCE
{
    ORIENTATION_PREFERENCE_NONE              = 0x0,
    ORIENTATION_PREFERENCE_LANDSCAPE         = 0x1,
    ORIENTATION_PREFERENCE_PORTRAIT          = 0x2,
    ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED = 0x4,
    ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED  = 0x8
} ORIENTATION_PREFERENCE;

typedef BOOL (WINAPI *pSDARP)(ORIENTATION_PREFERENCE orientation);

pSDARP pARP;

pARP = (pSDARP) GetProcAddress( GetModuleHandle(TEXT("user32.dll")),"SetDisplayAutoRotationPreferences" );

if( pARP )
{
    pARP( (ORIENTATION_PREFERENCE)(ORIENTATION_PREFERENCE_LANDSCAPE |
ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED) );
}

Сенсорные жесты

Сенсорные жесты делают игровой процесс более интуитивным. В зависимости от типа игры сенсорное управление может быть более интуитивным, чем управление с помощью клавиатуры и мыши. Например, в игре жанра «стратегия в реальном времени» (RTS) сенсорное управление дает пользователю возможность обводить игровые единицы на экране, чтобы выбирать их. После этого можно скомандовать этим единицам перейти в нужное место, коснувшись мини-карты или изменив масштаб основной карты и выбрав место, которое до этого находилось за границей экрана. Кроме того, в играх RTS пользователь может выбрать игровые единицы и прочертить по экрану определенный маршрут для патрулирования. Такие команды трудно представить себе наглядно и непросто реализовать в традиционных системах ввода, но в сенсорном режиме все значительно проще.

Рисунок 8.В игре Civilization V были добавлены сенсорные элементы для удобного сенсорного управления игрой.

Мультисенсорный ввод позволяет добавить множество команд в простой интерфейс. Например, в игре Civilization V используются следующие сенсорные элементы управления[8]:

• Сведение и разведение пальцев — приближение и удаление камеры
• Перетаскивание — отображение информации об игровой единице или об участке земли, над которым проходит палец
• Прокрутка двумя пальцами — перемещение камеры выше или ниже, левее или правее
• Касание — выбор игровой единицы
• Двойное касание — команда на перемещение выбранной игровой единицы
• Касание двумя пальцами — выход из текущей команды без отдачи приказа
• Касание тремя пальцами — закрытие открытых меню или открытие игрового меню

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

Выбор сенсорных API

В классических приложениях для Microsoft Windows 8 поддержку сенсорного ввода и жестов можно реализовать тремя способами: с помощью сообщений WM_POINTER, WM_GESTUREили WM_TOUCH messages. [9]

• WM_POINTER— самый простой для написания код, поддерживается самый широкий набор жестов, но поддерживается только операционная система Windows 8 и более поздние версии.
• Для WM_GESTUREнесложно писать код; поддерживается обратная совместимость с Windows 7, но накладывается ряд ограничений.
• WM_TOUCHтоже обратно совместим с Windows 7, но требует создания наибольшего объема кода, поскольку требуется написать собственные алгоритмы распознавания жестов и манипуляций на основе низкоуровневых сенсорных событий.

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

Рисунок 9. Сравнение сенсорных API Windows.

Вот ссылка на пример кода, где показана интеграция сенсорного управления в приложении с помощью API WM_GESTUREи WM_TOUCH: https://software.intel.com/en-us/vcsource/samples/windows-7-touch [10]

Упаковка в Unity 3D

Некоторые версии движка Unity 3D не обрабатывают сообщения касания в приложениях, работающих под управлением Windows 7 и классического интерфейса Windows 8. Движок Unity сам по себе не занимается обработкой сообщений касания, но можно зарегистрировать окно Unity для касаний с помощью подключаемого модуля. Проблема в том, чтобы создать подключаемый модуль, использующий разные API Windows для перехвата сообщений касания, отправляемых в приложения. После регистрации окна подключаемый модуль предоставляет доступ к сообщениям касания в сценарии приложения Unity. Образец кода этого подключаемого модуля см. здесь: https://software.intel.com/en-us/articles/adding-multi-touch-support-to-unity-games-on-microsoft-windows-7-and-windows-8-desktop [11]

Сравнение задержек устройств ввода

Рисунок 10.Описание полного набора программных и аппаратных компонентов, влияющих на задержки реагирования при сенсорном управлении.

В зависимости от устройства длительность задержки может составлять 50—100 мс, но этот показатель постоянно улучшается [12].Под задержкой подразумевается время между распознаванием ввода (путем касания) и отображением на экране соответствующего эффекта. Она не сильно отличается от задержки при традиционном вводе с помощью мыши или сенсорной панели. Аппаратная задержка обычной мыши составляет около 8 мс, но к этому нужно добавить задержку программных компонентов.

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

Режим вспомогательного приложения

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

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

Другие важные факторы

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

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

Об авторе

Дорайсами Ганешкумар (Doraisamy Ganeshkumar) — старший инженер по программному обеспечению в отделе Intel Developer Relations. Он помогает разработчикам игр для ПК оптимизировать свои игры для продукции Intel. В нерабочее время ему нравится кататься на велосипеде, гулять, заниматься столярным ремеслом и сооружать различные технические приспособления.

Справочные материалы

[1]Ноутбуки и планшеты: достоинства и недостатки: http://www.lenovo.com/us/en/faqs/laptop-vs-tablet/

[2]Сенсорное взаимодействие в Windows: http://msdn.microsoft.com/en-us/library/windows/apps/hh465415.aspx

[3]Создание высококачественного сенсорного интерфейса для игры Defense Grid: The Awakening: https://software.intel.com/en-us/articles/creating-a-first-class-touch-interface-for-defense-grid-the-awakening

[4]Библиотека API Windows: http://msdn.microsoft.com/en-us/library/windows/desktop/ms724385%28v=vs.85%29.aspx

[5]Обнаружение режимов планшета и ноутбука, а также ориентации экрана на трансформерах: https://software.intel.com/en-us/articles/detecting-slateclamshell-mode-screen-orientation-in-convertible-pc

[6]Использование сенсорной клавиатуры в классических приложениях для Windows* 8: https://software.intel.com/en-us/blogs/2013/06/11/touch-keyboard-access-for-windows-8-desktop-apps

[7]Обработка функции автоматического поворота Windows 8 в приложениях: https://software.intel.com/en-us/blogs/2013/01/10/handling-windows-8-auto-rotate-feature-in-your-application

[8]Новая платформа для гиганта игровой отрасли: компания Firaxis выходит на мобильный рынок, оптимизируя игру Civilization V* для ультрабуков с сенсорным экраном: http://www.intel.com/content/www/us/en/gaming/firaxis-civ-v.html

[9]Сравнение методик написания кода для обработки сенсорного ввода — образец классического приложения для Windows 8: https://software.intel.com/en-us/articles/comparing-touch-coding-techniques-windows-8-desktop-touch-sample

[10]Сенсорный ввод в классических приложениях для Windows: https://software.intel.com/en-us/vcsource/samples/windows-7-touch

[11]Добавление поддержки мультисенсорного ввода в игры Unity* для Microsoft Windows* 7 и классического интерфейса Windows* 8: https://software.intel.com/en-us/articles/adding-multi-touch-support-to-unity-games-on-microsoft-windows-7-and-windows-8-desktop

[12]Измерение реакции на сенсорный ввод, анализ и оптимизация для приложений Windows*: https://software.intel.com/en-us/articles/touch-response-measurement-analysis-and-optimization-for-windows-applications

Download PDF
Download Zipfile

Содержание

Содержание
Введение
Неоднородные рабочие группы
Обзор учебной программы
Требования для учебной программы
Запуск учебной программы
Справочные материалы

Введение

Модель выполнения OpenCL™ включает понятие рабочих групп, которые являются группами отдельных рабочих элементов в NDRange. Рабочие элементы в составе одной и той же рабочей группы могут вместе использовать локальную память, проводить синхронизацию с помощью барьера группы и взаимодействовать с помощью таких групповых функций, как async_work_group_copy. Если приложение использует OpenCL 1.x, то размеры NDRange должны нацело (без остатка) делиться на размеры рабочих групп. Если вызов clEnqueueNDRangeKernelвключает параметры global_sizeи local_sizeкоторые не делятся нацело, вызов возвратит код ошибки CL_INVALID_WORK_GROUP_SIZE. Если же вызов clEnqueueNDRangeKernelуказывает значение NULL для параметра local_size, разрешая выполняемому модулю выбрать размер рабочей группы, то выполняемому модулю потребуется выбрать размер, на который можно нацело разделить глобальные размеры NDRange.

Необходимость выбора такого размера рабочих групп, чтобы на него нацело делился размер NDRange, может вызвать затруднение у разработчиков. Рассмотрим простой алгоритм размытия изображения 3х3 (алгоритм входит в учебный код). В этом алгоритме каждый выходной пиксель вычисляется как среднее значение для значений входных пикселей в соседней области размером 3х3. Такие алгоритмы применяются во множестве приложений для обработки изображений, работающих с соседними группами пикселей, для таких операций, как свертывание, стирание, размытие и фильтрация по среднему. В алгоритмах такого типа можно использовать разные способы для обработки выходных пикселей, расположенных на рамке изображения. Эти пиксели зависят от пикселей вне границ входного изображения. Эта проблема показана на приведенном ниже рисунке.

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

В этом примере используется размытие 3х3, но эта проблема существует и для других алгоритмов.

Неоднородные рабочие группы

В OpenCL 2.0 появилась новая возможность, в которой устранены проблемы, описанные в предыдущем разделе. Речь идет о так называемых неоднородных рабочих группах: выполняемый модуль OpenCL 2.0 может разделить NDRange на рабочие группы неоднородного размера по любому измерению. Если разработчик укажет размер рабочей группы, на который размер NDRange не делится нацело, выполняемый модуль разделит NDRange таким образом, чтобы создать как можно больше рабочих групп с указанным размером, а остальные рабочие группы будут иметь другой размер. Например, для NDRange размером 1918x1078 рабочих элементов при размере рабочей группы 16x16 элементов среда выполнения OpenCL 2.0 разделит NDRange, как показано на приведенном ниже рисунке.

Благодаря этому OpenCL может использовать рабочие группы любого размера для любого размера NDRange, когда разработчик передает значение NULL параметра local_sizeв clEnqueueNDRangeKernel. В целом использование значения NULL в параметре local_sizeостается предпочитаемым методом выполнения ядер, если логика вашего приложения не требует какого-либо определенного размера рабочей группы.

Внутри кода ядра встроенная функция get_local_size()возвращает фактический размер рабочей группы, из которой она была вызвана. Если ядру требуется точный размер, указанный для параметра local_sizeв clEnqueueNDRangeKernel, то встроенная функция get_enqueued_local_size() возвращает эти значения.

Чтобы включить использование неоднородных рабочих групп, необходимо скомпилировать ядро с флагом “-cl-std=CL2.0”, включающим эту и другие возможности OpenCL 2.0. Без использования этого флага компилятор будет использовать версию OpenCL 1.2, даже если устройство поддерживает OpenCL 2.0. Кроме того, неоднородные рабочие группы можно отключить для ядер, скомпилированных для флага “-cl-std=CL2.0” с помощью флага “-cl-uniform-work-group-size”. Это может быть полезно для устаревшего кода ядра до полного перехода на OpenCL 2.0.

Функция неоднородных рабочих групп в OpenCL 2.0 повышает простоту использования OpenCL и может повысить производительность некоторых ядер. Разработчики больше не добавляют код системы и ядра для работы с размерами NDRange, которые не делятся нацело. Код, созданный для использования этой возможности, может эффективно использовать SIMD и выравнивание доступа к памяти: такие преимущества обеспечиваются правильным выбором размера рабочих групп.

Обзор учебной программы

TВ коде учебной программы реализован алгоритм размытия 3х3, описанный выше. Самая интересная часть кода находится в файле main.cpp. Код в этом файле действует следующим образом:

1. Загрузка входного растрового файла.
2. Сборка ядра OpenCL C с помощью параметров OpenCL 1.2.

   // Get the box blur kernel compiled using OpenCL 1.2 (which is the
   // default compilation, even on an OpenCL 2.0 device).  This allows
   // the code to show the pre-OpenCL 2.0 behavior.
   cl::Kernel kernel_1_2 = GetKernel(device, context);

3. Сборка ядра OpenCL C с помощью параметров OpenCL 2.0 (обратите внимание на передачу параметров сборки с флагом OpenCL 2.0).

   // Get the box blur kernel compiled using OpenCL 2.0.  OpenCL 2.0
   // is required in order to use the non-uniform work-groups feature.
   kernel_2_0 = GetKernel(device, context, "-cl-std=CL2.0");

4. Задание глобального размера, который используется для всех разновидностей запущенных ядер.

   // Set the size of the global NDRange, to be used in all NDRange cases.
   // Since this is a box blur, we use a global size that is two elements
   // smaller in each dimension.  This creates a range which often doesn't
   // divide nicely by local work sizes we might commonly pick for running
   // kernels.
   cl::NDRange global_size = cl::NDRange(input.get_width() - 2,
                                         input.get_height() - 2);

5. Размытие изображения с помощью версии ядра, скомпилированной для OpenCL 1.2, параметр local_sizeимеет значение NULL.

   // Blur the image with a NULL local range using the OpenCL 1.2 compiled
   // kernel.
   cout << "Compiled with OpenCL 1.2 and using a NULL local size:"<< endl << endl;
   output = RunBlurKernel(context, queue, kernel_1_2, global_size,
                          cl::NullRange, input, true);

6. Размытие изображения с помощью версии ядра, скомпилированной для OpenCL 1.2, при значении параметра local_size 16x16.

   // Blur the image with an even local range using the OpenCL 1.2
   // compiled kernel.  This won't work, even if we are running on an
   // OpenCL 2.0 implementation.  The kernel has to be explicitly compiled
   // with OpenCL 2.0 compilation enabled in the compiler switches.
   try
   {
       cout << "Compiled with OpenCL 1.2 and using an even local size:"<< endl << endl;
       output = RunBlurKernel(context, queue, kernel_1_2,
                              global_size, cl::NDRange(16, 16), input,
                              true);
       cout << endl;
       output.Write(output_files[1]);
   }
   catch (...)
   {
       cout << "Trying to launch a non-uniform workgroup with a kernel ""compiled using"<< endl <<"OpenCL 1.2 failed (as expected.)"<< endl << endl;
   }

7. Размытие изображения с помощью версии ядра, скомпилированной для OpenCL 2.0, при значении параметра local_size NULL.

   // Blur the image with a NULL local range using the OpenCL 2.0
   // compiled kernel.
   cout << "Compiled with OpenCL 2.0 and using a NULL local size:"<< endl << endl;
   output = RunBlurKernel(context, queue, kernel_2_0, global_size,
                          cl::NullRange, input, true);

8. Размытие изображения с помощью версии ядра, скомпилированной для OpenCL 2.0, при значении параметра local_size 16x16.

   // Blur the image with an even local range using the OpenCL 2.0
   // compiled kernel.  This will only work on an OpenCL 2.0 device
   // and compiler.
   cout << "Compiled with OpenCL 2.0 and using an even local size:"<< endl << endl;
   output = RunBlurKernel(context, queue, kernel_2_0,
                          global_size, cl::NDRange(16, 16), input,
                          true);

9. Запись выходных файлов, созданных в пп. 2—5.

Для каждого варианта в пп. 5—8 результаты вызова get_local_size () и get_get_enqueued_local_size () в каждом из четырех углов NDRange отображаются на экране. Таким образом, мы видим, как происходит разделение NDRange на рабочие группы.

Для предоставленного входного изображения шаг 6 не будет выполнен, поскольку NDRange невозможно разделить без остатка на рабочие группы 16х16. Кроме того, шаги 7 и 8 не будут выполнены для реализаций OpenCL, не поддерживающих OpenCL 2.0.

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

Требования для учебной программы

Для сборки и запуска этой учебной программы нужен ПК, соответствующий следующим требованиям:

• Процессор серии Intel® Core™ с кодовым названием Broadwell
• Microsoft Windows* 8 или 8.1
• Intel® SDK для приложений OpenCL™ версии 2014 R2 или более поздней
• Microsoft Visual Studio* 2012 или более поздней версии

Запуск учебной программы

Учебная программа представляет собой консольное приложение, которое прочитывает входное растровое изображение и записывает выходные растровые изображения для каждой разновидности NDRange, описанной в приведенном выше разделе (кроме шага 3, поскольку в этом случае возникает ошибка). Эта учебная программа поддерживает несколько параметров командной строки:

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

Input file: input.bmp
Output files: output_0.bmp, output_1.bmp, output_2.bmp, output_3.bmp

Device: Intel(R) HD Graphics 5500
Vendor: Intel(R) Corporation

Compiled with OpenCL 1.2 and using a NULL local size:

   Work Item  get_global_id()  get_local_size()  get_enqueued_local_size()
---------------------------------------------------------------------------
    Top left       (  0,   0)        (  1, 239)                  undefined
   Top right       (637,   0)        (  1, 239)                  undefined
 Bottom left       (  0, 477)        (  1, 239)                  undefined
Bottom right       (637, 477)        (  1, 239)                  undefined


Compiled with OpenCL 1.2 and using an even local size:

Trying to launch a non-uniform workgroup with a kernel compiled using
OpenCL 1.2 failed (as expected.)

Compiled with OpenCL 2.0 and using a NULL local size:

   Work Item  get_global_id()  get_local_size()  get_enqueued_local_size()
---------------------------------------------------------------------------
    Top left       (  0,   0)        (  1, 239)                 (  1, 239)
   Top right       (637,   0)        (  1, 239)                 (  1, 239)
 Bottom left       (  0, 477)        (  1, 239)                 (  1, 239)
Bottom right       (637, 477)        (  1, 239)                 (  1, 239)


Compiled with OpenCL 2.0 and using an even local size:

   Work Item  get_global_id()  get_local_size()  get_enqueued_local_size()
---------------------------------------------------------------------------
    Top left       (  0,   0)        ( 16,  16)                 ( 16,  16)
   Top right       (637,   0)        ( 14,  16)                 ( 16,  16)
 Bottom left       (  0, 477)        ( 16,  14)                 ( 16,  16)
Bottom right       (637, 477)        ( 14,  14)                 ( 16,  16)


Done!

Входное изображение имеет размер 640x480, поэтому размер NDRange в каждом случае составит 638x478. Приведенный выше результат показывает, что запуск ядра OpenCL 1.2 со значением NULL параметра local_sizeвынуждает использовать нечетные размеры для каждой рабочей группы (1, 239). Размеры рабочих групп, не являющиеся степенями двойки, могут работать очень медленно в некоторых ядрах. Конвейеры SIMD могут простаивать, синхронный доступ к памяти может нарушиться.

Запуск ядра OpenCL 1.2 с указанным размером рабочей группы (16x16) выдает ошибку, поскольку ни 648, ни 478 не делятся нацело на 16.

Запуск ядра OpenCL 2.0 со значением NULL параметра local_sizeпозволяет выполняемому модулю OpenCL разделить NDRange на рабочие группы любого размера. Выше показан результат: видно, что выполняемый модуль продолжает использовать однородный размер рабочих групп точно так же, как для ядра OpenCL 1.

Запуск ядра OpenCL 2.0 с заданным размером рабочей группы (16x16) приведет к тому, что размер NDRange будет разделен на неоднородные рабочие группы. Мы видим, что левая верхняя рабочая группа имеет размер 16х16, правая верхняя — 14х16, левая нижняя — 16х14 и правая нижняя — 14х14. Поскольку в большинстве случаев размер рабочей группы составляет 16х16, это ядро будет очень эффективно использовать конвейеры SIMD и доступ к памяти будет очень быстрым.

Справочные материалы

1. Intel® SDK для приложений OpenCL™ — руководство по оптимизации
2. Спецификация API Khronos OpenCL 2.0
3. Спецификация Khronos OpenCL 2.0 для языка C

Download PDF      Download Code

Для новичков в области программирования на OpenCL раздел в спецификации OpenCL 2.0, касающийся этой темы, может показаться слишком академичным и малопонятным. Коротко говоря, функции рабочих групп включают три классических алгоритма уровня рабочих групп (value broadcast, reduce и scan), а также две встроенные функции, проверяющие логический результат операции, проведенной для всей рабочей группы. Алгоритмы reduce и scan поддерживают операции add, min и max.

Описание функций рабочих групп

Для новичков в области программирования на OpenCL раздел в спецификации OpenCL 2.0, касающийся этой темы, может показаться слишком академичным и малопонятным. Коротко говоря, функции рабочих групп включают три классических алгоритма уровня рабочих групп (value broadcast, reduce и scan), а также две встроенные функции, проверяющие логический результат операции, проведенной для всей рабочей группы. Алгоритмы reduce и scan поддерживают операции add, min и max.

Функциональность встроенных функций рабочих групп очевидна из названий:

• work_group_broadcast() распространяет значение выбранного рабочего элемента на все элементы рабочей группы
• work_group_reduce()вычисляет значения sum, minили maxдля всех элементов рабочей группы, а затем распространяет полученное значение на все элементы рабочей группы
• work_group_scan()  вычисляет значения sum, minили maxдля всех предшествующих рабочих элементов (с возможным включением текущих)
• work_group_all()возвращает логическое И для одинакового логического выражения, вычисленного для каждого рабочего элемента
• work_group_any()действует аналогично work_group_all(), но использует логическое ИЛИ

Важное ограничение, касающееся перечисленных встроенных функций: они действуют только для скалярных типов данных (например, популярные типы int4 и float4 не поддерживаются). Кроме того, не поддерживаются 8-разрядные типы данных, такие как char или uchar.

Полное описание см. в главе 6.13.15 спецификации OpenCL 2.0 C.

Функции рабочих групп, что следует из их названия, всегда работают параллельно для целой рабочей группы. Из этого проистекает неявное следствие: любой вызов функции рабочей группы действует в качестве барьера.

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

Пример

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

Простое ядро OpenCL для выполнения этой задачи может выглядеть так:

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

Соответствующий код показан ниже:

__kernel void Calc_wg_offsets_naive(

__kernel void Calc_wg_offsets_naive(
                            __global const uint* gHistArray,
                            __global uint* gPrefixsumArray,
                            uint bin_size
                            )
{
    uint lid = get_local_id(0);
    uint binId = get_group_id(0);

    //calculate source/destination offset for workgroup
    uint group_offset = binId * bin_size;
    local uint maxval;

    //initialize cumulative prefix
    if( lid == 0 )  maxval = 0;
    barrier(CLK_LOCAL_MEM_FENCE);

    do
    {
        //perform a scan for every workitem
        uint prefix_sum=0;
        for(int i=0; i<lid; i++)
            prefix_sum += gHistArray[group_offset + i];

        //store result
        gPrefixsumArray[group_offset + lid] = prefix_sum + maxval;
        prefix_sum += gHistArray[group_offset + lid];

        //update group offset and cumulative prefix
        if( lid == get_local_size(0)-1 )  maxval += prefix_sum;
        barrier(CLK_LOCAL_MEM_FENCE);

        group_offset += get_local_size(0);
    }
    while(group_offset < (binId+1) * bin_size);
}

Такой примитивный подход крайне неэффективен в большинстве случаев (кроме очень маленьких рабочих групп). Очевидно, что внутренний цикл for()выполняет слишком много избыточных операций загрузки и сложения; эту процедуру явно можно оптимизировать. Причем с увеличением размера рабочей группы возрастает и избыточность. Для более эффективного использования аппаратных ресурсов Intel HD Graphics требуется более эффективный алгоритм, например Blelloch. Мы не будем подробно его рассматривать: он замечательно описан в классической статье GPU Gems - http://http.developer.nvidia.com/GPUGems3/gpugems3_ch39.html.

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

#define WARP_SHIFT 4
#define GRP_SHIFT 8
#define BANK_OFFSET(n)     ((n) >> WARP_SHIFT + (n) >> GRP_SHIFT)

__kernel void Calc_wg_offsets_Blelloch(__global const uint* gHistArray,
                              __global uint* gPrefixsumArray,
                              uint bin_size
                              ,__local uint* temp
                            )
{
    int lid = get_local_id(0);
    uint binId = get_group_id(0);
    int n = get_local_size(0) * 2;

    uint group_offset = binId * bin_size;
    uint maxval = 0;
    do
    {
        // calculate array indices and offsets to avoid SLM bank conflicts
        int ai = lid;
        int bi = lid + (n>>1);
        int bankOffsetA = BANK_OFFSET(ai);
        int bankOffsetB = BANK_OFFSET(bi);

        // load input into local memory
        temp[ai + bankOffsetA] = gHistArray[group_offset + ai];
        temp[bi + bankOffsetB] = gHistArray[group_offset + bi];

        // parallel prefix sum up sweep phase
        int offset = 1;
        for (int d = n>>1; d > 0; d >>= 1)
        {
            barrier(CLK_LOCAL_MEM_FENCE);
            if (lid < d)
            {
                int ai = offset * (2*lid + 1)-1;
                int bi = offset * (2*lid + 2)-1;
                ai += BANK_OFFSET(ai);
                bi += BANK_OFFSET(bi);
                temp[bi] += temp[ai];
            }
            offset <<= 1;
        }

        // clear the last element
        if (lid == 0)
        {
            temp[n - 1 + BANK_OFFSET(n - 1)] = 0;
        }

        // down sweep phase
        for (int d = 1; d < n; d <<= 1)
        {
            offset >>= 1;
            barrier(CLK_LOCAL_MEM_FENCE);

            if (lid < d)
            {
                int ai = offset * (2*lid + 1)-1;
                int bi = offset * (2*lid + 2)-1;
                ai += BANK_OFFSET(ai);
                bi += BANK_OFFSET(bi);

                uint t = temp[ai];
                temp[ai] = temp[bi];
                temp[bi] += t;
            }
        }
        barrier(CLK_LOCAL_MEM_FENCE);

        //output scan result to global memory
        gPrefixsumArray[group_offset + ai] = temp[ai + bankOffsetA] + maxval;
        gPrefixsumArray[group_offset + bi] = temp[bi + bankOffsetB] + maxval;

        //update cumulative prefix sum and shift offset for next iteration
        maxval += temp[n - 1 + BANK_OFFSET(n - 1)] + gHistArray[group_offset + n - 1];
        group_offset += n;
    }
    while(group_offset < (binId+1) * bin_size);
}

Как правило, такой код работает эффективнее и образует не столь высокую нагрузку на аппаратные ресурсы, но с некоторыми оговорками.

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

Кроме того, обратите внимание на усложнение кода и дополнительную логику, предназначенную для исключения конфликтов в общей локальной памяти (например, макрос BANK_OFFSET).

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

__kernel void Calc_wg_offsets_wgf(
                            __global const uint* gHistArray,
                            __global uint* gPrefixsumArray,
                            uint bin_size
                            )
{
    uint lid = get_local_id(0);
    uint binId = get_group_id(0);

    uint group_offset = binId * bin_size;
    uint maxval = 0;

    do
    {
        uint binValue = gHistArray[group_offset + lid];
        uint prefix_sum = work_group_scan_exclusive_add( binValue );
        gPrefixsumArray[group_offset + lid] = prefix_sum + maxval;

        maxval += work_group_broadcast( prefix_sum + binValue, get_local_size(0)-1 );

        group_offset += get_local_size(0);
    }
    while(group_offset < (binId+1) * bin_size);
}

Результаты производительности обоих оптимизированных алгоритмов измерены для достаточно большого объема входных данных (каждая рабочая группа сканирует 65 536 элементов, что, в зависимости от локального размера, соответствует 8192 … 2048 итерациям внешнего цикла).

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

Если задать оптимальный размер рабочей группы для заданного алгоритма, то сравнение ядер будет таким:

Обратите внимание, что применение work_group_scan_exclusive_add() значительно повышает производительность рабочей группы любого размера и одновременно упрощает код.

Заключение

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

By Raghvendra Maloo

Введение

Компьютеры-моноблоки уже много лет используются и дома, и в офисах: они обладают неплохой вычислительной мощностью и большим экраном, но при этом не занимают много места. С появлением операционной системы Microsoft Windows* 8 моноблоки, помимо традиционных клавиатур и мышей, получили и современные возможности сенсорного управления. А сейчас появились устройства нового типа, в которых эти возможности расширены, — портативные моноблоки (pAIO).

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

• Пользовательские интерфейсы с мультисенсорным вводом для одновременной работы нескольких пользователей
• Многорежимное взаимодействие на основе голосового управления и использо-вания камеры для распознавания жестов
• Многоцелевое использование устройств, например использование смартфонов в качестве игровых контроллеров
• Использование Intel® Wireless Display (WiDi) для вывода изображения игры или приложения на ТВ высокой четкости
• Технология Intel Rapid Start для быстрого возобновления работы системы

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

Правило № 1. Изучите возможности платформы портативных моноблоков

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

Переносные моноблоки во многом схожи с обычными моноблоками. Системы на базе процессоров Intel обладают рядом важных характеристик, расширяющих возможности разработчиков и конечных пользователей. Переносные моноблоки поддерживают стационарную и адаптивную установку. Механизм наклона экрана поддерживает возможность установки в вертикальном, наклонном и горизонтальном положении. Размер экрана составляет от 18,4 до 27 дюймов (см. рис. 1). Моноблоки оборудуются сенсорными экранами, поддерживающими не менее 10 одновременных точек касания. Встроенные аккумуляторы обеспечивают ограниченную мобильность таких систем. Возможность работы в горизонтальном положении открывает пути для разработки принципиально новых программ, в полной мере использующих все преимущества мультисенсорных многопользовательских программ на больших экранах.

Рисунок 1.Среды разработки приложений для Windows 8.

Семейство процессоров Intel® Core™ обеспечивает высокую производительность и возможность использования великолепных визуальных эффектов, необходимых для полнофункционального применения многопользовательских мультисенсорных приложений на моноблоках в различных категориях: в играх, обучении, развлече¬ниях, здравоохранении, — для создания содержимого и просто для получения информации. Разработчики приложений могут в полной мере положиться на мощь процессоров Intel Core: приложения будут работать быстро и плавно (см. таблицу 1).

Новые современные технологии также раскрывают возможности переносных моноблоков. С появлением новых процессоров Intel Core 4-го поколения переносные моноблоки смогли воспользоваться новыми технологиями этой платформы, включая технологии Intel Rapid Start, Intel Smart Connect и не только их. Технология Intel Rapid Start позволяет быстро возобновлять работу из состояния глубокого сна (примерно за 6 секунд). Основные преимущества:

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

Технология Intel Smart Connect поддерживает более полезное состояние сна: система периодически пробуждается, чтобы обновить данные всех открытых приложений. После обновления содержимого система вновь возвращается в состояние сна.

Таблица 1.Сравнение процессоров.

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

Windows 8 поддерживает две разные среды разработки, каждая из которых обладает определенным набором средств разработки, набором компонентов и возможностей, определенным уровнем совместимости с прежними версиями Windows и определенной моделью распространения и продаж.

Приложения для Windows 8 можно создавать с помощью различных языков программирования и инструментов. Можно создавать компоненты на одном языке и использовать их в приложении, написанном на другом языке программирования. Тем не менее на самом раннем этапе разработки нужно принять решение и выбрать тип разрабатываемого приложения; это может быть приложение для Магазина Windows либо приложение рабочего стола Windows (см. рис. 2).

Приложения рабочего стола работают в классическом режиме Windows 8. Этот режим похож на традиционную среду Windows, но интерфейс различается. В классическом режиме поддерживается и сенсорное управление, и датчики. Кроме того, некоторые драйверы оборудования и некоторые возможности устройств, например Intel® Wireless Display (Intel® WiDi) и OpenGL*, в настоящее время доступны только для приложений рабочего стола.

Приложения для Магазина Windows используют новые API WinRT и разрабатываются в среде Visual Studio* 2012 на языках C++, C# или с помощью веб-технологий, таких как HTML5, JavaScript* и CSS3.

Рисунок 2.Среды разработки приложений для Windows* 8

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

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

Таблица 2. Функциональная совместимость приложений для Магазина Windows* и приложений рабочего стола.

Правило № 3. Реализация сенсорного управления крайне важна для создания привлекательных приложений для портативных моноблоков

В Windows 8 предусмотрены гибкие возможности и для приложений для Магазина Windows, и для приложений рабочего стола

Сенсорное управление — это интуитивный, привлекательный и естественный способ взаимодействия пользователей с приложением. Пользовательский мультисенсорный интерфейс многопользовательских приложений на переносных моноблоках на базе процессоров Intel Core опирается на современную модель использования сенсорного управления как неотъемлемую часть общей архитектуры решения. К счастью, корпорация Майкрософт предоставила сенсорные API для поддержки и классических приложений, и приложений для Магазина Windows.  

Приложения для Windows Store

В Windows поддерживается два набора API для создания приложений для Магазина Windows: среда выполнения Windows (WinRT) и библиотека Windows для JavaScript (WinJS).

Среда исполнения Windows.Эти API JavaScript, C#, Visual Basic* и C++ предоставляют доступ ко всем основным функциям платформы.

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

Библиотека Windows для JavaScript. WinJS предоставляет библиотеку API JavaScriptс элементами управления, стилями CSS и вспомогательными функциями для написания кода. Пространство имен WinJS покрывает функци­ональность, близкую к пространствам имен Windows.UI.XAML в среде WinRT.

Приложения рабочего стола для Windows 8

Приложения рабочего стола работают в классическом режиме Windows 8. В приложениях рабочего стола для Microsoft Windows 8 можно реализовать поддержку сенсорного ввода и жестов тремя способами:

• WM_POINTER — самый простой с точки зрения написания кода и поддерживает самый широкий набор жестов, но работает только под управлением Windows 8. Сообщения WM_POINTER используются для получения сенсорного ввода сообщения, а для распознавания жестов и манипуляций — функции контекста взаимодействия.
• Для WM_GESTURE также несложно писать код; в этом случае поддерживается обратная совместимость с Windows 7, но накладывается больше всего ограничений.
• WM_TOUCH предоставляет полное решение для поддержки сенсорного управления в Windows 7 с обратной совместимостью. Оно уведомляет приложение о каждом событии касания, а ваш код должен собирать эти события и распознавать соответствующие жесты.

Существует довольно распространенное заблуждение: якобы невозможно разрабатывать приложения, работающие с сенсорным вводом и датчиками, для классического режима Windows 8. Это неверно. Кроме того, некоторые драйверы оборудования и некоторые возможности устройств, например WiDi и OpenGL*, в настоящее время доступны только для приложений рабочего стола.

Многорежимное взаимодействие

В приложениях рабочего стола для Windows 8, включая и игры, можно применить многорежимное взаимодействие, основанное на применении голосового управления и распознавания жестов камерой. Разработчики могут рассмотреть возможность использования Intel^® RealSense SDK для поддержки многорежимного взаимодействия на переносных моноблоках. Кроме того, разработчики могут использовать Intel^® Common Connectivity Framework (Intel^® CCF) для поддержки сценариев с одновременным использованием нескольких устройств: дополнительные устройства, например смартфоны, можно использовать в качестве контроллеров для игр, запущенных на моноблоке.

Программные платформы и тестирование

Разработчики игр для классического интерфейса Windows 8 получают в свое распоряжение широкий набор существующих программных платформ и средств тестирования. Эти средства помогают ускорить цикл разработки, оптимизировать производительность и отладить сенсорные интерфейсы приложений для моноблоков (см. таблицу 3).

Таблица 3.Программные платформы и средства тестирования приложений рабочего стола для Windows* 8

Правило № 4. Поставьте себя на место пользователя

Проектирование многопользовательских мультисенсорных приложений для больших горизонтальных экранов требует другого мышления, это уже не экран телефона!

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

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

Таблица 4.Примеры использования в многопользовательских играх

Расположение пользователя

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

• На раннем этапе проектирования нужно четко определить количество и тип пользователей. Потребуется ли каждому пользователю отдельный набор элементов управления (как в большинстве игр) или будет достаточно одного набора элементов управления?
• Наиболее удобные цели касания должны быть у краев экрана.
• У нескольких игроков в любой момент времени может быть несколько точек фокуса

Огромное значение имеют пользовательские средства управления

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

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

Приложения должны быть увлекательными и интересными

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

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

Заключение

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

About the Author

Raghvendra Maloo is a Senior System Software Engineer in the PCCG Innovation Development Vehicle (IDV) team. He is a Microsoft Windows Expert and currently working on Touch and Stylus software stack of IDV Reference Systems. Raghvendra’ s focus areas includes Multi User Multi Touch experience on the All-in-One Form Factor Systems. Before joining Intel, Raghvendra worked for Microsoft as a Software Design Engineer for its Office Mobile Products. Raghvendra owns multiple patents and publications in the field of Touch Sensors, New User Experiences and Parallel Computing. Raghvendra was also a speaker in Intel Developer Forum 2013 presenting Software Development Opportunities for All-in-One Systems

Проектирование и разработка:

1. Проектирование для ультрабуков и сенсорных настольных приложений:
   http://software.intel.com/en-us/articles/designing-for-ultrabook-devices-and-touch-enabled-desktop-applications
2. Разработка с использованием API классического интерфейса:
   http://software.intel.com/en-us/articles/developing-with-desktop-natural-user-interface-api-s-for-developers
3. Средства разработки приложений рабочего стола для Windows:
   http://software.intel.com/en-us/articles/designer-tools-for-windows-desktop-applications
4. Преобразование приложений для ультрабуков — сенсорные интерфейсы:
   http://software.intel.com/en-us/blogs/2012/08/09/re-imagining-apps-for-ultrabook-part-1-touch-interfaces/
5. Принципы проектирования сенсорных интерфейсов — позы и целевые объекты касания:
   http://software.intel.com/en-us/blogs/2012/08/29/touch-design-principles-part-2-postures-and-touch-targets
6. Поддержка сенсорного управления в приложениях для Windows* 8 на языке C#:
   http://software.intel.com/en-us/articles/enabling-touch-in-windows-8-metro-style-apps-with-c
7. Сенсорное управление. Создание современных приложений для ультрабуков:
   http://software.intel.com/en-us/articles/the-human-touch-building-ultrabook-applications-in-a-post-pc-age
8. Обработка сенсорного ввода в приложениях для Windows* 8:
   http://software.intel.com/en-us/articles/handling-touch-input-in-windows-8-applications
9. Кнопки интерфейса с поддержкой сенсорного управления:
   http://software.intel.com/en-us/articles/touch-friendly-control-buttons-bubbles-2
10. Образцы реагирования на касания:
    http://software.intel.com/en-us/articles/touch-reactive-sample-bubbles
11. Центр разработчиков Windows 8.1:
    http://msdn.microsoft.com/en-us/windows/apps/br229516
12. Руководство пользователя по технологии Intel Rapid Start:
    http://download.intel.com/support/motherboards/desktop/sb/rapid_start_technology_user_guide.pdf 

13. Технология Intel^® Smart Connect:
    http://www.intel.com/content/www/us/en/architecture-and-technology/smart-connect-technology.html

Образцы кода:

1. Сравнение методик написания кода для обработки сенсорного ввода — образец приложения рабочего стола для Windows 8:
   http://software.intel.com/en-us/articles/comparing-touch-coding-techniques-windows-8-desktop-touch-sample
2. Образцы сенсорных приложений:
   http://software.intel.com/en-us/articles/touch-samples
3. Разработка приложений для ультрабуков под управлением Windows* 8 — приложения для обработки фото с сенсорным управлением и датчиками:
   http://software.intel.com/en-us/articles/photo-application-for-ultrabook-and-windows-8-desktop-applications-development-with-touch-and-sensors
4. Образец приложения рабочего стола Windows с управлением при помощи сенсорного ввода и камеры:
   http://software.intel.com/en-us/articles/windows-desktop-touch-camera-sample-whitepaper

© Intel Corporation, 2013.  Все права защищены.

Intel, эмблема Intel, AppUp, Core, InTru и Ultrabook являются товарными знаками корпорации Intel в США и в других странах.

* Прочие наименования и товарные знаки могут быть собственностью третьих лиц.

^† OpenCL и эмблема OpenCL являются товарными знаками Apple Inc. и используются с разрешения Khronos.

¹ (Технология Intel^® Turbo Boost) Требуется система, поддерживающая технологию Intel^® Turbo Boost. Технологии Intel Turbo Boost и Intel Turbo Boost 2.0 доступны только на некоторых процессорах Intel^®. Обратитесь к изготовителю устройства. Производительность может различаться в зависимости от оборудования, программ и конфигурации системы. Дополнительные сведения см. по адресу www.intel.com/go/turbo.

² (Гиперпоточность) Требуется система с поддержкой технологии гиперпоточности Intel^®; обратитесь к изготовителю компьютера. Производительность может различаться в зависимости от использованного оборудования и программ. Доступно не на всех процессорах Intel^®. Дополнительные сведения, в том числе и сведения о том, какие процессоры поддерживают технологию гиперпоточности Intel, см. по адресу http://www.intel.com/go/ht.

³ (Quick Sync Video — 3-летний базовый показатель) Перекодирование видео с помощью CyberLink* MediaEspresso 6 для отображения видеофайла в формате MPG2 длительностью 4 минуты, объемом 449 МБ, с разрешением 1920 x 1080i и скоростью потока 18 884 Кбит/с для воспроизведения на Apple iPod* с разрешением 640 x 360, кодек H.264, формат файла MP4. Ускорение в 4 раза на процессорах Intel^® Core™ третьего поколения i5-3450 (настольный ПК) и Intel^® Core™ i5-3320M (ноутбук) по сравнению с процессорами Intel^® Core™ (настольный ПК), Intel^® Core™2 Duo E8400 (настольный ПК) и P8600 (ноутбук).

⁴ (Встроенная графика) Встроенные компоненты обработки графики доступны не на всех ПК. Может требоваться оптимизированное программное обеспечение. Обратитесь к изготовителю системы. Подробные сведения см. по адресу http://www.intel.com/go/biv.

⁵ (Intel^® Wireless Display) Требуется ПК, планшет или смартфон, поддерживающий Intel^® Wireless Display, а также совместимый адаптер и телевизор. Воспроизведение видео высокой четкости в формате 1080p и Blu-ray* или другого защищенного содержимого поддерживается некоторыми процессорами Intel^®со встроенной графикой. Обратитесь к изготовителю ПК. Дополнительные сведения см. по адресу www.intel.com/go/widi.

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

Содержание

Введение 
Новые возможности, представленные в выпуске Intel® AMT 10.0
Подготовка клиента Intel® AMT к использованию
Советы по настройке вручную
Режим управления для клиента и режим управления для администратора
Доступ к Intel® AMT через веб-интерфейс
Intel® AMT LMS, UNS и IMSS
Пакет средств для разработки ПО на основе Intel® AMT
Другие ресурсы

Введение

Технология Intel^® Active Management Technology¹ (Intel^® AMT) — один из компонентов технологии Intel^® vPro™². Платформы, оснащенные Intel AMT, поддерживают удаленное управление, даже если операционная система недоступна или компьютер выключен. Системы, в которых активирована технология Intel^® AMT, поддерживают внеполосный доступ к сети через беспроводную (или проводную) сеть Intel^®. Благодаря этому они предоставляют приложениям для удаленного управления платформой безопасный доступ при условии, что платформа подключена к линии электроснабжения и к сети. Независимые поставщики ПО получили возможность создавать приложения, эффективно использующие функции Intel AMT, с помощью пакета средств для разработки ПО на основе Intel AMT. В данный пакет входит высокоуровневый API-интерфейс Intel AMT (Intel AMT HLAPI) — очень простой, единообразный API-интерфейс для всех версий AMT и ассортиментных позиций Intel. Дополнительная информация приводится в документации HLAPI, представленной в данном SDK.  Данный пакет средств для разработки ПО также включает Intel vPro Platform Solution Manager — консоль управления на основе API-интерфейса Intel AMT HLAPI.
Intel AMT использует несколько элементов архитектуры платформы Intel vPro, в частности Intel^® Management Engine (Intel^® ME), один из компонентов микропрограммы (поставляемый производителем системы вместе с BIOS). Данная микропрограмма использует небольшую долю ОЗУ системы, и поэтому, чтобы выполнять ее, необходимо заполнить и активировать слот 0. Микропрограмма также оснащена собственной флеш-памятью, в которой хранятся параметры конфигурации и другие данные.

Примечание. Чтобы использовать возможности внеполосного управления Intel AMT, необходимо использовать Intel^® Ethernet или к беспроводной Intel адаптер, поддерживающей подключение к микропрограмме Intel ME. 
Обратите внимание, что для использования выпуска Intel AMT 10.0 на платформу необходимо установить 10 версию микропрограммы Intel ME и драйвера. Драйвер 10.0 может быть установлен в системах, изначально использовавших микропрограммы 8.x. 9.x или 10.0.  Всегда используйте микропрограмму, предоставленную поставщиком системы.

Intel AMT поддерживает удаленные приложения, выполняемые в ОС Microsoft Windows* или Linux*; в то же время данная технология поддерживает локальные приложения только для ОС Windows. Полный список требований к системе приводится в документации, включенной в последний Intel® AMT Software Development Kit (SDK), а также в Руководстве по внедрению и применению Intel^® AMT, которое находится в папке Docs.

Новые возможности, представленные в выпуске Intel^® AMT 10.0:

 Примечание. Выпуск Intel AMT 10 обратно совместим с системами, в которых используются чипсеты Intel^®серий 7, 8 и 9.

• Самое важное изменение   OpenSSL* теперь используется без флага пульсации. По этой причине в системах, обновленных до выпуска AMT10, необходимо аннулировать и повторно оформить сертификаты, а также изменить пароли. 
• В инструмент приложения HLAPI и KVM добавлена функция очистки экрана клиента Intel AMT (при удаленном доступе).
• Обновленные файлы MOF и XSL, как и справочное описание класса, теперь относятся к версии 10.0.25.1048.
• Версия Real VNC* в Linux и KVM обновлена до 1.2.5.
• Connected Standby/InstantGo в ОС Windows поддерживаются для Windows 7 и более поздних версий (также доступны в HLAPI).
• Корректные операции управления питанием поддерживаются на 32-разрядных
  и 64-разрядных платформах Windows Vista, 7 и 8, включая (в Windows 8) режимы Connected Standby/InstantGo, а также генерирование событий UNS.
  Эта возможность также добавлена в API-интерфейс HLAPI.
• Теперь поддерживается инициализация в режимах управления для администратора и для клиента с защищенными именами FQDN.
  Дополнительная информация приводится в примечаниях к релизу.

Подготовка клиента Intel^® AMT к использованию    

Процесс настройки (инициализации) клиента AMT включает переключение клиента из режима установки и настройки в рабочий режим. Для перехода в режим настройки необходимо, чтобы поставщик системы настроил первоначальную информацию (которая зависит от версии AMT).  Для активации технологии Intel AMT необходимо расширение Intel^® Manageability Engine BIOS (Intel^® MEBx), внедренное поставщиком системы. Для установки и настройки можно использовать приложение для удаленного управления. Для разных версий AMT предусмотрены разные способы установки. Дополнительная информация приводится в документации по установке и настройке.

Выпуски AMT                                                                 Способ установки   
1.x; плюс 2.x, 3.x в старом режиме                              Старый
2.x, 3.x, 4.x, 5.x                                                               SMB
2.0 и более поздние версии                                          PSK
2.2, 2.6, 3.0 и более поздние версии                            PKI  (удаленно)      
6.0 и более поздние версии                                          Вручную      
7.0 и более поздние версии                                          Режим управления для клиента и режим управления для администратора
10.0                                                                                 Теперь поддерживаются безопасные имена FQDN

ПО Intel® Setup and Configuration Software (Intel® SCS) может выполнять инициализацию систем версии Intel AMT 2.X. Дополнительная информация о ПО Intel SCS и способах инициализации для разных выпусков Intel AMT приводится на странице: Загрузка последней версии Intel® Setup and Configuration Service (Intel® SCS).

Советы по ручной настройке

Настройка вручную выполняется в меню Intel MEBx, которое становится доступно сразу после отображения экрана запуска BIOS (обычно для этого необходимо нажать клавиши <Ctrl+P>). Иногда BIOS предоставляет возможность скрыть приглашение на нажатие <Ctrl+P>. 

Чтобы вручную настроить клиент Intel AMT, выполните следующие действия:

1. Введите пароль Intel MEBx по умолчанию (admin).
2. Замените пароль Intel MEBx по умолчанию новым безопасным паролем (обязательно).  Данный пароль должен содержать не менее восьми символов и как минимум одну заглавную букву, одну строчную букву, одну цифру и один специальный символ. Примечание. Приложение консоли управления может изменить пароль Intel AMT, не изменяя пароль Intel MEBx.
3. Выберите пункт Intel^® AMT Configuration (Настройка Intel^® AMT).
4. Выберите Manageability Feature Selection (Выборфункцийуправления).
   1. Выберите ENABLED (ВКЛЮЧЕНО), чтобы активировать технологию Intel^® AMT.
5. Выберите SOL/IDE-R/KVM и активируйте все эти функции. Включение режима Legacy Redirection Mode (Режим перенаправления старых устройств) обеспечивает совместимость с консолями управления, созданными для работы со старым режимом SMB, который не оснащен механизмом включения приемника. Обратите внимание, что, если в Intel MEBx не включены функции SOL/IDER/KVM, они будут недоступны для консолей управления.
6. Выберите User Consent (Разрешение пользователя).
   1. Выберите нужные параметры для операций KVM и Remote IT (Удаленное управление ИТ). Если включен режим разрешения пользователя, каждый раз при удаленном доступе к клиенту Intel AMT необходимо будет получить разрешение пользователя.
7. Введите Network Setup (Настройка сети), чтобы задать параметры сети для Intel ME.
8. Введите Activate Network Access (Активировать доступ к сети), чтобы включить Intel AMT.
9. Вернитесь в главное меню.
10. Выберите MEBx Exit (Выйти из MEBx), чтобы продолжить процесс загрузки системы.

Платформа настроена. Дополнительные параметры можно задать с помощью веб-интер­фейса или приложения консоли удаленного управления.

Режим управления для клиента и режим управления для администратора

По завершении установки, вне зависимости от способа, Intel AMT 7.0 и более поздние версии переходят в один из двух режимов управления.

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

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

1. Функция защиты системы недоступна.
2. Для выполнения действий перенаправления (IDE-R и KVM, но не инициирование сеанса SOL) и изменения параметров загрузки (включая загрузку в SOL) необходимо предварительно получить разрешение пользователя. Однако и в этом случае
   ИТ-специалисты могут удаленно решать проблемы конечного пользователя с помощью Intel AMT.
3. Если создана учетная запись аудитора, то для отмены инициализации разрешение аудитора не требуется.
4. Ряд функций заблокирован, чтобы не позволить ненадежному пользователю управлять платформой.
   
   Примечание. В AMT 9.0 и последующие версии добавлена возможность удаленно настраивать платформу, не оснащенную средствами контроля, без разрешения локального пользователя.

Доступ к клиентам Intel^® AMT через веб-интерфейс

Администратор с правами пользователя может удаленно подключиться к клиенту Intel AMT через веб-интерфейс, если введет в адресную строку браузера IP-адрес или имя FQDN клиента, а затем номер порта.  Если протокол TLS НЕ настроен, используйте http и порт 16992; в противном случае используйте https и порт 16993:      

           Пример. http://134.134.176.1:16992     или     https://amtsystem.domain.com:16993

Чтобы получить доступ к клиенту Intel AMT по технологии Serial Over LAN (SOL), необходимо установить драйвер SOL. 

Службы локального управления (LMS) и уведомления пользователей (UNS) Intel AMT

Служба локального управления (LMS) выполняется локально на устройстве Intel AMT и позволяет локальным приложениям для управления отправлять запросы и принимать ответы устройства. LMS прослушивает и перехватывает запросы, направленные на локальный сервер Intel AMT, чтобы затем передать их в Intel ME через драйвер интерфейса Intel ME.

Обратите внимание, что в Intel AMT 9.0 и более поздних выпусках службы локального управления и уведомления пользователей объединены. UNS регистрируется на устройстве Intel AMT для получения набора оповещений. Получив оповещение, UNS заносит его в журнал событий Windows Application. В качестве источника событий указывается Intel^® AMT.

Инструмент состояния управления и безопасности Intel (IMSS)

Чтобы получить доступ к инструменту IMSS, воспользуйтесь значком «синей кнопки» в области уведомлений Windows.

На вкладке General (Общие) в инструменте IMSS указано состояние служб Intel vPro, доступных на платформе, а также хронология событий. На других вкладках представлены дополнительные сведения.

На вкладке Advanced (Дополнительно) инструмента IMSS представлена более подробная информация о конфигурации и функциях Intel AMT. Представленный ниже снимок экрана подтверждает, что в системе настроена Intel AMT.

Intel AMT Software Development Kit (SDK)

Intel® AMT Software Development Kit (SDK) обеспечивает низкоуровневые возможности программирования, с помощью которых можно создавать приложения для управления, использующие все функции Intel AMT.

Пакет средств для разработки ПО на основе Intel AMT представляет собой образец кода и набор API-интерфейсов, позволяющих разработчикам просто и быстро добавить в приложения поддержку Intel AMT. Помимо этого, в пакет входит полный набор документации. Данный пакет средств для разработки ПО поддерживает C++ и C# в операционных системах Microsoft Windows и Linux. Важная информация по сборке образцов приведена в Руководстве пользователя и в файлах Readme в каждом из каталогов. 

SDK предоставляется как набор каталогов, который можно скопировать в любое выбранное место в системе для разработки. Поскольку компоненты взаимосвязаны, структуру каталога необходимо копировать целиком. На верхнем уровне находятся три папки, одна из которых называется DOCS (документация). Две другие содержат образец кода для Linux и для Windows. Дополнительная информация по началу работы и использованию данного пакета средств для разработки ПО приводится в "Руководстве по внедрению и применению Intel® AMT..”

Ниже представлен снимок экрана из «Руководства по внедрению и применению Intel® AMT». Дополнительная информация о требованиях к системе и инструкции по сборке образца кода приводятся в разделе «Использование пакета средств для разработки ПО на основе Intel® AMT SDK». Данная документация представлена в сети Intel® Software Network на этой странице: Пакет средств для разработки ПО на основе Intel® AMT (последний выпуск)

Другие ресурсы информации о Intel AMT SDK

Intel AMT SDK содержит платформы и образцы для упрощенной разработки приложений по стандарту WS-Management. Кроме того, в этот пакет входят примеры использования расширенных возможностей данного продукта. Дополнительная информация приводится на следующих страницах:

• • Высокоуровневый API-интерфейс
• Intel vPro Platform Solution Manager

Существует много разных средств разработки, для которых пишут ПО с поддержкой Intel AMT. Инструменты Intel vPro Enablement Tools доступны только в C++ (оболочка C# в пакете средств для разработки ПО), и для них требуется COM-объект, подготовленный Microsoft (не просто .NET). Примечание. Поддержка SOAP полностью удалена из пакета средств для разработки ПО в AMT 9.0 и более поздних версиях. 

Об авторе

Коллин Калбертсон — инженер-прикладник, работающий в группе Scale Enabling подразделения Intel Developer Relation Division в Орегоне. Ее опыт работы в Intel составляет более 15 лет. Она сотрудничает с различными рабочими группами и заказчиками и помогает разработчикам оптимизировать созданный ими код.

Intel, эмблема Intel и vPro являются товарными знаками корпорации Intel в США и в других странах.

© Intel Corporation, 2014. Все права защищены.
* Прочие наименования и товарные знаки могут быть собственностью третьих лиц.

¹ Intel AMT необходимо активировать. Для применения этой технологии требуется система с подключением к сети Intel, чипсет с поддержкой Intel^® AMT и соответствующее ПО. Для портативных компьютеров технология Intel AMT может быть недоступна или ограниченно доступна через беспроводное подключение к VPN на основе ОС сервера при включении, переходе в режим сна или гибернации либо при выключении. Результаты зависят от оборудования, установки и настройки. За дополнительной информацией обращайтесь на страницу Intel® Active Management Technology.

² Intel^® vPro™ — интеллектуальная технология, которую необходимо установить и активи­ровать. Доступность ее функций и результаты работы с нею будут зависеть от установки
и настроек оборудования, ПО и ИТ-среды. Дополнительную информацию см. на веб-сайте : http://www.intel.com/technology/vpro.

Intel® Software Academic Program

Присоединяйтесь сегодня и создавайте приложения будущего ›

Почему важно присоединиться?

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

Что необходимо сделать, чтобы принять участие?

• Обращайтесь к экспертам корпорации Intel онлайн, а также на образовательных мероприятиях, которые проводятся по всему миру
• Учебные курсы по программированию и ресурсы сообщества для создания учебных программ мирового уровня
• Бесплатный доступ к средствам разработки ПО корпорации Intel
• Возможность получения образовательных грантов

Сколько это стоит?

От вас требуется только заполнить форму заявки и стать участником. Затем вы получите доступ к бесплатным ресурсам программы.

Download as PDF

Download sample code

Кристофер Берд (Christopher Bird), инженер по программному обеспечению

Источник приложений: Intel SSG

Введение

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

В этой статье описываются API-шифрования данных, доступные в Java* или OpenSSL*. Оба решения работают под управлением Android.

Мы рекомендуем пробовать описываемые возможности и компилировать код по мере чтения этой статьи.

Код шифрования данных

Если нужно зашифровать данные в Android, у вас два варианта: API Java Crypto и API OpenSSL. Мы рассмотрим шифрование данных обоими способами.

API Java Crypto

Использовать API Java Crypto в Android очень просто. Сначала нужно создать ключ для шифрования. Для этого используется класс KeyGenerator в пакете javax.crypto.

	mKey = null;
	try {
		kgen = KeyGenerator.getInstance("AES");
		mKey = kgen.generateKey();

	} catch (NoSuchAlgorithmException e) {
		e.printStackTrace();
	}

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

// open stream to read origFilepath. We are going to save encrypted contents to outfile
	InputStream fis = new FileInputStream(origFilepath);
	File outfile = new File(encFilepath);
	int read = 0;
	if (!outfile.exists())
		outfile.createNewFile();

	FileOutputStream encfos = new FileOutputStream(outfile);
	// Create Cipher using "AES" provider
	Cipher encipher = Cipher.getInstance("AES");
	encipher.init(Cipher.ENCRYPT_MODE, mKey);
	CipherOutputStream cos = new CipherOutputStream(encfos, encipher);

	// capture time it takes to encrypt file
	start = System.nanoTime();
	Log.d(TAG, String.valueOf(start));

	byte[] block = new byte[mBlocksize];

	while ((read = fis.read(block,0,mBlocksize)) != -1) {
		cos.write(block,0, read);
	}
	cos.close();
	stop = System.nanoTime();

	Log.d(TAG, String.valueOf(stop));
	seconds = (stop - start) / 1000000;// for milliseconds
	Log.d(TAG, String.valueOf(seconds));

	fis.close();

OpenSSL API

Для шифрования данных с помощью OpenSSL в Android нужно написать собственный код C, доступ к которому в Java осуществляется с помощью вызовов JNI. Здесь требуется больше работы, но и производительность будет выше. 

Сначала нужно создать ключ и вектор инициализации (ВИ).

unsigned char cKeyBuffer[KEYSIZE/sizeof(unsigned char)];
unsigned char iv[] = "01234567890123456";
int opensslIsSeeded = 0;
if (!opensslIsSeeded) {
	if (!RAND_load_file("/dev/urandom", seedbytes)) {
		return -1;
	}
	opensslIsSeeded = 1;
}

if (!RAND_bytes((unsigned char *)cKeyBuffer, KEYSIZE )) {
}

Затем можно использовать полученный ключ (cKeyBuffer) для шифрования файла. Инициализируйте EVP, предоставив ключ и ВИ. Затем подавайте сегменты байтов функции EVP_EncryptUpdate. Последний сегмент байтов файла нужно подать функции EVP_EncryptFinal_ex.

if (!(EVP_EncryptInit_ex(e_ctx, EVP_aes_256_cbc(), NULL, cKeyBuffer, iv ))) {
	ret = -1;
	printf( "ERROR: EVP_ENCRYPTINIT_EXn");
}

// go through file, and encrypt
if ( orig_file != NULL ) {
   	origData = new unsigned char[aes_blocksize];
    	encData = new unsigned char[aes_blocksize+EVP_CIPHER_CTX_block_size(e_ctx)]; // potential for encryption to be 16 bytes longer than original

	printf( "Encoding file: %sn", filename);

	bytesread = fread(origData, 1, aes_blocksize, orig_file);
	// read bytes from file, then send to cipher
	while ( bytesread ) {


		if (!(EVP_EncryptUpdate(e_ctx, encData, &len, origData, bytesread))) {
			ret = -1;
			printf( "ERROR: EVP_ENCRYPTUPDATEn");
		}
		encData_len = len;

		fwrite(encData, 1, encData_len, enc_file );
		// read more bytes
		bytesread = fread(origData, 1, aes_blocksize, orig_file);
	}
	// last step encryption
	if (!(EVP_EncryptFinal_ex(e_ctx, encData, &len))) {
		ret = -1;
		printf( "ERROR: EVP_ENCRYPTFINAL_EXn");
	}
	encData_len = len;

	fwrite(encData, 1, encData_len, enc_file );

	// free cipher
	EVP_CIPHER_CTX_free(e_ctx);

Заключение

Работая с примерами кода, представленными в этом документе, вы можете быстро узнать, как использовать API Java Crypto и OpenSSL для шифрования данных на платформах с процессором Intel^®под управлением Android.

Обавторе

Кристофер Берд (Christopher Bird) — сотрудник отдела Intel Software and Solutions Group (SSG), подразделения Developer Relations Division в составе группы Intel^® Atom^™ Processor Mobile Enabling Team. 

Другие статьи и ресурсы по этой теме:

• Intel Security and Encryption
• Intel Developer Zone - Android

Примечания

Перед размещением заказа получите последние версии спецификаций в региональном офисе продаж Intel или у местного дистрибьютора.

Копии документов с порядковым номером, ссылки на которые приведены в этом документе или в другой документации Intel, можно получить, обратившись по телефону 1-800-548-4725, или на сайте: http://www.intel.com/design/literature.htm

Программное обеспечение и нагрузки, использованные в тестах производительности, могли быть оптимизированы для достижения высокой производительности на микропроцессорах Intel. Тесты производительности, такие как SYSmark* и MobileMark*, проводятся на определенных компьютерных системах, компонентах, программах, операциях и функциях. Любые изменения любого из этих элементов могут привести к изменению результатов. При выборе приобретаемых продуктов следует обращаться к другой информации и тестам производительности, в том числе к тестам производительности определенного продукта в сочетании с другими продуктами.

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

Intel, эмблема Intel и Atom являются товарными знаками корпорации Intel в США и в других странах.

© Intel Corporation, 2014. Все права защищены.

* Прочие наименования и товарные знаки могут быть собственностью третьих лиц.

Приглашаем вас принять участие в конкурсном отборе идей IoT проектов. Авторы самых интересных идей будут приглашены на Intel IoT мастер-класс и получат плату Intel® Edison для реализации прототипа.

До 26 февраля 2015 года необходимо прислать описание своего проекта на адрес swcontest@intel.comс пометкой в заголовке [IoT from Siberia]. В заявку необходимо включить:

1. Подробное описание проекта, в чем состоит его уникальность и инновационность.
2. Технический принцип работы проекта. Проект должен активно использовать основные особенности платформы Edison – высокую производительность и/или беспроводные интерфейсы.
3. Информацию об участниках вашей команды (если есть) и опыте разработки. Мы должны быть уверены в том, что вы сможете реализовать свой проект.

Мы отберем 10 наиболее интересных проектов. Проектные команды будут приглашены на Intel IoT мастер-класс, который состоится в Новосибирском Академгородке 1 марта 2015г. На этом мероприятии вы получите плату Intel® Edison и научитесь ее программировать.

Но и это еще не все!После мастер-класса у вас будет целых два месяца на разработку прототипа. В конце апреля 2015г. вы сможете представить свой проект на форуме Сибирская Индустрия Информационных Систем. Все успешные проекты получат возможность принять участие в маркетинговых программах и международных конкурсах Intel, а самый интересный проект получит специальный приз от Intel.

Дополнительные ресурсы:

• Maker — ваш DIY-справочник по продуктам Intel.
• Практикум «Intel IoT»: Galileo Gen2 — Первое знакомство.
• Практикум «Intel IoT»: Galileo Gen2 — Linux & Arduino.
• Практикум «Intel IoT»: Galileo Gen2 — Eclipse & libmraa+UPM

Download as PDF

Введение

Ультрабуки-трансформеры — это ПК, которые можно переключать между режимом ноутбука (для работы) и режимом планшета (для потребительских целей). В этой статье вы узнаете об аппаратных возможностях трансформеров, о возможностях трансформеров под управлением Windows* 8/8.1 для потребительских и профессиональных задач, а также получите рекомендации по разработке приложений для наибольшего удобства пользователей в каждом режиме.

Содержание

• Разработка приложений для рабочего стола Windows 8/8.1.
• Классификация трансформеров (какие устройства являются трансформерами, а какие нет).
• Модели использования трансформеров.
• Приложения с поддержкой режимов работы трансформеров.
• Рекомендации по разработке приложений для ультрабуков.
• Оценка готовности приложений к работе на трансформерах

Что такое ультрабук-трансформер?

Ультрабук-трансформер — это устройство, которое можно использовать как ноутбук и как планшет. По вычислительной мощности и производительности он не отличается от обычных ноутбуков, что позволяет выполнять всю работу и все задачи по созданию данных без ограничений. Большинство трансформеров также поддерживают сенсорный ввод, оборудованы датчиком и пером. Когда пользователи находятся в поездках и используют устройство соответственно (например, смотрят фильм, играют в игры, проверяют почту или читают книги), они могут переключить трансформер в режим планшета, который не только более удобен, но и устраняет необходимость иметь несколько гаджетов. Длительное время работы трансформеров от аккумулятора дополняет их преимущества.

У настоящих трансформеров клавиатура всегда входит в конструкцию, а в планшетном режиме она либо складывается, либо отсоединяется. Устройства, для которых можно отдельно приобрести клавиатуру, не являются трансформерами. Дополнительные характеристики трансформеров — мощная полнофункциональная операционная система, такая как Windows 8/8.1, и экран размером 10 дюймов или больше.

В следующей таблице перечислены некоторые доступные в данный момент конфигурации трансформеров.

Таблица 1:Доступные варианты конфигурации трансформеров

Что не является ультрабуком-трансформером?

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

• Ноутбуки с сенсорным экраном. Сенсорное управление — новая функция на многих ноутбуках, но их нельзя считать трансформерами, потому что они не переключаются из режима ноутбука в режим планшета; многие из таких устройств имеют слишком большой вес и не обладают различными возможностями планшетов.
• Планшеты под управлением Android*/iOS*/Win RT. К таким устройствам можно подключать приобретаемую отдельно клавиатуру, но такие устройства не поддерживают многозадачность, запуск различных приложений и не имеют совместимости с периферийными устройствами, а потому не могут считаться трансформерами.
• Моноблоки AIO. Это современные устройства, часто используемые для игр, но они не обладают возможностями ноутбука и планшета, встроенными в одно устройство.
• Фаблеты. Устройства этого типа являются промежуточными между телефонами и планшетами, но не обладают такой же вычислительной мощностью, графическими возможностями и способностью долго работать от аккумулятора, как трансформеры, а потому не могут быть считаться таковыми.

Примеры моделей использования

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

Использование потребителем

• Многозадачность или использование одного приложения. Режим ноутбука поддерживает многозадачность и запуск множества приложений одновременно, что менее вероятно в режиме планшета. Обратите внимание, что это различие касается использования устройств в классическом режиме Windows 8. Приложения с современным интерфейсом Windows должны следовать требованиям Windows 8 в отношении «песочницы».
• Игры. Интерактивные игры, поддерживающие клавиатуру и джойстик, в режиме ноутбука и сенсорные элементы управления в режиме планшета (пример: GestureWorks* GamePlay)
• Создание данных или потребление данных. Реализация функций создания и потребления данных в одном и том же приложении требует пересмотреть структуру этого приложения.

TВ таблице 2 перечислены некоторые виды использования обоих режимов и показаны различия и требования для разработки приложений для ультрабуков:

Таблица 2: Сравнение режима ноутбука и режима планшета для потребительского использования

Профессиональное использование

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

Таблица 3:Сравнение режима ноутбука и режима планшета для профессионального использования

Приложения с поддержкой трансформеров

Ниже приводятся примеры возможностей приложений для трансформеров:

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

Рекомендации по разработке приложений для ультрабуков

Если у вас есть существующие приложения для Windows 7 или Windows* XP, имеет смысл учесть следующие рекомендации по разработке, чтобы обеспечить гладкий переход при создании приложений для ультрабуков и трансформеров.

• Если приложение предусматривает ввод данных, реализуйте в приложении поддержку программной клавиатуры, чтобы поддержать удобство работы пользователей в режиме планшета, когда физическая клавиатура недоступна.
• Оптимизируйте существующие приложения для Windows 7 и Windows XP к сенсорному управлению для поддержания удобства работы пользователей на трансформерах с Windows 8.
• Используйте руководство по сенсорному управлению для разработчиков: http://software.intel.com/en-us/touch-and-sensors
• Оптимизируйте ваше приложение к использованию его на экранах различных размеров, разрешения и ориентации, учитывая фактические размеры и разрешения экранов, доступных на рынке ультрабуков. Кроме того, в режиме ноутбука, как правило, используется альбомная ориентация, но в режиме планшета ориентация во многом зависит от приложения. Убедитесь, что разметка вашего приложения и используемые элементы управления автоматически масштабируются для разных разрешений и ориентаций.
• Узнайте о масштабировании для разных размеров экрана: http://blogs.msdn.com/b/b8/archive/2012/03/21/scaling-to-different-screens.aspx
• Узнайте о разработке приложений для высоких значений DPI для Windows* 8: http://software.intel.com/en-us/articles/developing-for-high-dpi-applications-for-windows-8
• Узнайте о поддержке нескольких разрешений: http://msdn.microsoft.com/en-us/library/windows/apps/dn263244.aspx

Оценка готовности приложений к работе на трансформерах

Способ переключения каждого приложения из режима ноутбука в режим планшета зависит от этого приложения. Тем не менее все приложения для трансформеров должны: 1) обнаруживать изменения состояния и 2) содержать функциональность для поддержки изменений состояния. Опираясь на модели использования и требования поддержки трансформеров, перечисленные в предыдущем режиме, можно привести рекомендации, которые следует учесть при разработке приложений для трансформеров.

• Определение изменения состояния. В таблице 1 перечислены некоторые трансформеры и показано изменение их аппаратного режима. Тем не менее определение изменения режима приложением в некоторой степени зависит от BIOS и микропрограммы и поддерживается не всеми доступными на рынке устройствами. При подготовке приложения к поддержке трансформеров мы рекомендуем понять, как использовать API Windows 8 для определения смены режимов. Дополнительные сведения об обнаружении этого изменения см. в следующей статье:
  • Определение переключения из режима ноутбука в режим планшета: http://software.intel.com/en-us/articles/detecting-slateclamshell-mode-screen-orientation-in-convertible-pc
  • Как написать приложение, поддерживающее трансформеры: http://software.intel.com/en-us/articles/how-to-write-a-2-in-1aware-application
    
    Примечание. Не все устройства, доступные на рынке в настоящее время, автоматически определяют изменение состояния. Автоматическое определение изменения состояния зависит от компонентов, упомянутых в приведенных выше справочных статьях. Дополнительные сведения по этой теме будут опубликованы в ближайшее время. В то же время разработчикам рекомендуется рассмотреть перечисленные ниже варианты: некоторые из них можно использовать без зависимости.
• Разработайте разные интерфейсы для режима ноутбука и режима планшета. Способы взаимодействия пользователей с трансформерами в режиме ноутбука и в режиме планшета существенно различаются. В режиме ноутбука в качестве основных методов ввода используют мышь и клавиатуру, а в режиме планшета предпочитают сенсорный экран и перо. Для повышения удобства пользователей имеет смысл разрабатывать отдельные интерфейсы для режима ноутбука и для режима планшета.
  • См. пример Krita Gemini, чтобы изучить тонкости создания эффективного приложения для трансформеров с динамическим переключением интерфейсов в соответствии с режимами:http://software.intel.com/en-us/articles/krita-gemini-twice-as-nice-on-a-2-in-1
• Напишите код для определения изменений состояния вручную. Поскольку автоматическое определение смены состояния устройства может быть недоступно, для начала неплохо написать ручной переключатель в приложении. В этом случае при появлении поддержки автоматического определения состояния будет проще доработать приложение.
  • Как написать приложение, поддерживающее трансформеры: http://software.intel.com/en-us/articles/how-to-write-a-2-in-1aware-application
• PСнабжайте игры дополнительным сенсорным интерфейсом для удобства пользователя. Для игр на ПК наложение сенсорного интерфейса следует считать эффективным способом преобразования приложения для трансформеров.
  • См. пример GestureWorks* GamePlay, чтобы понять, как доработать интерфейс игр в приложениях для ПК: http://software.intel.com/en-us/articles/gameplay-touch-controls-for-your-favorite-games
• Оптимизируйте приложения для обработки разных типов ввода. . Сенсорное управление/клавиатуру и мышь следует считать эффективными взаимозаменяемыми механизмами на случай, если один или несколько других методов ввода будут недоступны. Например, не все трансформеры поддерживают перо. Если ваше приложение использует перо, добавьте резервные механизмы, чтобы приложение работало на устройствах, не поддерживающих перо.
  • Сенсорный ввод и ввод с помощью пера в Windows* 8: http://software.intel.com/en-us/articles/mixing-stylus-and-touch-input-on-windows-8

Заключение

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

Об авторе

Мегана Рао (Meghana Rao) работает техническим маркетинговым инженером в подразделении Intel Software and Services. Она помогает разработчикам понимать возможности платформ Intel и писать приложения, удобные для пользователей.

Intel, the Intel logo, and Ultrabook are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2014 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.