Thursday, March 28, 2013

秘儀Liteのライブ壁紙:3000+ダウンロード:まだ数える



古典的なハニカムグリッドを点滅色の素晴らしい世界を探検。両方の錠剤や電話が完全に縦向きと横向きの両方のモードでサポートされています。

PRO版の特徴:さまざまな背景色、粒子のスタイル、グリッドスタイルやタッチの効果を選択するための非常にカスタマイズ可能なユーザー設定が事前に定義された一連のテーマに沿って提供されています

使用方法:ホーム - >メニュー - >壁紙を

更新日:

*低解像度のデバイスにサポートを追加しました

*クラッシュデバッグ初期化中





Monday, March 25, 2013

Arcane Lite Live Wallpaper: Close to 9000 downloads



Explore the wonderful world of colors flashing through the classic honeycomb grid. Both tablets and phones are fully supported in both portrait and landscape modes.

PRO Version Features: Extremely customizable user settings for selecting various background colors, particle styles, grid styles and touch effects are provided along with a set of pre-defined themes.

TO USE: home->menu->wallpapers

Updated:
* Added support to low resolution devices
* Crash while initializing debugged





Saturday, March 23, 2013

Samsung Galaxy Note gets Android 4.1.2 Jelly Bean update in India

Galaxy Note users in India will be happy to note that Samsung has started rolling out the Android 4.1.2 Jelly Bean update for its first-generation smartphone-tablet hybrid.

Samsung started rolling out the Android 4.1.2 Jelly Bean update for the first generation Galaxy Note in India. The Galaxy Note GT-N7000 can be considered as the first successful 5-inch smartphone-tablet hybrid to hit store shelves, and define the phablet category, after the lacklustre performance of the Dell Streak.
The Jelly Bean update for the Galaxy Note was rolled out in phases globally from February 2013 and is now available in India. Users can access the update either via OTA or connect their Samsung smartphones to their PC’s and update the OS via Samsung KIES desktop software.
The update will bring with it a slew of features to the Galaxy Note. The new features will include Android 4.1.2, better stability and responsiveness (thanks to Project Butter), Multi-View (Multi Windows Multitasking, same as in Note II), Page Buddy, Notification Panel can now be customized, New Additions in Notification Panel, Smart Rotation (Screen Display adjusts to your angle of sightings), Continuous Input in Samsung Keyboard (Like Swipe or Android 4.2 Keyboard), Samsung’s Cloud services, Features like Direct Call, Smart Stay and Pop-up Play, New Widgets From the Galaxy S III, 2 Home screen modes, New Notifications bar and of course, Google Now.
Under the hood, an ARM Cortex A9 dual-core 1.4GHz processor along with 1GB RAM power the Samsung Galaxy Note. It has a 5.3-inch Super AMOLED display with a 1280 x 800 pixel resolution. It bears 16GB built-in storage expandable up to 32GB via a microSD card. It also houses an 8MP camera with 1080p HD videos and is powered by a 2500mAh battery.

Friday, March 22, 2013

Jellybam 7.2 available




So Why JellyBam?

Features:
- Overall features of AOKP, CM10.1 and AOSPA (ParanoidAndroid)
- BAM CONTROL(includes All features Merged in One)
- Built in SUPERUSER integrated In settings
- Overall features of Jelly Bean 4.2.2
- Latest Cm10.1 kernel with vsync and mali patch
- New mali driver inside
- ExTweaks for Overclock, Undervolt and system optimization
- OTA Update via UpdateMe App
- You can keep your ROM up to date with latest Tweaks, Mods, Themes via
- UpdateMe app
- Pre-Installed GAPPS
- Gallery support for picasa and google sync
- Bluetooth hacked for send / receive APK
- Apollo music player comes from teamhacksung
- Sony Bravia Engine v2
- DSP Manager for sound boost and quality
- 4 Themes: System (My favourite with inverted Apps is very cool), Jelly Blue, Jelly - Dark and Blue Infinitum available in UpdateMe
- TouchWiz Launcher and Apex launcher
- YouTube hacked with 3G+WiFi HD 720p PlayBack
- Gmail with pinch-to-zoom hack
- Alsa audio Technology
- Added Google drive app
-JellyBoom Scripts
- Init.d scripts for boost performance and battery life
- V6 Supercharger for RAM Optimization
- Automatic Zipalign and Permission fix at boot
- SmoothScrolling Tweak
- Build.prop tweak for battery life and system optimization
- Tweaks for 3G and Wifi speed
- Media quality rised to maximum
- Faster GPS
- Roboto font
- JellyBam Special bootanimation
- Multi languages



Thursday, March 21, 2013

Arcane Lite Live Wallpaper Update v1.7



Explore the wonderful world of colors flashing through the classic honeycomb grid. Both tablets and phones are fully supported in both portrait and landscape modes.

PRO Version Features: Extremely customizable user settings for selecting various background colors, particle styles, grid styles and touch effects are provided along with a set of pre-defined themes.

TO USE: home->menu->wallpapers

Updated:
* Added support to low resolution devices
* Crash while initializing debugged





What is Internet Minute?


In one internet minute - more than 
  • 135 botnet infections
  • 204 million email
  • 47000 app downloads
  • 204 million emails are sent, 
  • 6 million Facebook pages are viewed, 
  • 1.3 million YouTube clips are downloaded, 
  • and 20 identities are stolen. Please share. :-)
This interesting infographic is by chipmaker Intel.

Wednesday, March 20, 2013

Android 5.0 Key Lime Pie: Top 10 Facts

google android 5.0, android 5.0, android 5.0 key lime pie
Google Android 5.0, rumored to be called Key Lime Pie, has been one of the most highly-anticipated software updates for Android devices in recent months. But, what do we know about the still-unconfirmed Android software update? Here's what you need to know about Android 5.0 Key Lime Pie, including rumored features and a potential release date. We'll continue to this post as more information leaks regarding Google Android 5.0 Key Lime Pie, so be sure to stay tuned.

1. We May See Android 5.0 Key Lime Pie as Soon as May

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
Google I/O, Google's annual developer conference, will be held in San Francisco from May 15th to the 17th. Last year, Google introduced Android 4.1 Jelly Bean at Google I/O 2012, and most analysts are expecting Google to follow the same timeline. Note: Google I/O 2013 is over a month earlier than it was last year (the event was in late June in 2012).

2. It May Come to a Number of Devices
According to SamMobile, a number of Samsung Galaxy devices will be getting upgrades to Android 5.0 Key Lime Pie. Due to fragmentation, the time frame on when these devices will be able to get the updates is unclear, but SamMobile's insider claims Galaxy S4, S3, S2, Galaxy Note 8 3G, LTE, Wi-Fi, Galaxy Note 2, and the Galaxy Note 10.1 will all be getting Key Lime Pie.

3. Most Nexus Devices Will Be Able To Update To Android 5.0 Key Lime Pie
android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors

Depending on how old the device is, it is assumed that most Nexus devices will be able to upgrade to Android 5.0 Key Lime Pie. It makes sense since Nexus devices are the only Android products developed (in part) by Google.

Google Nexus 5: Top 10 Facts You Need to Know

The Google Nexus 5 is rumored to be coming later this year. Find out the rumored release date, features, and specs. Click here to read more

4. The Samsung Galaxy S4 Will Likely Get Key Lime Pie and a Brand New Feature

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
Samsung Orb was supposed to be a brand new feature introduced last week during Samsung's Galaxy S4 unveiling in New York City last week. Obviously, it wasn't, and it seems that's because the feature wasn't finished by the time the event rolled around. But, according to recent reports from Android Authority, the Samsung Orb will be coming along with Android 5.0 Key Lime Pie.

5. It May be a lot Faster

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
Google gets criticized heavily for some issues with the Android ecosystem, namely that updates take a long time to arrive to all Android devices (again, mostly because of fragmentation) and that the operating system has a few glitches. However, with Android 5.0 Key Lime Pie, Google has moved to a a different kernel, which means that the operating system will use less RAM and be faster and better with multitasking.

Fans of Google and Android OS? Share this article and tell your friends about it!

Facebook Twitter Email

6. It Could be a Combination of Jelly Bean and Chrome OS

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
With Andy Rubin, ex-head of Android development, leaving Google and Chrome OS director Sundar Pichai taking over his position, many are hypothesizing that Android 5.0 Key Lime Pie may be a combo of Android OS and Chrome OS. Similar to what Apple has done with the iOS and OS X operating system, Apple could be moving toward a closer integration between the two operating systems.

7. Key Lime Pie May Include Something Called Google Babble

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
Geek.com reported that Google is preparing on unifying their chat services into one massive service called Google Babble. No timeline was given, but Geek.com guessed that the service could be introduced at Google I/O, which means it could be unveiled alongside Android 5.0 Key Lime Pie.

8. It MAY Help the Android Adoption Rate

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
The Android Jelly Bean operating systems' adoption rate has been poor considering Android is the most popular operating system in the world (probably because there are so many Android devices). The problem, again, is fragmentation. With so many different screen sizes to develop for, it takes awhile for Google and app developers to update the operating system and apps. But, depending on how good Android 5.0 Key Lime Pie is, it could help improve upon the abysmal Jelly Bean adoption rate (though they've picked up in recent months).

9. It Could Have a Guest Mode

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
A "Guest Mode" is where your family members or friends can use your phone without accessing the settings or key features on your devices, like SMS messaging. IBTimes AU writes that this feature could be introduced to Android 5.0 Key Lime Pie, though it seems like a kind of random feature to include in Android 5.0.

10. Google Could Do Well By Copying Apple

android 5.0 key lime pie, key lime pie rumors, android 5.0 rumors
Apple's mastered the integration between mobile devices and computers, which is the biggest issue with Android devices. Yes, there are features and services like Google Drive, but the overall similarities between iOS and OS X - not only aesthetically but in terms of features as well — makes the Apple OS ecosystem easier to use for consumers. Android needs to develop a stronger bond between Chrome OS and Android 5.0 Key Lime Pie to move up to the same level as Apple.

Samsung Galaxy S3 Android 4.2 Update

Owners of the Samsung Galaxy S3 have had superb news about the update to Jelly Bean 4.2. Screenshots have been posted of the handset running the updated OS and this shows that it does exists and that it will be rolled out for the international version of the device.
If this happens to be the real thing then owners of the Samsung Galaxy S3 will be treated to the new features such as Smart Scroll. Owners will be able to scroll through pages on their device just by using their eyes. This was one of the biggest selling points of the Samsung Galaxy S4 when it was revealed.
We thought that the screen shot was of the new device, but then found out that it was its predecessor, this was shown in the About screen.
Smart Pause will also feature on the device and this allows users to pause the video by looking away from the display. The feature makes use of the front camera of the handset.
It is thought that Smart Scroll may only work with certain apps as we can see this on the screenshot, which shows the control screen. This is where the user can set up the apps to use with the software.
Samsung Galaxy S3 owners will welcome the handset, there has also been news that Sprint will get a new colour, purple.

Review: Sony Xperia Z

 http://venturebeat.files.wordpress.com/2013/01/sony-xperia-z-1.jpg?w=558&h=9999&crop=0

The Sony Xperia Z is the latest in a long line of increasingly enormous Android phones. At a latitudinous 139x71mm, it is slightly larger than the already whopping Samsung Galaxy S3, and absolutely dwarfs an iPhone 5 that now looks more atrophied than svelte.

All joking aside, Sony's latest flagship handset really is colossal, with a meaty £500 price-tag to match.
Alas, phones are not judged on girth alone. Luckily, for that money, you get a truly state-of-the-art device that packs in a lot of really great stuff. The technological calibre of its internal gubbins is unimpeachable. The quad-core 1.5GHz processor makes it more powerful than the desktop PC this review is being written on, while it also has 2GB of RAM, (expandable) 16GB of storage, and a 1080p HD screen. It also has 13 megapixels' worth of camera. In short, it's a pocket powerhouse.
The Android operating system is similarly impressive; after a shaky start, Android has finally ironed out its flaws, and can stand shoulder to shoulder with Apple. It still lacks a smidgen of the iPhone's operative polish, but what it lacks in slickness, it gains in flexibility. Android, with its more gently policed app store and less psychotic attitude to tinkering, allows you a much greater degree of opportunity to install weird stuff on your phone. The battery life is not perfect – it'll last you not quite a day with really intensive usage – but everyone knows that if you're going to use your phone to watch a lot of video, you need to carry a spare charger with you.
And that's it. This is a splendid phone, if you've a strong forearm. It takes sharp pictures, plays sharper video and, befitting its Walkman lineage, plays the sharpest audio. It even makes calls and sends text messages, and no one is going to force you to use iTunes with it.
The thing is, the smartphone market has pretty much matured. Apple has lost its early advantage now the competition has worked out how to copy them,  and with one phone manufacturer pretty much as good as all the others (Samsung, Sony, HTC are all on a par), they're increasingly making  strange design decisions to make themselves stand out. So, let's discuss idiosyncrasies.
Gigantism notwithstanding, it's the screen that gives the Xperia its USP. For people without eagle vision, each top-tier smartphone is going to have visuals roughly as good as everyone else's, so Sony is trying to make its pitch with acreage. That screen takes up very nearly the entire face of the phone. It's highly impressive, but it doesn't have much by way of edge protection. It claims to be shatterproof, of course, but speaking as someone who has managed to crack every smartphone screen he's had since 2008, it seems like tall talk. And shatterproof it may be, but fingerprintproof it most certainly is not.
Furthermore, the decision to give the phone all sleek, uninterrupted lines means it is a beautiful chunk of the future right out of the box, but it'll come at a cost. Each of the ports is hidden by a little plastic tag that looks as though it'll snap off with more than five minutes of ordinary human usage – and then you'll end up with a chic, wide phone with little holes all round the edges.
That's a hypothetical nitpick of course. The Xperia Z is great: exactly the sum of its impressive parts. It's not perfect, but it's as good a phone as you'll buy in the current generation.


Which is better: Samsung's Galaxy S4 or LG's Optimus G Pro?


Samsung and LG continue their rivalry with the Galaxy S4 and Optimus G Pro, but which carries more clout? We find out.

Samsung Galaxy S4: Key specs and features

The main strengths of the Samsung Galaxy S4 are its huge, Full HD display and its earth-shattering processing power.
The display is a 5-inch Super AMOLED touchscreen with a 1920x1080 pixel Full HD resolution at 440 pixels-per-inch (ppi). Visuals are crisp and colourful with excellent contrast, while the sheer size of the display panel makes it ideal for media consumption whether you’re watching back-to-back feature films on a long trip, playing games or browsing the web.
The issue of the processor is a little turbulent at this specific point in time. As we’re writing this, news is just breaking that the UK version of the Galaxy S4 will ship with Qualcomm’s Snapdragon S4 600 quad-core chip clocked at 1.9GHz with an Adreno 320 graphics processing unit (GPU) and 2GB of RAM.
Nothing wrong with that, of course, but the controversy is everyone thought we were getting Samsung’s Exynos 5 Octa eight-core powerhouse, with two quad-core clusters clocked at 1.6GHz and 1.2GHz and promising a finely honed balance of optimised power and battery efficiency. This setup would’ve also come with 2GB of RAM and a shiny new PowerVR SGX544MP3 triple-core GPU.
Either way it’s an absolute monster with more power than you can shake a stick at.
Other strong points include a diverse selection of storage options with 16GB, 32GB or 64GB onboard, plus microSD support for cards up to 64GB.
The camera has been improved from the Galaxy S3’s 8-megapixel back-illuminated sensor (BSI) to a 13-megapixel unit with an LED flash and 1080p HD video capture. What’s really significant, however, is the additional functionality Samsung has built into the phone.
It has a unique dual-camera capability allowing you to capture stills and video footage from both front and rear-facing cameras at the same time. The multishot mode has made  return, except this time it’ll take 100 snaps in four seconds and can stitch them together into a time-lapse with ‘Drama Shot’.
Android 4.2 is great to have with its Butter UI, Google Now app and generally improved performance, but aside from the camera tweaks we mentioned Samsung’s TouchWiz UI is neither a particular highlight nor a hindrance – it’s just sort of...there.

LG Optimus G Pro: Key specs and features

If the latest official rumblings do stick and we do see the Galaxy S4 sporting a Qualcomm 600 chip then that’ll be something it has in common with LG’s Optimus G Pro (not the only thing, by any means, but we’ll come back to that).
However, the Optimus G Pro has a lower clock-speed of 1.7GHz for its implementation of Qualcomm’s top-of-the-line quad-core processor. There’s still an Adreno 320 GPU and 2GB of RAM propping things up too.
LG’s display is slightly larger at 5.5-inches and it’s an IPS LCD rather than OLED. It has the same 1920x1080 pixel Full HD resolution, resulting in a slightly lower pixel density than its rival at around 400ppi.
Other specs make a similar tit-for-tat comparison. The camera is rated at 13-megapixels with an LED flash and 1080p video ccapture.
Storage space is limited to one option of 32GB onboard but it does come with microSD support for up to 64GB, so you’re unlikely to be left wanting.
The Android version is 4.1 Jelly Bean, which is still feature-rich and up-to-date enough to get a pass, it’s layered with LG’s own UI but we’ll cover this further in the next section.

Points to consider: Practical use

It’s impossible not to draw some fairly close comparisons between these two phones.
They’re both large form-factor 5-inch plus devices with high-end Qualcomm quad-core chips, plastic bodyshell construction and premium display panels. And, they both also run Android Jelly Bean with quite similar-looking custom UIs on top.
Samsung’s exterior build is the usual stuff we’ve seen before from the manufacturer with rounded corners and a physical home button, the plastic has a tacky quality to it which doesn’t suggest a £500+ price tag and therefore can’t help but disappoint somewhat.
Visually the design is exactly like an inflated Galaxy S3, although to be fair the bezel on the longer edges barely exists, lending a sleek look to things.
LG’s design is very similar indeed, it has virtually saved itself from Samsung’s wrath by making the handset a wee bit squarer, thicker and chunkier, with broad, flat edges somewhat reminiscent of the Sony Xperia S, except not as sharp. The home button is smaller too.
The material is much the same as Samsung’s though – robust enough in reality but not at all premium feeling in the hand. It also sports the same wafer-thin bezel around the display.
Other differences are a bit more subtle and ultimately quite inconsequential. Both phones have 13-megapixel camera setups, the LG simply lacks Samsung’s fancy feature jiggery-pokery such as dual-camera capture which, while nice to have, isn’t exactly a deal-maker or deal-breaker in either direction.
Similarly, the processor setup is identical aside from the clock-speed being 200MHz faster on the Samsung Galaxy S4 – at this end of the spectrum that’s really not a big deal and performance is likely going to be in the same ballpark.
The display quality on both phones is equally great, the Galaxy S4 has a 40ppi lead which will barely register unless you have Superman’s vision.
Probably our main gripe would fall on the LG Optimus G Pro having a highly fluffy UI for very little benefit in terms of added features. Samsung’s UI is also quite thick but at least it has a clear intent and purpose.
We’d rather not have either though, and this can easily be solved with a quick app download, so again, in reality both are on a fairly even keel here.

Conclusion

Take your pick, really, you’re getting a very similar package either way.
We could lean towards the Samsung based on the usability of the default UI and the added camera features, but there’s not a lot in it.

Direct spec comparison: Shootout

Device Samsung Galaxy S4
LG Optimus G Pro
Dimensions 136.6x69.8x7.9mm, 130g 150.2x76.1x9.4mm, 172g
Display 5-inch Super AMOLED,1920x1080 pixels,440ppi 5.5-inch IPS LCD,1920x1080 pixels,400ppi
Camera 13-megapixel,LED flash,1080p video 13-megapixel,LED flash,1080p video
Storage 16GB/32GB/64GB, microSD up to 64GB 32GB, microSD up to 64GB
Processor, RAM, Graphics 1.9GHz quad-core Qualcomm 600,2GB RAM, Adreno 320 GPU 1.7GHz quad-core Qualcomm 600,2GB RAM,Adreno 320 GPU
Operating System, Android 4.2.2 Jelly Bean Android 4.1 Jelly Bean
UI  TouchWiz LG UI
Connectivity microUSB,Bluetooth,NFC,Wi-Fi,Wi-Fi Direct,Wi-Fi Hotspot,DLNA,4G,GPS,MHL Bluetooth,microUSB,NFC,Wi-Fi,Wi-Fi Direct,Wi-Fi Hotspot,DLNA,GPS,4G,MHL
Battery 2,600mAh 3,140mAh       

OpenGL ES Tutorial for Android – Part III – Adding colors

Last tutorial was about transformations. This tutorial will be a short one. I'm going to talk about adding color to your mesh. I will continue with the source code from tutorial II.

Adding color

3D models with no colors are pretty boring so let's add some color to it. In general colors need no explanation. OpenGL ES uses a color model called RGBA ( Red, Green, Blue and Alpha ). The first three are self explained. The fourth is transparency, how solid the color should be. If you like to read more about colors go to: RGB color model - Wikipedia, the free encyclopedia
You might be familiar with defining colors with hex (#FF00FF) or with decimals (255, 0, 255) we will use 0..1 where 0 map to 0 (#00) and 1 map against 255 (#FF).
The easiest way of coloring meshes is called vertex coloring and I am going to show you two different ways of doing that. Flat coloring that gives one solid color and smooth coloring that will blend colors specified for each vertex. Texturing is also a way of giving your mesh colors but it is not vertex coloring so I will show you how to do that in a later tutorial.

Flat coloring

Flat ColoringFlat coloring is really easy just tell OpenGL ES what color to use when it is going to render. One thing to remember is that when you set the color OpenGL ES uses this color until you change the color. This means that if you have two different squares and you tell OpenGL ES to change the color right before the second square the first frame the two squares will have different color but the next rendered frame both squares will have the same color.
To tell OpenGL ES what color to work with you use this command:
public abstract void glColor4f(float red, float green, float blue, float alpha)
The default values are: red = 1, green = 1, blue = 1 and alpha = 1. Those values are white, and that's why all the squares we previous made has a white color.
Create a new class called FlatColoredSquare it should be identical to the Square class. Then in the FlatColoredSquare function draw, add this line:
gl.glColor4f(0.5f, 0.5f, 1.0f, 1.0f); // 0x8080FFFF
I usually add a comment like the one above ( // 0x8080FFFF ) because I am used to read that. It makes it easier for me when reviewing the code.
It should now look like this:
public void draw(GL10 gl) {
        gl.glColor4f(0.5f, 0.5f, 1.0f, 1.0f);
        ...
Then change in the renderer so it uses the FlatColoredSquare instead of the Square.
public class OpenGLRenderer implements Renderer {
 private FlatColoredSquare flatSquare; // CHANGED

 public OpenGLRenderer() {
  // Initialize our square.
  flatSquare = new FlatColoredSquare(); // CHANGED
 }

        public void onDrawFrame(GL10 gl) {
                ...
  flatSquare.draw(gl); // Don't forget to change this one.
                ...
 }
Remember that anything rendered after you set a color uses the same color and that this spans over frames and will not be reset in-between.
If you compile and run the application you will see one big flat colored blue square.
Just to give place to the smooth colored square coming up we move the flat square up.
public void onDrawFrame(GL10 gl) {
 gl.glLoadIdentity();
 // Translates 7 units into the screen and 1.5 units up.
 gl.glTranslatef(0, 1.5f, -7);
        // Draw our flat square.
 flatSquare.draw(gl);
}
Notice that with flat coloring you don't need to tell OpenGL ES to turn it on or off. OpenGL ES uses flat coloring as a default way of coloring the meshes.

Smooth coloring

Smooth ColoringSmooth coloring is gained when you give each vertex its own color. OpenGL ES will interpolate the colors between the vertices and you will gain a smooth coloring effect. Just as with the flat coloring you tell OpenGL ES what to work with and it will be used as long as you don't say anything else.
Create a new class called SmoothColoredSquare it should be identical to the Square class just as you did with the FlatColoredSquare. Modify the new class with this:
Define the colors you like your vertices to have.
public class SmoothColoredSquare {
        ...
        // The colors mapped to the vertices.
        float[] colors = {
                1f, 0f, 0f, 1f, // vertex 0 red
                0f, 1f, 0f, 1f, // vertex 1 green
                0f, 0f, 1f, 1f, // vertex 2 blue
                1f, 0f, 1f, 1f, // vertex 3 magenta
        };
        ...
The order of defining the colors are important since they map against the vertices so in this example above the first color (1f, 0f, 0f, 1f ) map against the top left vertex ( -1.0f, 1.0f, 0.0f ) the green against the bottom left vertex and the rest you can figure out. Hint: Look at the image above.
And put them in a buffer just as we did with the vertices and indices.
public SmoothColoredSquare() {
 ...

 // float has 4 bytes, colors (RGBA) * 4 bytes
 ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length * 4);
 cbb.order(ByteOrder.nativeOrder());
 colorBuffer = cbb.asFloatBuffer();
 colorBuffer.put(colors);
 colorBuffer.position(0);
 }
Don't forget to add colorBuffer as a variable to the class as well.
        // Our color buffer.
 private FloatBuffer colorBuffer;
We also need to enable the color buffer and tell openGL where it is.
public void draw(GL10 gl) {
        ...
 gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);

 // Enable the color array buffer to be used during rendering.
 gl.glEnableClientState(GL10.GL_COLOR_ARRAY); // NEW LINE ADDED.
 // Point out the where the color buffer is.
 gl.glColorPointer(4, GL10.GL_FLOAT, 0, colorBuffer); // NEW LINE ADDED.

 gl.glDrawElements(GL10.GL_TRIANGLES, indices.length,
    GL10.GL_UNSIGNED_SHORT, indexBuffer);
 ...
        // Disable the color buffer.
 gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
        ...
 }
Don't forget to disable the use of the color array. If you don't disable the color array both squares will be smooth colored. Try it.
Let's use this new smooth square as well. Start by adding it to your renderer.
public class OpenGLRenderer implements Renderer {
 private FlatColoredSquare flatSquare;
 private SmoothColoredSquare smoothSquare; // NEW LINE ADDED.

 public OpenGLRenderer() {
  // Initialize our squares.
  flatSquare = new FlatColoredSquare();
  smoothSquare = new SmoothColoredSquare(); // NEW LINE ADDED.
 }
We need to move the square down a bit so they don't collide.
public void onDrawFrame(GL10 gl) {
 ...
        // Translate to end up under the flat square.
 gl.glTranslatef(0, -3f, 0);
 // Draw our smooth square.
 smoothSquare.draw(gl);
}

OpenGL ES Tutorial for Android – Part II – Transformations

Last tutorial was about setting up the stage for open gl. This tutorial is all about transformations, how to move the polygons around. I will continue this tutorial from where the previous ended so you can use that source code or make a copy of it. I am not going to bore you with a lot of mathematics but I believe it is important to know that when OpenGL render a mesh it multiplies all vertices with a matrix. All the transformations you do are about manipulating the vertices in different ways by modifying this matrix. You can think of the matrix as a paper and that you never move the pen before you start to draw. You always draw in the center. But by doing a translation on the matrix you are moving the paper and also the center. A rotation is like rotating the paper around the center. And a scale is a bit harder to visualize with the paper view but it is like changing the unit size regarding to how you translate your meshes. Usually you talk about transformations according to the mesh not the world, but it is still important to know about.

Coordinate System

OpenGL uses a so called right-handed coordinate system. A system is called right-handed if you look from the positive end towards the origin of the axis the counter-clockwise rotation is considered to be a positive rotation. When you have started up your view and haven't applied any transformations the axis are aligned like this: The x-axis goes from left to right, the y-axis comes from the bottom and goes up and the z-axis is moving from the back of the screen towards the front of the screen. Coordinate System

Translate

public abstract void glTranslatef (float x, float y, float z) //OpenGL docs.
Coordinate SystemA translations added to the matrix makes the mesh appear as it has been moved. Translations are made along the axis and with no rotation added the axis are in there default state. Translation affects all the vertices in a polygon the same amount over the same axis. Translations are simply additions and subtractions to a current value. The image to the right shows a translation in 2 dimensions.
The start point is {x:-2, y:1} we like to go to {x:1, y:3} so we add {x:3, y:2}.
A simple addition: {x:-2, y:1} + {x:3, y:2} = {x:-2 + 3, y:1 + 2} = {x:1, y:3}.
In 3 dimensions we do the same, if we are located at position: {x:1, y:1, z:0} and we like to move 3 units into the screen we add {x:0, y:0, z:-3} and end up at: {x:1, y:1, z:-3}.
In the last tutorial we moved the square 4 units into the screen just to be able to see the square. What we did was that we added {x:0, y:0, z:-4} to the current position. This is the code we used for the translation:
// Translates 4 units into the screen.
gl.glTranslatef(0, 0, -4); OpenGL docs.
If you do several translations after each other the order of the movement is along the X, Y and Z axis, in that order. On translate the order isn't so important but when we do a rotation it's really important.
It can be quite tricky to remember how the axis are aligned. Fortunate there is a good trick to remember the direction of the axis. Hold your left hand like the photo below. The point on each finger represents the positive direction on one axis. Your thumb is y-axis, index finger is x-axis and your middle finger would represent the z-axis. When I first started with 3D programming I actually wrote the letters, x, y and z on my fingers :)

Help with the axis.

Rotate

public abstract void glRotatef(float angle, float x, float y, float z)//OpenGL docs.
Rotating is what it sounds like. You add a rotation to the matrix making it appears like the mesh are rotated. With no translation before the rotation is around the origo. The x, y and z values defines the vector to rotate around. The angle value is the number of degrees to rotate. Coordinate System
If you remember these three things you will manage rotation quite easy.
1. The rotation value are in degrees.
Most frameworks and math functions on computers use radians but OpenGL use degrees.
2. When doing several rotations the order are important.
If you like to restore a rotation you negate the angle or all the axis like this: glRotatef(angle, x, y, z) is restored with glRotatef(angle, -x, -y, -z) or glRotatef(-angle, x, y, z).
But if you do several rotations after each other like this:
gl.glRotatef(90f, 1.0f, 0.0f, 0.0f); // OpenGL docs.
gl.glRotatef(90f, 0.0f, 1.0f, 0.0f); // OpenGL docs.
gl.glRotatef(90f, 0.0f, 0.0f, 1.0f); // OpenGL docs.
gl.gRotatef(90f, 1.0f, 1.0f, 1.0f)
And want to restore the mesh to it's original position you can't just negate the angle like this:
gl.glRotatef(90f, -1.0f, 0.0f, 0.0f); // OpenGL docs.
gl.glRotatef(90f, 0.0f, -1.0f, 0.0f); // OpenGL docs.
gl.glRotatef(90f, 0.0f, 0.0f, -1.0f); // OpenGL docs.
gl.gRotatef(90f, -1.0f, -1.0f, -1.0f)
You have to revert the order of the rotations as well like this:
gl.glRotatef(90f, 0.0f, 0.0f, -1.0f); // OpenGL docs.
gl.glRotatef(90f, 0.0f, -1.0f, 0.0f); // OpenGL docs.
gl.glRotatef(90f, -1.0f, 0.0f, 0.0f); // OpenGL docs.
The order of several rotations is important.
3. If you look from the positive end towards the origin of the axis the positive rotation is counter-clockwise.
If you take a pencil in your hand, let the point be in the same direction as your thumb, as in the picture below, then aligns the pencil with the x-axis. Let the pencil's point be aligned with the positive direction of the axis. Your other fingers will now point in the positive direction of the rotation over that axis.
Positive rotation.

Translate & Rotate

Since both rotation and translations are made within each mesh own coordinate system it is important to remember that the order you do the translation and rotation are very important.
If you do a translation on the mesh first and then rotate it, the translation is made on the current state of the mesh coordinate system and then rotated at the new location.

Translate Rotate

If you first rotate and the move the mesh it will be moved accordingly to its own rotated coordinate system.
Translate Rotate

Scale

public abstract void glScalef (float x, float y, float z) // OpenGL docs.
Scaling is just as it sounds and it is possible to scale over each axis separately. Scaling is the same as multiplying all vertexes with the same scalar. In the image below we scale with: gl.glScalef(2f, 2f, 2f). That means that we multiply all vertixes with 2.

Scale.

Translate & Scale

The order of scaling and translating does matter. If you translate before scaling the transformation is intact. Like this example, first a translation of 2 units and then scale it by 0.5.
gl.glTranslatef(2, 0, 0); // OpenGL docs.
gl.glScalef(0.5f, 0.5f, 0.5f); // OpenGL docs.
Translate scale.

But if you scale before the translation you get a different result. Since you scale the mesh coordinate system then do the translation you will not move the mesh the same amount as you would before the scaling. So if you first scale with 0.5 and then do a translation of 2 units the result will appear as a translation of 1 unit.
gl.glScalef(0.5f, 0.5f, 0.5f); // OpenGL docs.
gl.glTranslatef(2, 0, 0); // OpenGL docs.
Scale translate.

Load Identity, push and pop matrix

When you translate, rotate or scaling you are not applying the transformation from the same preconditions, you are applying them to the previous transition. You need to be able to reset the position.

glLoadIdentity

public abstract void glLoadIdentity() // OpenGL docs.
glLoadIdentity replaces the current matrix with the identity matrix. It is the same as calling glLoadMatrix with the identity matrix:
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
There are situations where you don't want to reset the model matrix, you rather want to go back to how it was just before your latest transformation.

glPushMatrix

public abstract void glPushMatrix() // OpenGL docs.
glPushMatrix makes a copy of the current matrix and put it on the stack. This means that when you do any kind of translations after glPushMatrix you are doing them on a copy.

glPopMatrix

public abstract void glPopMatrix() // OpenGL docs.
To get back to the previous matrix you use the glPushMatrix command.
A good practice can be to have one glLoadIdentity in the begining of each frame and after that use glPushMatrix and glPopMatrix.

Putting it all togetter

So to make something with this new knowlege let us do 3 squares call them A, B and C. Scale them so that B is 50% smaller then A and C is 50% smaller then B. Then let A rotate counter-clockwise in the center of the screen. B should rotate clockwise around A and finaly C rotating clockwise around B and counter-clockwise in a high speed around it's own center.
public void onDrawFrame(GL10 gl) {
 // Clears the screen and depth buffer.
 gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
 // Replace the current matrix with the identity matrix
 gl.glLoadIdentity();
 // Translates 10 units into the screen.
 gl.glTranslatef(0, 0, -10);

 // SQUARE A
 // Save the current matrix.
 gl.glPushMatrix();
 // Rotate square A counter-clockwise.
 gl.glRotatef(angle, 0, 0, 1);
 // Draw square A.
 square.draw(gl);
 // Restore the last matrix.
 gl.glPopMatrix();

 // SQUARE B
 // Save the current matrix
 gl.glPushMatrix();
 // Rotate square B before moving it, making it rotate around A.
 gl.glRotatef(-angle, 0, 0, 1);
 // Move square B.
 gl.glTranslatef(2, 0, 0);
 // Scale it to 50% of square A
 gl.glScalef(.5f, .5f, .5f);
 // Draw square B.
 square.draw(gl);

 // SQUARE C
 // Save the current matrix
 gl.glPushMatrix();
 // Make the rotation around B
 gl.glRotatef(-angle, 0, 0, 1);
 gl.glTranslatef(2, 0, 0);
 // Scale it to 50% of square B
 gl.glScalef(.5f, .5f, .5f);
 // Rotate around it's own center.
 gl.glRotatef(angle*10, 0, 0, 1);
 // Draw square C.
 square.draw(gl);

 // Restore to the matrix as it was before C.
 gl.glPopMatrix();
 // Restore to the matrix as it was before B.
 gl.glPopMatrix();

 // Increse the angle.
 angle++;
}
And don't forget to add angel as a variable as well.
public class OpenGLRenderer implements Renderer {
 private Square square;
 private float angle; // Don't forget to add this.
        ...