Giant Android

Android 11 is almost ready

2020-08-08T01:42:00.004-07:00

Android 11 is almost ready and we have got beta release from google now.

Google calling it as release candidate for final release.

https://developer.android.com/android11

SQL Performance enhancement for count function

2016-04-11T05:20:00.000-07:00

SQL count aggregate function with case is helpful to reduce time to process sql db.
If you want count for any column bases on the value we can use the count function with case to reduce the processing time.

e..g. select count(case column1 when 'value1' then 1 else null end) as count1, count(case column1 when 'value2' then 1 else null end) as count2 from table1

Gradle

2016-02-24T03:10:00.000-08:00

The Gradle build system

Since the Gradle build system (http://www.gradle.org) gets more and more attention I decided to have a look at how it works. This article should give you a brief overview of some of the features so that you get the taste of Gradle. It is not meant to be a tutorial to get you started and it’s recommended that you know about another build system.

What is it?

Gradle is a build system that combines and extends the best features of Ant and Maven. It supports task based build processes like Ant and follows convention over configuration like Maven. On top of that, Gradle build scripts are written in the Groovy language allowing to define more complex behaviour in cases where it is necessary. But you don’t need to be a Groovy expert because Gradle comes with a domain specific language (DSL) to define the builds.
Dependencies can be managed using Ivy and Maven repositories or by yourself if that is required. Most of the behaviour is defined in Gradle plug-ins that ship with its distribution. They can be used out of the box and adapted to your needs.

A simple example

A simple example of a build.gradle script for a Java project looks like this:

apply plugin: 'java'

It expects the default layout from Maven which consists of src/main/java, src/main/resource, src/test/java and src/test/resource. And it expects the source to be compatible with the current JVM it is running on. To change these properties of the ‘java’ plug-in you can use Gradle’s DSL:

sourceSets.main.java.srcDirs = ['src/java', 'src/generated']

sourceCompatibility = 1.6

Dependency management

Repositories

Gradle can access Maven and Ivy repositories. Here are some samples how to configure the repositories:

repositories {

  mavenLocal()

  maven {

    url "http://repo.mycompany.com/repo"

  }

  mavenCentral()

}

repositories {

  ivy {

    url "http://repo.mycompany.com/repo"

  }

}

The look-ups will be done in the order given within the repositories section. So in the above Maven example it will first look in the local repository of the user, then on the company’s server and finally on Maven Central.

Dependencies

To depend on an internal module, i.e. a module from the same project, you just write:

dependencies {

  compile project(':shared')

}

You can also add dependencies to external modules from Maven or Ivy repositories if you have defined them as described above.

dependencies {

  runtime group: 'org.hibernate', name: 'hibernate', version: '3.0.5'

  testRuntime 'org.mockito:mockito-core:1.8.4'

}

The above sample contains the long and the short version of a module identifier. If you have a dependency on a local file then you can specify it with:

dependencies {

  compile files('libs/a.jar', 'libs/b.jar')

  testCompile fileTree(dir: 'testlibs', include: '*.jar')

}

More sophisticated features can be found in the documentation and include stuff like:

overwriting transitive dependencies
use Ivy specific dependency features
etc.

Tasks

Tasks are the central building blocks of the build process. They consist of two lists of actions. One list is to configure the task and the other to execute it. Here is a sample:

// Just define an empty task

task myTaskA

// Add a configuration action

myTaskA {

  println "config A"

}

// Add an execution action

myTaskA << {

  println "action A"

}

// Another task depending on myTaskA with configuration and action

task myTaskB (dependsOn: myTaskA) {

  println "config B"

  doLast {

    println "action B"

  }

}

Now you can start it:

$ gradle myTaskB

The configuration steps will be executed first. And since myTaskB depends on myTaskA the output will be:

config A

config B

:myTaskA

action A

:myTaskB

action B

BUILD SUCCESSFUL

Tasks can also be of a predefined type. The follwoing example uses the JavaExec type to start some Java code:

apply plugin: 'java'

… // dependencies, repositories etc.

task startMain(type: JavaExec, dependsOn: classes) {

  main = 'mypackage.Main'

  args = "-x -y -z".split().toList()

  classpath sourceSets.main.classesDir

  classpath configurations.compile

}

The command gradle startMain prepares the classes and then starts the program using the classes and also the external dependencies as classpath.

Maven sample comparison

Just to be clear: this is not an A is better than B comparison. The purpose is only to show you the two different versions of a Maven and a Gradle build script that achieve the same thing.

<project xmlns="http://maven.apache.org/POM/4.0.0"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>

   <groupId>ch.bbv.mavendemo</groupId>

   <artifactId>simpleMavenDemo</artifactId>

   <version>0.0.1-SNAPSHOT</version>

   <properties>

       <java.source.version>1.7</java.source.version>

       <junit.version>4.8.2</junit.version>

   </properties>

   <dependencies>

       <dependency>

           <groupId>junit</groupId>

           <artifactId>junit</artifactId>

           <version>${junit.version}</version>

           <scope>test</scope>

       </dependency>

   </dependencies>

   <build>

       <plugins>

           <plugin>

               <artifactId>maven-compiler-plugin</artifactId>

               <version>2.3.1</version>

               <configuration>

                   <source>${java.source.version}</source>

                   <target>${java.source.version}</target>

               </configuration>

           </plugin>

       </plugins>

   </build>

</project>

In Gradle this would be:

apply plugin: 'java'

apply plugin: 'maven'

group = 'ch.bbv.gradledemo'

version = '0.0.1-SNAPSHOT'

//the default artifact id is the project name, which is per default the directory name of the project

project.ext.junitVersion='4.8.2'

sourceCompatibility = 1.7

targetCompatibility = 1.7

repositories {

   mavenCentral()

}

dependencies {

   testCompile 'junit:junit:'+junitVersion

}

The ‘maven’ plug-in allows you to install the artifact in your local Maven repository. Gradle’s DSL makes the build script much easier to read. Of course one could use polyglot Maven but that didn’t take off yet.

IDE integration

The first thing I tried was the Gradle plug-in called ‘eclipse’ (it’s a bit unlucky that everything is now called plug-in). This plug-in can generate eclipse configuration files with settings, project and classpath. This works quite well but you have to update and refresh the project yourself after changing the build.gradle file.
The opposite way around there are also plug-ins for eclipse. The first one is Groovy support so you can edit Groovy code in eclipse. The second one is the Gradle plug-in itself which manages the dependencies of your project, allows you to start Gradle tasks and more.
There is support for other IDEs as well. The current state of tooling can be found here: http://www.gradle.org/tooling

Documentation

Gradle comes with a comprehensive set of documentation including a user guide, reference material and even a book titled “Building and Testing with Gradle”. You can read the book online if you register on Gradleware’s web site. It’s a good read and covers all the stuff you need to get started with Gradle.
The user guide documents all the parts of Gradle and will be continuously extended as Gradle grows. The reference material is generated Java/Groovy doc for Gradle’s API and DSL.

Conclusion

I see three scenarios where Gradle can be a good candidate for your build system.

If you are currently using Ant and the build.xmls get too complicated to handle. With the task based build and the support for existing Ant tasks, Gradle support the migration from Ant.
You have trouble to get Maven to do what you want and maybe already started to write your own Maven plug-ins. Gradle supports the convention over configuration paradigm similar to Maven but can also be scripted with Groovy to do more powerful stuff.
You start a new project.

Gradle as a build system makes a very good impression to me. Hopefully there will be more plug-ins developed when more and more projects use it. I’ve seen that a Jacoco plug-in is under development for example. Gradle itself will continuously be extended and there is also a short- and long-term road-map available. It is licensed under the Apache License, Version 2.0 and is used by open source projects like Spring and Hibernate and also by commercial entities.
Even though it has a bit of a steep learning curve it is worth a closer look.

This entry was posted in ALM, Java and tagged Build, Gradle, java. Bookmark the permalink.

Firefox OS

2013-05-28T04:08:00.000-07:00

FireFox OS

Firefox OS is a new mobile operating system developed by Mozilla. It uses a Linux kernel and boots into a Gecko-based runtime engine, which lets users run applications developed entirely using HTML, JavaScript, and other open web application APIs.

Firefox OS is currently under heavy development; we are constantly working on ways to make it easier for you to use and hack on Gaia (the default set of apps) and create your own. However, you need knowledge about systems in order to do things like build the entire Firefox OS stack, or flash a phone with a build of Firefox OS. Linked below are guides meant for Web developers interested in running and making changes to Gaia or developing apps to run on Firefox OS devices.

check this https://developer.mozilla.org/en/docs/Mozilla/Firefox_OS for more details.

Here are the steps to install firefox os on your phone

http://support.mozilla.org/en-US/kb/download-and-install-applications-firefox-os

receive screen OnOff or Headset plug broadcast

2013-05-28T03:56:00.000-07:00

There are some broadcast in android which you can't detect just declaring receiver with intent-filters in Android-Manifest.xml to detect them you need one active component service or activity which will register Custom broadcast receiver at run time as follows

MyReceiver br = new MyReceiver();
IntentFilter theFilter1 = new IntentFilter(Intent.ACTION_HEADSET_PLUG);
IntentFilter theFilter2 = new IntentFilter(Intent.ACTION_SCREEN_ON);
registerReceiver(br, theFilter1);
registerReceiver(br, theFilter2);

Android Emulator soft/hard key shortcuts

2013-02-18T22:35:00.001-08:00

Android Emulator soft/hard key shortcuts

Home      Home Button
F2                  Left Softkey / Menu / Settings button (or Page up)
Shift+f2   Right Softkey / Star button (or Page down)
Esc                Back Button
F3                 Call/ dial Button
F4   Hang up / end call button
F5   Search Button
Ctrl+F5         Volume up (or + on numeric keyboard with Num Lock off)
Ctrl+F6         Volume down (or + on numeric keyboard with Num Lock off)
F7   Power Button
Ctrl+F3        Camera Button
Ctrl+F11      Switch layout orientation portrait/landscape backwards
Ctrl+F12      Switch layout orientation portrait/landscape forwards
F8                Toggle cell network
F9               Toggle code profiling
Alt+Enter   Toggle fullscreen mode
F6               Toggle trackball mode

Micromax A116 Canvas HD goes official with 5" screen, quad CPU

2013-01-21T23:06:00.000-08:00

Micromax has announced the latest Canvas series smartphone today and it is called A116 Canvas HD unlike the rumours of Canvas 3. Packing a MediaTek 6589 quad-core processor, it will go on sale starting the first week of next month (i.e. February). Company has revealed that it wants to price A116 Canvas HD under INR 15K, which will surely make it an instant hit.
We thought it was time that we compared Micromax A116 with previous iteration of Canvas smartphones from Micromax.

Micromax A116 is significant improvement over the previous versions, considering that it packs a 720p display, quad-core processor and 1GB RAM. Canvas 1 and Canvas only have 512MB RAM, single and dual core processors respectively and WVGA resolution displays.

opengl with android part I

2012-10-09T11:49:00.000-07:00

OpenGL

OpenGL (originally called Open Graphics Library) is a 2D and 3D graphics API that was
developed by Silicon Graphics, Inc. (SGI) for its Unix workstations. Although SGI’s
version of OpenGL has been around for a long time, the first standardized spec of
OpenGL emerged in 1992. Now widely adopted on all operating systems, the OpenGL
standard forms the basis of much of the gaming, computer-aided design (CAD), and
even virtual reality (VR) industries.
The OpenGL standard is currently being managed by an industry consortium called The
Khronos Group (http://www.khronos.org), founded in 2000 by companies such as
NVIDIA, Sun Microsystems, ATI Technologies, and SGI. You can learn more about the
OpenGL spec at the consortium’s web site:
http://www.khronos.org/opengl/

The official documentation page for OpenGL is available here:
http://www.opengl.org/documentation/

OpenGL ES

The Khronos Group is also responsible for two additional standards that are tied to
OpenGL: OpenGL ES, and the EGL Native Platform Graphics Interface (known simply as
EGL). As we mentioned, OpenGL ES is a smaller version of OpenGL intended for
embedded systems.
The EGL standard is essentially an enabling interface between the underlying operating
system and the rendering APIs offered by OpenGL ES. Because OpenGL and OpenGL
ES are general-purpose interfaces for drawing, each operating system needs to provide
a standard hosting environment for OpenGL and OpenGL ES to interact with. Android
SDK, starting with its 1.5 release, hides these platform specifics quite well. We will learn
about this in the second section titled “Interfacing OpenGL ES with Android.”

Fundamentals of OpenGL
This section will help you understand the concepts behind OpenGL and the OpenGL ES
API. We’ll explain all the key APIs. To supplement the information from this chapter, you
might want to refer to the “Resources” section towards the end of this chapter. The
indicated resources there include the Red book, JSR 239 documentation, and the
Khronps Group API reference.

here is list of some of this api

glVertexPointer
glDrawElements
glColor
glClear
gluLookAt
glFrustum
glViewport

cheapest dual core android india stellar horizon

2012-10-09T11:35:00.002-07:00

General Information
Brand	Spice
Model	Mi-500 Stellar Horizon
Weight	0 G
Form Factor	Touch Bar
Dimensions	0x0x0 MM
Operating Frequency	GSM 900 / 1800 / UMTS 2100 MHz \| GSM 900 / 1800 / UMTS 2100 MHz
Dual Sim	Yes, Dual SIM, Dual Standby
Touch Screen	Yes, Capacitive Touchscreen

Display Details
Display Color	5.0 inches Capacitive Touchscreen
Display Size	Spice Mi-500 Stellar Horizon has a display size of 480 x 800 px

Camera
Camera	Yes, Rear Camera : 5.0 MP Camera (2592x1944 Pixels) with Auto Focus and LED Flash, Front Camera : 0.3 MP, VGA Camera (640x480 Pixels)
Camera Res.	2592 x 1944 Pixels
Zoom	Yes, Digital Zoom
Video	Yes
Video Recording	Yes
Video Player	Yes, MP4 Player

Software
Games	Yes
Java	Yes
Browser	Yes
Operating System	Android OS, v2.3 (Gingerbread), upgrade to v4.0

Call Records
Phone Book	Practically Unlimited
Missed Calls	Practically unlimited
Received Calls	Practically unlimited
Dialed Calls	Practically unlimited

Battery
Stand By Time	N/A
Talk Time	N/A
Li-ion	2150 mAH

Memory
Internal Memory	Yes, Internal Memory : 4 GB ROM + 512 MB RAM
External Memory	Yes, Up to 32 GB
Memory Slot	Yes, Micro SD/T-Flash Card

Message
SMS	Yes
MMS	Yes
Email	Yes
Instant Messaging	Yes
Social Networking Services	Yes

Music
Ring Tone	Vibration, Polyphonic, MP3
FM	Yes, FM Radio
Music	Yes, Music Formats : MP3, AAC, AAC+, WAV with Loud Speaker, 3.5mm Audio Jack
Speaker	Yes
Headset	Yes

Data
GPRS	Yes
Bluetooth	Yes
Wirless Protocol	Yes, Wi-Fi 802.11 b/g, Wi-Fi Tethering
Port	Yes, USB Port
Edge	Yes
Infra Red	No
3G	Yes
GPS	Yes
CPU	Yes, Dual core 1GHz processor
Salespack	Handset, Battery, Charger, Earphone, USB Cable, User Manual, Warranty Card

Others

Applications :

Secured by NQ Mobile Security Apps

Colours

Black

Spice MI-500

create nice looking ListView filter on Android

2012-08-08T11:38:00.000-07:00

First, you need to create an XML layout that has both an EditText, and a ListView.

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <!-- Pretty hint text, and maxLines -->
    <EditText android:id="@+building_list/search_box" 
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="type to filter"
        android:inputType="text"
        android:maxLines="1"/>

    <!-- Set height to 0, and let the weight param expand it -->
    <!-- Note the use of the default ID! This lets us use a 
         ListActivity still! -->
    <ListView android:id="@android:id/list"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" 
         /> 
</LinearLayout>

This will lay everything out properly, with a nice EditText above the ListView. Next, create a ListActivity as you would normally, but add a setContentView() call in the onCreate() method so we use our recently declared layout. Remember that we ID'ed the ListView specially, with android:id="@android:id/list". This allows the ListActivity to know which ListView we want to use in our declared layout.

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.filterable_listview);

        setListAdapter(new ArrayAdapter<String>(this,
                       android.R.layout.simple_list_item_1, 
                       getStringArrayList());
    }

Running the app now should show your previous ListView, with a nice box above. In order to make that box do something, we need to take the input from it, and make that input filter the list. While a lot of people have tried to do this manually, most ListView Adapter classes come with a Filter object that can be used to perform the filtering automagically. We just need to pipe the input from the EditText into the Filter. Turns out that is pretty easy. To run a quick test, add this line to your onCreate() call

adapter.getFilter().filter(s);

Notice that you will need to save your ListAdapter to a variable to make this work - I have saved my ArrayAdapter<String> from earlier into a variable called 'adapter'.
Next step is to get the input from the EditText. This actually takes a bit of thought. You could add an OnKeyListener() to your EditText. However, this listener only receives some key events. For example, if a user enters 'wyw', the predictive text will likely recommend 'eye'. Until the user chooses either 'wyw' or 'eye', your OnKeyListener will not receive a key event. Some may prefer this solution, but I found it frustrating. I wanted every key event, so I had the choice of filtering or not filtering. The solution is a TextWatcher. Simply create and add a TextWatcher to the EditText, and pass the ListAdapter Filter a filter request every time the text changes. Remember to remove the TextWatcher in OnDestroy()! Here is the final solution:

private EditText filterText = null;
ArrayAdapter<String> adapter = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.filterable_listview);

    filterText = (EditText) findViewById(R.id.search_box);
    filterText.addTextChangedListener(filterTextWatcher);

    setListAdapter(new ArrayAdapter<String>(this,
                   android.R.layout.simple_list_item_1, 
                   getStringArrayList());
}
private TextWatcher filterTextWatcher = new TextWatcher() {

    public void afterTextChanged(Editable s) {
    }

    public void beforeTextChanged(CharSequence s, int start, int count,
            int after) {
    }

    public void onTextChanged(CharSequence s, int start, int before,
            int count) {
        adapter.getFilter().filter(s);
    }
};
@Override
protected void onDestroy() {
    super.onDestroy();
    filterText.removeTextChangedListener(filterTextWatcher);
}

convert Drawable to Bitmap

2012-08-08T11:30:00.002-07:00

This piece of code helps.

Bitmap icon = BitmapFactory.decodeResource(context.getResources(),
                                           R.drawable.icon_resource);

Edit: Here a version where the image gets downloaded.

String name = c.getString(str_url);
URL url_value = new URL(name);
ImageView profile = (ImageView)v.findViewById(R.id.vdo_icon);
if (profile != null) {
    Bitmap mIcon1 =
        BitmapFactory.decodeStream(url_value.openConnection().getInputStream());
    profile.setImageBitmap(mIcon1);
}

This converts a BitmapDrawable to a Bitmap.

Drawable d = ImagesArrayList.get(0);  Bitmap bitmap = ((BitmapDrawable)d).getBitmap();

transparent activity android

2012-08-08T11:27:00.000-07:00

Add the following style In your res/values/styles.xml file (if you don’t have one, create it.) Here’s a complete file:

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <style name="Theme.Transparent" parent="android:Theme">
    <item name="android:windowIsTranslucent">true</item>
    <item name="android:windowBackground">@android:color/transparent</item>
    <item name="android:windowContentOverlay">@null</item>
    <item name="android:windowNoTitle">true</item>
    <item name="android:windowIsFloating">true</item>
    <item name="android:backgroundDimEnabled">false</item>
  </style>
</resources>

(the value @color/transparent is the color value #00000000 which I put in res/values/color.xml file. You can also use @android:color/transparent in later Android versions)
Then apply the style to your activity, for example:

<activity android:name=".SampleActivity" android:theme="@style/Theme.Transparent">
...</activity>

pick a image from gallery (SD Card) for my app in android

2012-08-08T11:25:00.001-07:00

Here's some sample code on how to do that:

protected void onActivityResult(int requestCode, int resultCode, Intent imageReturnedIntent) { 
    super.onActivityResult(requestCode, resultCode, imageReturnedIntent); 

    switch(requestCode) { 
    case REQ_CODE_PICK_IMAGE:
        if(resultCode == RESULT_OK){  
            Uri selectedImage = imageReturnedIntent.getData();
            String[] filePathColumn = {MediaStore.Images.Media.DATA};

            Cursor cursor = getContentResolver().query(selectedImage, filePathColumn, null, null, null);
            cursor.moveToFirst();

            int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
            String filePath = cursor.getString(columnIndex);
            cursor.close();


            Bitmap yourSelectedImage = BitmapFactory.decodeFile(filePath);
        }
    }
}

set HttpResponse timeout for Android in Java

2012-08-08T11:23:00.002-07:00

HttpGet httpGet = new HttpGet(url);
HttpParams httpParameters = new BasicHttpParams();
// Set the timeout in milliseconds until a connection is established.
// The default value is zero, that means the timeout is not used. 
int timeoutConnection = 3000;
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
// Set the default socket timeout (SO_TIMEOUT) 
// in milliseconds which is the timeout for waiting for data.
int timeoutSocket = 5000;
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
HttpResponse response = httpClient.execute(httpGet);

If you want to set the Parameters of any existing HTTPClient (e.g. DefaultHttpClient or AndroidHttpClient) you can use the function setParams().

httpClient.setParams(httpParameters);

check internet access on android

2012-08-08T11:21:00.002-07:00

here is the code which will help to check internet available

public boolean isOnline() {
    ConnectivityManager cm =
        (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
    NetworkInfo netInfo = cm.getActiveNetworkInfo();
    if (netInfo != null && netInfo.isConnectedOrConnecting()) {
        return true;
    }
    return false;
}

Tutorials and libraries for OpenGL-ES games on Android

2012-08-08T11:14:00.000-07:00

Android tutorials:

Other Android OpenGL-ES information:

Google IO lecture regarding games, not much OpenGLES
The The Khronos Reference Manual is also relevant to have, but its not exactly the best place to start.

iPhone OpenGL-ES tutorials (where the OpenGl-ES information is probably useful):

As for libraries which a beginner might use to get a simpler hands-on experience with OpenGL-ES, I have only found Rokon, which is recently started, thus has many holes and bugs. And it's gnuGPL licensed (at the moment) which means it cannot be used, if we wish to sell our games.

1. INsanityDesign
2. nehe

Difference between Corona, Phonegap, Titanium

2012-08-06T10:41:00.001-07:00

PhoneGap is not just a native wrapper of a web app. Through the PhoneGap javascript APIs, the "web app" has access to the mobile phone functions such as Geolocation, Accelerometer Camera, Contacts, Database, File system, etc. Basically any function that the mobile phone SDK provides can be "bridged" to the javascript world. On the other hand, a normal web app that runs on the mobile web browser does not have access to most of these functions (security being the primary reason). Therefore, a PhoneGap app is more of a mobile app than a web app. You can certainly use PhoneGap to wrap a web app that does not use any PhoneGap APIs at all, but that is not what PhoneGap was created for.
Titanium does NOT compile your html, css or javascript code into "native bits". They are packaged as resources to the executable bundle, much like an embedded image file. When the application runs, these resources are loaded into a UIWebView control and run there (as javascript, not native bits, of course). There is no such thing as a javascript-to-native-code (or to-objective-c) compiler. This is done the same way in PhoneGap as well. From architectural standpoint, these two frameworks are very similar.

3. Corona SDK is a software development kit created by Walter Luh, co-founder of Corona Labs (formerly known as Ansca Mobile). It allows software programmers to build mobile applications for the iPhone, iPad, and Android devices.
Corona lets developers use integrated Lua, layered on top of C++/OpenGL, to build graphically rich applications that are also lightweight in size and quick in development time. The SDK does not charge per-app royalty or impose any branding requirement, and has a subscription-based purchase model that allows new features to be rolled out immediately to users.

hide Android Soft Keyboard

2012-08-06T10:27:00.001-07:00

hide Android Soft Keyboard

You can force Android to hide the virtual keyboard using the InputMethodManager, calling `hideSoftInputFromWindow`, passing in the token of the window containing your edit field.

InputMethodManager imm = (InputMethodManager)getSystemService(
      Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);

This will force the keyboard to be hidden in all situations. In some cases you will want to pass in InputMethodManager.HIDE_IMPLICIT_ONLY as the second parameter to ensure you only hide the keyboard when the user didn't explicitly force it to appear (by holding down menu).

Also useful for hiding the soft keyboard is:

getWindow().setSoftInputMode(
      WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

This can be used to suppress the keyboard until the user actually touches the edittext view.

python on android

2012-08-06T10:23:00.001-07:00

Python on Android

http://kivy.org/#home
"Open source library for rapid development of applications that make use of innovative user interfaces, such as multi-touch apps."
"Kivy is running on Linux, Windows, MacOSX and Android. You can run the same [python] code on all supported platforms."
Kivy Showcase app
https://market.android.com/details?id=org.kivy.showcase&hl=en

There is also the new ASE project, it looks awesome, and has some integration with native Android components. Android Scripting Environment

Difference between px, dp, dip and sp in Android

2012-08-06T10:13:00.001-07:00

A dimension value defined in XML. A dimension is specified with a number followed by a unit of measure. For example: 10px, 2in, 5sp. The following units of measure are supported by Android:

dp: Density-independent Pixels - An abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi (dots per inch) screen, on which 1dp is roughly equal to 1px. When running on a higher density screen, the number of pixels used to draw 1dp is scaled up by a factor appropriate for the screen's dpi. Likewise, when on a lower density screen, the number of pixels used for 1dp is scaled down. The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion. Using dp units (instead of px units) is a simple solution to making the view dimensions in your layout resize properly for different screen densities. In other words, it provides consistency for the real-world sizes of your UI elements across different devices.
sp: Scale-independent Pixels - This is like the dp unit, but it is also scaled by the user's font size preference. It is recommend you use this unit when specifying font sizes, so they will be adjusted for both the screen density and the user's preference.
pt: Points - 1/72 of an inch based on the physical size of the screen.
px: Pixels - Corresponds to actual pixels on the screen. This unit of measure is not recommended because the actual representation can vary across devices; each devices may have a different number of pixels per inch and may have more or fewer total pixels available on the screen.
mm: Millimeters - Based on the physical size of the screen.
in: Inches - Based on the physical size of the screen.

Note: A dimension is a simple resource that is referenced using the value provided in the name attribute (not the name of the XML file). As such, you can combine dimension resources with other simple resources in the one XML file, under one <resources> element.

“Debug certificate expired” error in Eclipse Android plugins

2012-08-06T10:10:00.000-07:00

Here is the solution for your problem

Delete your debug certificate under ~/.android/debug.keystore on Linux and Mac OS X; the directory is something like %USERPROFILE%/.androidon Windows.
The Eclipse plugin should then generate a new certificate when you next try to build a debug package. You may need to clean and then build to generate the certificate.

Google: Ice Cream Sandwich now accounts for 7.1 percent of Android user base

2012-06-02T08:59:00.001-07:00

Well, it's about time that Ice Cream Sandwich made some headway -- even if the process is much slower than consumers deserve. According to the Android developer hub, Android 4.0 now accounts for 7.1 percent of all Android smartphone and tablet installations, which is a sharp and welcome increase over the 2.9 percent figure that we reported just two months ago. Naturally, Gingerbread users still account for the lion's share of the Android ecosystem with 65 percent, but it's worth pointing out that this segment also grew during the last month -- no doubt at the expense of Froyo and Eclair. Don't know about you, but we like our desserts fresh, thank you very much. Go ahead and hop the break to see the full breakdown.

HTC Desire C goes on sale at Three UK

2012-06-02T08:57:00.001-07:00

HTC's Desire C has made its way onto Three's speedy network in the UK. The budget-conscious handset (C is rumored to stand for "cheap") comes with 4GB storage, microSD slot and a 5-megapixel camera. You'll be pawing at Ice Cream Sandwich via a 480 x 320 display which is driven by a surprisingly decent 600MHz processor. You can snatch one on contract for as little as £13 a month, or buy the thing outright for £150 from today.

Filed Under Cellphones HTC One S shows up in Taiwan with 1.7GHz Snapdragon S3, speed lovers wail

2012-06-02T08:55:00.001-07:00

We'd been wondering just where the HTC Ville C would go with its odd mix of a 1.7GHz Snapdragon S3 and the One S' otherwise sleek hardware. Of all places, it's HTC's home turf of Taiwan: although the One S is still branded as the same phone, the usual 28-nanometer, 1.5GHz Snapdragon S4 we've come to love has been replaced with a high-frequency version of its ancestor. When grilled about the switch by ePrice, HTC insisted that the new version would "provide consumers [with] the same experience." We're not so sure after having seen lower Nenamark scores, but we suspect many owners will be too happy with the micro arc oxidized body and rapid-fire camera to notice. All the same, charging NT$17,900 ($600) for a less efficient take on the same formula makes us wonder if supply for the 28-nanometer S4 didn't force a swap.

Sony announces water/dust-proof Xperia go, acro S

2012-06-02T08:27:00.000-07:00

Sony Mobile Communications (“Sony Mobile”) today announced two new Xperia™ smartphones for consumers looking for premium specifications and beautiful design with extra durability and water resistance. Xperia go and Xperia acro S have scratch resistant mineral glass displays and meet industry standard IP ratings* (International Protection) for protection against dust and water immersion.
Xperia go and Xperia acro S enable easy connectivity to share and enjoy content on TV, smartphone, laptop or tablet. They also come preloaded with Music Unlimited and Video Unlimited from Sony Entertainment Network giving access to Hollywood blockbusters, TV series and millions and millions of music tracks. Xperia go and Xperia acro S will be available globally from the third quarter of 2012.
Consumer demand for durable and water resistant smartphones
Industry research demonstrates that consumers consider durability and water resistance as important features when purchasing a smartphone. For example, a study conducted in Japan by Mobile Marketing Data Labo** highlighted water resistance in the top three most important features for smartphone buyers. In a recent poll*** on Sony Mobile’s Facebook community more than a third of participants stated durability as the most important feature when choosing a smartphone. Also, Xperia acro HD, which has the same durability and water resistance features as Xperia acro S, has been the best selling smartphone in Japan since its launch in March****, further demonstrating the appeal of durability and water resistance.
Xperia go – the stylish Sony smartphone made for extra durability
With Xperia go consumers can watch the latest movies and TV shows in razor sharp quality and with super fast performance. Its sleek and stylish design means durable and water resistant smartphones no longer have to look bulky and ruggedized.
Xperia acro S – The stylish water resistant HD smartphone
Xperia acro S boasts a 4.3” HD Reality Display for razor sharp clarity, full HD video recording, HD video chat and easy HDMI TV connectivity to enjoy content on the big screen. NFC enabled, Xperia acro S can easily open applications with one touch against an Xperia SmartTag.

Giant Android

Android 11 is almost ready

SQL Performance enhancement for count function

Gradle

The Gradle build system

What is it?

A simple example

Dependency management

Repositories

Dependencies

Tasks

Maven sample comparison

IDE integration

Documentation

Conclusion

Firefox OS

receive screen OnOff or Headset plug broadcast

Android Emulator soft/hard key shortcuts

Micromax A116 Canvas HD goes official with 5" screen, quad CPU

opengl with android part I

cheapest dual core android india stellar horizon

Spice MI-500

create nice looking ListView filter on Android

convert Drawable to Bitmap

transparent activity android

pick a image from gallery (SD Card) for my app in android

set HttpResponse timeout for Android in Java

check internet access on android

Tutorials and libraries for OpenGL-ES games on Android

Difference between Corona, Phonegap, Titanium

hide Android Soft Keyboard

hide Android Soft Keyboard

You can force Android to hide the virtual keyboard using the InputMethodManager, calling hideSoftInputFromWindow, passing in the token of the window containing your edit field.

Also useful for hiding the soft keyboard is:

python on android

Difference between px, dp, dip and sp in Android

“Debug certificate expired” error in Eclipse Android plugins

Google: Ice Cream Sandwich now accounts for 7.1 percent of Android user base

HTC Desire C goes on sale at Three UK

Filed Under Cellphones HTC One S shows up in Taiwan with 1.7GHz Snapdragon S3, speed lovers wail

Sony announces water/dust-proof Xperia go, acro S

You can force Android to hide the virtual keyboard using the InputMethodManager, calling `hideSoftInputFromWindow`, passing in the token of the window containing your edit field.