If you’re a game developer looking for tools that will help you compete without breaking the bank in the process, you’ll want to check out Project Anarchy, a free mobile game development suite available for developers from Havok, which you might recognize as the physics engine used by most of the big name console and PC game platforms out there.

What is Havok?

Havok – an Intel-owned company – is one of the big names on the game development landscape:

“As a leading provider of games development technologies, Havok has over 13 years of experience servicing the most demanding technology requirements for leading customers in the commercial games and entertainment industry. A combination of superior technology and dedication to delivering industry leading support to its customers has led to the company’s technologies being used in over 500 of the best known and award-winning titles including Halo 4, Assassin’s Creed® III, The Elder Scrolls® V: Skyrim™, Guild Wars 2, Call of Duty®: Black Ops II, Skylanders Giants™ and Modern Combat 4: Zero Hour.” – Havok Releases Project Anarchy, Completely Free

Here are just a few of the projects that Havok has been included in:

“Havok works in partnership with the world’s best known publishers, developer studios and developer teams, including Microsoft Games Studios®, Sony Computer Entertainment Inc., Nintendo®, Ubisoft®, NC Soft, Rockstar, EA, Bethesda ™, Insomniac, Relic, Bungie, Naughty Dog, Evolution Studios and Guerrilla Games. Its cross-platform, professionally supported technology is available for Xbox One®, the all-in-one games and entertainment system from Microsoft, the Xbox 360® games and entertainment system from Microsoft, PlayStation®4 and PlayStation®3 computer entertainment systems, Windows® 7, Windows® 8, PlayStation Vita®, Wii™, Wii U, Android™, iOS,  Windows® RT, Windows® Phone 8, Apple Mac OS and Linux. Havok’s products have also been used to drive special effects in movies such as Harry Potter, Clash of the Titans, Watchmen, James Bond, and The Matrix. Havok has offices in Dublin (Ireland), San Francisco, Seoul, Tokyo, Shanghai, and Germany.”

What is Project Anarchy?

We already know it’s free, but here are some more technical specs:

“Project Anarchy is a free mobile game engine for iOS, Android (including X-86), and Tizen. It includes Havok’s Vision Engine along with Havok Physics, Havok Animation Studio and Havok AI. It has an extensible C++ architecture, optimized mobile rendering, a flexible asset management system, and Lua scripting and debugging. There are also complete game samples included with the SDK along with extensive courseware on the Project Anarchy site that game developers can use to quickly get up to speed with the engine and bring their game ideas to life.” – Introducing Project Anarchy, a Free Mobile Game Engine by Havok

You can watch a demo of the engine in action below:

Basically, Project Anarchy is a fully functional collaboration of Havok’s software. This release of Project Anarchy includes Havok’s Vision Engine, along with access to the Havok suite of tools for Physics, Animation, and AI. Developers can look forward to customizable game samples, advanced debugging, a flexible asset management system, and extensible C++ architecture.

Havok has also made available an online hub of game development content – including forums, Q and A, courseware, and video tutorials. One of the best ways to see what Project Anarchy really has to offer is this fantastic walkthrough from GameFromScratch.com, which includes screenshots, resources, and an honest review of the engine/tools from a seasoned game developer:

“There’s tons of functionality packed in this engine, and this is just looking at the tool side of the equation.  Of course there are dozens upon dozens of APIs behind the scenes as well.  In the future I will look closer at how you actually put it all to use….I will say, I am a lot more impressed than I thought I was going to be.  I thought it would be a bunch of poorly documented tools mashed together with minimal documentation.  In reality, it’s a remarkably cohesive and powerful package that covers almost all of the bases.  They certainly have my interested piqued.  Good job Havok!”

Giving back

Releasing such a full-featured game development engine, the natural inclination for many people is to ask “what’s the catch?” The Project Anarchy folks address this; basically, become part of the Project Anarchy community, agree to possibly work with them if you end up shipping a title, and build an x86-compatiabil version of the game you’re working on. More from the Project Anarchy page:

“To help Havok make Project Anarchy free for iOS, Android and Tizen we only ask for a few things in return. First and foremost we'd encourage you to become part of the Project Anarchy community and join us in making Project Anarchy a great place to make awesome games. Secondly we'd like the opportunity to do some co-marketing with you when you come to ship your game. We won't be able to work with everyone that ships a title but when you sign up we do ask that you agree to Havok having the option, and don't worry - we don't bite!

Thirdly, if you have created a game targeting Android (or another platform that supports x86 devices such as Tizen) that you plan to upload to an app store, the license requires that you build an equivalent x86-compatible version of the game and upload it alongside any other versions that you have built. Building an x86-compatible version of an Android executable is a very straightforward process and if you have any questions on this part of the process, please contact us at x86buildsupport@projectanarchy.com and we'll do our best to help.”

Now it’s your turn

IF you’re a developer, do you plan on downloading Project Anarchy and using the Havok suite of tools to create your next game? If you’ve already downloaded it, let us know what you think so far in the comments below.

Introducción

Este documento le servirá de guía durante la instalación de la imagen de Intel® Atom™ x86 para Android* Jelly Bean, que puede utilizarse para el desarrollo en una arquitectura Intel x86.

Requisitos previos

La imagen del emulador Android x86 requiere que sea instalado Android SDK. Para obtener instrucciones de instalación y configuración de Android SDK, consulte el sitio de desarrolladores de Android (http://developer.android.com/sdk/).

Opcional: La imagen del emulador x86 para Android puede acelerarse utilizando Intel Hardware Accelerated Execution Manager (HAXM). Para más información, consulte la sección “Optimización” de este documento.

Problemas conocidos:

• Problema de la cámara: La cámara falla al grabar video en la imagen del sistema Android 4.2, este problema ha sido reportado en: http://code.google.com/p/android/issues/detail?id=41227
• Problema del navegador: El navegador produce aleatoriamente una falla en el emulador de un equipo con Vista de 32 bits. Se ha reportado en: http://code.google.com/p/android/issues/detail?id=42733
• Problema de estabilidad: El emulador puede fallar al establecerse el tamaño RAM de dispositivo de un AVD (Android Virtual Device) en 1024. Intel está actualmente investigando y caracterizando este problema.

Instalación

Descarga mediante Android SDK Manager

1. Inicie Android SDK Manager.
2. Bajo Android 4.2 (API 17), seleccione "Intel x86 Atom System Image":
   
   
3. Una vez seleccionado, haga clic en “Install Package”.
4. Revise el acuerdo de licencia de Intel. Si acepta los términos, seleccione “Accept” y pulse “Install”.
5. SDK Manager descargará y extraerá la imagen del sistema en el sitio apropiado dentro del directorio Android SDK.

Utilización de la Imagen del Sistema

1. Inicie Android AVD Manager y cree un AVD nuevo, indicando “Target” para "Android 4.2 – API Level 17" y "CPU/ABI" para "Intel Atom (x86)"

   La imagen de Intel Atom x86 para Android Jelly Bean puede utilizar las características gráficas del hardware GPU para incrementar el rendimiento de juegos, programas que hacen uso intensivo de gráficos y elementos de la interfaz de usuario. Para obtener el mejor rendimiento asegúrese tildar el cuadro "Use Host GPU" al crear la imagen.

   Nota: La funcionalidad y el desempeño de la aceleración de GPU (Unidad de procesamiento gráfico, en inglés) depende en gran medida de la tarjeta gráfica y sus controladores gráficos. La aceleración de GPU debe ser habilitada por cada AVD.
   
   

   Nota: Si la opción de CPU/ABI “Intel Atom (x86)” no está disponible, asegúrese que la imagen del sistema esté instalada correctamente.

2. Pulse el botón “Create AVD”.
3. El AVD ha sido creado exitosamente y está listo para ser usado:
   
   

Optimización

Aceleración de CPU

El rendimiento de la imagen de Intel Atom x86 para Android Jelly Bean puede mejorar con virtualización basada en hardware, mediante tecnología Intel VT-x. 

Si su equipo tiene un procesador Intel compatible con VT-x, se recomienda que Intel Hardware Acceleration Execution Manager (HAXM) sea utilizado en conjunto con la imagen del sistema. Para más información sobre Intel HAXM, visite http://www.intel.com/software/android.

Nota: Intel HAXM es compatible solamente con Windows y OS X. En entornos Linux, puede utilizarse Kernel-based Virtual Machine (KVM) para acelerar el rendimiento de emulación. Para obtener información sobre la instalación y configuración de KVM en Ubuntu, consulte esta guía: https://help.ubuntu.com/community/KVM/Installation

<sub>Copyright (C) 2013 Intel Corporation. Todos los derechos reservados.
Intel, Atom, y el logo Intel logo son marcas registradas de Intel Corporation en EE.UU. y/o otros países.
Todos los productos, sistemas de computación, fechas y cifras especificados son preliminares en base a expectativas actuales y están sujetos a cambio sin previo aviso.
* Otros nombres o marcas pueden ser propiedad de terceros.</sub>

El paquete Intel Android USB te permitirá conectar tu máquina basada en Windows* a tu dispositivo Android equipado con procesador Intel Atom.

Nota: El paquete Intel Android USB versión 1.1.5 está diseñado para desarrolladores de apps Android con soporte adicional para Microsoft Windows* 8. Para asistencia al consumidor, por favor revísalo con el fabricante de tu dispositivo. Para la versión previa 1.1.4 hay un link para descargar el driver.

Microsoft Windows*
Windows 8 (32/64-bit), Windows 7 (32/64-bit), Windows Vista (32/64-bit), Windows XP (32-bit únicamente)
Guía de instalación y requisitos de sistema - Windows

One of the best known C++ threading libraries Intel® Threading Building Blocks (Intel® TBB) was recently updated to a new release 4.2. The updated version contains several key new features comparing to previous release 4.1. Some of them were already released in TBB 4.1 updates.

New synchronization primitive speculative_spin_mutex introduces support for speculative locking. This has become possible using Intel(R) Transactional Synchronization Extensions (Intel® TSX) hardware feature available in 4th generation Intel® Core™ processors. On processors that support hardware transactional memory (like Intel® TSX) speculative mutexes work by letting multiple threads acquire the same lock, as long as there are no "conflicts" that may generate different results than non-speculative locking. So no serialization happens in non-contended cases. This may significantly improve performance and scalability for “short” critical sections. If there is no hardware support for transactional synchronization, speculative mutexes behave like their non-speculating counterparts, but possibly with worse performance.

Intel TBB now supports exact exception propagation feature (based on C++11 exception_ptr). With exception_ptr, exception objects can be safely copied between threads. This brings flexibility in exception handling in multithreaded environment. Now exact exception propagation is available in prebuilt binaries for all platforms: OS X*, Windows* and Linux*. On OS X* there are two sets of binaries: first is linked with gcc standard library – it used by default and doesn’t support exact exception propagation. To use the feature you should take the second set of binaries linked with libc++, the C++ standard library in Clang. To use these, set up the Intel TBB environment and build your application in the following way:

# tbbvars.sh libc++

# clang++ -stdlib=libc++ -std=c++11 concurrent_code.cpp -ltbb

In addition to concurrent_unordered_set and concurrent_unordered_map containers, we now porvide concurrent_unordered_multiset and concurrent_unordered_multimap based on Microsoft* PPL prototype.  concurrent_unordered_multiset provides ability to insert an item more than once, that is not possible in  concurrent_unordered_set. Similarly, concurrent_unordered_multimap allows to insert more than one <key,value> pair with the same key value. For the both “multi” containersfindwill return the first item (or <key,value> pair ) in the table with a matching search key.

Intel TBB containers can now be conveniently initialized with value lists as specified by C++ 11 (initializer lists):

tbb::concurrent_vector<int> v ({1,2,3,4,5} );

Currently initialize lists are supported by the following containers:

concurrent_vector
concurrent_hash_map
concurrent_unordered_set
concurrent_unordered_multiset
concurrent_unordered_map
concurrent_unordered_multimap
concurrent_priority_queue

Scalable memory allocator has caches for allocated memory in each thread. This is done for sake of performance, but often at the cost of increased memory usage. Although the memory allocator tries hard to avoid excessive memory usage, for complex cases Intel TBB 4.2 gives more control to the programmer: it is now possible to reduce memory consumption by cleaning thread caches with scalable_allocation_command() function. There were also made several improvements in overall allocator performance.

Intel TBB library is widely used on different platforms. Mobile developers can now find prebuilt binary files for Android in the Linux* OS package. Binary files for Windows Store* applications were added to the Windows* OS package.

Atomic variables tbb::atomic<T> now have constructors when used in C++11. This allows programmer to value-initialize them on declaration, with const expressions properly supported. Currently this works for gcc and Clang compilers:

tbb::atomic<int> v=5;

The new community preview feature allows waiting until all worker threads terminate. This may be needed if applications forks processes, or TBB dynamic library can be unloaded in runtime (e.g. if TBB is a part of a plugin). To enable waiting for workers initialize task_scheduler_init object this way:

#define TBB_PREVIEW_WAITING_FOR_WORKERS 1
tbb::task_scheduler_init scheduler_obj (threads, 0, /*wait_workers=*/true);

Find the new TBB 4.2 from commercial and open source sites. Download and enjoy the new functionality!

Each opportunity to engage with students today must to be met with contempory solutions at par with the user interfaces (UI) students have grown accustom.  Watching the video featuring Evan Lang of Identity Mine you see how his company chose to design their Air Hockey game specifically for Intel's All In One (AIO) platform. The AIO is large enough and flexible enough to lay flat, allowing the game to be played by more than one person on any flat surface.  With the bigger size comes the increased performance to handle the fast pace of the game along with graphics to create a more realistic user experience.  The features that make the Identity Mine Air Hockey game compelling can make Physics, Astronomy, Geometry and others more interactive and collaborative between students and teachers.  Borrow some gaming techniques to take a 'good' education application to a great learning experience.

Introduction

Wireless display technology is becoming more and more popular on Android* phones and tablets since Google started supporting Miracast on Android 4.2. Wireless display technology makes it easier for end users to expand their phone’s LCD size. I think there is a good chance that ISVs will integrate the wireless display feature into their applications, especially games and video players.

But how to realize Intel® wireless display differentiation for Miracast on Android for x86 phones is a big challenge for enabling ISVs. This article introduces how to enable dual display differentiation for Miracast by showing a case study of enabling iQiyi online video player and WPS office on K900. We hope that lots of amazing applications can be enabled in the future.

What is Miracast

The Wi-Fi Alliance officially announced Wi-Fi* CERTIFIED Miracast on 2012.9.19 , which is a groundbreaking solution for seamlessly displaying video between devices, without cables or a network connection. Users can do things like view pictures or videos from a smartphone on a big screen television, share a laptop screen with the conference room projector in real time, and watch live programs from a home cable box on a tablet. Miracast connections are formed using Wi-Fi CERTIFIED Wi-Fi Direct*, so access to a Wi-Fi network is not needed—the ability to connect is inside Miracast certified devices.

The connection of Miracast is based on a Wi-Fi direct, peer to peer connection. The Wi-Fi-based Miracast architecture is shown below.

Figure 1: Miracast* architecture

There are four modes of Miracast connection as shown below:

Figure 2: Miracast* connection modes

With a Miracast connection, you can enable connectivity across devices without Wi-Fi AP infrastructure, as topology 1 shows. You can also connect to a display via an adaptor while connecting to an AP, as topology 2 shows. It is very convenient to watch online video at home with this mode. If you have a smart TV that also supports Miracast, your TV, AP, and your smartphone can even connect to each other, as topology 4 shows.

According to the Miracast standard, the interactive mode of source and display devices can be diagrammed as follows:

Figure 3: Miracast* session management

Source and display devices discover each other’s Miracast capabilities prior to connection setup. The connection is based on Wi-Fi direct or TDLS. Source and display devices determine the parameters for the Miracast session based on capability negotiation. The negotiation process is based on the TCP connection. Source devices will transfer content to display devices via MPEG2-TS format based on the UDP connection.

Miracast wireless streaming-supported formats are listed in Table 4.

Table 4: Miracast* streaming format

Miracast on Android 4.2

Google started supporting Miracast on Android version 4.2. End users can share movies, photos, YouTube videos, and anything that’s on your screen with HDTV via wireless display technology. The external HDTV is listed as an external display.

Now Miracast on Android supports clone mode and presentation mode, as shown below:

Figure 5: Miracast* support modes

Clone mode duplicates the phone display on the remote display. The resolution of the frames sent to the adapter matches the resolution of the local display. In this mode, both local and remote displays are turned on and show the same content.

In presentation mode, Android now allows your app to display unique content on additional screens that are connected to the user’s device over either a wired connection or Wi-Fi. The apps must be modified to support this mode, or they will default to clone mode.

Develop differentiation for Miracast on Intel Architecture (IA) phone

Intel’s wireless display solution on Android phones and tablets is fully compatible with Miracast. We also enable some apps with differentiation usages to Miracast on IA phone.

The first one is to enable iQiyi to realize the video background streaming function. Users can send video to a remote display at 1080p resolution using a iQiyi app that enables background streaming while users can navigate out of the app and play 1080p video on the local screen or use any other application, including sending email or accessing their browser without any disruption to background playback, as shown below:

Figure 6: iQiyi video BGM function

The second one is to enable WPS office to realize split the UI function on both local and remote displays. When connecting to TV via wireless display, the enabled WPS office app can show PPT slides on the remote screen while showing PPT notes on the phone’s screen, which is very convenient for the speaker. We plan to add a timer clock on the phone’s screen to give a time reminder to the speaker in the future.

Figure 7: WPS office split UI function

These two differentiation usages are developed based on Miracast’s Presentation mode using the phone’s IA hardware capability. The two applications have been uploaded to Intel AppUp® for end users to download and install on their IA phones.

Case study: How to enable dual display differentiation usages

In this section, I will introduce how to realize a video background streaming function based on our experience of enabling a iQiyi app.

As we know, to realize the video BGM function, the key difficulty is to get a service to play video in the background and deal with the surface view or video view correctly. When users press the home key, the surface view or video view will be destroyed automatically, so we have to apply a secondary display to show the background streaming video. The program flowchart is shown below:

Figure 8: Background video streaming flow chart

To create unique content for a secondary display, extend the Presentation class and implement the onCreate() callback. Within onCreate(), specify your UI for the secondary display by calling setContentView(). As an extension of the Dialog class, the Presentation class provides the region in which your app can display a unique UI on the secondary display.

There are two methods for applying the secondary display for your presentation. Use either the DisplayManager or MediaRouter APIs. The easiest way to choose a presentation display is to use the MediaRouter API. The media router service keeps track of which audio and video routes are available on the system. The media router recommends the preferred presentation display that the application should use if it wants to show content on the secondary display.

Here's how to use the media router to create and show a presentation on the preferred presentation display using getPresentationDisplay().

 MediaRouter mediaRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE);
 MediaRouter.RouteInfo route = mediaRouter.getSelectedRoute();
 if (route != null) {
     Display presentationDisplay = route.getPresentationDisplay();
     if (presentationDisplay != null) {
         Presentation presentation = new MyPresentation(context, presentationDisplay);
         presentation.show();
     }
 }

Another way to choose a presentation display is to use the DisplayManager API directly. The display manager service provides functions to enumerate and describe all displays that are attached to the system including displays that may be used for presentations.

The display manager keeps track of all displays in the system. Here's how to identify suitable displays for showing presentations using getDisplays(String) and the DISPLAY_CATEGORY_PRESENTATION category.

 DisplayManager displayManager = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
 Display[] presentationDisplays = displayManager.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION);
 if (presentationDisplays.length > 0) {
      Display display = presentationDisplays[0];
     Presentation presentation = new MyPresentation(context, presentationDisplay);
     presentation.show();
 }

Developers can Reference the presentation demo code in Android SDK shown as below:

\sdk\sources\android-17\android\app\Presentation.java

Summary

Besides the selling point of Intel Inside® for IA-based phones and tablets, the wireless display feature may become a shining point. ISVs should take notice and develop more innovative usages based on wireless display, especially the dual display differentiation usages.

Reference

1. http://www.wi-fi.org
2. http://developer.android.com/about/versions/android-4.2.html
3. Wi-Fi_Display_Technical_Specification_v1.0.0

Copyright © 2013 Intel Corporation. All rights reserved.

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

On September, 10, 2013, we released the Intel® XDK NEW, our initial release of a new version of the Intel® XDK.  I want to let you know why we did this.  As you probably know, Intel acquired the appMobi* HTML5 development tools last February, which included the then appMobi* XDK and Dev Center (the build service.)  We re-launched it as the Intel® XDK shortly thereafter.

Our goal with getting into the HTML5 tools business is to help promote and enable cross-platform HTML5 app development – for all platforms, not just Intel’s.  It’s very important to us that HTML5 reaches its promise of a true cross-platform, responsive, run-anywhere language and runtime, and which is based on standards.  We found that to fully enable that goal, we needed to extend the Intel XDK’s abilities in the app “creation”  (UI design and editing), testing and debugging (emulation, on-device testing and debugging), device API support, and build targets – pretty much everything.  We needed more flexibility to add new tools and capabilities, including that from open-source and third-parties. 

So, we rebuilt it.  Here’s what we did:

• Eliminated the dependence on Java* and Chrome* (not that there’s anything wrong with them!), and replaced it with node-webkit.  Now we can run the Intel XDK on just about any host platform, and gives us the ability to have better local file management in addition to cloud.  These are the biggest complaints/requests we’ve heard over the past several months from our customers.   (BTW, big kudos to Roger Wang for creating and maintaining node-webkit– he’s done a great service to web/HTML5 developers with this project.)
• A new UI builder – App Designer– and integrated it with Intel XDK NEW.  It supports more frameworks (jQuery Mobile*, Twitter* Bootstrap, and App Framework) for more UI design choices, as well as allowing “round-trip” design, edit, re-design within the tool.  In this initial release, App Starter, the fast prototyping, UI building tool for App Framework specifically is only available in the cloud; we’ll be integrating it back into the XDK as soon as we can.
•  A new editor – Brackets* - you can go back and forth on files created in the UI builder or just use this great editor.  Our kudos to the contributors behind www.brackets.io– it offers great developer help like syntax highlighting, auto-completion, JSLint*, and more.  Of course, you can still choose to use your own favorite editor and import files, but if you do not have a favorite, try it.
• A new emulator based on Ripple* - appMobi had done a great job with the emulator in the current Intel XDK, but we wanted to add Cordova support in addition to appMobi device APIs.  This offers more flexibility in adding APIs and gives you more device/platform simulation.
•  A new User Interface – we rewrote everything based on web technologies.  This allowed us to create a new UI to make the tools a bit easier to access and hopefully make it easier to create and manage projects and files all the way through to the build service.
• More host platforms – Intel XDK NEW will run on Ubuntu* Linux* in addition to Windows* and OS X*.  As of September 10, though, we only have the Windows*-hosted version available; we’ll get the OS X* and Linux* ones out over the next couple of months.
• Cordova 2.9 support – you can now create, test, emulate, debug, and build Cordova-based apps in addition to appMobi device API-based ones.

We are releasing Intel XDK NEW as a technology preview now.  Here's the link to it.  We'll greatly appreciate any feedback you can give us so that we can address it while we polish it toward becoming our main product later in the year, replacing the existing Intel XDK.  We have set up a new user forum just for Intel XDK NEW issues and suggestions. 

So, give Intel® XDK NEW a try, and please, let us know how we did!

概述

本指南用于帮助开发人员将现有的基于 ARM* 的 NDK 应用移植到 x86。 如果您已经拥有一个正常运行的应用，需要知道如何能够快速让 x86 设备在 Android* Market 中找到您的应用，本文将可以为您提供一些入门信息。 同时本指南还提供了一些技巧和指南，以帮助您解决在移植过程中可能会遇到的编译器问题。

目录

1. 概述
2. NDK 概述
   • JNI 的性能影响和开销
   • 获取 NDK
   • NDK 内部组件简介
     • Makefiles
     • 命令行构建
     • 处理原生库文件
     • 运行时验证
   • 概要
3. 移植概述
4. 移植技巧：从 ARM* 到 x86
   • 工具链兼容性
   • 内存对齐影响： 比较 ARM* 与英特尔® 凌动™
   • 浮点运算： 比较 ARM* 与英特尔® 凌动™
   • 将 ARM* NEON* 指令移植至英特尔® 凌动™ 的英特尔® SSE
     • 什么是 NEON？
     • SSE： 英特尔推出的类似 NEON 的工具
     • NEON 与 SSE 在汇编层面的比较
     • NEON 与 SSE 在C/C++ 层面的比较
5. 结论

NDK 概述

原生开发套件(NDK)是一款强大的工具，将原生 x86 代码的强大功能和 Android* 应用的图形界面结合在一起。 通过使用该工具，开发人员将能够提升某些应用的性能优势，但同时开发人员也需要十分谨慎，因为在某些情况并不能实现预期的效果

NDK 致力于支持开发人员完成以下工作：

• 编译原生 C/C++ 库（由包装程序 Java* 代码调用），以备在 Android* 应用包中使用
• 重新编译 ARM* 原生库，供在 x86 平台（英特尔® 凌动™ 微架构）上使用，并在必要时进行移植

对于以上提到的第二点，部分情况下可能只需要简单地修改 Build Flag 并重新编译即可，但有时却并不这么简单。 例如，如果原生库涉及到 C 代码内的内嵌汇编，那么代码将无法通过简单的汇编来实现在两种不同的架构自如运行的目标，此时将需要进行重新编写（更多信息请参见比较 ARM* 的 NEON* 与英特尔的 SSE 的部分）。

JNI 的性能影响和开销

Java* 原生接口（JNI）将 Android* Java* 代码与由 NDK 预编译的原生代码结合在一起。 如欲了解有关该接口的更多信息，请访问： http://java.sun.com/docs/books/jni/。

以上链接对 JNI 规范进行了广泛、深入的剖析。 若只是希望了解其概况，Wiki 页面即可满足您的要求（存在疑问时，请随时参考规范以检查其正确性）。Wiki 页面的网址如下： http://en.wikipedia.org/wiki/Java_Native_Interface。

JNI 的开销十分庞大，因此在理想情况下，开发人员应在应用中尽可能减少对 JNI 的调用。 具体而言，在 Android* 应用中使用原生代码并不一定能提升性能。 通常而言，当原生代码涉及到由 CPU 进行的运算时（如大量使用 SSE 指令），将可以实现一定的性能提升。但在另外一些情况下，如现有的应用仅用于为用户提供复杂的 Web 界面，此时通过 JNI 使用原生代码可能会降低性能。 在何时该用和不该用 NDK 上，不存在成文的规则，以上几点只是提供了一些需要注意的通用准则和事项。

获取 NDK

开发人员可通过以下网址获取 NDK 的最新版本： http://developer.android.com/sdk/ndk/index.html。 在最新版本 NDK r6b 中，NDK 可用于构建基于 ARM* 和基于 x86（英特尔® 凌动™ 微架构）的原生库。 这为开发人员在一个应用包内进行原生代码移植提供了方便。

NDK 内部Makefile简介

开发人员将需要为项目创建一个 Android.mk 文件和一个 Application.mk 文件（可选）。 其中，Application.mk 文件用于描述您的应用需要哪些原生模块。 Android.mk 文件用于控制如何和从哪里构建一个模块（静态/共享库）。 以下是一个简单 Android.mk 文件的片段：

图 1： 简单 Android.mk 文件的内容

构建系统时将前置一个库，并同时生成一个名称为 libtest.so 的库。按预期，开发者将在 LOCAL_SRC_FILES 中为项目源文件命名。 LOCAL_LDLIBS 和 LOCAL_CFLAGS 分别用于指定 Linking Flag（链接标记）和Compilation Flag（编译标记）。

命令行构建

以下命令行提供了一个有关如何指定构建指向 x86 架构的示例： ndk-build APP_ABI=x86

调用原生库可采用以下两种方法： System.loadLibrary("relative_path_and_name") and System.load("full_path_to_lib_file")。 前者更常用，后者更稳定。 使用前者时，Android.mk 指定的库名称中的“lib”部分可丢弃。 调用示例如下：

图 2： 调用原生代码示例

此外，对于原生代码，开发人员需要确保原生代码的输入方法具有正确的 JNIEXPORT 方法签名，而不是典型的 C/C++ 标头。 前面提及的 JNI 链接包含有更多相关信息。

处理原生库文件

开发人员可通过两种方式加载原生库：1) 在 Android* apk 包中提供该库并在运行时对其进行引用；2) 在 Android* 文件系统上提供通往该库的绝对路径。 采用以上方式中的哪一种取决于开发人员的偏好。但无论采用哪种方式，均应进行相应的正确处理。

运行时验证

通过使用 adb logcat 命令，开发人员可确保在运行时成功加载目标原生库。 以下提供了一个描述原生库已加载的系统日志的示例。 注意需提供通往原生库文件的完整路径。

图 2： 调用原生代码示例

概要

以上各部分提供了有关如何使用 NDK 的入门知识。 如欲了解更加复杂的细节，请阅读 NDK 应用包中包含的相关文档。 这些文档提供有出色的教程和针对各种应用的源代码示例。

移植概述

对于大多数应用而言，将现有的 NDK 应用移植到 x86 非常简单。 除非原生代码使用 ARM* 特有的特性，否则移植应用只需进行重新编译、重新打包和重新发布操作即可完成。

以下内容向您介绍了将 NDK 应用移植到 x86 涉及到的步骤。

1. 获取最新的 NDK 工具。 x86 支持最先在 android-ndk-r6 中提供，但当时仍存在一些问题，之后谷歌很快进行了修复。 确保您已经从 Android* NDK 网站下载和安装了最新的（写入时，最新的 NDK 为 android-ndk-r6b）NDK。

    

2. 如果您已有一个 Application.mk 文件，可编辑 APP_ABI 行加入 x86。 示例：
   
   APP_ABI := armeabi armeabi-v7a x86
   
   如果您没有用 Application.mk 文件，可将 x86 添加到命令行构建中。以下为构建一个 NDK 示例应用时的命令行和输出内容。
   $ ndk-build APP_ABI="armeabi armeabi-v7a x86"
   
   Install : test-libstl => libs/armeabi/test-libstl
   Install : test-libstl => libs/armeabi-v7a/test-libstl
   Install : test-libstl => libs/x86/test-libstl
3. 在前一步中，我们可以发现包含每种架构的二进制代码的文件夹在 Libs 目录下创建。 下一步，我们将重新打包 APK 以包含新库。 由于 Libs 目录位于根项目文件夹之下，用于创建 APK 的构建工具已经知晓该文件夹中的二进制代码。 利用 Eclipse，只需简单地重新构建项目 APK 即可包含新的 x86 二进制代码。 使用命令行进行构建的操作与此相同。 以下列出了重新构建示例演示 hello-jni 时的示例输出内容：
   
   $ android.bat update project --path C:/Tools/android-ndk-r6b/samples/hello-jni
   Updated local.properties
   Added file C:\Tools\android-ndk-r6b\samples\hello-jni\build.xml
   Added file C:\Tools\android-ndk-r6b\samples\hello-jni\proguard.cfg
   $ ant -f hello-jni/build.xml debug
   Buildfile: C:\Tools\android-ndk-r6b\samples\hello-jni\build.xml
   …
   debug:
   [echo] Running zip align on final apk...
   [echo] Debug Package: android-ndk-r6b\samples\hello-jni\bin\HelloJni-debug.apk
   BUILD SUCCESSFUL
4. 下一步为在英特尔架构设备或 x86 模拟器上进行运行和测试。 验证所有二进制代码均已正确打包的最后一步为使用 zip 存档工具打开 APK 并确保其中包含二进制代码。 以下是存在 x86 二进制代码时 APK 结构外观的截屏。

移植技巧：从 ARM* 到 x86

将应用移植到 x86 应当非常简单，尽管很多人可能都有这样的想法，但在实际的代码中，仍需要谨慎注意并解决英特尔® 凌动™ 和 ARM* 架构之间的差异。 以下主题介绍了您在移植过程中可能遇到的问题以及如何予以解决。

工具链兼容性

您的构建环境有可能直接使用了工具链，而不是 Android* 构建脚本。 在 ARM* 中，所用的路径如下：

android-ndk\toolchains\arm-linux-androideabi-4.4.3
对于 x86，使用路径：
android-ndk\toolchains\x86-4.4.3
有关详细信息，请参阅位于 android-ndk/docs/STANDALONE-TOOLCHAIN.html 的 NDK 文档。

内存对齐影响： 比较 ARM* 与英特尔® 凌动™

在 ARM* 和英特尔® 凌动™ 微架构之间移植 C/C++ 代码时可能出现内存对齐不匹配的情况。 以下文章针对这一点提供了一个典型的示例： /en-us/blogs/2011/08/18/understanding-x86-vs-arm-memory-alignment-on-android。 主要的一点是：开发者应当在设计代码时，在必要的地方考虑对数据进行明确的强制对齐。 否则，开发人员将无法保证数据在不同的平台能够得到正确的处理。

浮点运算： 比较 ARM 与英特尔® 凌动™

目前，在构建 NDK 库时，可以使用三种支持的应用二进制接口(ABI)：

1. ‘armeabi’ – 默认选项，将创建以基于 ARM* v5TE 的设备为目标的库。 具有这种目标的浮点运算使用软件浮点运算。 使用此 ABI 创建的二进制代码将可以在所有 ARM* 设备上运行。
2. ‘armeabi-v7a’ – 创建支持基于 ARM* v7 的设备的库，并将使用硬件 FPU 指令。
3. ‘x86’ – 生成的二进制代码可支持包含基于硬件的浮点运算的 IA-32 指令集。

所有这些 ABI 选项均支持浮点运算。除非使用的是特定于 ARM* 的汇编指令，否则在将代码移植到 x86 时不会发生问题。 其优势在于，如果碰巧您的应用仅针对“armeabi”进行编译，而现在需要支持 x86，则您在进行大多数浮点运算时均能感觉到性能提升。

将 ARM* NEON* 指令移植至英特尔®凌动™ 的英特尔® SSE

尽管这篇短小的文章不可能包罗万象，但是以下提供的信息将能够让您大致了解在英特尔架构和 ARM* 中，SIMD 扩展的实施有何不同。 借助此简介，开发者还将获得一些工具，以便于开始进行一些简单的编码练习。

什么是 NEON？

NEON* 是一种 ARM* 技术，主要用于多媒体（智能手机和高清电视等）应用。 ARM* 表示其基于 128 位 SIMD 引擎的技术 – ARM* Cortex*（一种串行扩展）—可提供比 ARM* v5 架构至少高 3 倍的性能，以及比 ARM* v6 至少高 2 倍的性能。 如欲了解有关此技术的详细信息，以深入了解 NEON 及其它性能考虑，请访问以下网址： http://www.arm.com/products/processors/technologies/neon.php

此处的关键理念为，各寄存器被“堆积”成一个矢量，其中每一个寄存器均为一个元素，并与其它元素的数据类型相匹配。 在此基础之上，运算在管道内执行，因而这一方法被称作 Packed SIMD。

SSE： 英特尔推出的类似 NEON 的工具

SSE 指面向英特尔架构(IA)的SIMD 流指令扩展。 目前，英特尔® 凌动™ 最高支持 SSSE3（补充 SIMD 流指令扩展 3）。 凌动™ 暂不支持 SSE4.x。后者也是一个 128 位引擎，用于打包浮点数据。 这一执行模式开始于 MMX 技术。SSx 是较新的技术，取代了 MMX。。 如欲了解详细信息，请参阅英特尔《IA-32 和 IA-64 软件开发人员手册》中的“第一卷： 基础架构”部分。网址为： http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html。 目前，SSE 概述部分在 5.5 节。 它提供 SSE、SSE2、SSE3 和 SSSE3 的操作码。注意，数据运算通常会涉及到处理基于精度的打包浮点数值；并且需要在 XMM 寄存器之间，或在这些寄存器与内存之间批量传输数据。 XMM 寄存器主要用于取代 MMX 寄存器。

NEON 与 SSE 在汇编层面的比较

在推荐使用前述《英特尔架构软件开发人员手册》来了解所有单个 SSE(x) 助记符的同时，我们也鼓励开发人员通过以下链接了解各种 SSE 汇编级指令，网址为： http://neilkemp.us/src/sse_tutorial/sse_tutorial.html。

在该链接中，您可通过“目录”部分直接跳到代码示例或首先详细了解某些背景信息。 同样，以下直接来自 ARM* 的手册提供了一些信息和 NEON* 汇编小片段： /sites/default/files/m/b/4/c/DHT0002A_introducing_neon.pdf。 请参阅 ARM* 文档中的第 1.4 节。

以下是在一般层面上比较 NEON 和 SSE 汇编代码时的几个要点（注意：随着技术的发展，信息随时会过时；根据具体的 SIMD 技术和当下的应用编码问题，可能还存在其它差异）：

字节存储次序。 英特尔仅支持低位优先汇编，而 ARM* 则同时支持高位或低位优先顺序（ARM* 支持两种顺序）。 在提供的代码示例中，同英特尔一样，ARM* 代码采用的也是低位优先顺序。 注意尽管如此，在 ARM 中可能会存在一些编译器影响*。 例如，使用 GCC* 为 ARM* 进行编译时具有 -mlittle-endian 和 -mbig-endian 标记。 有关详细信息请访问：http://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html

粒度。 在引用简单汇编代码示例的情况中（请再次注意这并不包含开发人员可能发现的 NEON 和 SSE 之间的所有差异），将 SSE 的 ADDPS 指令与 NEON 的 VADD.ix（即：x = 8 或 16）进行比较。 请注意，后者在作为引用助记符的一部分而待处理的数据上有一定粒度降低。

NEON 与 SSE 在C/C++ 层面的比较

在将 C/C++ 代码 NEON 代码移植到 SSE 时，可能会出现很多 API 问题。 此处请注意本文的一个假设，即这里未使用内嵌汇编，而使用的是真正的 C/C++ 代码。

对于更高层级的编程，NEON 与 SSE 之间的差异涉及到大尺寸数据（128 位）的处理。 本文针对这种移植练习提供了一个简短示例： http://stackoverflow.com/questions/7203231/neon-vs-intel-sse-equivalence-of-certain-operations

结论

我们希望这一指南能够为您提供一些实用信息，帮助您成功将基于 NDK 的应用移植到 x86。 移植到 x86 后，您的应用将可以供一种全新类型的 Android* 设备进行下载、购买和使用。 如果您在移植过程中遇到问题，请随时在本文中发表评论。我们将非常乐意回答您的问题，为您提供帮助。

通知

* 其他的名称和品牌可能是其他所有者的财产。

英特尔公司 © 2013 年版权所有。 所有权保留。

英特尔、Atom 和凌动是英特尔在美国和/或其他国家的商标。

本文件中包含关于英特尔产品的信息。 本文件不构成对任何知识产权的授权，包括明示的、暗示的，也无论是基于禁止反言的原则或其他。 除英特尔产品销售的条款和条件规定的责任外，英特尔不承担任何其他责任。英特尔在此作出免责声明：本文件不构成英特尔关于其产品的使用和/或销售的任何明示或暗示的保证，包括不就其产品的(i)对某一特定用途的适用性、(ii)适销性以及(iii)对任何专利、版权或其他知识产权的侵害的承担任何责任或作出任何担保。

除非经过英特尔的书面同意认可，英特尔的产品无意被设计用于或被用于以下应用：即在这样的应用中可因英特尔产品的故障而导致人身伤亡。

英特尔有权随时更改产品的规格和描述而毋需发出通知。 设计者不应信赖任何英特产品所不具有的特性，设计者亦不应信赖任何标有“保留权利”或“未定义”说明或特性描述。 英特尔保留今后对其定义的权利，对于因今后对其进行修改所产生的冲突或不兼容性概不负责。 此处提供的信息可随时改变而毋需通知。 请勿根据本文件提供的信息完成一项产品设计。

本文件所描述的产品可能包含使其与宣称的规格不符的设计缺陷或失误。 这些缺陷或失误已收录于勘误表中，可索取获得。

在发出订单之前，请联系当地的英特尔营业部或分销商以获取最新的产品规格。

索取本文件中或英特尔的其他材料中提的、包含订单号的文件的复印件，可拨打1-800-548-4725，或登陆 http://www.intel.com/design/literature.htm

目标

面向 Eclipse (ADT) 的 Android 插件现在支持基于 NDK 的应用开发。 其可自动生成项目和构件文件以及代码存根，并可集成到整个 Android 应用开发中（构建原生库、将库复制到项目内的相应 JNI 文件夹、将应用打包以及生成带有 NDK 代码的最终 APK）。 本文将讨论如何配置 Eclipse 以利用该功能，并示范移植 NDK 应用的示例。

配置 Eclipse ADT 插件以配合 NDK 使用

必须先配置 Eclipse ADT 插件指向 NDK 安装路径的位置后，方可使用该新功能。 首先务必更新 Eclipse 中的 ADT 插件以获得最新更改，并从下面的网站下载最新的 NDK：

http://developer.android.com/tools/sdk/ndk/index.html

在 Eclipse 中，打开“窗口”->“首选项”->Android->NDK。 如下所示输入 NDK 安装路径（在此我们假定您已将 NDK 下载至了 Windows* 上的 c:\sw\android-ndk），单击“应用”，然后单击“确定”。

图 1： Eclipse Android ADT 插件中的 NDK 配置

我们现在应当在 Eclipse ADT 中启用和激活与 NDK 相关的功能。 让我们打开其中一个 NDK JNI 示例并进行构建。

打开 Eclipse 中的 hello-jni 示例 NDK 应用，并将 NDK build 支持添加至项目

要在 Eclipse 中构建 NDK JNI 原生示例，我们需要让 Eclipse ADT 了解该示例使用原生/NDK 代码。

让我们先将 HelloJni 示例导入 eclipse。 在 Eclipse 中打开“文件”->“新建”->“项目”-> Android ->“来自现有代码的 Android 项目”。 在下个屏幕中，输入 hello-jni 示例项目（在 NDK 安装文件夹中提供）的路径，并选择“复制到工作区”复选框，再单击“完成”。 使用来自您 NDK 安装文件夹的 HelloJni 路径替代根目录路径。

图 2： 将示例 HelloJni 项目导入 Eclipse

由于 x86 Android NDK 支持 Gingerbread* 及更高的 Android 平台，我们要确保更新应用描述文件中的最小和目标 SDK 配置。 在 Eclipse 中打开 HelloJni 示例下的 AndroidManifest.xml；单击 AndroidManifest 编辑器中的“使用 SDK”并检查最小 SDK 是否设置为 10 (API 10)。

图 3： Eclipse 中的描述文件编辑器

我们现在已准备好向 Eclipse 中的该项目添加 NDK build 支持。 在 Eclipse 中，右键单击 hello-jni 项目 (com.example.hellojni.HelloJni) -> Android 工具 -> Add Native 支持 -> 完成。

图 4： 将 NDK 支持添加至 Eclipse 中的项目

这样将使用和 NDK 构件相关的设置更新项目配置。 在我们重新构建项目时，它将先编译并构建 NDK 代码，将构建的库复制到相应的项目文件夹，然后继续常规的 APK 构建流程。

在模拟器中构建并运行应用

现在继续构建应用，并在 Android 模拟器中运行它。 我们假定已经在基于 HAXM 的 Android 模拟器上运行 Gingerbread x86 AVD。

在 Eclipse 中，右键单击 hello-jni 项目 (com.example.hellojni.HelloJni) -> 运行为 -> Android 应用。 Eclipse 应当自动重建项目并尝试在模拟器上部署/运行 APK。

但是在模拟器运行时我们看到了下面的错误消息，这是因为默认的 NDK 项目设置不支持 x86。

图 5： 在模拟器中运行示例应用

在 Eclipse 中，您可看到 logcat 显示错误“无法加载 hello-jni”

图 6： Logcat 显示无法加载原生库

默认情况下，NDK build 不会自动为 x86 ABI 进行构建。 我们将需要创建构件文件“Application.mk”来明确指定我们的构建目标，或将命令行参数传入 NDK build 命令。

移植应用以使用 x86 ABI 和 NDK build 文件

我们可修改项目以支持 x86 ABI。 在 Eclipse 中，右键单击 hello-jni 项目中的“jni”文件夹，然后选择“新建”->“文件”-> 将“Application.mk”作为文件名输入，然后单击“完成”。

图 7： 将新的 NDK build 文件“Application.mk”添加至示例项目

编辑文件“Application.mk”，如下所示添加行“APP_ABI := all”，然后保存文件。

图 8： 编辑 Application.mk 文件以将“all”架构作为目标

构建应用，验证它是否构建 x86 库，并在 x86 模拟器中测试应用

当前在我们重新构建应用时，其将为 NDK 中所有支持的 ABI 进行构建。 右键单击 Eclipse -> 运行为 -> Android 应用中的“hello-jni”。 Eclipse 将自动调用 NDK build 并生成所有原生库。 您可如下所示在库文件夹下验证它。

图 9： Eclipse 项目资源管理器显示生成的原生库

Eclipse 将在模拟器中部署应用。 此时我们应当会看到应用成功运行，如该截屏中所示：

图 10： 示例应用成功地在 x86 Android 模拟器内运行

我们希望该文章可帮助您了解如何配置 Eclipse ADT 以在 NDK 代码开发中使用它，以及如何使用 NDK build 文件“Application.mk”来为所需的目标 ABI 进行构建。

通知

本文件中包含关于英特尔产品的信息。 本文件不构成对任何知识产权的授权，包括明示的、暗示的，也无论是基于禁止反言的原则或其他。 英特尔不承担任何其他责任。英特尔在此作出免责声明：本文件不构成英特尔关于其产品的使用和/或销售的任何明示或暗示的保证，包括不就其产品的(i)对某一特定用途的适用性、(ii)适销性以及(iii)对任何专利、版权或其他知识产权的侵害的承担任何责任或作出任何担保。

本文件中包含关于英特尔产品的信息。 本文件不构成对任何知识产权的授权，包括明示的、暗示的，也无论是基于禁止反言的原则或其他。 英特尔不承担任何其他责任。英特尔在此作出免责声明：本文件不构成英特尔关于其产品的使用和/或销售的任何明示或暗示的保证，包括不就其产品的(i)对某一特定用途的适用性、(ii)适销性以及(iii)对任何专利、版权或其他知识产权的侵害的承担任何责任或作出任何担保。

英特尔有权随时更改产品的规格和描述而毋需发出通知。 设计者不应信赖任何英特产品所不具有的特性，设计者亦不应信赖任何标有“保留权利”或“未定义”说明或特性描述。 对此，英特尔保留将来对其进行定义的权利，同时，英特尔不应为因其日后更改该等说明或特性描述而产生的冲突和不相容承担任何责任。 此处提供的信息可随时改变而毋需通知。 请勿根据本文件提供的信息完成一项产品设计。

本文件所描述的产品可能包含使其与宣称的规格不符的设计缺陷或失误。 这些缺陷或失误已收录于勘误表中，可索取获得。

在发出订单之前，请联系当地的英特尔营业部或分销商以获取最新的产品规格。

索取本文件中或英特尔的其他材料中提的、包含订单号的文件的复印件，可拨打1-800-548-4725，或登陆 http://www.intel.com/design/literature.htm

在性能检测过程中涉及的软件及其性能只有在英特尔微处理器的架构下方能得到优化。 诸如SYSmark和MobileMark等测试均系基于特定计算机系统、硬件、软件、操作系统及功能。 上述任何要素的变动都有可能导致测试结果的变化。 请参考其他信息及性能测试（包括结合其他产品使用时的运行性能）以对目标产品进行全面评估。

对本文件中包含的软件源代码的提供均依据相关软件许可而做出，任何对该等源代码的使用和复制均应按照相关软件许可的条款执行。

英特尔和 Intel 标识是英特尔在美国和/或其他国家的商标。

英特尔公司 © 2013 年版权所有。 所有权保留。

* 其他的名称和品牌可能是其他所有者的资产。

优化声明

Introduction

Initially, Intel GPA was created for developers targeting PC games running the Windows* OS. Many of the top-selling games utilized Intel GPA when analyzing and optimizing their games running on the Windows platform.

For Windows workloads, developers can run one of three tools: Intel GPA System Analyzer (both HUD and Remote), Intel GPA Frame Analyzer, and Intel GPA Platform Analyzer. Each of these tools helps customers quickly pinpoint performance issues with a different aspect of their graphics application, such as whether the game is CPU-bound or GPU-bound, or what portions of the rendering pipeline are responsible for performance bottlenecks within a specific frame.

But with the rapid rise of Android* game development, Intel GPA System Analyzer also supports game analysis for Intel Atom processor-based phones running the Android operating system. With this capability, Android developers get a real-time view of over two dozen critical system metrics covering the CPU, GPU, and OpenGL-ES* API. In addition, the tool provides a number of graphics pipeline experiments that help developers quickly isolate graphics bottlenecks. And in keeping with the flexible nature of Android development, Intel GPA System Analyzer runs on three different development platforms: Windows OS, Apple OS X*, and Linux* Ubuntu*.

You can download the various versions of the product from the Intel GPA Home Page.

The rest of this article provides more information about Intel GPA's support of the Android platform, and provides guidance on which version of the product you should download and install.

Versions of Intel GPA

Intel GPA's architecture is quite adaptable, and is based upon communication via sockets between the target system (where your game runs) and the analysis system (where you run the Intel GPA tools). Because of this extensible architecture, the product supports the analysis of both Windows* OS platforms as well as mobile platforms -- you can analyze games on Intel® Atom™ phones running the Android* OS from a variety of development systems: OS X, Ubuntu, and Microsoft Windows.

Here is a chart showing the different platforms supported by Intel GPA, and some tips on installation of the product:

A couple of notes regarding the table above:

• All versions of the product are available from the Intel GPA Home Page -- click the Download button on the page to see a popup dialog box which includes download links for the different platforms.
• For the Windows* OS target platform, all Intel GPA tools can run on both the target platform and the analysis platform (that is, Intel GPA System Analyzer HUD, Intel GPA System Analyzer (client/server mode), Intel GPA Frame Analyzer, and Intel GPA Platform Analyzer). For the Android* OS target platform, only the Intel GPA System Analyzer (client/server mode) runs on the target platform.
• For the Microsoft* Windows* 8 OS, Intel GPA does not support the RT version of this OS.
• For more information about Intel GPA on the Android* OS platform, either read this article or see the Android* section of the Intel GPA Online Help.

Downloads

Article Download: 360 VideoBall Application Performance on Intel's Clover Trail+ Smartphones (PDF)

360 VideoBall Application Performance on Intel's Clover Trail+ Smartphones

Finwe, an agile software development and research company based in Finland, has been a major contributor to the mobile game and video solutions. Two of its game apps, Fantasy Dice and 3D gyro compass, gained positive feedback in the market. As a showcase of their skills, they have released a 360 panorama video player for mobile devices, called 360 VideoBall, which utilizes state-of-the-art sensor fusion to facilitate high accuracy motion tracking. In simple terms, you no longer need to struggle with touch navigation on a small screen. Instead, you can simply move the device to issue commands to videos, games, or applications.

Finwe, a company known to take user experience to new levels, is also known for optimizing its apps’ response times and user interaction. Its premier application, 360 VideoBall, was primarily built for the Android* ARM and iOS* platforms. Not too surprisingly, 360 VideoBall gave excellent results when ported to the x86 based Android OS* and tested on Intel® Atom™ processor-based tablets (code named Clover Trail) and smartphones. UI software development was done with Rightware Kanzi* Studio, which facilitated high optimization of the OpenGL* implementation. It actually came out as the second fastest platform with HD video streaming at a rate of 60 frames per second, which is much better than the 50 frames per second from the ARM build. The industry will have to wait and see, if we are getting this speed from 32-nm Clover Trail+ architecture-based smartphones running Android 4.2, what improvements will we see on the smartfones based on the 22-nm Bay Trail platform.

You can download the 360 VideoBall application for free here: https://play.google.com/store/apps/details?id=fi.finwe.panoramavideo

I am back in my hotel after the first day at IDF2013. I did not do any of the fun stuff today, but I did work... practiced my session content and in mid-afternoon delivered a session on Meshcentral.com and Intel platform features, it was a lot of fun! Thank you to everyone that attended. Tomorrow I am doing it again, this time two 2 hour labs back-to-back.

SFTL003: Using Intel® AMT and Intel® Smart Connect Features From the Cloud
Day 2, Wednesday September 11th, 1:00 to 3:15pm, Room 2000
Day 2, Wednesday September 11th, 3:45 to 6:00pm, Room 2000

For people that want more technical details, I will be diving into code and showing off even more features of Meshcentral.com. Hope to see many of you there.

Ylian
meshcentral.com

In many marketing strategies, you will often see product offerings get positioned in a Good / Better / Best kind of framework. Whether intentional or accidental, this morning's keynote followed the same pattern, broken out by the VPs that presented. So let's go through them in order..

Dr. Hermann Eul, Vice President & General Manager, Mobile and Communications Group

This was the "good" presentation, but not because there were some great news in the segment, but rather because the execution could have been better. On the upside, he was able to announce the new Atom-class processor called Bay Trail, formally known as: "Intel® Atom™ Z3000 Series." You can read the full press release here: http://newsroom.intel.com/community/intel_newsroom/blog/2013/09/11/intel-launches-new-multicore-low-power-socs-for-tablets-2-in-1s-and-other-computing-devices

But, some of the highlights of this amazing new product is that is built on our latest, cutting edge, 22nm process that uses the tri-gate transistors and is based on our ultra-efficient Silvermont architecture and will come with 4 cores. Perhaps the best part of this announcement was that, purely by coincidence (I swear the guy wasn't a plant), our CEO got asked yesterday: "Tablets are cool and everything, but when do I get to edit video on a tablet?" I believe Brian's answer was roughly "soon." Well, we now know what Brian means by "soon" because, as part of a demo of what Bay Trail can do, live on stage the specialist used it to actually edit video on a tablet. From any angle you look at it, that was awesome! But then we slipped into the area that wasn't so awesome. The next demo involved brining some fashion "expert" lady up on stage & the next 20 minutes seemed to drag on as she talked about things that I don't understand. i think I'm in the core demographic of the audiance where I can honestly say that a) I've never walked down a cat walk & b) i have no intention of ever doing that, in the real world or the virtual one. While, mathematically I can appriciate the computational complexities of simmulating the  behavioer of cloth on an avatar, every minute of an IDF keynote is precisious and to waste it on this topic that didn't resonate with the audiance really should have been reconsidered. But aside from that glitch, there was some great news and the future of Intel in tablets looks extremely bright!

Kirk Skaugen, Senior Vice President & General Manager, PC Client Group

This was definitely the better keynote because every keynote was amazing. There was a combination of Bay Trail and Haswell designs shown that really highlight the innovative designs that are either hear already or coming around the corner. The new term of #2in1 is really going to make people rethink their future purchase. I, like many other people that have tried a tablet, can see the advantages they have pretty easily. But, like most profesionals that spend more time typing on a keyboard than I'd care to admit, I sometimes need the power of a more conventiona computing experience. And that is where this 2in1 concept shines;

It is a Tablet when you want and a PC when you need it

it is literally the perverbial "best of both worlds" and that is an approach that has people talking. At one point they had 4 different folks with 4 different models - some slide, some detached, some flipped, and one of them did cartwheels - or ferriswheels as they called it. Since the keynote, I've spoken to several people and, interstingly, many different folks like the different solutions better. Which, says to me, the future will usen many of these various different approaces to get you what you really want - which is simply whatever you want, whatever you want, without compromises.

Another big part of Kirk's talk was about the wonders of the vPro refesh. In fact there was 1 slide that had some amazing stuff on it, but he went through it so fast, it felt a little bit like an auction, but here's the slide:

But then, as if the potential future of nevery having to remember a password again wasn't good enough, we got a little peak at the next core product, codenamed Broadwell, which is based on 14 nm and was running live on stage. The interesting point was the showed it running the same bechnmark as a current generation processor (Haswell), but it consumed 30% Less Power! That is so cool (all pun intended) that there should actually be completely fanless versions of the future Intel Core products. How amazing is that?

Douglas Fisher, Vice President & General Manager, Software and Services Group

And last, but the best, was Doug Fisher, who closed out the keynote with great story after great story, including a brief conversation with an executive with Google.. All of that was to completely cement the sentiment what Intel is into Android in a big way. Between the two of them, there was tight commitment to be closely aliigned on all future releases which, quite honestly was music to my ears. In truth, I've been an Android Fan Boy since 1.6 and I think it is just brilliant. But then to find out that there are over 1,000 engineers at Intel devoted to JUST supporting OSes from Google, I thought that was just brilliant! But it didn't stop there. Instead, there were some really cool tools and services that are available today for your use. In order that they were discussed, they were:

• Beacon Mountain - fulling integrated Android development environment
• http://software.intel.com/en-us/vcsource/tools/beaconmountain
• Havok Project Anarchy - a FREE tool for developing for Android, iOS, and Tizen
• http://www.projectanarchy.com/
• The NEW Intel XDK - an HTML5 Cross-platform Development Kit that publishes to Windows 8, Windows Phone 8, Android, iOS, and Facebook
• http://html5dev-software.intel.com/

But the umbrella that covered it all was the Intel Developer Zone - the 1 place that any and all software developers can go to get all kinds of support regardless of the type of development they are doing. It doesn't matter if you write for Windows, or for Android, or in HTML5, we've got all types of help for you from Tools to code snippets and other resources to help you to get your project finished! You can find it at:

http://software.intel.com<< go there and sign-up today to get kept informed of what's going on!

So that's it - that's what I saw - leave me a comment below if you have any questions or hit me on social media at:

~ +Eric Mantion on Google+ or @CaptGeek on Twitter

O Inside the Bracketsé uma série de discussões online sobre HTML5 que a Intel promove entre grandes especialistas da Indústria e desenvolvedores. Em cada discussão, você primeiro ouve os especialistas debatendo sobre o tema do dia, e na sequência existe uma sessão de perguntas e respostas via chat, uma excelente oportunidade para os desenvolvedores brasileiros tirarem todas as suas dúvidas direto com eles.

Depois do sucesso do primeiro episódio, que discutiu os motivos pelos quais empresas e desenvolvedores devem considerar o HTML5 como plataforma de desenvolvimento de Apps, trazemos no segundo episódio uma discussão que costuma ser mais do que acalorada nas rodas de bate papo que tenho frequentado em eventos no Brasil: HTML5 vs Código Nativo ?

Aplicações em HTML5 tem como principal característica o suporte a múltiplas plataformas e diferentes tipos de dispositivos com uma única base de código. Aplicações desenvolvidas em código nativo tem em geral uma integração maior com os sistemas operacionais, o que as torna potencialmente mais otimizadas, mas este possível ganho de performance e integração demanda uma maior dedicação e expertise do desenvolvedor.

Enquanto com o HTML5 uma única base de código atende a um número elevado de plataformas, no desenvolvimento nativo, diversas bases de código precisam ser desenvolvidas e mantidas, pois cada sistema operacional possui seu próprio SDK e uma linguagem específica de desenvolvimento (ex. Java, Objective-C e C#). Analisar os prós e contras de cada abordagem é essencial para o sucesso de qualquer App no competitivo mercado que temos hoje.

Se você já desenvolve Apps, e também tem esta dúvida tão comum nos dias de hoje, recomendo que participe da discussão e aproveite a oportunidade para tirar as suas dúvidas diretamente com pessoas que estão trabalhando em projetos e empresas de ponta no mundo dos Apps.

A inscrição gratuita pode ser feita aqui, e a discussão vai acontecer ao vivo no dia 18 de Setembro (Quarta Feira) ao meio dia, com uma segunda sessão agendada para a meia noite.

Se quiser mais informações sobre os especialistas que vão participar deste episódio, clique aqui.

Aproveite esta oportunidade para aprender e debater mais sobre o assunto, afinal de contas cedo ou tarde você estará em uma roda de conversa onde ele será mencionado. Prepare-se !

No último dia 10 de Setembro, foi anunciado o Intel® XDK NEW, a nova versão do Intel® XDK, com diversas novidades que simplificam mais ainda o desenvolvimento de Apps híbridos em HTML5.

Para quem quiser dar uma olhada em como está ficando esta nova versão, disponibilizamos um preview dela através deste link. O preview está disponível apenas para Windows, mas na versão final da ferramenta teremos suporte a Windows*, Linux* (Ubuntu*) e OS X*.

Estas foram as principais mudanças na ferramenta:

• Eliminada a dependência do Java* e do Chrome* (nada contra eles !). A nova versão do XDK foi desenvolvida usando o node-webkit, o que nos permite rodar o XDK em praticamente qualquer plataforma, além de nos dar maior controle sobre o gerenciamento local de arquivos, além do controle de arquivos na nuvem. Esta é uma das mudanças que atende a diversas sugestões que recebemos dos nossos usuários nos últimos meses. Aproveitando a oportunidade, gostaríamos de agradecer ao Roger Wang por criar e manter o node-webkit. Seu trabalho e seu projeto é de grande importância aos desenvolvedores web/HTML5.

• Uma nova ferramenta para construção de UI – App Designer – totalmente integrada ao XDK New. Ela suporta mais frameworks (jQuery Mobile*, Twitter* Bootstrap, e App Framework) permitindo mais escolhas para o design de UI, e permite ainda o “round-trip”, ou seja, você pode criar e modificar a sua UI a qualquer momento de forma totalmente integrada (quem usou o App Starter do XDK sabe bem do que estou falando aqui). Falando em App Starter, nesta primeira versão do XDK New, o App Starter vai estar disponível apenas na nuvem, mas planejamos integrá-lo ao XDK.

• Um novo editor de código, o Brackets*. Gostaríamos de agradecer aqui aos contribuidores do www.brackets.io, que nos oferece bastante ajuda na edição de código com syntax highlighting, auto-completion, JSLint* e muito mais. Claro que você pode usar o editor de código da sua preferência no dia a dia e importar os arquivos gerados por ele, mas se ainda não tem um editor predileto, vale a pena dar uma olhada no Brackets* que incluímos no XDK New.

• Um novo emulador baseado no Ripple* –  a AppMobi havia feito um grande trabalho no emulador atual do XDK, mas gostaríamos de adicionar suporte ao Cordova além das APIs da appMobi. Com esta mudança, você tem mais flexibilidade para adicionar APIs e usar recursos mais interessantes de simulação de dispositivos e plataformas. Uma das mudanças que mais gostei no emulador, é que agora ele, quando integrado ao App Framework, mostra como fica a UI do seu App caso você deixe a adaptação de temas a cargo do App Framework (sim, você escreve a UI uma única vez e o App Framework altera a sua apresentação gráfica de acordo com o sistema operacional e o tema utilizado, fazendo com que a sua UI fique “no padrão” do dispositivo do seu usuário, sem que você tenha que escrever uma única linha de código adicional para tratar isso).

• Uma nova interface de usuário –  simplesmente reescrevemos tudo baseado em tecnologias web. Isso nos permitiu criar uma nova UI para facilitar ainda mais a utilização da ferramenta e esperamos com isso facilitar a criação e gerenciamento de projetos, desde o armazenamento local deles até o seu build na nuvem.

• Suporte a mais plataformas – o Intel XDK New terá versões para Ubuntu* Linux*, Windows* e OS X*. Apenas o preview da versão Windows está disponível agora, mas em breve serão lançadas as outras versões.

• Suporte ao Cordova 2.9 – você agora pode criar, testar, emular, depurar e fazer o build na nuvem de apps baseadas no Cordova (PhoneGap*), além de poder continuar usando usar as APIs da AppMobi.

Para mais detalhes sobre as novas funcionalidades do XDK New, recomendo uma olhada nesta página aqui e se quiser baixar e testar logo o nosso preview, clique aqui.

Se quiser dividir conosco a sua opinião sobre esta nova versão da ferramenta, ou se tiver alguma dificuldade em utilizá-la, temos uma área especial do nosso fórum dedicada a ela, e pode ser acessada aqui.

With Android continually increasing in popularity it is always interesting to take a look at the latest collection of game engines available for the paltform. I am also further intersted in seeing which game engines include x86 support since the number of Intel x86 based mobile devices continue to increase. There are many game engine choices out there, all with a different set of features, pricing, maturity, etc. After doing some research, I found a wide variety of game engines that can be used for creating games that run on Android* based mobile devices. Some engines provide x86 support, while others can be ported to support x86 devices without too much effort.

Here is the ever expanding list of game engines I have collected information about. The list includes some features and details about each engine and an example game on Google Play if I could find one.

• Project Anarchy by Havok - http://www.projectanarchy.com/
  • FREE Cross-Platform Engine and Toolkit for Mobile Game Developers
  • Develop and release titles on iOS, Android and Tizen for free.
  • Extendible C++ plugin based architecture
  • Includes Havok’s Vision Engine together with Havok’s leading Physics, Animation Studio and AI tools
  • Available now

• GameMaker by YoYo Games - http://www.yoyogames.com/gamemaker/studio
  • 2D Cross platform game engine with support for iOS, Android, HTML5, Mac OS, Windows 8, Ubuntu and Windows Phone 8
  • Integrated Development Environment that manages fonts, sounds, game objects, etc.
  • Use GameMaker scripting language to write game logic.
  • Free for Mac and Windows export, license required for Android export.
  • Has native x86 Android support.
  • Examples: https://play.google.com/store/apps/details?id=com.yoyogames.lazymousefree, https://play.google.com/store/apps/details?id=com.yoyogames.planetdescent
  • More games: https://play.google.com/store/apps/developer?id=YoYo+Games+Ltd

• Corona Game Edition - http://www.coronalabs.com/products/corona-sdk/
• 2D cross platform (iOS, Android, Kindle and Nook) engine.
• Write games in scripting language Lua.
• Animated sprites, Social API integration, native device features integrated.
• Also used for application and eBook development.
• C++ based engine that should easily port to x86 Android devices.
• Starter license available for free and allows publishing. Additional features available with a paid license.
• https://market.android.com/details?id=com.base2.walkaboutb, https://play.google.com/store/apps/details?id=com.frozengun.freeze

• Unity 3D – http://unity3d.com
  
  • 2D/3D cross platform (iOS, Android, PC) with full-featured integrated editor.
  • PhysX physics engine, C#, javascript or Boo scripting language, multiplayer and network support, streaming assets, etc.
  • License purchase required for phone publishing, try for free.
  • No Android x86 support in current version.
  • https://market.android.com/details?id=com.ArtInGames.AirAttackHDLite

• Cocos2D - http://www.cocos2d-x.org/projects/cocos2d-x
• A port to C++ of the popular iPhone Cocos2D engine.
• Cross platform (Android, iPhone, Win32) 2D engine
• C++ based engine that supports x86 Android devices.
• Free engine with full source code.
• Example: https://market.android.com/details?id=com.xmg.cowsvsaliens

• jPCT-AE- http://www.jpct.net/jpct-ae/
• A java 3D engine optimized for Android.
• Nice set of features including 3DS, OBJ and other file support, skeletal animations, shader support, texture compression, collision detection, various lighting modes, transparency, fog, and more.
• An all java game engine that supports x86 Android devices.
• Free for personal and commercial use.
• Example: https://play.google.com/store/apps/details?id=mk.grami.max

• Libgdx - http://code.google.com/p/libgdx/
• Cross platform (Windows, Linux, OSX and Android) 2D/3D Android engine. Build, run and iterate on the PC before deploying to phone.
• C++ and Java based engine that easily ports to x86.
• Box2d physics, TMX tile map, shaders, 2D particle system, sprite support, camera apis, OBJ and MD5 model loaders.
• Full source code available for free.
• C++/Java based engine that with a few minor changes I was able to run on x86 Android devices.
• https://market.android.com/details?id=com.tani.penguinattack

• PlayN – https://code.google.com/p/playn/
  
  • Cross-platform game abstraction library for writing games. Compiles to, Desktop Java, HTML5 Browsers, Android, iOS and Flash
  • Include APIs for graphics, assets, Box2d physics, and more
  • Free and open source.
  • Examples: https://play.google.com/store/apps/details?id=gabumba.tupsu.android, https://play.google.com/store/apps/details?id=cz.rb.game
  • More demo and example links: https://code.google.com/p/playn/wiki/DemoLinks

• gameplay – http://gameplay3d.org/index.php
  
  • Open-source cross-platform 3D engine aimed at the indie game developer ecosystem.
  • Supports BlackBerry 10 and PlayBook, Apple iOS 5+, Android NDK 2.3+, Microsoft Windows 7, Apple MacOS X, Linux
  • Full featured rendering system, node-based scen graph system, particle system, Bullet physics engine, audio and UI systems, etc.
  • Open sourced under the Apache 2.0 license

• Adobe AIR – http://www.adobe.com/products/air.html
  
  • Use Action Script and Flash to build 2D/3D cross platform (iOS, Android, PC, BlackBerry and TV) apps and games.
  • There are several engines built on top of Flash that provide APIs to build games easily, see a list here http://www.adobe.com/devnet/games/gaming_engines.html
  • Hardware accelerated graphics, native extensions, Android Licensing Service support, and more.
  • Adobe authoring tool purchase required.
  • No Android x86 support in current version.
  • https://play.google.com/store/apps/details?id=air.com.d20studios.heromages

• Andengine - http://www.andengine.org/
  
  • 2D Android game engine
  • SplitScreen support, network multiplayer apis, live wallpaper support
  • Primarily a Java engine with some C++ that includes x86 native libraries.
  • Full source code available for free.
  • http://wiki.andengine.org/List_of_Apps_and_Games
  • https://market.android.com/details?id=com.bestcoolfungamesfreegameappcreation.bunnyshooter

• Esenthel Engine - http://www.esenthel.com/?id=overview
  
  • Modern 2D/3D C++ based game engine (Windows, Mac, Android and iOS)
  • Available for unlimited trial if used non-commercially
  • Scripting and C++ support, multiple renderers, animation system, physics engine, streaming game engine, GUI, etc.
  • DirectX 9,10,11, OpenGL, OpenGL ES 2.0, PhysX 3, PhysX 2, Bullet physics integration
  • Tools include a world editor, model editor, data browser, code editor and more.
  • One-click cross platform publishing
  • Android native x86 support
  • https://play.google.com/store/apps/developer?id=Esenthel

• Linderdaum Engine - http://www.linderdaum.com
  
  • Cross platform (Windows, Android) 2D/3D engine
  • Free engine with full source code
  • C++ based engine that supports ARM and x86 Android devices (precompiled x86-libs are also included).
  • http://play.google.com/store/apps/developer?id=Linderdaum

• ShadingZen - http://traxnet.github.com/ShadingZen/
  
  • A 2D/3D Engine for Android
  • Open Source (MIT License) with full source code
  • Java based and heavily optimized for mobile, supports multi-core CPUs.
  • https://play.google.com/store/apps/details?id=org.traxnet.kidscube

• Kivy - http://www.madewithmarmalade.com/
  
  • Open source Python library
  • Cross platform, running on Linux, Windows, MacOSX, Android and IOS.
  • Kivy is 100% free to use, under LGPL 3 licence.
  • Suport for getures, multi-touch, graphics and shaders
  • https://play.google.com/store/apps/details?id=org.kivy.showcase

• Marmalade SDK (previously Airplay SDK) - http://www.madewithmarmalade.com/
  
  • Cross platform (iOS, Android, BlackBerry PlayBook OS, bada, Windows Desktop, Mac OS, WindowsPhone 8) 3D C++ game engine.
  • Free to try for 30 days, license purchase required to publish.
  • C++ based engine that should easily port to x86 Android devices.
  • https://market.android.com/details?id=com.imperialgamestudio.golfbattle3d

• Gideros Studio - http://www.giderosmobile.com/
  
  • 2D cross platform (iPhone iPad, Android) game engine.
  • Write Lua code in provided IDE, iterate on PC with simulator.
  • Features include Box2d physics engine, fonts, sprites, tile maps and sensor integration.
  • Free version includes Gideros Splash screen, licensed version removes it.
  • https://play.google.com/store/apps/details?id=com.jenots.mashballs

• App game kit -http://www.appgamekit.com/
  
  • Cross platform (iOS, Windows, MacOS, Android, BlackBerry)
  • A 2D OpenGL based game engine with Box2D. Include support for Sprites, particles, input APIs, sound and music.
  • Looks like it is a C++ based engine that should easily port to x86 Android devices.
  • Write game code in BASIC or has an available upgrade option for writing native C++ code.
  • Free to try, license purchase required to publish.
  • https://market.android.com/details?id=com.texasoftreloaded.theblackhole

• ShiVa3D - http://www.stonetrip.com/
  
  • Multi-platform 3D game engine, which handles advanced shading systems, physics engine , HUD rendering and the sound library.
  • Cross platform (Windows, Mac OS, Linux, iPhone, Android, Palm, Wii, iPad, BlackBerry)
  • Write code in Lua or C++
  • C++ based engine that should easily port to x86 Android devices.
  • https://play.google.com/store/apps/details?id=com.dvidearts.crusadeofdestiny

• Orx - http://orx-project.org/
  
  • Orx is an open source, portable, lightweight, plugin-based, data-driven and extremely easy to use 2D-oriented game engine.
  • Cross platform (iPhone, iPad, Mac, Windows, Linux, Android) game engine.
  • Camera APIs, animations, sound, sprite rendering and data driven for fast and easy prototyping and development.
  • Free open source.
  • C++ based engine that should easily port to x86 Android devices.
  • Example: https://market.android.com/details?id=lyde.sik.gravity

• DX Studio - http://www.dxstudio.com/
  
  • 3D game engine with editor.
  • Android limited features now supported.
  • C++ based engine that should easily port to x86 Android devices.
  • Currently offered for free.

• SIO2 Engine – http://sio2interactive.com/
  
  • 2D/3D cross platform (iOS, Android, bada, WebOS, WIN32 ) game engine.
  • Iterate via simulator on PC
  • Features lua support, exporters for various 3d modeling tools, Bullet physics engine, path finding, sound apis, shader support, animation and networking support.
  • C++ based engine that should easily port to x86 Android devices.
  • Various licenses available for purchase, free to trial.

• Papaya Social Game Engine - http://papayamobile.com/developer/engine
  
  • Cross platform (iOS and Android) 2D engine.
  • Write games in scripting language, includes social APIs, physics, and particle effects.
  • C/C++ based OpenGL engine that should easily port to x86 Android devices.
  • Engine is free to download.
  • https://market.android.com/details?id=com.papaya.papayaFish_hd

• moai - http://getmoai.com/
  
  • Open-source game framework for Android, iOS and Chrome (via NaCl).
  • Lua scripting language based development engine that has integrated cloud services available.
  • Engine is open source and free to use, pay for cloud services.
  • https://play.google.com/store/apps/details?id=com.ziplinegames.slotstycoon

• Unigine - http://unigine.com/products/unigine/
  
  • 3D cross platform (Windows, Linux, Max, PS3, iOS, Android)
  • Physics, scripting, etc. Unclear what features are supported for mobile.
  • Evaluation available to companies working on commercial projects. License purchase required.
  • C++ based engine that should easily port to x86 Android devices.
  • Example: http://www.demolicious-game.com/

• Candroidengine - http://code.google.com/p/candroidengine/
  
  • 2D Java engine.
  • Sprites, tile animation, background APIs, etc.
  • Dalvik only engine that should work on all architectures.
  • Full source code available for free.

• Mages Engine - http://code.google.com/p/mages/
  
  • multiplayer client/server game engine
  • Java engine that should work on all architectures.
  • Full source code available for free.

• Unreal Development kit - http://udk.com/
  
  • No Android support in UDK. The full license on Unreal Engine needed for Android support.
  • This is the free edition of Unreal Engine 3 that provides access to the 3D game engine.
  • UDK supports iOS and Windows only.
  • Free to use UDK for noncommercial and educational use

• Rokon - http://code.google.com/p/rokon/
  
  • 2D engine no longer being updated, suggests the libgdx engine as an alternative.

• Cuttlefish Engine - http://www.cuttlefishengine.com/
  
  • Site is no longer working
  • 2D cross platform (Windows Phone, Android, iPhone, Windows PC) game

The great thing about Android on x86 is that it opens a new class of devices for all of the games built on these engines. Unfortunately not all these game engines have support for x86 native binaries but it’s probably just a matter of time. x86 support is available in the latest Android NDK. Porting to x86 for some of these engines may simply be a recompile. We have created a couple of documents to guide you and have forums available to help along the way.

• NDK Android Application Porting Methodologies
• Understanding x86 vs ARM Memory Alignment on Android
• Android* Application on Intel® Architecture Forum link

This post continues to gain in popularity, as does the number of Android game engine choices. I will continue to update this post with the latest information from user comments and news from the web. I hope this list helps as a great starting point for those thinking about writing an Android game. Feel free to post comments about game engines I am missing or any updated information you find.

The idea of Kenya as the 'Silicon Savannah' (or Digital Savannah, as some would argue) is one that has gained a lot of traction over the last couple of years. Tech is the one area in which many young Kenyans generally and Africans specifically see themselves as having a genuine chance of making it big both locally and internationally. The concept of tech as the 'great equalizer' is one that holds great sway, and, combined with Generation Y's desire to work in non-traditional structures and break new ground as captains of their own destiny, the allure of tech in the developing world is huge and undeniable.

It therefore makes sense for Intel to seek to tap into the potential of this group of individuals. Following a similar event at Strathmore University in August in which the Intel Codezone Student Ambassador Program was launched, the SSG organized an Intel Developer Day at the Jomo Kenyatta University of Agriculture and Technology (JKUAT) on September 13, 2013. This Developer Day featured an app lab in the morning, followed by a talk in the afternoon by the iHub's Executive Director, Josiah Mugambi, and Intel's SSG Africa Lead, Agatha Gikunda to an audience of close to 300 IT students. The talk focused on exposing the students to what opportunities exist for them in tech in Kenya, and how they can take advantage of those opportunities by partnering with Intel and the iHub.

During an interactive session, the inevitable question of students being afraid to share their ideas because of the fear of those ideas being stolen came up. This issue has been brought up time and again, with a significant majority of students and tech entrepreneurs believing that they have to keep their ideas to themselves and guard them heavily in case they are appropriated by another entrepreneur or organization. While there is some truth to this, the problem with this approach is that there's very limited collaboration or idea-sharing among local tech entrepreneurs, which ultimately ends up hurting the industry on the whole as there is a proliferation of multiple similarly-themed concepts that could be strengthened considerably by working together.

To paraphrase this piece from Wired on how successful networks nurture good ideas:

Why would the same ideas have occurred to different people at the same time? Ogburn and Thomas argued that it was because our ideas are, in a crucial way, partly products of our environment. They’re “inevitable.” When they’re ready to emerge, they do. This is because we do not work in a sealed-off [environment]. The things we think about are deeply influenced by the state of the art around us: the conversations taking place among educated folk, the shared information, tools, and technologies at hand. 

When you can resolve multiples and connect people with similar obsessions, ideas flourish and multiply. Scientific journals and citation were a successful attempt to create a worldwide network, a mechanism for not just thinking in public but doing so in a connected way.

Today we have something that works in the same way but for everyday people: the Internet, which encourages public thinking. It’s now the world’s most powerful engine for putting heads together.

Failed networks kill ideas, but successful ones trigger them.

It is clear that the students have talent. Several of them already have apps that are in local appstores, with one of those apps having over a million downloads to date. The ability to create is not in question. In order to foster a better culture for developers to really thrive and build sustainable, profitable products, though, ways need to be found to push for greater openness and increased collaboration in spaces like these. Connecting the students to each other across both similar and disparate disciplines, connecting them to mentors, strengthening the power of networks to help their ideas really take root - this is perhaps how best to help this nascent industry grow.