1. Introduction

The 4.1 version of Android* has a new improvement that optimizes multi-thread applications running on multi-core processors. The Android operating system can schedule threads to run on each CPU core. In addition, on Intel architecture (IA)-based devices, you have another way to implement multi-core optimization—Intel® Threading Building Blocks (Intel® TBB).

Intel TBB can be downloaded from http://threadingbuildingblocks.org/download. You must choose the Linux* version. You also need libtbb.so and libtbbmalloc.so, which you can download from lib/android.

2. Using Intel TBB with SSE

As we know, SSE ( Streaming SIMD Extensions) can get amazing performance improvements on IA devices, but it only works for single core. Using Intel TBB together with SSE will get the best performance on multi-core devices. Here, I use a program called YUV2RGB as an example.

YUV2RGB is a color space transform function. You can find this function in many open-source web sites, such as ffmpeg and opencv. Generally it has SSE (or MMX2) function for IA platforms. SSE optimization can get nearly a 6x performance improvement.

See * below

But on the Intel® Atom™ processor which is based on a 2-core 4 hyper-threads , Intel TBB can get 2.2X performance improvement. The score should be better when running on more CPU cores.

See * below for performance tests notice

3. How to do in detail

For image processing, we generally apply SSE optimization on the image width. That is to say, we get 8~16 pixels and package them into the XMM register, and then run the SSE instruct on the whole width. Generally, for each width the operation is nearly the same, so parallelism is possible for the height. Sample code for parallelism image processing is shown below:

#include "tbb/task_scheduler_init.h"
#include "tbb/blocked_range.h"
#include "tbb/parallel_for.h"

using namespace tbb;

class multi_two
{
public:
  void operator()(const tbb::blocked_range<size_t>& range) const
  {		
		Log (“range.begin(),range.end()”);
		for(int j=range.begin();j<range.end();j++) {
			for(i=0; i<ImgWidth; i+=8) {
				__asm__ volatile(
				// do sse 
			);
				YUVBuffer+=8;
			}
		}
		//.. the same as UV
  }
    multi_two(BYTE * _RGBBuffer, BYTE * _YUVBuffer)
    {
    	RGBBuffer = _ RGBBuffer;
		YUVBuffer = _ YUVBuffer;
    }
private:
		BYTE * RGBBuffer;
BYTE * YUVBuffer;
};

void YUV2RGB(BYTE * YUVBuffer, BYTE * RGBBuffer)
{
	tbb::parallel_for(tbb::blocked_range<size_t>(0, height/2), multi_two(YUVBuffer , RGBBuffer ));
	
	//if using MMX, remember add emms after all parallel computing finish
	//__asm__ volatile("emms");	
}

parallel_for is the simplest usage for Intel TBB. You must create a class that has a function named “operator,” and pass this class as a parameter. The blocked range is important to Intel TBB, as the range tells Intel TBB to split the whole operation into several task ranges from range.begin() to range.end(). So if you set the range as [0,4], you can get 4 logs which may be [2,3], [0,1], [3,4], [1,2]. Generally, we set the task range from 0 to height/2 (for UV height, it is Y height/2).

Note: The task is not a thread. Intel TBB will create a thread pool according to the CPU core number and distribute these tasks into running threads (from the thread pool). So Intel TBB will try splitting tasks evenly into each thread (each thread binding into a CPU core), and get the best performance compared to multi-thread.

4. Intel TBB vs. Multi-Thread

pthread_create(&m_StreamingThread1, NULL, streamingThreadProc1, NULL);
pthread_create(&m_StreamingThread2, NULL, streamingThreadProc2, NULL);
pthread_create(&m_StreamingThread3, NULL, streamingThreadProc3, NULL);
pthread_create(&m_StreamingThread4, NULL, streamingThreadProc4, NULL);

void* status;
pthread_join(m_StreamingThread1,&status);  //wait thread1 finish
pthread_join(m_StreamingThread2,&status);  //wait thread2 finish
pthread_join(m_StreamingThread3,&status);  //wait thread3 finish
pthread_join(m_StreamingThread4,&status);  //wait thread4 finish

This demo compares Intel TBB and multi-thread. It splits single threads like this:

When no other threads are running, the execution times for Intel TBB and multi-thread are nearly the same. But when I add some dummy threads that just wait 200 ms, things change. Multi-thread is slower even than single thread, but Intel TBB’s time is still good. The reason, you assume, is that all threads will finish at the same time. But actually some other threads will block the four threads running, so that the total finish time will be slower.

Test results are shown in the table below (each step adds 2 dummy threads, the dummy thread is just waiting 10 ms).

See * below for performance tests notice

"*": Software and workloads used in performance tests may have been optimized for performance only on Intel microprocessors. Performance tests, such as SYSmark and MobileMark, are measured using specific computer systems, components, software, operations and functions. Any change to any of those factors may cause the results to vary. You should consult other information and performance tests to assist you in fully evaluating your contemplated purchases, including the performance of that product when combined with other products.
Configurations: [describe config + what test used + who did testing]. For more information go to http://www.intel.com/performance

Introduction

NFC (near field communication) is a standards-based, short-range wireless connectivity technology that enables simple and intuitive two-way interactions between electronic devices. It is very convenient to touch and communicate between two NFC devices. For example, with smartphone-integrated NFC technology, you can easily touch your phone to purchase items, share business cards, download discount coupons and so on. You will see many NFC-based new usages will be developed in the future.

This paper introduces NFC-based technology and usage modes in the current market. Then it also describes how to use NFC in the android applications. Finally, it presents two case studies for how to develop the NFC-based reader/writer applications.

NFC Technology Architecture

NFC is based on RFID technology at 13.56 MHz, with a typical operating distance up to 10 cm. The data exchange rate is up to 424 kilobits/s. Compared to other communication technology, the biggest advantage of NFC is it is quick and easy to use. The following graph compares NFC to other communication technologies.

Figure 1: Comparison of short-range communication technologies

NFC technology has three modes: NFC card emulation mode, peer-to-peer mode, and reader/writer mode, shown in the following graph.

Figure 2: NFC Protocol Families

In card emulation mode, NFC simulates an RFID integrated circuit (IC) card, with a security module, which allows users to make purchases safely. In peer–to-peer mode, you can share information, such as business cards, between different NFC devices via an NFC connection. You can also set up a WiFi* or Bluetooth* connection quickly through the NFC connection and transfer big files through the WiFi or Bluetooth connection. In reader/writer mode, you can use NFC-enabled devices to read NFC tags and launch smart tasks.

Each mode is discussed in more detail below.

NFC Card Emulation Mode

An NFC module usually consists of two parts: an NFC controller and a secure element (SE). The NFC controller is responsible for communication. The SE is responsible for encrypting and decrypting sensitive data.

Figure 3: NFC Hardware Components

The SE connects to the NFC controller via SWP (Single Wire Protocol) or DCLB (Digital Contactless Bridge) bus. NFC standards define a logical interface between the host and the controller allowing them to communicate via the RF-field. A built-in app or a small OS implements the SE, which is responsible for the encrypting and decrypting the sensitive data.

The three solutions to implement the SE are:

• Embedded in SIM card
• Embedded in SD card
• Embedded in NFC Chip

Figure 4: Three NFC SE Solutions

The telecom operators, such as CMCC (China Mobile Communication Corporation), Vodafone and AT&T, usually prefer the SIM card-based solution, who are encouraging their users to replace old SIM cards with new NFC-enabled ones for free.

NFC Peer-to peer Mode

Two devices with NFC can communicate directly and easily to share small files such as business cards. Two NFC-enabled devices can also share configured .xml files with each other and establish Bluetooth/WiFi connection to share big files. In this mode, no SE module is needed.

NFC Reader /Writer Mode

In this mode, the NFC host can read/write NFC tags. A good example is to read useful

information from smart posters. Users can access links to view the advertisements and download discount coupons.

Figure 5: NFC Reader/Writer Mode

Introduction to Android NFC development

Android supports NFC with two packages: android.nfc and android.nfc.tech.

The main classes in the android.nfc package are:

NfcManager: Android devices can be used to manage all indicated NFC adapters, but because most Android devices support only one NFC adapter, NfcManager is generally called directly with getDefaultAdapter to get the specific phone adapter.

NfcAdapter: It works as an NFC agent, which is similar to the network adapter installed in the computer,by which cellphones access the NFC hardware to initiate NFC communication.

NDEF: NFC standards define a common data format called NFC Data Exchange Format (NDEF), which can store and transport various kinds of items, ranging from any MIME-typed object to ultra-short RTD-documents, such as URLs. NdefMessage and NdefRecord are two kinds of NDEF for the NFC forum defined data formats, which will be used in the sample code.

Tag: Android defined it represents a passive object like labels, cards, and so on. When the device detects a tag, Android will create a tag object, then put it in the Intent object, lastly send it to the appropriate Activity.

The android.nfc.tech package also contains many important sub-classes. These sub-classes provide access to a tag technology's features, which contain read and write operations. Depending on the type of technology used, these classes are divided into different categories, such as: NfcA, NfcB, NfcF, MifareClassic, and so on.

When a phone has NFC turned on, and after detection of a TAG, the TAG distribution system will automatically create a package of NFC TAG information of intent. If the phone has more than one application that can deal with this intent, a pop-up box will ask the user to choose which TAG activity to do. The TAG distribution system defines three types of intent. It is arranged in descending order of priority:

NDEF_DISCOVERED, TECH_DISCOVERED, TAG_DISCOVERED

Here we use the action intent-filter type to handle all types from TECH_DISCOVERED to ACTION_TECH_DISCOVERED. The file nfc_tech_filter.xml is used for the types defined in the file TAG. For details, see the Android documentation. The figure below shows the Activity of the matching process when the phone detects a TAG .

Figure 6: Process of NFC Tag Detected

Case study: Develop an NFC-based reader/writer application

The following demo shows the reader/writer function for the NFC tag. Before you can access a device's NFC hardware and properly handle NFC intents, declare these items in your AndroidManifest.xml file:

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

The minimum SDK version that your application must support is level 10, so declare these items in your AndroidManifest.xml file:

<uses-sdk android:minSdkVersion="10"/>

In the onCreate function，you can apply the NfcAdapter：

public void onCreate(Bundle savedInstanceState) {
……
adapter = NfcAdapter.getDefaultAdapter(this);
……
}  

The following Intent call back shows the reader function. If the system broadcast Intent equals NfcAdapter.ACTION_TAG_DISCOVERED , then you can read the information in the tag and show it.

@Override
	protected void onNewIntent(Intent intent){
		if(NfcAdapter.ACTION_TAG_DISCOVERED.equals(intent.getAction())){
		mytag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);  // get the detected tag
		Parcelable[] msgs =
intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
			NdefRecord firstRecord = ((NdefMessage)msgs[0]).getRecords()[0];
			byte[] payload = firstRecord.getPayload();
			int payloadLength = payload.length;
			int langLength = payload[0];
			int textLength = payloadLength - langLength - 1;
			byte[] text = new byte[textLength];
			System.arraycopy(payload, 1+langLength, text, 0, textLength);
			Toast.makeText(this, this.getString(R.string.ok_detection)+new String(text), Toast.LENGTH_LONG).show();
					}
	}

The following code shows the writer function. Before you can determine the value of mytag, you must know whether there is a tag detected or not, then write the information to mytag.

If (mytag==Null){
	……
}
else{
……
write(message.getText().toString(),mytag);
……
}
	private void write(String text, Tag tag) throws IOException, FormatException {
		NdefRecord[] records = { createRecord(text) };
		NdefMessage  message = new NdefMessage(records);
// Get an instance of Ndef for the tag.
		Ndef ndef = Ndef.get(tag); // Enable I/O
		ndef.connect(); // Write the message
		ndef.writeNdefMessage(message); // Close the connection
		ndef.close();
	}

Depending on the information read from the tag, you can do more operations, such as launch a smart task, access a web site, and so on.

Case study: Develop an NFC-based application that uses the MifareClassic Card

In this demo, we use the Mifare card for the data read test and use the card’s TAG type, MifareClassic. The MifareClassic card is commonly used in many scenarios, such as ID card，bus card and so on. The traditional MifareClassic card’s storage space is divided into 16 zones (Sector), each zone has four blocks (Block), and each block can store 16 bytes of data.

The last block in each district is called the Trailer, which is mainly used to store the local block key for reading and writing data. It has two keys: A and B, and each key length is 6 bytes, the default value of which is generally full-key FF or 0 by the MifareClassic.KEY_DEFAULT definition.

So when writing the Mifare card, you first need to have the correct key value (play a protective role), and the successful authentication must be done before a user can read and write data in the area.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"   
    package="org.reno"   
    android:versionCode="1"   
    android:versionName="1.0">   
    <uses-permission android:name="android.permission.NFC" />   
    <uses-sdk android:minSdkVersion="14" />   
    <uses-feature android:name="android.hardware.nfc" android:required="true" />   
    <application   
        android:icon="@drawable/ic_launcher"   
        android:label="@string/app_name">   
        <activity   
            android:name="org.reno.Beam"   
            android:label="@string/app_name"   
            android:launchMode="singleTop">   
            <intent-filter>   
                <action android:name="android.intent.action.MAIN" />   
   
                <category android:name="android.intent.category.LAUNCHER" />   
            </intent-filter>   
            <intent-filter>   
                <action android:name="android.nfc.action.TECH_DISCOVERED" />   
            </intent-filter>   
            <meta-data   
                android:name="android.nfc.action.TECH_DISCOVERED"   
                android:resource="@xml/nfc_tech_filter" />   
        </activity>  
    </application>   
</manifest>   

res/xml/nfc_tech_filter.xml：

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> 
    <tech-list> 
       <tech>android.nfc.tech.MifareClassic</tech> 
    </tech-list> 
</resources> 

An example of how to read a MifareClassic card is as follows:

     private void processIntent(Intent intent) {    
        Tag tagFromIntent = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);   
        for (String tech : tagFromIntent.getTechList()) {   
            System.out.println(tech);   
        }   
        boolean auth = false;   
        MifareClassic mfc = MifareClassic.get(tagFromIntent);   
        try {   
            String metaInfo = "";   
            //Enable I/O operations to the tag from this TagTechnology object.   
            mfc.connect();   
            int type = mfc.getType(); 
            int sectorCount = mfc.getSectorCount();   
            String typeS = "";   
            switch (type) {   
            case MifareClassic.TYPE_CLASSIC:   
                typeS = "TYPE_CLASSIC";   
                break;   
            case MifareClassic.TYPE_PLUS:   
                typeS = "TYPE_PLUS";   
                break;   
            case MifareClassic.TYPE_PRO:   
                typeS = "TYPE_PRO";   
                break;   
            case MifareClassic.TYPE_UNKNOWN:   
                typeS = "TYPE_UNKNOWN";   
                break;   
            }   
            metaInfo += "Card type：" + typeS + "n with" + sectorCount + " Sectorsn, "   
                    + mfc.getBlockCount() + " BlocksnStorage Space: " + mfc.getSize() + "Bn";   
            for (int j = 0; j < sectorCount; j++) {   
                //Authenticate a sector with key A.   
                auth = mfc.authenticateSectorWithKeyA(j,   
                        MifareClassic.KEY_DEFAULT);   
                int bCount;   
                int bIndex;   
                if (auth) {   
                    metaInfo += "Sector " + j + ": Verified successfullyn";   
                    bCount = mfc.getBlockCountInSector(j);   
                    bIndex = mfc.sectorToBlock(j);   
                    for (int i = 0; i < bCount; i++) {   
                        byte[] data = mfc.readBlock(bIndex);   
                        metaInfo += "Block " + bIndex + " : "   
                                + bytesToHexString(data) + "n";   
                        bIndex++;   
                    }   
                } else {   
                    metaInfo += "Sector " + j + ": Verified failuren";   
                }   
            }   
            promt.setText(metaInfo);   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
    }   

Summary

The smartphone equipped with NFC allow individuals to have everything they need at the tip of their fingers without lugging around ticket stubs or parking passes. The technology can even connect with friends to share information, play games, and transfer data. NFC strives to embrace both work and play, a crucial factor in creating its success and facilitating our lives in the future.

About the Author

Songyue Wang and Liang Zhang are application engineers in Intel Software and Service Group, and focus on mobile application enabling, including Android applications development and optimization for x86 devices, Web HTML5 application development.

Big news last week for Baidu, China's No. 1 search engine giant, Baidu, Inc. announced   that it will buy all equity interests in smartphone apps distributor 91 Wireless from NetDragon for a record 1.9 billion U.S. dollars. According to the memorandum of understanding, the move, which is Baidu's latest effort to show muscle to expand it business,  beyond its core search engine,  to the world’s No. 1  blooming mobile phone and tablet users ecosystem, is set to mark China's biggest merger and acquisition.

Another news for Baidu this week, Intel and Baidu announced the official launch of a joint mobile application Test Center (MTC), and offer free virtual test platform for compatibility as well as full test for application developed on Android on IA.

Picture above shows the Baidu Application Store interface. Most applications are free and in-app ads supported.

To help the majority of app application developers to quickly and cost-effectively develop and  publish applications for mobile devices based on Intel architectured.  Intel and Baidu is making available a combination of back-end server to the front end use of mobile devices,  mobile statistical services and one-stop testing and migration for mobile applications developers.  

Picture above shows the offical  Temple Run 2 application on Baidu.com. The application has 50 millions downloads thus far.

Every time  there is a new phone comeing out on the market, it is a very troubling issue for an app developer, as they need to buy a lot of mobile phones to be tested, or borrow a phone from a friend. So it is very beneficial for developers and partners to have  a  free virtual environment for a quick and easy way to validate their app and to enter the ecosystem with minimum cost. The proposed MTC testing center can complete the quick compatibility test in 2 hours and is comprehensive fully compatible test  in 6 hours online.

The picture above shows the in-browser application store on Baidu.com. Baidu has integrated its app store with the Baidu search page.. Bai Du Fact Sheet provides more information about Baidu and its search business.

      I’ll try to figure out what is new for Intel® Atom™ architecture in new versions of GCC and how this affects performance and code size on the well-known EEMBC® CoreMark®  benchmark: www.coremark.org

      The chart below shows CoreMark performance results for base and peak option sets on various GCC versions relative to GCC 4.4.6 base performance (higher is better):

base: “-O2 -ffast-math -mfpmath=sse -m32 -march=atom”

base + if convertion: “-O2 -ffast-math -mfpmath=sse -ftree-loop-if-convert -m32 -march=atom”

peak: “-Ofast -funroll-loops -mfpmath=sse -m32 -march=atom”, for 4.4 and 4.5 versions “-Ofast” is replaced with “-O3 -ffast-math”

See: http://software.intel.com/en-us/blogs/2012/09/26/gcc-x86-performance-hints for performance option details. One of the peak performance option: “-flto” delivers no extra performance on CoreMark.

Here we can see that the base option set with “-ftree-loop-if-convert” reached peak performance on CoreMark.

      The chart below shows peak to base binary code size ratio on CoreMark for different GCC versions:

      The chart below shows binary code size increase on CoreMark for base option set relative to GCC 4.4.6 base option set:

“-ffunction-sections -Wl,--gc-sections -fno-asynchronous-unwind-tables -Wl,--strip-all” was added to base and peak option sets to get numbers in the chart. These options do not affect performance on CoreMark.

See: http://software.intel.com/en-us/blogs/2013/01/17/x86-gcc-code-size-optimizations for details.

Here we can see that code size at peak option set is ~2 times larger than base and keeps growing, base option set code size is a little better than stable.

All measurements were made for the single thread run at Fedora 17 on Intel® Atom™ CPU D525, 1.80GHz, 4Gb memory, 2 cores.

      GCC showed very good progress from 4.4 to 4.8 version (mostly from 4.6 to 4.7 and from "if conversion" on base at 4.8 version). Code size on base option set is unchanged, on peak it keeps growing.

Below is a short summary of optimizations influence on CoreMark:

• GCC 4.5 is the first version introducing "-march=atom" (see http://gcc.gnu.org/gcc-4.5/changes.html). GCC 4.4 represented here just for back reference and CoreMark for this version was built with “-march=i686 -mtune=generic -mssse3”. Major number of current Unix systems are using gcc-4.4+. Note that some gcc-4.4 builds may have “-march=atom” option backported from 4.5. For example, Android NDK gcc-4.4.
• 4.6 version of GCC introduces much better inline algorithm and new opportunity to improve CoreMark performance: "-ftree-loop-if-convert" which is enabled by default at "-O3 (-Ofast)" and gives ~8% at “base” option set. Official changes: http://gcc.gnu.org/gcc-4.6/changes.html
• At 4.7 version GCC “-march=atom” get LEA and IMUL tuning as well as other Atom™ architecture specific improvements. By IMUL tuning, I mean IMUL grouping as the architecture has to switch into a special mode to calculate IMUL (fixed in latest Atom™ processor Silvermont). LEA tuning is replacing LEA with moves and adds when LEA result goes to ALU (fixed in latest Atom™ processor Silvermont). Official changes: http://gcc.gnu.org/gcc-4.7/changes.html
• 4.8 version of GCC improves bool optimizations resulting in less register pressure for some functions in CoreMark (affects only base option set with "-ftree-loop-if-convert” turned on). Also the 4.8 version introduces the ability to lower scheduler pressure: “-fschedule-insns -fsched-pressure” at high stability level on x86 (gives ~1% for CoreMark on peak option set). Generally “-fschedule-insns -fsched-pressure” add performance if "-funroll-loops" option is set. Official changes: http://gcc.gnu.org/gcc-4.8/changes.html

      What if GCC "-march=atom" was just “-march=i686 -mtune=generic -mssse3” at 4.8 version? Performance drop would be ~5%. "-ftree-loop-if-convert” would yield an additional 13% at "base". That’s another reason to switch to the newer version of GCC.

      So if you want to tune Atom™ application performance and care about code size, try GCC 4.8 with:

“-O2 -ffast-math -mfpmath=sse -ftree-loop-if-convet -fschedule-insns -fsched-pressure -m32 -march=atom”

      If code size is not critical, use GCC 4.8 and:

“-Ofast -flto -funroll-loops -mfpmath=sse -fschedule-insns -fsched-pressure -m32 -march=atom”

For people following work on Meshcentral, this day has been a long time coming. Today we are announcing that we started making Meshcentral available for hosting on Amazon EC2. Computer administrators anywhere now have a choice of using Meshcentral.com or launch their very own instance of Meshcentral on Amazon. They get control over the management data, user accounts and more. With many other online service, you have to use servers you don’t control and give up your data to someone else. Now, with this new option, you’re launching your own Meshcentral instance and take all of the control back, enabling a truly personal and secure cloud of devices.

Right now, we are making a free instance of Meshcentral available publically on Amazon with a 10 device management limit. This instance can run on the smallest Amazon instance, the “t1.micro”. Users new to Amazon AWS can run a t1.micro instance for 1 year for free, and so, many can try their own Meshcentral instance completely free of change. We have made amazing efforts to make Meshcentral fit on such a small virtual machine.

Even in such a tight virtual machine, Meshcentral instances packs loads of features: in-band web based remote desktop, terminal, file access, remote power control, audit logs, web page relay, TCP relay, mesh messaging, remote WMI, WiFi location, Intel AMT cloud provisioning, Intel AMT control, wide OS/CPU support and much more. When you launch a Meshcentral instance, fresh updated software is downloaded from Meshcentral.com and installed. Instances are always kept updated as new mesh features are added thanks to our unique Platform Manager software, that keeps track of signed software packages and deploys updates to all Amazon instances.

To get startedwe have documentation that includes a quick start guide, along with a YouTube tutorial video. Takes about 5 minutes to launch the instance and 15 to 20 minutes for the instance to set itself up. Instances create new certificates and cryptographic keys upon first launch so each Meshcentral instance is unique and secure. Give it a try, and give us feedback.

Ylian
meshcentral.com

Use a Meshcentral Amazon instance to create a truly personal cloud.
Run your own small business online management console.

Mesh Amazon Instances are setup and kept up to date from Meshcentral.com.

The all new online Mesh Settings Editor allows administrators to configure the Mesh Server online.
(You can even change IIS security and certificates, we restart and reconfigure IIS automatically)

Durante os dias 29, 30, 31 de Julho e 01 de Agosto tive o prazer de coordenar um Workshop de HTML5 na FEI, em São Bernardo do Campo. O evento foi organizado pela Faculdade e fez parte do calendário de cursos de inverno que eles oferecem. As inscrições foram abertas a todos os alunos da Faculdade e contamos com a presença de alunos dos cursos de Ciência da Computação e de Engenharia, além da participação de alguns funcionários do departamento de TI da FEI.

Tivemos 42 participantes durante os quatro dias de Workshop, que na verdade foi realizado nos moldes de um Hackathon dividido em quatro tempos. Dentro do grupo, contamos com desenvolvedores com experiência em javascript, css e HTML5, mas a grande maioria teve seu primeiro contato com estas linguagens durante o evento. O empenho e dedicação deles me impressionou bastante, principalmente se imaginarmos que ele foi realizado nas férias escolares, e que contamos com a aprazível temperatura de 7 graus no primeiro dia do evento, sem contar uma neblina digna do Silent Hill.

Foram criadas 25 ideias de apps durante o brainstorm realizado no segundo dia do evento, e desenvolvidas 10 Apps em pouco menos de 12 horas de codificação.

Abaixo vocês podem conferir o que foi desenvolvido, e todos eles são Apps híbridos em HTML5 que rodam em diversos sistemas operacionais e dispositivos móveis, e tivemos a oportunidade de ver isso na prática durante o evento, pois nos grupos de desenvolvimento era comum encontrar diversos tipos de dispositivos móveis com sistemas operacionais distintos.

Gostaria de agradecer imensamente a dedicação e empenho dos participantes, pois me mostraram mais uma vez que criatividade e vontade de aprender são mesmo características especiais de estudantes brasileiros. Vocês deram um show e me diverti bastante durante o tempo que passamos juntos.

Vale a pena a menção de que um décimo primeiro App foi desenvolvido no evento, a título de brincadeira (aliás, uma piada digital das boas), para mostrar que diversão também faz parte de um evento como este.

AppRun

App para monitoramento de corrida. Ao iniciar a aplicação o aparelho cronometra o tempo, distancia e exibe no mapa o resultado final Distancia X Velocidade, capturando o posicionamento do atleta através do GPS do dispositivo móvel.

Desenvolvedores: Anderson Drumond, Guilherme Sirça, Gleidson Roque, Heltom Pereira, Michelle Mota

Controle de Gastos

App que auxilia no controle de gastos, oferecendo função de inserir créditos e débitos, mostrando a quantidade de dinheiro restante e uma tabela com o histórico dos dados inseridos.

Desenvolvedores: Artur Seidi Hamada e Felipe Paes de Oliveira

GS Esportes – App para controle de eventos esportivos

Foi desenvolvido um aplicativo cliente para o site www.gsesportes.com.br, que é mantido por um dos desenvolvedores do projeto, onde o principal objetivo é fornecer uma interface amigavél de consulta de informações sobre eventos, resultados, fotos e demais produtos oferecidos pelo site. Há possibilidade dos usuários também de acompanharem e se inscreverem nos eventos que estão disponíveis na agenda da GS Esportes.

Desenvolvedores: Ramiro de Souza Silva e André Furlan

HelpDesk

O aplicativo tem como finalidade auxiliar o usuário de TI que não possui fácil acesso ao Computador ou ramal no local em que o mesmo se encontra, facilitando assim a abertura de chamado ao Helpdesk da empresa que presta o suporte técnico a este usuário.

Desenvolvedores: Antonio Samuel e Marcos Guedes.

Jogo da Velha

Jogo da Velha para dois jogadores desenvolvido com HTML5

Desenvolvedores: Allan Alves Hungaro dos Santos, Gabriel Silva de Alcântara e Paulo H. Máximo Vicentini

Gerenciador Financeiro – MyWallet

O MyWallet é o aplicativo ideal para você que quer controlar suas despesas, com ele você vai saber exatamente para onde seu salário esta indo.

Desenvolvedores: Thiago Cardoso, Vitor Corá, Victor Oliveira e Rafael Prado

OCR

O App de OCR extrai e exibe o texto de uma imagem já existente ou tirada através da câmera do smarphone pelo próprio aplicativo. Para converter a imagem em texto, o App utiliza um serviço na nuvem gratuito e já existente.

Desenvolvedores: Thiago Freitas dos Santos, Igor Leite Ladessa e Danilo Gouveia Castro

Pedido Remoto

Aplicativo que funciona como um garçom virtual, facilitando o atendimento em estabelecimentos grandes ou cheios. Os pedidos são feitos remotamente, por meio de cardápios disponíveis no App.

Desenvolvedores: Edson Oliveira, Eric Wu, Gustavo Gregorio, Héctor de Arruda, Newton Pereira Junior e Rodolfo Araujo

Simulador de tempo de torneio

O App foi criado com o intuito de calcular o tempo que um torneio pode durar, de acordo com os seguintes elementos: Número de Inscritos, Duração de um Set(rodada), Número de Estações e a possibilidade de ter Repescagem. Ele calcula o tempo e devolve em quantidade de Segundos. Por isso, ele também conta com um conversor que devolve essa quantidade de Segundos no tempo ideal: Horas, minutos e segundos.

Desenvolvedores: Anderson Minoru Ogura e Djalma Bereta Silva

Client para Streaming de Áudio

O App é um "Catálogo" para escolha de músicas para streaming de um servidor baseado em seleção de musicas por código.

Desenvolvedores: Fernando Oruê Dainese e Diego Takizawa

Today I am announcing Meshcentral’s support for in-band Windows multi-display. This is by far the most requested feature to date. In Meshcentral, administrators can select a device and click on the desktop tab, this bring them to a fully web-based Javascript remote display viewer what can connect to remote computes and get full remote desktop. The protocols is fully web-optimized offering high speed remote desktop over the internet and inside a browser. No need to download a special application, all you need is an HTML5 web browser. Today, we added multi-display capability to this viewer. Users can see all the displays at once, or select to view only one. They can also switch in real time between the different viewers.

In addition to in-band remote display, Meshcentral already supports Intel AMT out-of-band remote multi-display. So, on select Intel platforms, administrators can perform web-based remote desktop in both in-band mode (then the OS is up) or out-of-band mode (when the OS is down). Allowing for complete control over a computer under any circumstances. Administrators will favor in-band remote desktop when possible because it can see all the multi-displays at once and has much greater speed over the Internet.

The new multi-display feature is part of Mesh Agent v1.72. The new mesh agent solves a problem where the agent would not switch correctly on some computers when pressing CTRL-ALT-DEL, so all around improvements.

Enjoy!
Ylian
https://meshcentral.com

Meshcentral now supports multi-monitor devices in our remote desktop web viewer.
(Unlimited monitor count)

Meshcentral also supports Windows 8 and Intel AMT out-of-band multi-monitor (up to 3 monitors*).
*Depending on Intel AMT version

今年暑假我有幸参加了大连汇博英特尔的安卓应用开发培训。

培训班各项事宜的安排都很好，师资力量强大，培训设备、场地设施等俱佳，就是教室离食宿场所比较远。

本次培训班举办地点在山东科技大学黄岛校区，学校是山东省著名高等学府，校区风景优美，所在的黄岛更是风光旖旎的海滨城市。虽时值暑假，但山东科技大学校园里却到处都是忙忙碌碌的人们，科研、学习气氛浓郁，非常有利于开展培训与学习活动。

安卓应用越来越广泛，特别是在手机、平板电脑等移动计算设备上。英特尔凌动嵌入式平台更是以无比拟的优势，占据了安卓移动应用的大半江山。

本次英特尔安卓应用培训的师资安排非常给力，青年才俊谷红亮老师携自己的专著《基于英特尔的android应用开发》亲自执鞭。谷老师对基于英特尔凌动的嵌入式平台研究颇深，加之培训教材是自己的专著，所以对讲授的内容非常娴熟，讲课中时时旁征博引，处处驾轻就熟，可以深入浅出，更能举重若轻，有行云流水之快感，有拨云见日之奇功。谷老师的讲课风格颇受大家的欢迎，他风趣幽默的谈吐使枯燥乏味的培训过程变的轻松愉快，他更大的特点是能信手拈来地运用事例以诠释概念、原理与机制，这一方面体现了他的用心，另一方面也更加反映出了他在研究方向上的专业功底。

培训之前我对英特尔平台上的安卓应用开发基本没有了解，通过培训我总体了解了技术路线与轮廓，特别是深入理解了基于英特尔凌动的嵌入式平台中的若干关键问题，收获颇丰。相信自己基于本次学习，今后能比较快地开展这方面的教学与科研工作。同时，谷老师的讲课风格与技巧对我也颇有教益。

感谢大连汇博英特尔组织的本次有意义的培训！感谢谷老师的辛勤教诲！

首先十分感谢贵单位给我们提供这次宝贵的学习机会，在谷老师幽默风趣和极具水平的教学中，我深入学习了嵌入式和移动系统的定义、特点、典型结构；英特尔嵌入式与移动硬件平台；嵌入式应用开发流程、英特尔Android应用开发工具链的概述、安装与配置、Android开发工具的使用和模拟器加速；Android操作系统；Android应用图形用户界面设计，包括嵌入式应用图形用户界面概述、Android应用程序概述、Android GUI基础知识、Android基础界面应用、多活动界面应用、自绘图形与触摸屏输入、键盘输入响应、对话框使用、应用属性的设计；应用的性能优化、NDK与C/C++优化及应用的低功耗设计。通过这次学习，我进一步理解了Android应用开发的平台、开发原理、开发应用及性能优化，掌握了Android应用开发的开发流程。我初步计划将培训所学内容用于指导学生进行毕业设计、开放实验项目和课外科技活动等，从而提高学生Android应用开发的水平和能力。最后再次诚挚地感谢贵单位、谷老师及一起学习的各位老师教导。

Intel IPP provides highly optimized building block functions for image processing, signal processing, vector math and small matrix computation. Several IPP domains contain the hand-tuned functions for Intel(R) Atom™ processor by taking advantage of Intel® Streaming SIMD Extensions (Intel® SSE) instructions.  The IPP static non-threaded Linux* libraries now support Android* OS, and can be used with Android applications.

This article gives an introduction on how to add Intel IPP functions into Android NDK applications. Intel IPP provides processor-specific optimization, and only can be linked with native Android C/C++ code.  To use Intel IPP with your application, you need to include Intel IPP functions in your source code, and you also need to add IPP libraries into the building command line.

Using Intel IPP

1. Adding Intel IPP functions in source

• In source files, include the Intel IPP header files (ipp.h)
• Call ippInit() before using any other IPP functions.  Intel IPP detects the processor features and selects the optimizing code path for the target processors.  Before calling any other Intel IPP functions, call the ippInit() to initialize the CPU dispatching for Intel IPP.
• Call Intel IPP functions in your C/C++ source.

2. Including Intel IPP libraries into the Android NDK building files

• Copy Intel IPP libraries and headers to your project folder.
• Find Intel libraries required for the application: Intel IPP libraries are categorized into different domains. Each domain has its own library, and some domain libraries depend on other ones. It needs to include all domain libraries and their dependency ones into the linkage line.  Check the “Intel IPP Library Dependencies” article to learn required Intel IPP libraries.
• Add the IPP libraries to android building script file “jni/Android.mk”:
  Declare each IPP library as the prebuilt library module. For example, if the application uses two Intel IPP libraries "libipps.a" and "libippcore.a", add the following into the file:

include $(CLEAR_VARS)
LOCAL_MODULE := ipps
LOCAL_SRC_FILES := ../ipp/lib/ia32/libipps.a
include $(PREBUILT_STATIC_LIBRARY)

 

include $(CLEAR_VARS)
LOCAL_MODULE := ippcore
LOCAL_SRC_FILES := ../ipp/lib/ia32/libippcore.a
include $(PREBUILT_STATIC_LIBRARY) 

 

Add the header path and IPP libraries into the modules calling IPP functions:

  
include $(CLEAR_VARS)
LOCAL_MODULE     := IppAdd
LOCAL_SRC_FILES  := IppAdd.c
LOCAL_STATIC_LIBRARIES := ipps ippcore
LOCAL_C_INCLUDES := ./ipp/include
include $(BUILT_SHARED_LIBRARY)

Building one sample code

A simple example is included bellow that shows Intel IPP usage in the native Android code. The code uses Intel IPP ippsAdd_32f()function to add data for two arrays. 

To review Intel IPP usage in the code:

1. Download the sample code and unpack it to your project folder(<projectdir>).
2. Learn IPP usage in the source files: The "jni/IppAdd.c" file provides the implementation of one native function NativeIppAdd(). The function call Intel IPP ippsAdd_32f() function.  The "src/com/example/testippadd/ArrayAddActivity.java" file call the native "NativeIppAdd()" function through JNI.
3. Check "jni/Andriod.mk" file. This file adds the required IPP libraries into the building script. The sample uses ippsAdd_32f()function, which is belong to Intel IPP signal processing domain. The function depends on "libipps.a" and "libippcore.a" libraries.  The "Andriod.mk" file creates two prebuilt libraries for them. 

You can build the sample code either using the SDK and NDK command tools or using Eclipse* IDE

    Build the sample from a command line

1. Copy the Intel IPP headers and libraries into your project folder (e.g. <projectdir>/ipp). 
2. Run the "ndk-build" script from your project's directory to build the native code
    >cd  <projectdir> 
    ><ndkdir>/ndk-build
3. Build android package and install the application
   >cd <projectdir>
   >android update project -p  . -s
   >ant debug
   >adb install bin/NativeActivity-debug.apk

     Build the sample by Eclipse* IDE

1. Copy the Intel IPP headers and libraries into your project folder (e.g. <projectdir>/ipp).
2. In Eclipse, click File >> New >> Project...>>Andriod>> Andriod Project from Existing Code.  In the  "Root Directory", select the sample code folder,  then click Finish.
3. Run the 'ndk-build' script from your project's directory to build the native code: 
   >cd <projectdir> 
   ><ndkdir>/ndk-build
4. Build the application in the Eclipse IDE and deploy the .apk file.

Summary
This article provide the introduction on IPP usage with the native Android* applications. Check more information on Intel IPP functions in the IPP manual.

Objetivo

Este documento describe el proceso de instalar el SDK y configurar los entornos para desarrollar aplicaciones que se ejecuten en dispositivos de Android* basados en Arquitectura Intel®.

Introducción al SDK de Android*

El kit de desarrollo de software (SDK) incluye herramientas y componentes de plataforma para que los desarrolladores compilen, prueben y depuren sus aplicaciones Android*, y manejen la instalación de componentes en la plataforma Android*. También ofrece formas sencillas de integración con los entornos de compilación y desarrollo, por ejemplo, con Eclipse* o Apache Ant*.

Requisitos del sistema

En esta sección se describen los entornos de hardware y software necesarios para el SDK de Android*.

Supported Operating Systems

• Windows XP* (32 bits), Vista* (32 o 64 bits) o Windows 7* (32 o 64 bits)
• Linux* (Ubuntu, Fedora)
  • Se requiere GNU C Library (glibc) 2.7 o superior.
  • En Ubuntu Linux, se requiere versión 8.04 o superior.
  • En Fedora, las versiones objetivo son la F-12 y superiores.
  • Las distribuciones de 64 bits deben ser capaces de ejecutar aplicaciones de 32 bits.

Requisitos de hardware

El SDK de Android* requiere espacio en disco para todos los componentes que elija instalar. Se necesita espacio adicional en disco para ejecutar el emulador, por ejemplo, con el fin de crear tarjetas SD para los dispositivos virtuales de Android* (AVD).

Instalación del JDK

Se requiere Java* JDK 5 o JDK 6 para el SDK. No es suficiente con el JRE (Java* Runtime Environment) solamente. Si su sistema no tiene instalado JDK 5 o JDK 6, puede descargar JDK SE 6 de http://www.oracle.com/technetwork/java/javase/downloads/index.html e instalarlo en su equipo.

Instalación de Eclipse*

Se recomienda firmemente instalar el SDK con Eclipse* para desarrollar aplicaciones Android*. Vaya a http://www.eclipse.org/downloads/ para descargar o actualizar Eclipse*. Sugerimos usar las siguientes configuraciones de Eclipse* si se desea desarrollar aplicaciones Android* para Arquitectura Intel:

• Eclipse* 3.5 (Galileo) o superior
• Eclipse* Classic (versiones 3.5.1 y superiores)
• Android* Development Tools Plugin (recomendado)

Instalación de Apache Ant (opcional)

Se recomienda firmemente usar un entorno de desarrollo integrado como Eclipse* para desarrollar aplicaciones Android*. Pero, como alternativa, se puede usar Apache Ant* para trabajar con el SDK a fin de crear aplicaciones Android*. Visite http://ant.apache.org/ para descargar las distribuciones binarias e instalar Ant. Para trabajar con el SDK, se necesita Ant 1.8 o superior.

Descarga del SDK Starter Package y cómo agregar los componentes del SDK

El SDK Starter Package se puede descargar en http://developer.android.com/sdk/index.html. Este paquete no incluye los componentes específicos de la plataforma necesarios para desarrollar aplicaciones Android*. Sólo proporciona las herramientas básicas del SDK y usted debe descargar el resto de los componentes de la plataforma.

Después de instalar el SDK Starter Package, ejecute Android* SDK and AVD Manager.

• En Windows*, seleccione Inicio > Todos los programas > Android* SDK Tools > SDK Manager
• En Linux*, ejecute asdk/tools/android, donde “asdk” representa el nombre de su directorio de Android SDK.

En el panel izquierdo del cuadro de diálogo Android* SDK and AVD Manager, seleccione “Available packages”; en el panel derecho, haga clic y expanda el nodo “Android Repository”, y seleccione los paquetes que desee instalar.

Cómo configurar Eclipse* para que funcione con el SDK

Si usa el entorno de desarrollo integrado (IDE) de Eclipse* para desarrollar software, recomendamos firmemente que instale y configure el complemento Android* Development Tool (ADT) Plugin.

Instalación del plugin ADT para Eclipse*

1. Inicie Eclipse*, seleccione Help > Install New Software…, en el cuadro de diálogo Install, haga clic en el botón Add.
2. En el cuadro de diálogo Add Repository, escriba “ADT Plugin” en el campo Name e ingrese “https://dl-ssl.google.com/android/eclipse/” en el campo Location y luego haga clic en OK.

3. Regresará al cuadro de diálogo Install, se conectará con el servidor de repositorio de Google y mostrará los paquetes de ADT disponibles:

4. Seleccione Next, acepte el acuerdo de licencia y seleccione Finish.
5. Reinicie Eclipse*.

Configuración del plugin ADT

1. Inicie Eclipse*, seleccione Windows > Preferences
2. En el panel izquierdo del cuadro de diálogo Preferences, seleccione Android*. En el panel derecho, use el botón Browse para navegar al directorio en el que instaló Android* SDK y haga clic en Apply; aparecerá una lista de objetivos de SDK que ha instalado. En este momento, haga clic en OK.

Resumen

Después de seguir los pasos descritos más arriba, tendrá a disposición las herramientas necesarias para iniciar el desarrollo de Android* para Arquitectura Intel. Si es nuevo en Android*, este es un buen momento para escribir su primera aplicación Android* ¡y probarla en un dispositivo basado en Arquitectura Intel!

¹http://ant.apache.org/manual/

Seguem abaixo os slides das apresentações que a Intel promoveu durante o TDC SP:

Trilha: HTML5 e JavaScript (10/07)

Desenvolvendo Apps Multiplataforma para dispositivos móveis com HTML5 

Palestrante: Jomar Silva

Trilha: Marketing Digital (11/07)

Afinal, o que é um Community Manager? 

Palestrantes: Luciano Palma e George Silva

Trilha: HPC (11/07)

Computação Manycore: uma arquitetura muito além do multicore! 

Palestrante: Luciano Palma

Trilha: Android (12/07)

Escreva sua app Android sem gastar energia 

Palestrante: George Silva

Trilha: Java (12/07)

Utilizando multi-touch e sensores com JavaFX e JNI 

Palestrante: Felipe Pedroso

Trilha: Mobile (14/07)

Utilizando Sensores dos Ultrabooks no Windows 8

Palestrante: Felipe Pedroso

Trila: Games

Inovação na Experiência do Usuário: Apresentando o Intel Perceptual Computing SDK 

Palestrante: Felipe Pedroso

The Intel® XDK is a tool to help build HTML5 apps and deploy them across a variety of platforms. Two of those platforms are the Apple* Appstore and Google* Play. The XDK includes an online build service called the App Dev Center that allows HTML5 developers to create hybrid native apps. The App Dev Center takes the HTML5 code written for the app and wraps it in native code and returns the appropriate binary. One feature of the App Dev Center is the ability to add a "bridge" JavaScript* API to access the native features of these devices.

The App Dev Center within the Intel® XDK now supports the Cordova JavaScript API. Create a hybrid HTML5 app using the sample code included as an attachment with this article by following these directions.

• Create a developer account and install the Intel® XDK here.
• Log into the App Dev Center here.
• Click on the button labeled Start a New App.

• Name your new project, and select the development path Create your own from scratch. Click Next.

• Select Start with a project bundle. Browse to the attachment included with this article, and click Next.

• Click Next again to complete the process.

• The test application should be available for build for iOS and Android.

For more information about building the application binary, check out these articles:

Building an HTML5 App For Google Play
How Do I Make My First App Using the Intel® XDK
How To Import Apps Into the Intel® XDK

The Android Native Development Kit (NDK) is a companion tool to the Android SDK and allows you to implement parts of your app using native-code languages such as C and C++.

You can download the NDK toolkit: http://developer.android.com/tools/sdk/ndk/index.html

NDK for X86 Instruction Set Architecture

Android is an open-source operating system developed by Google. Currently, Android can be run on three families of instruction set architectures:  ARM, x86, and MIPS. X86 denotes a family of instruction set architectures based on the Intel 8086 CPU, introduced in 1978. Let’s describe the differences between X86 (also called Intel® architecture or IA) and the other chipsets that Android runs on from an application perspective.

Android applications can be classified into two types:

• Dalvik applications that include Java* code and use the official Android SDK API only and necessary resource files, such as .xml and .png, compiled into an APK file.
• Android NDK applications that include Java code and resource files as well as C/C++ source code and sometimes assembly code. All native code is compiled into a dynamic linked library (.so file) and then called by Java in the main program using a JNI mechanism.

Android Game Engine

The game engine is a key module for game applications. There are several engines that run in Android, including 2D and 3D engines which are open source and commercial engines. Thus, it is difficult to migrate and develop Android-based games to run on the IA platform. Cocos2d-x and Unity 3D are the most popular game engines for Android platforms.

Cocos2d-x is based on Cocos2d-iPhone and consists of expanding supported platforms, with multiple programming languages that share the same API structure. Since its introduction in July 2010, cocos2d-x has been downloaded over 500 million times. Giants in the mobile game industry such as Zynga, Glu, GREE, DeNA, Konami, TinyCo, Gamevil, HandyGames, Renren Games, 4399, HappyElements, SDO, and Kingsoft are using cocos2d-x.

Unity 3D is a cross-platform game engine with a built-in IDE developed by Unity Technologies. It is used to develop video games for web plugins, desktop platforms, consoles, and mobile devices, and is utilized by over one million developers. It grew from an OS X supported game development tool in 2005 to a multi-platform game engine. The latest update, Unity 4.1, was released March 2013. It currently supports development for iOS, Android, Windows, Blackberry 10, OS X, Linux, web browsers, Flash*, PlayStation 3, Xbox 360, Windows Phone, and Wii.

Developing Android NDK-based games on IA platforms

Before we talk game development, we should talk about the Android platform in general. As you know, games come in many different styles. Different styles of games need different design principles. At the start of your project, you usually decide the genre of your game. Unless you come up with something completely new and previously unseen, chances are high that your game idea fits into one of the broad genres currently popular. Most genres have established game mechanic standards (e.g., control schemes, specific goals, etc.). Deviating from these standards can make a game a great hit, as gamers always long for something new. Some of the common genres are:

• Arcade & Action
• Brain & Puzzle
• Cards & Casino
• Casual
• Live Wallpaper
• Racing
• Sports Games
• Widgets
• etc

The process for developing general Android games is similar to any other Android application. First, download the Android SDK and NDK from Google’s web site and install them properly.

I assume you have done all the installation and preparation work. Using Cocos2d-x game engine as the example, let’s see how to create a game for Intel architecture.

Download Cocos2D-x

Download the latest stable version of Cocos2D-x from the web site: http://www.cocos2d-x.org/projects/cocos2d-x/wiki/Download

Execute the batch

Execute the batch from Windows Explorer. When it asks you for the project location, set it to something like com.yourproject.something, and choose the project name and target ID. This will create a folder with the project name inside the cocos2dx installation folder. You should see the execution of a script, without any error, something like this:

Set Environment Variables of NDK_ROOT

Add the following environment variable at the end of the home\<yourname>\.bash_profile file (in this case:c:\cygwin\home\user\.bash_profile):

NDK_ROOT=/cygdrive/<yourname>/

export NDK_ROOT
 

restart cygwin,input cd $NDK_ROOT, and you should see this screen:

Execute the build_native.sh file

The default configuration is ARM; we need to change it to compile for x86. Open the file \helloworld\proj.android \build_native.sh, find ndk-build command, and add the APP_ABI=x86 parameter to the end of the command. Run it in Cygwin and you will see:

Import project to Eclipse

Now go to Eclipse, create a new project -> Import from existing project.

Build and Run

At this step, Eclipse will have some problems:

The import org.cocos2dx.lib cannot be resolved HelloWorld.java

/HelloWorld/src/com/young40/test line 26 Java Problem Cocos2dxActivity cannot be resolved to a type HelloWorld.java

/HelloWorld/src/com/young40/test line 30 Java Problem Cocos2dxActivity cannot be resolved to a type HelloWorld.java

/HelloWorld/src/com/young40/test line 33 Java Problem

You must import the following library into Eclipse as a project:

cocos2d-2.1beta3-x-2.1.1/cocos2dx/platform/android/java

Go to Project -> Build, and then Run As -> Android Application:

Then a game framework for the cocos2dx game engine will be built. You can add game logic, audio, picture, etc. resources to this project to make a full game.

Optimize Android NDK-based games on IA platforms

Intel® System Studio is a suite of tool for profiling and optimizing applications on Android platforms. Of course, we can use it for optimizing games. Intel System Studio includes:

• Intel^® C++ Compiler
• Intel^® Graphics Performance Analyzers
• Intel^® VTune^™ Amplifier
• (Intel^® JTAG Debugger)

Here we won’t explain the details about each tool. Instead, we will walk through an example that shows how Intel tools work.

First, let’s take an application, called Bounding Ball, that we will run on an Intel® Atom™ Z2460 (code name Medfield) processor. The game has more than 800 balls that move at random speed and collide with each other without any regularity. We can see the performance is bad by measuring the FPS, which is only 6 without any optimization.

We can use Intel® Graphics Performance Analyzers (Intel® GPA) to locate which module is the bottleneck and find out if it is CPU bound or GPU bound.

The Intel GPA screen shot below shows a chart that describes the details of this application via the GPA on Android platform . From this, you can see that the CPU consumed 52.5% of the resources. That is a rather high ratio for one application. Meanwhile ISP Load, TA Load, TSP Load and USSE Total Load running inside GPU are all less than 10%, which means that the GPU load is normal. Thus we can conclude the bottleneck is in CPU module. To further analyze the CPU bottleneck issue, we need to profile the code using the VTune™ analyzer.

Here, we don’t describe how to use the VTune analyzer, we just explain the results we obtained when we ran it. The hotspots are the sin and cos functions inside libm.so. So the question is: why does the application spend so much time and CPU cycles to run these two functions?

By checking the application source code, we find that these two hotspot functions are called when every ball is rendered by OpenGL ES*. As geometry of all the balls is the same, only the size is different. We can duplicate balls using the OpenGL function glScale so that hotspot function can be decreased greatly.

After code optimization, performance is improved 80%; the FPS is 14. Further, we can compile the application with Intel C/C++ Compiler to get better performance on Intel architecture platforms. The Intel C/C++ Compiler has many flags for performance optimization on IA platforms. Here we just introduce some of them.

• SSSE3_ATOM
  Supplemental Streaming SIMD Extensions 3 (SSSE3 or SSE3S) is a SIMD instruction set created by Intel and is the fourth iteration of the SSE technology.
• IPO
  Interprocedural Optimization flag will reduce function call overhead, eliminate dead code, and reorder constant propagation and procedure.
• PGO
  Profile-Guided Optimizations flag will analyze leaves many questions open for the optimizer like:
• How often is x > y
• What is the size of count
• Which code is touched and how often

In addition, the Intel C/C++ Compiler can also enhance applications as follows:

• More accurate branch prediction
• Basic block movement to improve instruction cache behavior
• Better decision of functions to inline (help IPO)
• Better optimization of function ordering
• Optimization of switch-statements
• Better vectorization decisions

Using different compilers and different compiling parameters, an app can get different performance. Here is a performance comparison of two compilers GCC and ICC. Same application Bounding Ball is running on android phone based on Intel Medfield. Blue part is performance of GCC and red part is that of ICC. Baseline is to compile without any parameters. The second part of chart is to compile with arch=atom. The third part is to recompile with all parameters mentioned above. Finally, you can see the performance of app compiled by ICC is 60% higher than GCC.

Summary

We’ve given you a quick introduction of Android game development and optimization in IA platforms. Game engines are the core part of all game development. If they run well on IA platforms, then the games will run well too. We took the popular game engine, cocos2dx, as an example to demonstrate how to develop on the IA platform. Intel also offers many tools for developers to optimize their game applications on Android platforms. Using Intel System Studio we showed the steps of how to optimize a demo application.

About the Author

Tao Peng is an application engineer in Intel Software and Service Group, and focus on mobile application enabling, including Android applications development and optimization for x86 devices, Web HTML5 application development.

Sinopsis:

Si es un desarrollador Android* insatisfecho con el rendimiento del emulador de Android, este documento es para usted. Una y otra vez, hemos oído de muchos desarrolladores Android que el emulador es lento y molesto para trabajar, ¡pero no tiene por qué ser así! Si usa un equipo razonablemente moderno con un procesador Intel® que tenga Intel® Virtualization Technology habilitada y sistema operativo Microsoft Windows* o Apple Mac OS*, entonces puede usar el Intel® Hardware Accelerated Execution Manager (Intel® HAXM), o KVM para Linux*, para acelerar muy fácilmente el emulador de Android en un orden de magnitud, lo que hará más rápidas las pruebas y las depuraciones de sus aplicaciones de Android. En este documento se explican todos los pasos necesarios para acelerar el emulador y cómo trabajar con él. Luego explicamos cómo usar el kit de desarrollo nativo (NDK) para compilar código nativo x86 y la forma correcta de enviar APK que contengan bibliotecas nativas x86 a la tienda Google Play. Intel HAXM también se utiliza para acelerar el emulador de Tizen*, pero esto se encuentra fuera del alcance de esta documentación. Para obtener más información, visite tizen.org en la sección SDK.

Índice

1. Introducción
2. Instalación
2.1. Prerrequisitos
2.2. Instalación en Windows
2.3. Instalación en Linux
2.3.1. Instalación de KVM
2.4. Cómo crear un AVD (dispositivo virtual de Android*)
3. Métodos más conocidos
3.1. Cómo probar su aplicación con el emulador de Eclipse
3.2. Envío de varios APK para diferentes ABI comparado con el envío de binarios pesados a Google Play
3.3. Compile su NDK para x86
3.3.1. Cómo agregar la ruta del NDK a su variable de entorno
3.3.2. Cómo compilar con el NDK
3.3.3. Otra manera de compilar con el NDK

1. Introducción

Este documento lo guiará a lo largo de la instalación del Intel® Hardware Accelerated Execution Manager (Intel® HAXM), un motor de virtualización asistido por hardware (hipervisor) que usa Intel® Virtualization Technology (Intel® VT) para acelerar el desarrollo de Android* en Windows*. También explica cómo configurar una máquina virtual basada en kernel (KVM) asistida por hardware en Linux* y los métodos más conocidos de compilación nativa y envío de aplicaciones a la tienda Google Play para x86.

2. Instalación

2.1. Prerrequisitos

• Es necesario que tenga instalado el kit de desarrollo de software (SDK) de Android.
• Su equipo debe tener un procesador Intel compatible con Intel VT-x y EM64T, y con la funcionalidad Execute Disable (XD) Bit habilitada desde el BIOS.

2.2. Instalación en Windows

Después de haber instalado el SDK de Android, abra el SDK Manager. En la sección de extras, podrá encontrar el Intel HAXM.

Marque la casilla y haga clic en el botón “Install packages…”; cuando haya instalado el paquete, el estado aparecerá como “Installed”, es decir, instalado, lo que es engañoso, ya que este no es el caso. El SDK sólo copia el ejecutable de Intel HAXM a su máquina, y depende de usted instalar el ejecutable.

Para instalar el ejecutable de Intel HAXM, busque en su disco rígido IntelHaxm.exe (o IntelHAXM.dmg en Mac OS X). Si dejó todos los valores predeterminados, debería estar en C:\Program Files\Android\android-sdk\extras\Intel\Hardware_Accelerated_Execution_Manager\IntelHaxm.exe.

Intel HAXM sólo funciona en combinación con una de las imágenes de sistema x86 de procesador Intel® Atom™, que se encuentran disponibles para Android 2.3.3 (API 10), 4.0.3 (API 15), 4.1.2 (API 16), 4.2.2 (API 17). Estas imágenes de sistema de Intel se pueden instalar de la misma manera que las imágenes basadas en ARM, mediante el administrador de SDK.

Cuando hace clic en el ejecutable de IntelHaxm, se muestra una pantalla de bienvenida como esta:

Puede ajustar la cantidad de memoria RAM que se asigna a Intel HAXM. Después de ajustarla, haga clic en Next. La pantalla siguiente confirma la asignación de memoria. Si todo está como lo desea, haga clic en Install.

A fin de poder instalar el Intel HAXM, debe tener habilitada Intel VT-x en su BIOS, si no, verá un error como este durante la instalación:

Si se produce este error, vaya al BIOS y habilítela.

La segunda opción para descargar el Intel HAXM y la imagen de sistema del emulador x86 Emulator System Image es ir directamente al sitio web: http://software.intel.com/en-us/android y descargar de allí todos los componentes necesarios.

2.3. Instalación en Linux

Los pasos para acelerar el emulador de Android en Linux son diferentes que en Windows y Mac OS X, porque Intel HAXM no es compatible con Linux, así que es necesario usar KVM en su lugar. Los pasos que se muestran a continuación corresponden a Ubuntu* 12.04 y pueden diferir ligeramente en otras distribuciones de Linux.

Al igual que en Windows (y Mac OS X), primero necesita descargar el SDK de Android desde el sitio para desarrolladores de Android. Encontrará un paquete de ADT (herramientas para desarrolladores de Android) que contiene tanto el entorno de desarrollo integrado (IDE) de Eclipse* como el SDK de Android. Descargue el archivo zip y extráigalo a su máquina Linux. Asegúrese de elegir la versión adecuada para su distribución de Linux, ya sea de 32 o de 64 bits. Esto es fácil de verificar con el comando:

file /sbin/init

Antes de comenzar a instalar los paquetes requeridos para KVM, es recomendable que se asegure de tener el repositorio más reciente; para hacerlo, escriba:

sudo apt-get update

2.3.1. Instalación de KVM

Para instalar y ejecutar KVM, que es una solución de virtualización completa para Linux en hardware x86 (es decir, Intel VT), primero necesita comprobar que su CPU admita virtualización de hardware; para hacerlo, escriba:

egrep –c ‘(vmx|svm)’ /proc/cpuinfo

Si el resultado es 0, significa que su CPU no admite virtualización de hardware, la cual es necesaria para ejecutar KVM. Si el resultado es 1 o más, puede continuar, pero de todos modos asegúrese de que esté habilitada en el BIOS (ver Sección 2.2).

A continuación, debe instalar KVM, a menos que ya la tenga instalada. Para ver si su procesador admite KVM, escriba:

kvm-ok

Si tiene KVM, verá esto:

"INFO: Your CPU supports KVM extensions
INFO: /dev/kvm exists
KVM acceleration can be used"

Pero debe ir al BIOS y activar Intel VT si ve esto otro:

"INFO: KVM is disabled by your BIOS
HINT: Enter your BIOS setup and enable Virtualization Technology (VT),
and then hard poweroff/poweron your system
KVM acceleration can NOT be used"

El siguiente paso es instalar la KVM y otros paquetes necesarios. Para hacerlo, escriba:

sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

En la ventana siguiente, puede seleccionar “No configuration” si no desea hacer cambios a su configuración:

A continuación, agregue su usuario al grupo KVM y al grupo libvirtd. Para hacerlo, escriba:

sudo adduser your_user_name kvm
sudo adduser your_user_name libvirtd

Después de la instalación, vuelva a iniciar sesión y los cambios surtirán efecto. Para probar la instalación, escriba:

sudo virsh -c qemu:///system list

Ahora puede ir al paso siguiente, que es crear y ejecutar el dispositivo virtual de Android (AVD). Este procedimiento es el mismo para Linux y Windows.

2.4. Cómo crear un AVD (dispositivo virtual de Android*)

Después de instalar el SDK e Intel HAXM (o KVM en Linux), puede crear un dispositivo virtual que tenga emulación acelerada por hardware. Para hacerlo, vaya a AVD Manager y cree un nuevo dispositivo. Asegúrese de seleccionar Intel Atom (x86) como CPU/ABI. Esta selección sólo aparece en el menú desplegable si tiene instalada la imagen de sistema x86 Intel; para que los gráficos sean más suaves, active la emulación de GPU cuando cree el AVD.

	Haga clic en New y cree su AVD x86. Asegúrese de elegir una API compatible con imágenes de sistema x86, que CPU/ABI esté establecido en x86 y de haber habilitado la emulación de GPU (OpenGL ES*). Cuando haya hecho eso, haga clic en Create AVD para crear el AVD.
	Para iniciar el AVD x86, haga clic en Start y luego en Launch.

Si la instalación fue exitosa, cuando se esté iniciando el emulador, aparecerá un cuadro de diálogo que indicará que Intel HAXM se está ejecutando en modo virtual rápido.

Si no se convenció del todo de que está usando una imagen de sistema x86, siempre tiene la posibilidad de revisar los detalles en “About phone” dentro del emulador.

La mejora de rendimiento que apreciará con Intel HAXM o KVM depende de su PC, la unidad, la memoria, etc., pero debería ser de un orden de magnitud de entre 5x y 10x. La captura de pantalla de abajo muestra una comparación paralela de un AVD x86 con HAXM habilitado frente a un AVD basado en ARM. El AVD x86 arrancó hasta llegar a la pantalla de bloqueo en 15 segundos, mientras que el AVD no Intel tardó 40 segundos, una gran diferencia.

[La mejora de rendimiento que observará con el Intel HAXM (o la KVM) debería ser de entre 5x y 10x, según la configuración de su sistema: el software y las cargas de trabajo que se usen en la pruebas de rendimiento puede que hayan sido optimizadas para rendimiento solamente en microprocesadores Intel. Las pruebas de rendimiento, tales como SYSmark* y MobileMark*, se miden con sistemas informáticos, componentes, software, operaciones y funciones específicos. Todo cambio en cualquiera de esos factores puede hacer que varíen los resultados. Debe consultar más información y otras pruebas de rendimiento que lo ayuden a evaluar íntegramente las compras que contemple hacer, incluido del rendimiento del producto al combinarlo con otros. Configuración: en este caso, se usó Mac Book Pro para las pruebas. Si desea obtener más información, visitehttp://www.intel.com/performance”]

3. Métodos más conocidos

3.1. Cómo probar su aplicación con el emulador de Eclipse

Ya sea que se trate de una aplicación basada en NDK o una aplicación Dalvik*, puede usar Intel HAXM para acelerar el emulador cuando haga las pruebas. Si está desarrollando software con Eclipse, puede seguir estos sencillos pasos para cerciorarse de que esté usando Intel HAXM cuando inicie el emulador.

En primer lugar, confirme que haya creado el AVD como se describió en el paso 2. Si tiene el AVD listo, vaya a Run As -> Run Config, como se muestra abajo:

Debería ir a una página como esta:

Aquí, puede marcar la casilla para seleccionar el AVD que desee. Después de haber creado su AVD y haber establecido su configuración, para comenzar a compilar su proyecto y depurarlo con el emulador, seleccione Run As -> Android Application. Esto iniciará automáticamente el AVD acelerado por hardware.

Una vez iniciado el AVD, debería ver la pantalla de inicio de su aplicación (después de desbloquear la pantalla).

3.2. Envío de varios APK para diferentes ABI comparado con el envío de binarios pesados a Google Play

En el pasado, se enviaba un binario pesado de la aplicación desarrollada, que contenía todos los binarios y los archivos NDK, sin poder diferenciar entre arquitecturas. Eso significaba que los usuarios tenían que descargar el APK entero que contenía archivos no relevantes para las arquitecturas específicas; es decir, los usuarios de x86 descargaban código ARM y viceversa. El inconveniente de esto es que si usted tenía un binario realmente pesado, el usuario se veía forzado a descargar una gran cantidad de información no correspondiente al dispositivo. Normalmente, esto es aceptable si el APK es de menos de 10 a 20 MB.

Intel/Google han implementado ahora un mecanismo de filtrado de CPU, es decir que usted puede enviar ahora varios APK que contengan diferentes bibliotecas específicas de cada arquitectura con sólo seguir el código de versiones sugerido que se muestra abajo.

El primer dígito corresponde a la interfaz binaria de aplicación (ABI), o sea, 6 para x86; luego el nivel de API objetivo, esto es, 11; el tamaño de la pantalla, 13; y luego el número de versión de su aplicación: 3.1.0.

Asegúrese de tener al menos un número de versión de 8 dígitos y de asignar el primer dígito más alto a la versión x86. En el ejemplo de arriba, se pondría 6 para x86, 2 para ARMv7 y 1 para ARMv5TE. Al hacerlo, las versiones x86 serán las preferidas en los dispositivos x86 y las versiones ARM en los dispositivos ARM.

Al seguir estas pautas, puede garantizar que sus usuarios obtengan el mejor rendimiento del dispositivo que poseen. Como beneficio extra, puede evitar que los usuarios intenten ejecutar aplicaciones en dispositivos específicos debido a problemas de traducción de código.

Se puede encontrar más información en: http://software.intel.com/en-us/articles/google-play-supports-cpu-architecture-filtering-for-multiple-apk.

3.3. Compile su NDK para x86

En esta sección se mostrará cómo compilar la parte NDK de su aplicación para x86.

A fin de que la aplicación basada en NDK se ejecute en un AVD x86, debe compilar su biblioteca NDK para la arquitectura x86. Para hacerlo, siga estos pasos sencillos:

Abra el símbolo de sistema y navegue a la carpeta donde están sus archivos NDK, como se muestra abajo:

Asegúrese de haber establecido la ruta de la variable de entorno, así podrá usar el script de compilación ndk desde cualquier lugar.

3.3.1. Cómo agregar la ruta del NDK a su variable de entorno

A fin de configurar la variable de entorno para el NDK, haga clic en Computer y seleccione Properties. Vaya a Advanced system settings y busque “Environment variables”. Seleccione Path y haga clic en Edit. Al final de la cadena “Variable Value”, agregue la ruta a su carpeta raíz de NDK, la que contiene el archivo ndk-build.cmd, como en la imagen de abajo:

3.3.2. Cómo compilar con el NDK

Después de haber navegado con el símbolo de sistema a su carpeta NDK, ejecute:

ndk-build APP_ABI:=all

Esto compilará su archivo NDK para cada arquitectura disponible, es decir, ARMv5TE, ARMv7, x86 y mips.

Si desea compilar para una arquitectura específica, reemplace “all” con las diferentes arquitecturas. Por ejemplo:

ndk-build APP_ABI:=armeabi armeabi-v7a x86 mips

No olvide actualizar su proyecto en Eclipse para capturar la configuración más reciente, o sea las últimas carpetas que se crearon con el script de compilación ndk. En las bibliotecas de carpetas de sus proyectos, debería ver ahora cuatro carpetas, una por cada una de las arquitecturas.

Ahora está listo para usar el AVD x86 con su aplicación NDK.

3.3.3. Otra manera de compilar con el NDK

Otra manera de compilar su código nativo para todas las arquitecturas, incluida x86, es modificar su archivo Application.mk, que se encuentra en la carpeta jni. Si no tiene un archivo Application.mk, puede crear uno usted mismo y agregar la instrucción siguiente:

APP_ABI:=armeabi armeabi-v7a x86 mips

De este modo, cuando ejecute el archivo por lotes, es decir, el script de compilación ndk, compilará las bibliotecas para todas las arquitecturas disponibles.

Además, para facilitar el uso, en lugar de especificar todas las arquitecturas, puede simplemente poner “all”:

APP_ABI:=all

With a few exceptions, the App Dev Center within the Intel® XDK now supports the Cordova JavaScript API. Here is a list of known exceptions in the App Dev Center build system along with any status updates available on them.

• The InAppBrowser.window.open command does not support the target parameter of _self.

On a warm July summer evening in San Francisco, 65-ish coders gathered to focus on Android projects, both html5 and native, watch and listen to expert demos, and maybe even grab a few Intel-sponsored prizes. Here’s a report from this event, produced by Intel and BeMyApp.

(courtesy BeMyApp.com)

This event was held at the very picturesque Butchershop 3^rd St. Office (see more images here). As already noted, the focus was on Android projects both html5 and native. Several presentations were given, including:

Jason Polites (Socialize Inc.) 
Tips and Tricks for Effective Automated Testing on Android 
Some "rules of the road" including:

• Myths about testing
• Practical techniques to make testing easier and more effective
• Common pitfalls when creating tests on Android

Ashraf Hegab 

Creating a 3D multiplayer games in real-time 

Multi is a new hybrid 3d multiplayer games engine by MultiPlay.io that allows for the real-time creation of 3d multiplayer games across web and native devices. In this session we'll go through the process of creating a new game, by creating and editing levels, UI, 3d models and animations in real-time across Android devices and more.

Zac Bowling (Apportable) 
How to run Objective-C and C++ on Android 
Have you ever wanted to build a game in Objective-C or C++? Apps that have done this include: Spirits, Avernum, andSuperbrothers Sword & Sworcery.

You can see the entire presentation that Zac came up with here.

Yosun Chang (AReality3D) 
Native apps designed for Google Glass 
After a lightning perusal of the sensors on this, Android-on-your-head-sans-touchscreen-with-sidetouchpad-camera-lightmeter-mic-gyro-acc, I'll talk about a few native Glass hacks of mine: the GlassTrombone, computer-vision based markerless AR, and head rotation navigation within a 3D environment.

Christopher Price (iConsole.tv) 
Building a New High-end for Android Gaming 
Android-IA is a new platform that allows Android to run on x86 hardware. Android-IA is the (open) core of iConsole.tv, currently shipping around 4x faster than that Galaxy S 4 you're building for. Christopher will share an introduction to the platform, talk a bit about getting your head around developing games for iConsole.tv, and share some lessons learned along the way so far.

Gaythri (Intel)

Portable All-In-Ones are new form factor devices that feature high-end technical specifications: large touch screens (18.4 - 27-inch) that can operate in lay-flat orientations, and have a built-in battery. These capabilities make new use-cases possible in applications and games that incorporate features like multi-user capabilities with a minimum of 10 touch points.

All in all, it was a great night of demos and fellowship for Android developers. Were you at this meetup? Share your experience in the comments below!