Java Android Tutorials

How to check is connected to network

2012-02-07T22:40:00.001-08:00

public boolean isNetworkConnected(){    if (isGranted(android.Manifest.permission.ACCESS_NETWORK_STATE, getContext())) {            return false;        }        ConnectivityManager conMan = (ConnectivityManager) getContext().getSystemService(Context.CONNECTIVITY_SERVICE);        NetworkInfo activeNetwork = conMan.getActiveNetworkInfo();        return activeNetwork != null && activeNetwork.isConnected();} public boolean isGranted(String permission, Context ctx) {        return PackageManager.PERMISSION_DENIED == ctx.getPackageManager().checkPermission(                permission, ctx.getPackageName());    }

Simple code snippet to check that is device connected to network. There are also other helpful methods of NetworkInfo like isConnectedOrConnecting, isAvailable, isFailover, isRoaming etc

scale camera w.r.t resolution andEngine

2011-08-10T23:54:00.000-07:00

I made that simple camera factory for getting camera. It is really simple. look at the code below

public static class CameraFactory {        /**         * @param context         * @return Camera with device's width and height         */        public static Camera getDefaultCamera(Context context) {            final DisplayMetrics displayMetrics = new DisplayMetrics();             ((Activity) context).getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);             float cameraWidth = displayMetrics.widthPixels;            float cameraHeight = displayMetrics.heightPixels;             final float aspectRatio = cameraHeight / cameraWidth;             if (cameraWidth < 800) {                cameraWidth = 800;//800 is my base width and I developed game w.r.t to this width;// you can change to what ever you like            }             // as: AspectRatio = Height / Width            // so: Height = Width * AspectRatio            cameraHeight = Math.round(cameraWidth * aspectRatio);             context = null;             return new Camera(0, 0, cameraWidth, cameraHeight);        }

Dynamic load Textures Texture Regions AndEngine

2011-07-19T22:22:00.001-07:00

Hi,

Today I am going to show you how to dynamically load all Textures and TextueRegions with AndEngine.

You just need to provide it with a path to folder.

//--Class Levelpublic List<TiledTextureRegion> listTR = new ArrayList<TiledTextureRegion>();public List<Texture> texturelist = new ArrayList<Texture>();private String[] fileNames;private String[] folderNameArray = new String[] { new String("gfx/imgs/") };  public void loadTextures(Context context, Engine pEngine) {    BitmapFactory.Options opt = new BitmapFactory.Options();    opt.inJustDecodeBounds = true;     for (int i = 0; i < folderNameArray.length; i++) {        TextureRegionFactory.setAssetBasePath(folderNameArray[i]);        try {            fileNames = context.getResources().getAssets().list(folderNameArray[i].substring(0, folderNameArray[i].lastIndexOf("/")));            Arrays.sort(fileNames);            for (int j = 0; j < fileNames.length; j++) {                 String rscPath = folderNameArray[i].concat(fileNames[i]);                InputStream in = context.getResources().getAssets().open(rscPath);                BitmapFactory.decodeStream(in, null, opt);                 texturelist.add(new Texture(MathUtils.nextPowerOfTwo(opt.outWidth), MathUtils.nextPowerOfTwo(opt.outHeight), TextureOptions.BILINEAR_PREMULTIPLYALPHA));                 listTR.add(TextureRegionFactory.createTiledFromAsset(texturelist.get(j), context, fileNames[j], 0, 0, GameConstants.AnimationRxC[0], GameConstants.AnimationRxC[1]));                pEngine.getTextureManager().loadTexture(texturelist.get(j));            }        } catch (IOException e) {            e.printStackTrace();            return;        }    }    context = null;}

And you can access TextureRegions by using listTR.

Tags: AndEngine, Android, Textures, Texture Regions

Doc Object Model (DOM) Parsing Android

2011-06-27T09:51:00.000-07:00

"<Area><StartPoint:X>0</StartPoint:X><StartPoint:Y>0</StartPoint:Y><EndPoint:X>12.5</EndPoint:X><EndPoint:Y>50</EndPoint:Y><Status>4</Status></Area>";

public static void parser(String response) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(new ByteArrayInputStream(response.getBytes("UTF-8")));
Element root = dom.getDocumentElement();
NodeList items = root.getElementsByTagName("Area");

for (int i = 0; i < items.getLength(); i++) {

Node item = items.item(i);
NodeList properties = item.getChildNodes();
for (int j = 0; j < properties.getLength(); j++) {
Node property = properties.item(j);
String name = property.getNodeName();
String value = property.getFirstChild().getNodeValue();

System.out.println("name " + name + " value " + value);

}

}

} catch (Exception ex) {
ex.printStackTrace();
}
}

Android OpenGL Tutorial - Part 1

2011-06-16T01:28:00.000-07:00

package com.az.opengl.test; import android.app.Activity;import android.os.Bundle; public class MainActivity extends Activity {    private OpenGLSurfaceView mSurfaceView;    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        mSurfaceView = new OpenGLSurfaceView(this);        setContentView(mSurfaceView);    }}

package com.az.opengl.test; import javax.microedition.khronos.egl.EGLConfig;import javax.microedition.khronos.opengles.GL10; import android.opengl.GLSurfaceView; public class OpenGLrenderer implements GLSurfaceView.Renderer {    private float red = 0.9f;    private float blue = 0.2f;    private float green = 0.2f;     @Override    public void onDrawFrame(GL10 gl) {        // define the color we want to be displayed        gl.glClearColor(red, green, blue, 1.0f);        // clear the color buffer to show the ClearColor we called above...        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);    }     @Override    public void onSurfaceChanged(GL10 gl, int width, int height) {        gl.glViewport(0, 0, width, height);    }     @Override    public void onSurfaceCreated(GL10 gl, EGLConfig config) {     }     public void setColor(float r, float g, float b) {        this.red = r;        this.green = g;        this.blue = b;    }}

package com.az.opengl.test; import android.content.Context;import android.opengl.GLSurfaceView;import android.view.MotionEvent; public class OpenGLSurfaceView extends GLSurfaceView {    private OpenGLrenderer mRenderer;     public OpenGLSurfaceView(Context context) {        super(context);        mRenderer = new OpenGLrenderer();        setRenderer(mRenderer);    }     @Override    public boolean onTouchEvent(final MotionEvent event) {        queueEvent(new Runnable() {             @Override            public void run() {                mRenderer.setColor(event.getX() / getWidth(), event.getY() / getHeight(), 1.0f);            }        });        return true;    } }

<application android:icon="@drawable/icon" android:label="@string/app_name">        <activity android:name=".MainActivity"                  android:label="@string/app_name">            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>

Create a main activity and set content view to Open GL extended class

Create a class and extend it with GLSurfaceView and set renderer

Crate a class and implement GlSurfaceView.Renderer and implement methods

and run simple

Link: http://android-developers.blogspot.com/search/label/OpenGL%20ES

Tags: Android, OpenGL, Java

how to access data folder of rooted phone

2011-06-10T12:04:00.001-07:00

Step1: Install Terminal Emulator

Setp2: enter commands

chmod 777 data

and work is done.

Force Screen On without using Wake lock Android

2011-06-09T03:45:00.001-07:00

PLEASE DO NOT USE A WAKE LOCK

This requires that you give your app an additional permission, and it is very easy to introduce bugs where you accidentally remain holding the wake lock and thus leave the screen on.

It is far, far better to use the window flag FLAG_KEEP_SCREEN_ON, which you can enable on your activity's window in your onCreate() like this:

@Override protected void onCreate(Bundle icicle) {     super.onCreate(icicle);      getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); }

This will make sure that the screen stays on while your window is in the foreground, and only while it is in the foreground. It greatly simplifies this common use case, eliminating any juggling you need to do as your app transitions between states.

Tags: Android, wakelock, screen on, forcefully

Partial HTTP POST; show data webview

2011-06-01T09:11:00.000-07:00

Hi, Today I am going to depict complete example that how you can put some parameters to some page and then load it to show to user.

You will find its application in showing user inbox by entering username and password to and then show user emails.

Step1: Create a class and extend it with WebView

private class MwebViewClient extends WebViewClient {        @Override        public boolean shouldOverrideUrlLoading(WebView view, String url) {            view.loadUrl(url);            return true;        }         @Override        public void onPageStarted(WebView view, String url, Bitmap favicon) {            super.onPageStarted(view, url, favicon);            waitDialog = new ProgressDialog(CoinsAndSeaCash.this);            waitDialog.setMessage("Loading Page...");            waitDialog.setIndeterminate(true);            waitDialog.show();        }         @Override        public void onPageFinished(WebView view, String url) {            super.onPageFinished(view, url);            if (waitDialog != null) {                waitDialog.dismiss();            }        }         @Override        public void onScaleChanged(WebView view, float oldScale, float newScale) {            super.onScaleChanged(view, oldScale, newScale);//sometimes Android do not show soft keyboard when you press some text field// so this is a little hack            InputMethodManager inputMgr = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);            inputMgr.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_SHOWN, InputMethodManager.RESULT_UNCHANGED_SHOWN);        }    }

Step2: Create a inner class and extend it with AsyncTask

//declared waitDialog at class levelwaitDialog = new ProgressDialog(this);waitDialog.setMessage("Please Wait...");waitDialog.setIndeterminate(true);waitDialog.show();          class postSecureData extends AsyncTask<String, Void, Void> {    String data = "";     @Override    protected Void doInBackground(String... params) {        data = postData(params[0]);        return null;    }     @Override    protected void onPostExecute(Void result) {        super.onPostExecute(result);        if (waitDialog != null) {            waitDialog.dismiss();        }        mWebView.loadDataWithBaseURL(URL_STRING, data, "text/html", HTTP.UTF_8, null);        //rlwebview is RelativeLayout in which WebView resides        rlwebview.setVisibility(RelativeLayout.VISIBLE);    } } new postSecureData().execute((String) tv.getTag());

Step 3: write a method in your outer class

private final String URL_STRING = "https://www.paypal.com/purchase";     public String postData(String productId) {        String data = "";        try {            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();            nameValuePairs.add(new BasicNameValuePair("param1", "value1"));            nameValuePairs.add(new BasicNameValuePair("quantity", "1"));             HttpClient httpclient = new DefaultHttpClient();            HttpPost httppost = new HttpPost(URL_STRING);            httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs, HTTP.UTF_8));             HttpResponse response = httpclient.execute(httppost);             data = new BasicResponseHandler().handleResponse(response);                    } catch (Exception ex) {            ex.printStackTrace();        }        return data;    }

And you are done

Tags: Java Android WebView WebViewClient POST HTTPS Params

Root Nexus One Gingerbread 2.3.4

2011-06-01T07:53:00.001-07:00

Download these files first

su.zip

recovery-RA-passion-v2.2.1.img.

Alternate links are provided of there files here

1. Download su.zip, and put it on your phone’s SD card.

2. Download fastboot.zip, unzip it to C:\. Now you have a folder C:\fastboot\

3. Download recovery-RA-passion-v2.2.1.img, put it in C:\fastboot\

4. Shut down your phone. Then start your Nexus One in Fastboot mode by holding down the Trackball and press the Power button.

5. Connect your phone to your computer. Open a Command Prompt (Start -> All Programs -> Accessories -> Command Prompt), and run the following commands:

cd C:\fastboot fastboot devices fastboot flash recovery recovery-RA-passion-v2.2.1.img

6. Use Volume +/- keys to choose ‘Bootloader’ and hit the Power button.

7. Use Volume +/- keys to select ‘Recovery’ and hit the Power button.

8. From the menu, scroll the Trackball to select ‘Flash zip from sdcard’ and hit the Trackball.

9. Select the su.zip file you previously copied to your SD card and hit the Trackball. Hit it one more time.

10. When done, restart your Nexus One and you should be all set. ( you need to use your track ball to select and press it to make selection )

Tags: Root Android Nexus One 2.3.4

POST params with android webview

2011-05-31T09:11:00.001-07:00

private final String URL_STRING = "https://www.paypal.com/checkout/";

    public void postData() {

        try {

            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();

            nameValuePairs.add(new BasicNameValuePair("param1", "value1"));

            nameValuePairs.add(new BasicNameValuePair("param2", "value2"));

            HttpClient httpclient = new DefaultHttpClient();

            HttpPost httppost = new HttpPost(URL_STRING);

            httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs, HTTP.UTF_8));

            HttpResponse response = httpclient.execute(httppost);

            String data = new BasicResponseHandler().handleResponse(response);

            mWebView.loadDataWithBaseURL(httppost.getURI().toString(), data, "text/html", HTTP.UTF_8, null);

        } catch (Exception ex) {

            ex.printStackTrace();

This is a very simple approach for sending params in POST request to a secure HTTPS website.

This is solution that you want to do partial processing at your end and then transferring flow for entering credit card details to user.

What I am doing is that I have some information about user his game id and username and the money that he/she wants to purchase. If I take him to the website then user have to enter all the data again and that is quite irritating. So what I did is just posted some params as HTTP POST request and then took that data to show user to proceeded further.

Tags: Java, Android, HTTP POST, prams', parameters, easy, web view, webview

How to shutdown threads cleanly Java

2011-05-24T23:36:00.001-07:00

http://javaspecialists.co.za/archive/Issue055.html

How to shutdown threads cleanly

I remember starting off with JDK 1.0, and playing with Threads. I would start a Thread, and then to stop it, I simply called stop(). It was the most obvious thing to do, with disastrous consequences. If we refer back to the Oak Newsletter, that was the same as having all your code unprotected, and receiving an asynchronous exception in your Thread. The exception that is thrown asynchronously isjava.lang.ThreadDeath. Needless to say, the more I think about it, the more I am baffled that they allowed that in the first place, especially in the absence of the protect keyword that they had in Oak. Using stop() is incredibly dangerous, as it will kill your thread even if it is in the middle of something important. There is no way to protect yourself, so if you spot code that uses stop(), you should frown.

So, how do you shutdown a thread cleanly? The developers of Java have actually left the protect mechanism in place for us to use, it is just named differently. First of all, we should never use stop(). Ever. Period. Do not even think of using it. Sun should remove it from java.lang.Thread as soon as possible. Don't. No. Noooooo. Doooown. Secondly, the only place where we are allowed to receive an exception to tell us that the thread is being shutdown is while the thread is blocked. Getting a shutdown notification at any other time would be dangerous and nondeterministic. The way this works is via thejava.lang.InterruptedException. I admit that InterruptedException is not the most obvious choice of name for indicating that another thread is trying to shutdown your thread.

I have seen code that uses a boolean flag to indicate whether the thread is running or not. However, Java already provides that flag in the form of the interrupted flag, so why duplicate effort? Usually, the code would work something like this:

public class UsingFlagToShutdownThread extends Thread {

private boolean running = true;

public void run() {

while (running) {

System.out.print(".");

System.out.flush();

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {}

System.out.println("Shutting down thread");

public void shutdown() {

running = false;

public static void main(String[] args)

throws InterruptedException {

UsingFlagToShutdownThread t = new UsingFlagToShutdownThread();

t.start();

Thread.sleep(5000);

t.shutdown();

What is so bad with that code? This example is not too bad, since the longest we would wait unnecessarily would be one second. However if we normally sleep for 30 seconds, then it could take a while before your program is completely shut down. This is especially true if you have a lot of threads and you join() each one to make sure that it does finish.

Java has another mechanism that you should rather use: simply interrupt the thread. The code would then look like this:

public class UsingInterruptToShutdownThread extends Thread {

public void run() {

while (true) {

System.out.print(".");

System.out.flush();

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

Thread.currentThread().interrupt(); // very important

break;

System.out.println("Shutting down thread");

public static void main(String[] args)

throws InterruptedException {

Thread t = new UsingInterruptToShutdownThread();

t.start();

Thread.sleep(5000);

t.interrupt();

I must admit that I have not seen many programmers handle InterruptedExceptions correctly, i.e. using my way ;-) Most of the time, programmers view InterruptedException as an irritating checked exception that they have to catch, but which they usually ignore:

while (true) {

// ... do something

try {

Thread.sleep(30000);

} catch (InterruptedException ex) {}

Why do we have to interrupt the thread again?

In my example, after I caught the InterruptedException, I usedThread.currentThread().interrupt() to immediately interrupted the thread again. Why is this necessary? When the exception is thrown, the interrupted flag is cleared, so if you have nested loops, you will cause trouble in the outer loops. Consider the following code:

public class NestedLoops extends Thread {

private static boolean correct = true;

public void run() {

while (true) {

System.out.print(".");

System.out.flush();

for (int i = 0; i < 10; i++) {

System.out.print("#");

System.out.flush();

try {

Thread.sleep(100);

} catch (InterruptedException ex) {

if (correct) Thread.currentThread().interrupt();

System.out.println();

System.out.println("Shut down inner loop");

break;

try {

Thread.sleep(1000);

} catch (InterruptedException ex) {

if (correct) Thread.currentThread().interrupt();

System.out.println();

System.out.println("Shut down outer loop");

break;

System.out.println("Shutting down thread");

private static void test() throws InterruptedException {

Thread t = new NestedLoops();

t.start();

Thread.sleep(6500);

t.interrupt();

t.join();

System.out.println("Shutdown the thread correctly");

public static void main(String[] args)

throws InterruptedException {

test();

correct = false;

test();

When you run this code, you will see something like this:

.##########.##########.##########.######
Shut down inner loop

Shut down outer loop
Shutting down thread
Shutdown the thread correctly
.##########.##########.##########.######
Shut down inner loop
.##########.##########.##########.##########.##########.  etc.

Herein lies the danger with this approach: if some library incorrectly handlesInterruptedException then your code will not shut down correctly.

From a purely theoretical view, you should use the interrupt mechanism of threads to shut them down. However, you have to be very careful that you use that mechanism throughout your code, otherwise you will not be able to shut down all your threads.

What about threads blocked on IO?

Threads can be blocked on wait(), sleep(), waiting to enter a synchronized block or waiting on some IO to complete. We cannot shut down a thread waiting to enter a synchronized block, so if you have a livelock or deadlock you will not be able to shut down your system cleanly. wait() andsleep() both throw an InterruptedException, as does join(). But, what about when you're blocked on IO? There is an exception called java.io.InterruptedIOException, which is supposed to cover the situation where you interrupt a thread that is waiting on some IO to complete. As you might have guessed, it is not implemented consistently. It works for piped streams, but none of the others seem to have that effect.

If you want to stop a thread waiting on a socket, you will have to unfortunately close the socket underneath the thread. Fortunately, the interrupt() method is not final, so you can override it to also close the socket. Inside the catch clause of java.io.IOException you can then check whether the thread has been interrupted or not:

import java.io.IOException;

import java.io.InputStream;

import java.io.InterruptedIOException;

public class BlockedOnIO extends Thread {

private final InputStream in;

public BlockedOnIO(InputStream in) {

this.in = in;

public void interrupt() {

super.interrupt();

try {

in.close();

} catch (IOException e) {} // quietly close

public void run() {

try {

System.out.println("Reading from input stream");

in.read();

System.out.println("Finished reading");

} catch (InterruptedIOException e) {

Thread.currentThread().interrupt();

System.out.println("Interrupted via InterruptedIOException");

} catch (IOException e) {

if (!isInterrupted()) {

e.printStackTrace();

} else {

System.out.println("Interrupted");

System.out.println("Shutting down thread");

For shutting down threads reading from sockets, we would do something like this:

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

public class BlockedOnSocketIO {

public static void main(String[] args)

throws IOException, InterruptedException {

ServerSocket ss = new ServerSocket(4444);

Socket socket = new Socket("localhost", 4444);

System.out.println("Made socket, now reading from socket");

Thread t = new BlockedOnIO(socket.getInputStream());

t.start();

Thread.sleep(5000);

t.interrupt();

When we run our code, we see the following:

Made socket, now reading from socket
Reading from input stream
Interrupted
Shutting down thread

Alternatively, when we use Pipes:

import java.io.IOException;

import java.io.PipedInputStream;

import java.io.PipedOutputStream;

public class BlockedOnPipedIO {

public static void main(String[] args)

throws IOException, InterruptedException {

PipedInputStream in =

new PipedInputStream(new PipedOutputStream());

Thread t = new BlockedOnIO(in);

t.start();

Thread.sleep(5000);

t.interrupt();

When we run that code, we see the following:

Reading from input stream
Interrupted via InterruptedIOException
Shutting down thread

Unfortunately, the IO library in Java is not consistent, so you have to cater for both possibilities in your shutdown methods.

I hope that this newsletter will be as useful to you as it has been to me. Shutting down threads cleanly is unfortunately not as easy as it should be, but the mechanism in this newsletter is superior to callingstop() (and thereby using an asynchronous exception) and it is also better than using a flag to indicate whether the thread is supposed to carry on running or not.

The only problem with my approach is that if you use some library that does not handle InterruptedException correctly, you will have problems shutting down your thread. You might have to have a separate thread that calls join() with a timeout and repeatedly interrupts the thread until it is shut down.

.apk build process defined

2011-05-24T00:10:00.001-07:00

Android all Packages

2011-05-18T22:08:00.000-07:00

These are the Android APIs.

android

Contains resource classes used by applications included in the platform and defines application permissions for system features.

android.accessibilityservice

android.accounts

android.animation

These classes provide functionality for the property animation system, which allows you to animate object properties of any type.

android.app

Contains high-level classes encapsulating the overall Android application model.

android.app.admin

Provides device administration features at the system level, allowing you to create security-aware applications that are useful in enterprise settings, in which IT professionals require rich control over employee devices.

For more information, see the Device Administration developer guide.

android.app.backup

Contains the backup and restore functionality available to applications. If a user wipes the data on their device or upgrades to a new Android-powered device, all applications that have enabled backup can restore the user's previous data when the application is reinstalled.

For more information, see the Data Backup developer guide.

android.appwidget

Contains the components necessary to create "app widgets", which users can embed in other applications (such as the home screen) to quickly access application data and services without launching a new activity.

For more information, see the App Widgets developer guide.

android.bluetooth

Provides classes that manage Bluetooth functionality, such as scanning for devices, connecting with devices, and managing data transfer between devices.

For more information, see the Bluetooth developer guide.

android.content

Contains classes for accessing and publishing data on a device.

android.content.pm

Contains classes for accessing information about an application package, including information about its activities, permissions, services, signatures, and providers.

android.content.res

Contains classes for accessing application resources, such as raw asset files, colors, drawables, media or other other files in the package, plus important device configuration details (orientation, input types, etc.) that affect how the application may behave.

For more information, see the Application Resources developer guide.

android.database
Contains classes to explore data returned through a content provider.

android.database.sqlite
Contains the SQLite database management classes that an application would use to manage its own private database.

android.drm

Provides classes for managing DRM content and determining the capabilities of DRM plugins (agents).

android.gesture
Provides classes to create, recognize, load and save gestures.

android.graphics
Provides low level graphics tools such as canvases, color filters, points, and rectangles that let you handle drawing to the screen directly.

android.graphics.drawable

Provides classes to manage a variety of visual elements that are intended for display only, such as bitmaps and gradients.

android.graphics.drawable.shapes
Contains classes for drawing geometric shapes.

android.hardware

Provides support for hardware features, such as the camera and other sensors.

android.hardware.usb

Provides support to communicate with USB hardware peripherals that are connected to Android-powered devices.

android.inputmethodservice
Base classes for writing input methods (such as software keyboards).

android.location

Contains classes that define Android location-based and related services.

For more information about location services, see the documentation for Obtaining User Location.

android.media
Provides classes that manage various media interfaces in audio and video.

android.media.audiofx
Provides classes that manage audio effects implemented in the media framework.

android.mtp

Provides APIs that let you interact directly with connected cameras and other devices, using the PTP (Picture Transfer Protocol) subset of the MTP (Media Transfer Protocol) specification.

android.net
Classes that help with network access, beyond the normal java.net.* APIs.

android.net.http

android.net.rtp

Provides APIs for RTP (Real-time Transport Protocol), allowing applications to manage on-demand or interactive data streaming.

android.net.sip

Provides access to Session Initiation Protocol (SIP) functionality, such as making and answering VOIP calls using SIP.

android.net.wifi
Provides classes to manage Wi-Fi functionality on the device.

android.nfc
Provides access to Near Field Communication (NFC) functionality, allowing applications to read NDEF message in NFC tags.

android.nfc.tech

These classes provide access to a tag technology's features, which vary by the type of tag that is scanned.

android.opengl
Provides OpenGL utilities.

android.os
Provides basic operating system services, message passing, and inter-process communication on the device.

android.os.storage

android.preference
Provides classes that manage application preferences and implement the preferences UI.

android.provider

Provides convenience classes to access the content providers supplied by Android.

android.renderscript

The Renderscript rendering and computational APIs offer a low-level, high performance means of carrying out mathematical calculations and 3D graphics rendering.

android.sax
A framework that makes it easy to write efficient and robust SAX handlers.

android.service.wallpaper

android.speech

android.speech.tts

android.telephony
Provides APIs for monitoring the basic phone information, such as the network type and connection state, plus utilities for manipulating phone number strings.

android.telephony.cdma
Provides APIs for utilizing CDMA-specific telephony features.

android.telephony.gsm
Provides APIs for utilizing GSM-specific telephony features, such as text/data/PDU SMS messages.

android.test
A framework for writing Android test cases and suites.

android.test.mock
Utility classes providing stubs or mocks of various Android framework building blocks.

android.test.suitebuilder
Utility classes supporting the test runner classes.

android.text

Provides classes used to render or track text and text spans on the screen.

android.text.format

android.text.method

Provides classes that monitor or modify keypad input.

android.text.style

Provides classes used to view or change the style of a span of text in a View object.

android.text.util
Utilities for converting identifiable text strings into clickable links and creating RFC 822-type message (SMTP) tokens.

android.util
Provides common utility methods such as date/time manipulation, base64 encoders and decoders, string and number conversion methods, and XML utilities.

android.view
Provides classes that expose basic user interface classes that handle screen layout and interaction with the user.

android.view.accessibility

android.view.animation

Provides classes that handle tweened animations.

android.view.inputmethod
Framework classes for interaction between views and input methods (such as soft keyboards).

android.webkit
Provides tools for browsing the web.

android.widget
The widget package contains (mostly visual) UI elements to use on your Application screen.

dalvik.bytecode

Provides classes related to Dalvik bytecode.

dalvik.system

Provides utility and system information classes specific to the Dalvik VM.

Provides the system's ReferenceQueue implementation as well as different forms of reference objects which impose special behavior on the garbage collector.

java.nio.channels.spi

java.nio.charset

java.nio.charset.spi

java.security

This package provides all the classes and interfaces that constitute the Java security framework.

java.security.acl

This package provides the classes and the interfaces needed to build Access Control Lists.

java.security.cert

This package provides all the classes and all the interfaces needed to generate, administer and verify X.509 certificates.

java.security.interfaces

This package provides the interfaces needed to generate: (1) Keys for the RSA asymmetric encryption algorithm using the PKCS#1 standard; (2) Keys for the Digital Signature Algorithm (DSA) specified by FIPS-186; (3) Keys for a generic Elliptic Curve asymmetric encryption algorithm.

java.security.spec

This package provides the classes and interfaces needed to specify keys and parameters for encryption and signing algorithms.

java.sql

Provides a compatibility interface for accessing SQL-based databases.

java.text

java.util

java.util.concurrent
Utility classes commonly useful in concurrent programming.

java.util.concurrent.atomic
A small toolkit of classes that support lock-free thread-safe programming on single variables.

java.util.concurrent.locks
Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.

This package provides the classes and interfaces for cryptographic applications implementing algorithms for encryption, decryption, or key agreement.

javax.crypto.interfaces

This package provides the interfaces needed to implement the Diffie-Hellman (DH) key agreement's algorithm as specified by PKCS#3.

javax.crypto.spec

This package provides the classes and interfaces needed to specify keys and parameter for encryption.

javax.microedition.khronos.egl

javax.microedition.khronos.opengles

javax.net

This package provides factory classes to create sockets and server-sockets.

javax.net.ssl

This package provides all the classes and interfaces needed to implement and program the Secure Socket abstraction based on the SSL protocol SSSLv3.0 or TLSv1.2.

javax.security.auth

This package provides the classes and interfaces needed to implement and program different methods of users' authentication and role based users' authorization.

javax.security.auth.callback

This package provides classes and interfaces needed to interact with the application in order to execute the authentication and authorization processes.

javax.security.auth.login

This package provides a pluggable and stackable authentication system based on ideas and concepts from the Unix-PAM module.

javax.security.auth.x500

This package provides classes needed to store X.500 principals and their credentials.

javax.security.cert

This package is provided only for compatibility reasons.

javax.sql

javax.xml

Provides a utility class with useful XML constants.

javax.xml.datatype

XML/Java Type Mappings.

javax.xml.namespace

XML Namespace processing.

javax.xml.parsers
Provides classes allowing the processing of XML documents.

javax.xml.transform

This package defines the generic APIs for processing transformation instructions, and performing a transformation from source to result.

javax.xml.transform.dom

This package implements DOM-specific transformation APIs.

javax.xml.transform.sax

This package implements SAX2-specific transformation APIs.

javax.xml.transform.stream

This package implements stream- and URI- specific transformation APIs.

javax.xml.validation

This package provides an API for validation of XML documents.

javax.xml.xpath

This package provides an object-model neutral API for the evaluation of XPath expressions and access to the evaluation environment.

junit.framework
The junit test framework.

junit.runner
Utility classes supporting the junit test framework.

org.apache.http
The core interfaces and classes of the HTTP components.

org.apache.http.auth
The API for client-side HTTP authentication against a server, commonly referred to as HttpAuth.

org.apache.http.auth.params
Parameters for configuring HttpAuth.

org.apache.http.client
The API for client-side HTTP communication and entry point to the HttpClient module.

org.apache.http.client.entity

org.apache.http.client.methods
Request implementations for the various HTTP methods like GET and POST.

org.apache.http.client.params
Parameters for configuring HttpClient.

org.apache.http.client.protocol
Additional request and response interceptors.

org.apache.http.client.utils
Helpers and utility classes for HttpClient.

org.apache.http.conn
The client-side connection management and handling API at the heart of what is referred to as HttpConn.

org.apache.http.conn.params
Parameters for configuring HttpConn.

org.apache.http.conn.routing
The client-side route representation and tracking API, part of HttpConn.

org.apache.http.conn.scheme

org.apache.http.conn.ssl
TLS/SSL specific parts of the HttpConn API.

org.apache.http.conn.util

org.apache.http.cookie
The API for client-side state management via cookies, commonly referred to as HttpCookie.

org.apache.http.cookie.params
Parameters for configuring HttpCookie.

org.apache.http.entity
Representations for HTTP message entities.

org.apache.http.impl
Default implementations for interfaces in org.apache.http.

org.apache.http.impl.auth

org.apache.http.impl.client

org.apache.http.impl.conn

org.apache.http.impl.conn.tsccm
The implementation of a thread-safe client connection manager.

org.apache.http.impl.cookie

org.apache.http.impl.entity
Default implementations for interfaces in org.apache.http.entity.

org.apache.http.impl.io
Default implementations for interfaces in org.apache.http.io.

org.apache.http.io
The transport layer abstraction of the HTTP components.

org.apache.http.message
A selection of HTTP message implementations.

org.apache.http.params
The parameterization framework for HTTP components.

org.apache.http.protocol
HTTP protocol execution framework.

org.apache.http.util
Mostly utility classes with static helper methods for various purposes.

org.json

org.w3c.dom

Provides the official W3C Java bindings for the Document Object Model, level 2 core.

org.w3c.dom.ls

org.xml.sax

This package provides the core SAX APIs.

org.xml.sax.ext

This package contains interfaces to SAX2 facilities that conformant SAX drivers won't necessarily support.

org.xml.sax.helpers

This package contains "helper" classes, including support for bootstrapping SAX-based applications.

org.xmlpull.v1

org.xmlpull.v1.sax2

For complete detail please visit official page: http://developer.android.com/reference/packages.html

Power your mobile apps with android push notification (C2DM)

2011-05-17T20:35:00.000-07:00

Recently we were working on android application and we had requirements from our client to support push notification. We already had implemented Apple Push Notification Service for the iPhone application and thought there would be similar solution for android push too. As android platform doesn’t have single vendor like Apple so we were wondering who would support it. There are many custom build solutions based on application polling or asynchronous connection to server but timing of these event was tricky part plug they is additional usage of network resource and battery.

Welcome to the world of ’Cloud to Device Messaging’ or C2DM supported by google services. This solution provides a solution to send real time notification to the user on user’s handset. Since Google already uses its service for Calendar or gmail etc. on the android platform so there won’t be extra network usage or battery usage for c2dm.

There are plenty of excellent articles which explain working on C2DM push notification and provide sample code to Run. We feel some points were missing or not obvious in those articles specially when you are not aware of Push Notification concept. Also there is no default notification implementation on Android platform. So we decided to fill in the gap and allow developers to quickly run a sample android push application and recieve the push notification from third party server.

For this purpose, we created a sample application which registers the device to google service and send the registrationId to the our own third party server. The sample application displays the notification screen whenever a push notification is received by android application. You can find many server-side solutions for scripting language like php,shell script using curl etc. Since most of the enterprise applications run on J2EE platform so we decided to have a J2EE server-side solution. In our server-side implementation, you can regsiter device with registerId, view list of registerId and can send sample push to the client.

So the purpose of this article is to understand android push notification(c2dm) and start working on it quickly..Using this article developer can register the application from device and can send notification from web-interface. This way developer can also display push notification to clients or non-technical person.

There are three entity involved in android push notification:

Android application – registers the device with C2DM server and passes the registerId to third party server
Google’s C2DM servers – send messages to android device
Third Party Server – send messages to C2DM server

Sample Application for Android Push Notification (C2DM):

We have taken the source code from cw-advandroid and added few tweaks in the source code. The only thing you need to do is to download the code from below link and configure it in your favorite IDE (We would prefer to use eclipse though). You need to open strings.xml file inside res/values directory and change the server URL.

<?xml version="1.0" encoding="utf-8"?>

<resources>

        <string name="app_name">PushEndpointDemo</string>

        <string name="server_url">http://192.168.1.4:8080/c2dm/notify</string>

</resources>

If you are deploying the server application (We shall discuss server-side in next section) on local machine then replace the ipaddress with your machine’s ipAddress. Now your application is ready to register your app with google and send the registrationId to your third party server.

Please notice few points before running the app on android:

You must have android sdk 2.2+ and google service must be running on your emulator (We would recommend to install google sdk 2.3.1)
You must register your Google account on your emulator. You can do it by going to Settings -> Accounts & Sync and add gmail account. You cannot receive push notification unless Google account is set.
You must register your developer’s email address for your application at google . Please note one thing that this account is developer’s account and might not be account which is configured in ‘Accounts & Sync’ settings.

Third party server to register device and send Android Push Notification (C2DM):

We have built server-side solution on J2EE platform and application can be deployed on tomcat server(It might deployed fine on other servers but hav’nt tested it). Before deploying to server, you need to set the authentication code for your developer account in the application so please set it in the AUTH_KEY variable in class com.myor.c2dm.utils.Constants.java

public static final String AUTH_KEY = "" //Please set your authentication key

You can get authentication key using curl as mentioned this article or You can use the our utility com.myor.c2dm.utils.AuthenticationUtils

AuthenticationUtils.getAuthCode("<DEVELOPER_EMAIL>", "<PASSWORD>")

Please use maven to create war file and deploy it on your server web directory.

mvn clean package

You can access the application at

http://server:port/c2dm/notify

Now we ready to register and receive the android push notification on sample application. Please launch the application on your emulator or device and screen would be displayed like this:

Sample notification application

Enter your developer email account and click on the ‘Register!’ button. This shall make a call to google service to register the device for application. In the callback method, we make call to our third party server to register the registrationId for the device. We can access the registerId at

http://yourserver:port/c2dm/notify?act=1

List of devices registered on google service

Now we can send push notification to the android application by clicking the ‘Push’ link. The notification on the client–side look shall like this:

Android Push Notification Ticker text

Decompile Android .dex file into readable java file

2011-04-26T00:32:00.001-07:00

Step1: get dex2jar from http://code.google.com/p/dex2jar/

Step2: get jd ui from http://java.decompiler.free.fr/?q=jdgui

Process:

Search in market for the app you want to decompile and install it on your phone.
Install Astro File Manager from market (link). Open Astro > Tools > Application Manager/Backup and select the application to backup on to the SD card .

Mount phone as USB drive and access 'backupsapps' folder to find the apk of target app (lets call it targetapp.apk) . Copy it to your local drive.
Decomiling apk to Dex format

1) Download Dex2Jar (link) (Android runs applications which are in Dalvik Executable (.dex) format).
2) Run the command to convert apk to jar
dex2jar targetapp.apk file(./dex2jar targetapp.apk on terminal)
3) File ‘targetapp.apk.dex2jar.jar’ is created

Viewing/Decompiling the Jar files to Java

Method 1 : Use JavaDecompiler (JD)

Open ‘targetapp.apk.dex2jar.jar’ with jd-gui (link)
File > Save All Sources to sava the class files in jar to java files.

How to increase performance of Android apps

2011-04-21T07:26:00.001-07:00

An Android application will run on a mobile device with limited computing power and storage, and constrained battery life. Because of this, it should be efficient. Battery life is one reason you might want to optimize your app even if it already seems to run "fast enough". Battery life is important to users, and Android's battery usage breakdown means users will know if your app is responsible draining their battery.

Note that although this document primarily covers micro-optimizations, these will almost never make or break your software. Choosing the right algorithms and data structures should always be your priority, but is outside the scope of this document.

Introduction

There are two basic rules for writing efficient code:

Don't do work that you don't need to do.
Don't allocate memory if you can avoid it.

Optimize Judiciously

This document is about Android-specific micro-optimization, so it assumes that you've already used profiling to work out exactly what code needs to be optimized, and that you already have a way to measure the effect (good or bad) of any changes you make. You only have so much engineering time to invest, so it's important to know you're spending it wisely.

(See Closing Notes for more on profiling and writing effective benchmarks.)

This document also assumes that you made the best decisions about data structures and algorithms, and that you've also considered the future performance consequences of your API decisions. Using the right data structures and algorithms will make more difference than any of the advice here, and considering the performance consequences of your API decisions will make it easier to switch to better implementations later (this is more important for library code than for application code).

(If you need that kind of advice, see Josh Bloch's Effective Java, item 47.)

One of the trickiest problems you'll face when micro-optimizing an Android app is that your app is pretty much guaranteed to be running on multiple hardware platforms. Different versions of the VM running on different processors running at different speeds. It's not even generally the case that you can simply say "device X is a factor F faster/slower than device Y", and scale your results from one device to others. In particular, measurement on the emulator tells you very little about performance on any device. There are also huge differences between devices with and without a JIT: the "best" code for a device with a JIT is not always the best code for a device without.

If you want to know how your app performs on a given device, you need to test on that device.

Avoid Creating Unnecessary Objects

Object creation is never free. A generational GC with per-thread allocation pools for temporary objects can make allocation cheaper, but allocating memory is always more expensive than not allocating memory.

If you allocate objects in a user interface loop, you will force a periodic garbage collection, creating little "hiccups" in the user experience. The concurrent collector introduced in Gingerbread helps, but unnecessary work should always be avoided.

Thus, you should avoid creating object instances you don't need to. Some examples of things that can help:

If you have a method returning a string, and you know that its result will always be appended to a StringBuffer anyway, change your signature and implementation so that the function does the append directly, instead of creating a short-lived temporary object.
When extracting strings from a set of input data, try to return a substring of the original data, instead of creating a copy. You will create a new String object, but it will share the char[] with the data. (The trade-off being that if you're only using a small part of the original input, you'll be keeping it all around in memory anyway if you go this route.)

A somewhat more radical idea is to slice up multidimensional arrays into parallel single one-dimension arrays:

An array of ints is a much better than an array of Integers, but this also generalizes to the fact that two parallel arrays of ints are also a lot more efficient than an array of (int,int) objects. The same goes for any combination of primitive types.
If you need to implement a container that stores tuples of (Foo,Bar) objects, try to remember that two parallel Foo[] and Bar[] arrays are generally much better than a single array of custom (Foo,Bar) objects. (The exception to this, of course, is when you're designing an API for other code to access; in those cases, it's usually better to trade good API design for a small hit in speed. But in your own internal code, you should try and be as efficient as possible.)

Generally speaking, avoid creating short-term temporary objects if you can. Fewer objects created mean less-frequent garbage collection, which has a direct impact on user experience.

Performance Myths

Previous versions of this document made various misleading claims. We address some of them here.

On devices without a JIT, it is true that invoking methods via a variable with an exact type rather than an interface is slightly more efficient. (So, for example, it was cheaper to invoke methods on a HashMap map than a Map map, even though in both cases the map was a HashMap.) It was not the case that this was 2x slower; the actual difference was more like 6% slower. Furthermore, the JIT makes the two effectively indistinguishable.

On devices without a JIT, caching field accesses is about 20% faster than repeatedly accesssing the field. With a JIT, field access costs about the same as local access, so this isn't a worthwhile optimization unless you feel it makes your code easier to read. (This is true of final, static, and static final fields too.)

Prefer Static Over Virtual

If you don't need to access an object's fields, make your method static. Invocations will be about 15%-20% faster. It's also good practice, because you can tell from the method signature that calling the method can't alter the object's state.

Avoid Internal Getters/Setters

In native languages like C++ it's common practice to use getters (e.g. i = getCount()) instead of accessing the field directly (i = mCount). This is an excellent habit for C++, because the compiler can usually inline the access, and if you need to restrict or debug field access you can add the code at any time.

On Android, this is a bad idea. Virtual method calls are expensive, much more so than instance field lookups. It's reasonable to follow common object-oriented programming practices and have getters and setters in the public interface, but within a class you should always access fields directly.

Without a JIT, direct field access is about 3x faster than invoking a trivial getter. With the JIT (where direct field access is as cheap as accessing a local), direct field access is about 7x faster than invoking a trivial getter. This is true in Froyo, but will improve in the future when the JIT inlines getter methods.

Use Static Final For Constants

Consider the following declaration at the top of a class:

static int intVal = 42;
static String strVal = "Hello, world!";

The compiler generates a class initializer method, called <clinit>, that is executed when the class is first used. The method stores the value 42 into intVal, and extracts a reference from the classfile string constant table for strVal. When these values are referenced later on, they are accessed with field lookups.

We can improve matters with the "final" keyword:

static final int intVal = 42;
static final String strVal = "Hello, world!";

The class no longer requires a <clinit> method, because the constants go into static field initializers in the dex file. Code that refers to intVal will use the integer value 42 directly, and accesses to strVal will use a relatively inexpensive "string constant" instruction instead of a field lookup. (Note that this optimization only applies to primitive types and Stringconstants, not arbitrary reference types. Still, it's good practice to declare constants static final whenever possible.)

Use Enhanced For Loop Syntax

The enhanced for loop (also sometimes known as "for-each" loop) can be used for collections that implement the Iterable interface and for arrays. With collections, an iterator is allocated to make interface calls to hasNext() and next(). With an ArrayList, a hand-written counted loop is about 3x faster (with or without JIT), but for other collections the enhanced for loop syntax will be exactly equivalent to explicit iterator usage.

There are several alternatives for iterating through an array:

    static class Foo {
        int mSplat;
    }
    Foo[] mArray = ...

    public void zero() {
        int sum = 0;
        for (int i = 0; i < mArray.length; ++i) {
            sum += mArray[i].mSplat;
        }
    }

    public void one() {
        int sum = 0;
        Foo[] localArray = mArray;
        int len = localArray.length;

        for (int i = 0; i < len; ++i) {
            sum += localArray[i].mSplat;
        }
    }

    public void two() {
        int sum = 0;
        for (Foo a : mArray) {
            sum += a.mSplat;
        }
    }

zero() is slowest, because the JIT can't yet optimize away the cost of getting the array length once for every iteration through the loop.

one() is faster. It pulls everything out into local variables, avoiding the lookups. Only the array length offers a performance benefit.

two() is fastest for devices without a JIT, and indistinguishable from one() for devices with a JIT. It uses the enhanced for loop syntax introduced in version 1.5 of the Java programming language.

To summarize: use the enhanced for loop by default, but consider a hand-written counted loop for performance-critical ArrayList iteration.

(See also Effective Java item 46.)

Consider Package Instead of Private Access with Private Inner Classes

Consider the following class definition:

public class Foo {
    private class Inner {
        void stuff() {
            Foo.this.doStuff(Foo.this.mValue);
        }
    }

    private int mValue;

    public void run() {
        Inner in = new Inner();
        mValue = 27;
        in.stuff();
    }

    private void doStuff(int value) {
        System.out.println("Value is " + value);
    }
}

The key things to note here are that we define a private inner class (Foo$Inner) that directly accesses a private method and a private instance field in the outer class. This is legal, and the code prints "Value is 27" as expected.

The problem is that the VM considers direct access to Foo's private members from Foo$Inner to be illegal because Foo and Foo$Inner are different classes, even though the Java language allows an inner class to access an outer class' private members. To bridge the gap, the compiler generates a couple of synthetic methods:

/*package*/ static int Foo.access$100(Foo foo) {
    return foo.mValue;
}
/*package*/ static void Foo.access$200(Foo foo, int value) {
    foo.doStuff(value);
}

The inner class code calls these static methods whenever it needs to access the mValue field or invoke the doStuff method in the outer class. What this means is that the code above really boils down to a case where you're accessing member fields through accessor methods. Earlier we talked about how accessors are slower than direct field accesses, so this is an example of a certain language idiom resulting in an "invisible" performance hit.

If you're using code like this in a performance hotspot, you can avoid the overhead by declaring fields and methods accessed by inner classes to have package access, rather than private access. Unfortunately this means the fields can be accessed directly by other classes in the same package, so you shouldn't use this in public API.

Use Floating-Point Judiciously

As a rule of thumb, floating-point is about 2x slower than integer on Android devices. This is true on a FPU-less, JIT-less G1 and a Nexus One with an FPU and the JIT. (Of course, absolute speed difference between those two devices is about 10x for arithmetic operations.)

In speed terms, there's no difference between float and double on the more modern hardware. Space-wise, double is 2x larger. As with desktop machines, assuming space isn't an issue, you should prefer double to float.

Also, even for integers, some chips have hardware multiply but lack hardware divide. In such cases, integer division and modulus operations are performed in software — something to think about if you're designing a hash table or doing lots of math.

Know And Use The Libraries

In addition to all the usual reasons to prefer library code over rolling your own, bear in mind that the system is at liberty to replace calls to library methods with hand-coded assembler, which may be better than the best code the JIT can produce for the equivalent Java. The typical example here is String.indexOf and friends, which Dalvik replaces with an inlined intrinsic. Similarly, the System.arraycopy method is about 9x faster than a hand-coded loop on a Nexus One with the JIT.

(See also Effective Java item 47.)

Use Native Methods Judiciously

Native code isn't necessarily more efficient than Java. For one thing, there's a cost associated with the Java-native transition, and the JIT can't optimize across these boundaries. If you're allocating native resources (memory on the native heap, file descriptors, or whatever), it can be significantly more difficult to arrange timely collection of these resources. You also need to compile your code for each architecture you wish to run on (rather than rely on it having a JIT). You may even have to compile multiple versions for what you consider the same architecture: native code compiled for the ARM processor in the G1 can't take full advantage of the ARM in the Nexus One, and code compiled for the ARM in the Nexus One won't run on the ARM in the G1.

Native code is primarily useful when you have an existing native codebase that you want to port to Android, not for "speeding up" parts of a Java app.

(See also Effective Java item 54.)

Closing Notes

One last thing: always measure. Before you start optimizing, make sure you have a problem. Make sure you can accurately measure your existing performance, or you won't be able to measure the benefit of the alternatives you try.

Every claim made in this document is backed up by a benchmark. The source to these benchmarks can be found in the code.google.com "dalvik" project.

The benchmarks are built with the Caliper microbenchmarking framework for Java. Microbenchmarks are hard to get right, so Caliper goes out of its way to do the hard work for you, and even detect some cases where you're not measuring what you think you're measuring (because, say, the VM has managed to optimize all your code away). We highly recommend you use Caliper to run your own microbenchmarks.

You may also find Traceview useful for profiling, but it's important to realize that it currently disables the JIT, which may cause it to misattribute time to code that the JIT may be able to win back. It's especially important after making changes suggested by Traceview data to ensure that the resulting code actually runs faster when run without Traceview.

link to post:

http://developer.android.com/guide/practices/design/performance.html

delete database .sqlite android programmatically

2011-04-17T23:20:00.000-07:00

http://developer.android.com/reference/android/content/ContextWrapper.html#deleteDatabase(java.lang.String)

ContextWrapper cw = new ContextWrapper(ctx);

result = cw.deleteDatabase("DataBaseName.sqlite");

Install and Uninstall Android applications with Android PackageInstaller

2011-04-15T01:54:00.000-07:00

This is actually very simple.

See PackageInstaller code here:http://android.git.kernel.org/?p=platform/packages/apps/PackageInstaller.git;a=tree;h=refs/heads/donut;hb=refs/heads/donut

Intent filters for such actions are:

<activity android:name=".PackageInstallerActivity">

    <intent-filter>

        <action android:name="android.intent.action.VIEW" />

        <category android:name="android.intent.category.DEFAULT" />

        <data android:scheme="content" />

        <data android:scheme="file" />

        <data android:mimeType="application/vnd.android.package-archive" />

    </intent-filter>

</activity>

<activity android:name=".UninstallerActivity">

    <intent-filter>

        <action android:name="android.intent.action.VIEW" />

        <action android:name="android.intent.action.DELETE" />

        <category android:name="android.intent.category.DEFAULT" />

        <data android:scheme="package" />

    </intent-filter>

</activity

so if you want to install your .apk file from SD card – just write something like that:

String fileName = Environment.getExternalStorageDirectory() + "/myApp.apk";

Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setDataAndType(Uri.fromFile(new File(fileName)), "application/vnd.android.package-archive");

startActivity(intent);

for uninstallation:

Uri packageURI = Uri.parse("package:com.android.myapp");

Intent uninstallIntent = new Intent(Intent.ACTION_DELETE, packageURI);

startActivity(uninstallIntent)

be aware that by default INSTALL_NON_MARKET_APPS option is disabled. You may want to check this option and show user friendly dialog before trying to install the app:

int result = Settings.Secure.getInt(getContentResolver(), Settings.Secure.INSTALL_NON_MARKET_APPS, 0);

if (result == 0) {

    // show some dialog here

    // ...

    // and may be show application settings dialog manually

    Intent intent = new Intent();

    intent.setAction(Settings.ACTION_APPLICATION_SETTINGS);

    startActivity(intent);

if you want to uninstall your app by default from Pakage Manager then remove the category.DEFAULT line from uninstall app AndroidManifest.xml

Marquee TextView Android ticker

2011-03-11T00:49:00.000-08:00

Want to make your text view like news ticker, just set android Text View simple properties and voila..

android:singleLine="true"

   android:ellipsize="marquee"

   android:marqueeRepeatLimit ="marquee_forever"

   android:scrollHorizontally="true"

   android:focusable="true"

   android:focusableInTouchMode="true"

Reading and writing Serializable objects

2011-03-07T23:55:00.001-08:00

Example

import java.io.*;
import java.util.*;
import java.util.logging.*;

public class ExerciseSerializable {

public static void main(String... aArguments) {
//create a Serializable List
List<String> quarks = Arrays.asList(
"up", "down", "strange", "charm", "top", "bottom"
);

//serialize the List
//note the use of abstract base class references

try{
//use buffering
OutputStream file = new FileOutputStream( "quarks.ser" );
OutputStream buffer = new BufferedOutputStream( file );
ObjectOutput output = new ObjectOutputStream( buffer );
try{
output.writeObject(quarks);
}
finally{
output.close();
}
}
catch(IOException ex){
fLogger.log(Level.SEVERE, "Cannot perform output.", ex);
}

//deserialize the quarks.ser file
//note the use of abstract base class references

try{
//use buffering
InputStream file = new FileInputStream( "quarks.ser" );
InputStream buffer = new BufferedInputStream( file );
ObjectInput input = new ObjectInputStream ( buffer );
try{
//deserialize the List
List<String> recoveredQuarks = (List<String>)input.readObject();
//display its data
for(String quark: recoveredQuarks){
System.out.println("Recovered Quark: " + quark);
}
}
finally{
input.close();
}
}
catch(ClassNotFoundException ex){
fLogger.log(Level.SEVERE, "Cannot perform input. Class not found.", ex);
}
catch(IOException ex){
fLogger.log(Level.SEVERE, "Cannot perform input.", ex);
}
}

// PRIVATE //

//Use Java's logging facilities to record exceptions.
//The behavior of the logger can be configured through a
//text file, or programmatically through the logging API.
private static final Logger fLogger =
Logger.getLogger(ExerciseSerializable.class.getPackage().getName())
;
}

It is always best practice to use a buffer. (default size of a buffer is 8k).

HexConversions Convert String, byte to HEX

2011-02-10T02:47:00.001-08:00

// -----------------------------------------------------------------------------

// HexConversions.java

// -----------------------------------------------------------------------------

/*

 * =============================================================================

 * Copyright (c) 1998-2009 Jeffrey M. Hunter. All rights reserved.

 * All source code and material located at the Internet address of

 * http://www.idevelopment.info is the copyright of Jeffrey M. Hunter and

 * is protected under copyright laws of the United States. This source code may

 * not be hosted on any other site without my express, prior, written

 * permission. Application to host any of the material elsewhere can be made by

 * contacting me at jhunter@idevelopment.info.

 * I have made every effort and taken great care in making sure that the source

 * code and other content included on my web site is technically accurate, but I

 * disclaim any and all responsibility for any loss, damage or destruction of

 * data or any other property which may arise from relying on it. I will in no

 * case be liable for any monetary damages arising from such loss, damage or

 * destruction.

 * As with any code, ensure to test this code in a development environment

 * before attempting to run it in production.

 * =============================================================================

*/

import java.io.File;

/**

 * -----------------------------------------------------------------------------

 * This program provides several Convenience methods that can be used to convert

 * HEX values to/from Strings.

 * @version 1.0

 * @author  Jeffrey M. Hunter  (jhunter@idevelopment.info)

 * @author  http://www.idevelopment.info

 * -----------------------------------------------------------------------------

*/

public class HexConversions {

/**

     *  Convenience method to convert a byte array to a hex string.

     * @param  data  the byte[] to convert

     * @return String the converted byte[]

*/

    public static String bytesToHex(byte[] data) {

        StringBuffer buf = new StringBuffer();

        for (int i = 0; i < data.length; i++) {

            buf.append(byteToHex(data[i]).toUpperCase());

        return (buf.toString());

/**

     *  method to convert a byte to a hex string.

     * @param  data  the byte to convert

     * @return String the converted byte

*/

    public static String byteToHex(byte data) {

        StringBuffer buf = new StringBuffer();

        buf.append(toHexChar((data >>> 4) & 0x0F));

        buf.append(toHexChar(data & 0x0F));

        return buf.toString();

/**

     *  Convenience method to convert an int to a hex char.

     * @param  i  the int to convert

     * @return char the converted char

*/

    public static char toHexChar(int i) {

        if ((0 <= i) && (i <= 9)) {

            return (char) ('0' + i);

        } else {

            return (char) ('a' + (i - 10));

/**

     * Sole entry point to the class and application.

     * @param args Array of String arguments.

*/

    public static void main(String[] args) {

        // Create a String that will be stored in a byte[] array.

        // Consider this the "original" string.

        String str = "This is a test string.";

        System.out.println();

        System.out.println("Original String          : "  + str);

        byte[] bytes = str.getBytes();

        System.out.println("Created byte[] of length : " + bytes.length);

        System.out.println("Convert byte[] to String : " + bytesToHex(bytes));

        System.out.println();

        System.out.println("List individual entries of byte[]");

        System.out.println("---------------------------------");

        for (int i=0; i<bytes.length; i++) {

            System.out.println(

                    "bytes[" + i + "] " +

                    (i<=9 ? "  = " : " = ") +

                    ((int)bytes[i] < 9  ? "  " : "") +

                    ( ((int)bytes[i] > 9 && (int)bytes[i] <= 99) ? " " : "") +

                    bytes[i] + " : " +

                    " HEX=(0x" + byteToHex(bytes[i]) + ") : " +

                    " charValue=(" + (char)bytes[i] + ")"

);

Using Enumerations in for-each statements - five times faster than the JRE, without RAM limitations

2011-02-09T05:03:00.001-08:00

Main Point to understand is : adapting an enumeration into iterator and vice-versa to save RAM.

Post Taken from: http://weblogs.java.net/blog/mkarg/archive/2010/07/04/using-enumerations-each-statements-five-times-faster-jre-without-ram-l

I was such happy when years back the JRE was extended by the Collections Framework. It's just so intuitive to use it, and provides virtually anything the average programmer needs. Compared to the older Enumeration interface, this was really much better. And even better was the introduction of the for-each statement, so iterating over a Collection was a breeze. Unfortunately, the old Enumeration interface was already commonly used in lots of APIs like JNDI etc. which couldn't get changed without breaking compatibility, so what to do? The JRE authors solved this problem by providing compatibility factory methods in the Collections class, namely Collections.enumeration() and Collections.list(). While the first was turning a Collection into an Enumeration, the latter allowed using for-each with Enumerations by turning an Enumeration into an ArrayList. So far, so good.

Unfortunately the implementation of Collections.list() is not very smart. While Collections.list() just wraps the collection's iterator by a thin implementation of the Enumeration interface (which needs virtually no time and space), it's a mistery to me why the authors choose to return actually an ArrayList: This decision enforces the implementor to actually allocate RAM large enough to store the complete content of the Enumeration, and then actually copying the content. While this sounds easy these days, don't be surprised now. Its much slower than you think, and needs much more RAM than you think. Ever had the problem that you wanted to use for-each with an Enumeration filled with ten million integers? Good for you if not.

So if CPU time and RAM consumption is of any interest, it might be useful to choose a different solution: Not allocating any RAM, but directly map calls directly to the Enumeration - just as Collections.enumeration() does, but just the reverse way. I wonder why the JRE is not providing this solution, but until it is (and possibly it will never) one has to write this code on his own again and again. Or just download mine, if your project accepts GPLv3: www.headcrashing.eu/code.html

A short test confirms that this code can not only handles endless Enumerations where Collections.list() blasts your RAM, but also is five times faster than Collections.list(). Time to file a RFE now to get Collections extended by this implementation... ;-)

/*

 * Copyright 2009-2010 Markus KARG

 * This file is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 * This file is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 * For a copy of the GNU Lesser General Public License

 * see .

*/

package eu.headcrashing.util;

import java.util.Collections;

import java.util.Enumeration;

import java.util.Iterator;

/**

 * This class allows Enumerations to be iterated.

 * @author Markus KARG (markus@headcrashing.eu)

*/

public final class Enumerations {

/**

     * Allows using of {@link Enumeration} with the for-each statement. The

     * implementation is not using any heap space and such is able to serve

     * virtually endless Enumerations, while {@link Collections#list} is limited

     * by available RAM. As a result, this implementation is much faster than

     * Collections.list.

     * @param enumeration

     *            The original enumeration.

     * @return An {@link Iterable} directly calling the original Enumeration.

*/

    public static final <T> Iterable<T> iterable(final Enumeration<T> enumeration) {

        return new Iterable<T>() {

            public final Iterator<T> iterator() {

                return new Iterator<T>() {

                    public final boolean hasNext() {

                        return enumeration.hasMoreElements();

                    public final T next() {

                        return enumeration.nextElement();

/**

                     * This method is not implemeted as it is impossible to

                     * remove something from an Enumeration.

                     * @throws UnsupportedOperationException

                     *             always.

*/

                    public final void remove() {

                        throw new UnsupportedOperationException();

};

};