ARUNKUMAR

Check Network Connection Using BroadcastReceiver

2014-11-18T18:02:00.003+05:30

BroadCastSampleActivity.java

public class BroadCastSampleActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        this.registerReceiver(this.mConnReceiver,
                new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
    }
    private BroadcastReceiver mConnReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            boolean noConnectivity = intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
            String reason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
            boolean isFailover = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);

            NetworkInfo currentNetworkInfo = (NetworkInfo) intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
            NetworkInfo otherNetworkInfo = (NetworkInfo) intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);

            if(currentNetworkInfo.isConnected()){
                Toast.makeText(getApplicationContext(), "Connected", Toast.LENGTH_LONG).show();
            }else{
                Toast.makeText(getApplicationContext(), "Not Connected", Toast.LENGTH_LONG).show();
            }
        }
    };
}

Add uses-permission in AndroidManifest

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

Android - How to Get activity from context

2014-04-04T17:06:00.000+05:30

Sometimes we pass context of an activity as a parameter to some other function and later we might want the activity too. So instead of passing the activity also to that function, we can get the activity from context itself.

You can get the activity from the context by type casting the context to activity.

Activity activity = (Activity) _context;

How to check if an APK has the flag set as true

2013-12-23T14:49:00.002+05:30

Using the aapt tool you can check lots of things inside an apk. Use the following command:

aapt list -v -a myfile.apk

this shows hundreds of lines, but you must search the following text "android:debuggable"

this flag can have the values:

0x0: debuggable false
0xffffffff: debugabble true

in my case the entire line is the following

A: android:debuggable(0x0101000f)=(type 0x12)0xffffffff

Oops! My release build had the flag enabled ;)

Detect Current Location in Android Using GPS/NETWORK Provider

2013-08-21T12:39:00.000+05:30

Using the Location Manager class, we can obtain periodic updates of the device's geographical locations as well as fire an intent when it enters the proximity of a certain location.

1. Obtain a reference to the LocationManager class using the getSystemService() method.

LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

2. Create a LocationListener Class for notify the location changes.

Our MyLocationListener class should implements the LocationListener abstract class. There are four methods that you need to override in this implementation:

* onLocationChanged(Location location): This method is called when the location has changed.

* onProviderDisabled(String provider): This method is called when the provider is disabled by the user.

* onProviderEnabled(String provider): This method is called when the provider is enabled by the user.

* onStatusChanged(String provider, int status, Bundle extras): This method is called when the provider status changes.

3. To be notified whenever there is a change in location, you need to register for a request for changes in locations so that your program can be notified periodically. This is done via the requestLocationUpdates() method (see Listing 1).

This method takes in four parameters:

* provider: The name of the provider with which you register

* minTime: The minimum time interval for notifications, in milliseconds.

* minDistance: The minimum distance interval for notifications, in meters.

* listener: An object whose onLocationChanged() method will be called for each location update.

4. Set the following User-Permission in androidmanifest.xml

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

Sample Code :

package com.cureent;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;

public class TestActivity extends Activity implements OnClickListener, android.content.DialogInterface.OnClickListener {

   private EditText editTextShowLocation;
   private Button buttonGetLocation;
   private ProgressBar progress;

   private LocationManager locManager;
   private LocationListener locListener = new MyLocationListener();

   private boolean gps_enabled = false;
   private boolean network_enabled = false;

   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
       editTextShowLocation = (EditText) findViewById(R.id.editText1);

       progress = (ProgressBar) findViewById(R.id.progressBar1);
       progress.setVisibility(View.GONE);

       buttonGetLocation = (Button) findViewById(R.id.button1);
       buttonGetLocation.setOnClickListener(this);

       locManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE);
   }

   @Override
   public void onClick(View v) {
       progress.setVisibility(View.VISIBLE);
       // exceptions will be thrown if provider is not permitted.
       try {
           gps_enabled = locManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
       } catch (Exception ex) {
       }
       try {
           network_enabled = locManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
       } catch (Exception ex) {
       }

       // don't start listeners if no provider is enabled
       if (!gps_enabled && !network_enabled) {
           AlertDialog.Builder builder = new Builder(this);
           builder.setTitle("Attention!");
           builder.setMessage("Sorry, location is not determined. Please enable location providers");
           builder.setPositiveButton("OK", this);
           builder.setNeutralButton("Cancel", this);
           builder.create().show();
           progress.setVisibility(View.GONE);
       }

       if (gps_enabled) {
           locManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locListener);
       }
       if (network_enabled) {
           locManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, locListener);
       }
   }

   class MyLocationListener implements LocationListener {
       @Override
       public void onLocationChanged(Location location) {
           if (location != null) {
               // This needs to stop getting the location data and save the battery power.
               locManager.removeUpdates(locListener);

               String londitude = "Londitude: " + location.getLongitude();
               String latitude = "Latitude: " + location.getLatitude();
               String altitiude = "Altitiude: " + location.getAltitude();
               String accuracy = "Accuracy: " + location.getAccuracy();
               String time = "Time: " + location.getTime();

               editTextShowLocation.setText(londitude + "\n" + latitude + "\n" + altitiude + "\n" + accuracy + "\n" + time);
               progress.setVisibility(View.GONE);
           }
       }

       @Override
       public void onProviderDisabled(String provider) {
           // TODO Auto-generated method stub

       }

       @Override
       public void onProviderEnabled(String provider) {
           // TODO Auto-generated method stub

       }

       @Override
       public void onStatusChanged(String provider, int status, Bundle extras) {
           // TODO Auto-generated method stub

       }
   }

   @Override
   public void onClick(DialogInterface dialog, int which) {
       if(which == DialogInterface.BUTTON_NEUTRAL){
           editTextShowLocation.setText("Sorry, location is not determined. To fix this please enable location providers");
       }else if (which == DialogInterface.BUTTON_POSITIVE) {
           startActivity(new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS));
       }
   }

}

Reverse geocoding:

package com.exercise.AndroidFromLocation;

import java.io.IOException;

import java.util.List;

import java.util.Locale;

import android.app.Activity;

import android.location.Address;

import android.location.Geocoder;

import android.os.Bundle;

import android.widget.TextView;

public class AndroidFromLocation extends Activity {

double LATITUDE = 37.42233;

double LONGITUDE = -122.083;

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

TextView myLatitude = (TextView)findViewById(R.id.mylatitude);

TextView myLongitude = (TextView)findViewById(R.id.mylongitude);

TextView myAddress = (TextView)findViewById(R.id.myaddress);

myLatitude.setText("Latitude: " + String.valueOf(LATITUDE));

myLongitude.setText("Longitude: " + String.valueOf(LONGITUDE));

Geocoder geocoder = new Geocoder(this, Locale.ENGLISH);

try {

List<Address> addresses = geocoder.getFromLocation(LATITUDE, LONGITUDE, 1);

if(addresses != null) {

Address returnedAddress = addresses.get(0);

StringBuilder strReturnedAddress = new StringBuilder("Address:\n");

for(int i=0; i<returnedAddress.getMaxAddressLineIndex(); i++) {

strReturnedAddress.append(returnedAddress.getAddressLine(i)).append("\n");

}

myAddress.setText(strReturnedAddress.toString());

}

else{

myAddress.setText("No Address returned!");

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

myAddress.setText("Canont get Address!");

}

Main.xml

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

>

<TextView

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/hello"

/>

<TextView

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="Location"

android:background="#505050"

/>

<TextView

android:id="@+id/mylatitude"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

/>

<TextView

android:id="@+id/mylongitude"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

/>

<TextView

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="Address"

android:background="#505050"

/>

<TextView

android:id="@+id/myaddress"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

/>

</LinearLayout>

Supporting apps in different screen sizes

2013-07-30T16:14:00.000+05:30

Screen characteristic	Qualifier	Description
Size	`small`	Resources for small size screens.
	`normal`	Resources for normal size screens. (This is the baseline size.)
	`large`	Resources for large size screens.
	`xlarge`	Resources for extra large size screens.
Density	`ldpi`	Resources for low-density (ldpi) screens (~120dpi).
	`mdpi`	Resources for medium-density (mdpi) screens (~160dpi). (This is the baseline density.)
	`hdpi`	Resources for high-density (hdpi) screens (~240dpi).
	`xhdpi`	Resources for extra high-density (xhdpi) screens (~320dpi).
	`nodpi`	Resources for all densities. These are density-independent resources. The system does not scale resources tagged with this qualifier, regardless of the current screen's density.
	`tvdpi`	Resources for screens somewhere between mdpi and hdpi; approximately 213dpi. This is not considered a "primary" density group. It is mostly intended for televisions and most apps shouldn't need it—providing mdpi and hdpi resources is sufficient for most apps and the system will scale them as appropriate. If you find it necessary to provide tvdpi resources, you should size them at a factor of 1.33*mdpi. For example, a 100px x 100px image for mdpi screens should be 133px x 133px for tvdpi.
Orientation	`land`	Resources for screens in the landscape orientation (wide aspect ratio).
Orientation	`port`	Resources for screens in the portrait orientation (tall aspect ratio).
Aspect ratio	`long`	Resources for screens that have a significantly taller or wider aspect ratio (when in portrait or landscape orientation, respectively) than the baseline screen configuration.
Aspect ratio	`notlong`	Resources for use screens that have an aspect ratio that is similar to the baseline screen configuration.

You need to create different layout for diff screen size. Support all screen you need to create following layout:

Low density Small screens QVGA 240x320 (120dpi):

layout-small-ldpi (240x320)  
layout-small-land-ldpi (320x240)

Low density Normal screens WVGA400 240x400 (x432) (120dpi):

layout-ldpi  (240 x 400 )
layout-land-ldpi  (400 x 240 )

Medium density Normal screens HVGA 320x480 (160dpi):

layout-mdpi (320 x 480 )
layout-land-mdpi (480 x 320 )

Medium density Large screens HVGA 320x480 (160dpi):

layout-large-mdpi (320 x 480 )
layout-large-land-mdpi (480 x 320)

Galaxy Tab ( 240 dpi ):

layout-large  (600 x 1024) 
layout-large-land  (1024 x 600)

High density Normal screens WVGA800 480x800 (x854) (240 dpi):
```
layout-hdpi (480 x 800)
layout-land-hdpi (800 x 480)
```

Xoom (medium density large but 1280x800 res) (160 dpi):

layout-xlarge (800 x 1280)
layout-xlarge-land (1280 x 800)

Also add following code in .manifest file:

<supports-screens                                 
    android:smallScreens="true"                    
    android:normalScreens="true"         
    android:largeScreens="true"            
    android:xlargeScreens="true"             
    android:anyDensity="true" />

Toast show in center of screen

2013-07-30T16:07:00.002+05:30

Toast mostly visible in bottom of screen. In bottom if we have any design then that toast will appear in front of our design. It's very irritating and annoying. so, Here i gave solution for that.

Toast toast = Toast.makeText(test.this,"www.arunkumarpd.blogspot.com", Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();

Display the path of selected Picture in gallery

2013-05-21T14:26:00.000+05:30

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Gallery click = (Gallery) findViewById(R.id.gallery);

final List<String> sdcard = ReadSDCard();
click.setAdapter(new ImageAdapter(this, sdcard));

click.setOnItemClickListener(new OnItemClickListener()
{
public void onItemClick(AdapterView<?> parent,
View v, int position, long id) {
Toast.makeText(Galleryy.this,
(CharSequence)sdcard.get(position),
Toast.LENGTH_LONG).show();
}
});
}

Disable screen lock in android

2013-04-12T14:54:00.002+05:30

KeyguardManager keyguardManager = (KeyguardManager)getSystemService(Activity.KEYGUARD_SERVICE);
KeyguardLock lock = keyguardManager.newKeyguardLock(KEYGUARD_SERVICE);
lock.disableKeyguard();

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

Simple Alert Popup with Title, Message, Icon and Button

2013-04-12T14:53:00.001+05:30

AlertDialog alertDialog = new AlertDialog.Builder(this).create();
alertDialog.setTitle("Title");
alertDialog.setMessage("Message");
alertDialog.setButton("OK", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// TODO Add your code for the button here.
} });
// Set the Icon for the Dialog
alertDialog.setIcon(R.drawable.icon);
alertDialog.show();

Android- Embed Google Map in Web View

2013-04-12T14:46:00.001+05:30

package com.example.androidwebmap;
import android.os.Bundle;
import android.app.Activity;
import android.webkit.WebView;
import android.webkit.WebViewClient;

public class TestActivity extends Activity {

WebView myWebView;

String mapPath = "https://maps.google.com/?ll=37.0625,-95.677068&spn=29.301969,56.513672&t=h&z=4";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
myWebView = (WebView)findViewById(R.id.mapview);
myWebView.getSettings().setJavaScriptEnabled(true);
myWebView.setWebViewClient(new WebViewClient());

myWebView.loadUrl(mapPath);
}

}

XML File

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:orientation="vertical"
tools:context=".MainActivity" >

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />
<WebView
android:id="@+id/mapview"
android:layout_width="match_parent"
android:layout_height="match_parent" />

</LinearLayout>

Important:
- Permission of "android.permission.INTERNET" is need.

Download This project

Autostart our application when android device start from bootup

2013-04-10T17:53:00.003+05:30

when you power on the device open our application starts.
through receiver we can achieve this one .

Androidmenifest.xml
<receiver android:enabled="true" android:name=".Startourapp"
        android:permission="android.permission.RECEIVE_BOOT_COMPLETED">

        <intent-filter>
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <category android:name="android.intent.category.DEFAULT" />
        </intent-filter>

Startourapp.class

public class Startourapp extends BroadcastReceiver{
    @Override
    public void onReceive(Context context, Intent intent) {
            Intent i = new Intent(context, MainActivity.class);
            i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
               context.startActivity(i);
    }

}

Admob in Android

2013-03-26T17:15:00.001+05:30

Trick to get source code from APK file

2013-02-07T17:28:00.002+05:30

Required software's and Tools

Get APK source code files for Windows
or
Get APK source code files for Mac OS X
or
Get APK source code files for Linux

Step 1. Rename the .apk file you wish to retrieve and change the extension to .zip. Then extract the file that it creates.

Step 2. Copy the contents of the dex2jar folder to the extracted folder to make it easier for yourself, and run:

dex2jar classes.dex

and copy the resulting “classes.dex.dex2jar.jar” into a new folder.

Step 3. Open up the Java Decompiler and drag “classes.dex.dex2jar.jar” into the window and then go to File > Save and save the source in a .zip file.

Step 4. Extract the saved .zip and copy the contents to a new folder somewhere. This will be where we keep your source code.

Step 5. Now, copy “framework-res.apk” and “yourapk.apk” to the APKTool folder. Then open a command prompt or Terminal window and type:

apktool if framework-res.apk
apktool d <yourapk.apk>

Step 6. Now just copy the contents of the resulting folder to the same place you copied the contents of “classes.dex.dex2jar.jar” earlier and voila, you have your source code. You may need to remove a couple of things as shown in the video, but your entire code should be there!

Import project into eclipse

Step By step

1. Navigate to Import section
2. Select ‘Existing Android project into workshop’ option under ‘Android’ section and click on ‘Next’
3. In the next screen browse and select the app folder, check the option ‘Copy project into workspace’.

4.App is imported successfully.

Hope this help you guys:)

Android-Remote Debugging in chrome

2013-01-31T14:14:00.001+05:30

You can debug mobile web sites with the full suite of Chrome Developer Tools running on a desktop browser that's connected to your phone via USB. View and change HTML code and styles until you get a bug-free page that behaves perfectly on the phone or tablet.

Know more: https://developers.google.com/chrome/mobile/docs/debugging

Calling system settings from an Android app - GPS example

2013-01-02T19:06:00.001+05:30

This tutorial shows how to redirect the user to a system settings screen asking to modify some settings the application depends on. We will make a specific example with Gps: The application can be used only if gps is available.

The android system gps setting screen can be called just like any other Activities:

startActivityForResult(newIntent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS), 0);

To check GPS availability use the code code below: (the Activity must implement LocationListener)

LocationManager locationManager = (LocationManager)getSystemService(LOCATION_SERVICE);

locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 1000L,1.0f, this);

boolean isGPS = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);

The example application will do the following:

1. On application start check if gps is available. If it is on the application can proceed.

2. If GPS is turned off, display a dialog asking the user to turn it on, and 2 buttons, one to go to GPS settings screen, and a cancel button to exit the application.

3. When the dialog is displayed we must store in a variable that the user was already asked once to turn on GPS

4. If the user leaves to the GPS option screen, it is not sure that he will turn on the GPS!

5. When the user returns to application we recheck the GPS. If its available we can proceed, otherwise we close the application. (in order to check that it is a returm to the activity or is it its first start we check the variable we set in step 3)

So we will have the code in the applications starting Activity's on Resume method, where we will detect GPS availability, use a dialog to ask the user, an Intent to go to options screen, and a variable to indicate the state of the GPS turn on process. The code for this example application is available here. Turn off your GPS and try running it.

5 tips for converting iOS UI to Android

2012-12-14T15:31:00.002+05:30

5 tips for converting iOS UI to Android

Making your app look like it belongs into an Android phone

Many companies are converting their iOS apps to Android nowadays. However, simple one-to-one conversion of the UI might cause problems to the potential users.

I don't believe that inter-platform consistency between an app's different versions is as important than consistency between apps on a single platform. Not many users use multiple different phones at the same time. This post describes five simple rules how an iOS app can be made to fit into the growing Android app crowd.

1. Use top tabs

Google recommends that tabs in Android apps placed on top part of the UI instead of the very bottom.

a slide from Roman Nurik's GDD 2010 presentation

There's a very good reason for that recommendation. Take a look at the following pictures.Both of them features app called runtastic. Their Android port keeps the UI virtually unchanged and causes problems to big portion of Android users. Many Android phones have the 4 (or some 3) required Android buttons right on the screens bottom edge. Having your app's navigation immediately adjacent to the buttons will inevitably cause users to tap the navigation buttons from time to time.

Foursquare port does a good work moving the navigation tabs to higher and avoiding the same problems as runtastic has.

On the left: iOS version. On the right: Android version.

2. No back button in UI

All Android devices are required to have a back button and user's have used in using it. There's no need to add a back button to the UI.

Don't do this:

A bit embarrassingly this example is
from Android Central (an awesome source
for Android news) app.

3. Use Android platform icons

Android platform provides icons for most common actions. One of them is share. Allrecepies uses an iOS icon (top right corner). There's a well established "share" icon for Android seen for example in the default gallery app. It is freely available to use in every app.

On the left: Wrong. On the right: Correct.

4. Use Android's intent APIs

One of the most powerful features of Android platform is the intent API. It allows apps to extend other apps' functionality by offering access to their features. Probably the most common way of doing this is the share function on various apps. An app can chose to share text, URL, image etc. Other apps can then register to listen to intents that they can handle.

Apps should not implement their own interface for sharing through Facebook, twitter etc. If the app just let's the Android handle the share intent user can use their twitter etc app of choice. This way is much more convenient to users.

On the left: Wrong. On the right: Correct.

5. Consider using Action Bar

Action bar has become a single most easily identifiable feature in Android apps. Using it will instantly brand the app as an Android app. Users are used to the concept and it can improve app's usability. However, as always UI components should only be used if it makes sense.

Evernote uses Action Bar
pattern successfully

Conclusion

Simple one-to-one conversion from iOS design is usually not enough to create good user experience. However, the changed required might not require too huge amount of effort and will be rewarded by much better user satisfaction.

2012-12-04T16:57:00.004+05:30

Eclipse shortcuts for Android Developers

Editing shortcuts

Get list of currently installed apps

2012-11-29T17:46:00.000+05:30

List out all of the user's installed applications in an activity.
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
lView = (ListView) findViewById(R.id.list1);
PackageManager pm = this.getPackageManager();
Intent intent = new Intent(Intent.ACTION_MAIN, null); intent.addCategory(Intent.CATEGORY_LAUNCHER);
List list = pm.queryIntentActivities(intent, PackageManager.PERMISSION_GRANTED);
for (ResolveInfo rInfo : list) {
results.add(rInfo.activityInfo.applicationInfo.loadLabel(pm).toString());
Log.w("Installed Applications", rInfo.activityInfo.applicationInfo.loadLabel(pm).toString());
}
lView.setAdapter(new ArrayAdapter(this, android.R.layout.simple_ list_item_1, results));
}

check internet is available?

2012-11-21T15:09:00.006+05:30

This function will return true if you can access the internet (or false if you can't). You can change the parameter being return when roaming

/*
* @return boolean return true if the application can access the internet
*/
private boolean haveInternet(){
NetworkInfo info = ((ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
if (info==null || !info.isConnected()) {
return false;
}
if (info.isRoaming()) {
// here is the roaming option you can change it if you want to disable internet while roaming, just return false
return true;
}
return true;
}

Android interview questions and answers?

2012-11-21T15:04:00.001+05:30

Introduction Android:

Android is an operating system for mobile devices that includes middleware and key applications, and uses a modified version of the Linux kernel. It was initially developed by Android Inc..It allows developers to write managed code in the Java language, controlling the device via Google-developed Java libraries.....
The Android SDK includes a comprehensive set of development tools . These include a debugger, libraries, a handset emulator (based on QEMU), documentation, sample code, and tutorials. Currently supported development platforms include x86-architecture computers running Linux (any modern desktop Linux distribution), Mac OS X 10.4.8 or later, Windows XP or Vista.

Android does not use established Java standards, i.e. Java SE and ME. This prevents compatibility among Java applications written for those platforms and those for the Android platform. Android only reuses the Java language syntax, but does not provide the full-class libraries and APIs bundled with Java SE or ME

What is android?
Android is a stack of software for mobile devices which has Operating System, middleware and some key applications. The application executes within its own process and its own instance of Dalvik Virtual Machine. Many Virtual Machines run efficiently by a DVM device. DVM executes Java language?s byte code which later transforms into .dex format files.

What are the advantages of Android?
The following are the advantages of Android:

* The customer will be benefited from wide range of mobile applications to choose, since the monopoly of wireless carriers like AT&T and Orange will be broken by Google Android.
* Features like weather details, live RSS feeds, opening screen, icon on the opening screen can be customized
* Innovative products like the location-aware services, location of a nearby convenience store etc., are some of the additive facilities in Android.
Components can be reused and replaced by the application framework.
*Optimized DVM for mobile devices
*SQLite enables to store the data in a structured manner.
*Supports GSM telephone and Bluetooth, WiFi, 3G and EDGE technologies
*The development is a combination of a device emulator, debugging tools, memory profiling and plug-in for Eclipse IDE.

Features of Android
 Application framework enabling reuse and replacement of components
 Dalvik virtual machine optimized for mobile devices
 Integrated browser based on the open source WebKit engine
 Optimized graphics powered by a custom 2D graphics library; 3D graphics based on the OpenGL ES 1.0 specification (hardware acceleration optional)
 SQLite for structured data storage
 Media support for common audio, video, and still image formats (MPEG4, H.264, MP3, AAC, AMR, JPG, PNG, GIF)
 GSM Telephony (hardware dependent)
 Bluetooth, EDGE, 3G, and WiFi (hardware dependent)
 Camera, GPS, compass, and accelerometer (hardware dependent)
 Rich development environment including a device emulator, tools for debugging, memory and performance profiling, and a plugin for the Eclipse IDE.

Explain about the exceptions of Android?

The following are the exceptions that are supported by Android
* InflateException : When an error conditions are occurred, this exception is thrown
* Surface.OutOfResourceException: When a surface is not created or resized, this exception is thrown
* SurfaceHolder.BadSurfaceTypeException: This exception is thrown from the lockCanvas() method, when invoked on a Surface whose is SURFACE_TYPE_PUSH_BUFFERS
* WindowManager.BadTokenException: This exception is thrown at the time of trying to add view an invalid WindowManager.LayoutParamstoken.

Describe the APK format.
The APK file is compressed the AndroidManifest.xml file, application code (.dex files), resource files, and other files. A project is compiled into a single .apk file.

What is .apk extension?
The extension for an Android package file, which typically contains all of the files related to a single Android application. The file itself is a compressed collection of an AndroidManifest.xml file, application code (.dex files), resource files, and other files. A project is compiled into a single .apk file.

What is .dex extension
Android programs are compiled into .dex (Dalvik Executable) files, which are in turn zipped into a single .apk file on the device. .dex files can be created by automatically translating compiled applications written in the Java programming language

What is an adb ?
Android Debug Bridge, a command-line debugging application shipped with the SDK. It provides tools to browse the device, copy tools on the device, and forward ports for debugging.

What is an Application ?
A collection of one or more activities, services, listeners, and intent receivers. An application has a single manifest, and is compiled into a single .apk file on the device.

What is a Content Provider ?
A class built on ContentProvider that handles content query strings of a specific format to return data in a specific format. See Reading and writing data to a content provider for information on using content providers.

What is a Dalvik ?
The name of Android’s virtual machine. The Dalvik VM is an interpreter-only virtual machine that executes files in the Dalvik Executable (.dex) format, a format that is optimized for efficient storage and memory-mappable execution. The virtual machine is register-based, and it can run classes compiled by a Java language compiler that have been transformed into its native format using the included “dx” tool. The VM runs on top of Posix-compliant operating systems, which it relies on for underlying functionality (such as threading and low level memory management). The Dalvik core class library is intended to provide a familiar development base for those used to programming with Java Standard Edition, but it is geared specifically to the needs of a small mobile device.

What is an DDMS
Dalvik Debug Monitor Service, a GUI debugging application shipped with the SDK. It provides screen capture, log dump, and process examination capabilities.

What is Drawable?
A compiled visual resource that can be used as a background, title, or other part of the screen. It is compiled into an android.graphics.drawable subclass.

What is an Intent?
A class (Intent) that contains several fields describing what a caller would like to do. The caller sends this intent to Android’s intent resolver, which looks through the intent filters of all applications to find the activity most suited to handle this intent. Intent fields include the desired action, a category, a data string, the MIME type of the data, a handling class, and other restrictions.

What is an Intent Filter ?
Activities and intent receivers include one or more filters in their manifest to describe what kinds of intents or messages they can handle or want to receive. An intent filter lists a set of requirements, such as data type, action requested, and URI format, that the Intent or message must fulfill. For Activities, Android searches for the Activity with the most closely matching valid match between the Intent and the activity filter. For messages, Android will forward a message to all receivers with matching intent filters.

What is an Intent Receiver?
An application class that listens for messages broadcast by calling Context.broadcastIntent

What is a Layout resource?
An XML file that describes the layout of an Activity screen.

What is a Manifest ?
An XML file associated with each Application that describes the various activies, intent filters, services, and other items that it exposes.

What is a Resource
A user-supplied XML, bitmap, or other file, entered into an application build process, which can later be loaded from code. Android can accept resources of many types; see Resources for a full description. Application-defined resources should be stored in the res/ subfolders.

What is a Service ?
A class that runs in the background to perform various persistent actions, such as playing music or monitoring network activity.

What is a Theme ?
A set of properties (text size, background color, and so on) bundled together to define various default display settings. Android provides a few standard themes, listed in R.style (starting with “Theme_”).

What is an URIs?
Android uses URI strings both for requesting data (e.g., a list of contacts) and for requesting actions (e.g., opening a Web page in a browser). Both are valid URI strings, but have different values. All requests for data must start with the string “content://”. Action strings are valid URIs that can be handled appropriately by applications on the device; for example, a URI starting with “http://” will be handled by the browser.

Can I write code for Android using C/C++?
Yes, but need to use NDK
Android applications are written using the Java programming language. Android includes a set of core libraries that provides most of the functionality available in the core libraries of the Java programming language.
Every Android application runs in its own process, with its own instance of the Dalvik virtual machine. Dalvik has been written so that a device can run multiple VMs efficiently. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language compiler that have been transformed into the .dex format by the included “dx” tool.
Android only supports applications written using the Java programming language at this time.

What is an action?
A description of something that an Intent sender desires.

What is activity?
A single screen in an application, with supporting Java code.

What is intent?
A class (Intent) describes what a caller desires to do. The caller sends this intent to Android's intent resolver, which finds the most suitable activity for the intent. E.g. opening a PDF file is an intent, and the Adobe Reader is the suitable activity for this intent.

How is nine-patch image different from a regular bitmap?
It is a resizable bitmap resource that can be used for backgrounds or other images on the device. The NinePatch class permits drawing a bitmap in nine sections. The four corners are unscaled; the four edges are scaled in one axis, and the middle is scaled in both axes.

What languages does Android support for application development?
Android applications are written using the Java programming language.

What is a resource?
A user-supplied XML, bitmap, or other file, injected into the application build process, which can later be loaded from code.

How will you record a phone call in Android? How to get a handle on Audio Stream for a call in Android?
Permissions.PROCESS_OUTGOING_CALLS: Allows an application to monitor, modify, or abort outgoing calls.

What's the difference between file, class and activity in android?
File - It is a block of arbitrary information, or resource for storing information. It can be of any type.
Class - Its a compiled form of .Java file . Android finally used this .class files to produce an executable apk
Activity - An activity is the equivalent of a Frame/Window in GUI toolkits. It is not a file or a file type it is just a class that can be extended in Android for loading UI elements on view.

What is a Sticky Intent?
sendStickyBroadcast() performs a sendBroadcast (Intent) that is "sticky," i.e. the Intent you are sending stays around after the broadcast is complete, so that others can quickly retrieve that data through the return value of registerReceiver (BroadcastReceiver, IntentFilter). In all other ways, this behaves the same as sendBroadcast(Intent).

One example of a sticky broadcast sent via the operating system is ACTION_BATTERY_CHANGED. When you call registerReceiver() for that action -- even with a null BroadcastReceiver -- you get the Intent that was last broadcast for that action. Hence, you can use this to find the state of the battery without necessarily registering for all future state changes in the battery.

Does Android support the Bluetooth serial port profile?
Yes.

Can an application be started on powerup?
Yes.

How to Remove Desktop icons and Widgets
A. Press and Hold the icon or widget. The phone will vibrate and on the bottom of the phone you will see anoption to remove. While still holding the icon or widget drag it to the remove button. Once remove turns red drop the item and it is gone

Describe a real time scenario where android can be used?
Imagine a situation that you are in a country where no one understands the language you speak and you can not read or write. However, you have mobile phone with you.

With a mobile phone with android, the Google translator translates the data of one language into another language by using XMPP to transmit data. You can type the message in English and select the language which is understood by the citizens of the country in order to reach the message to the citizens.

How to select more than one option from list in android xml file?
Give an example.
Specify android id, layout height and width as depicted in the following example.

What languages does Android support for application development?
Android applications are written using the Java programming language.

Describe Android Application Architecture.
Android Application Architecture has the following components:
• Services – like Network Operation
• Intent - To perform inter-communication between activities or services
• Resource Externalization - such as strings and graphics
• Notification signaling users - light, sound, icon, notification, dialog etc.
• Content Providers - They share data between applications

Common Tricky questions
 Remember that the GUI layer doesn't request data directly from the web; data is always loaded from a local database.
 The service layer periodically updates the local database.
 What is the risk in blocking the Main thread when performing a lengthy operation such as web access or heavy computation? Application_Not_Responding exception will be thrown which will crash and restart the application.
 Why is List View not recommended to have active components? Clicking on the active text box will pop up the software keyboard but this will resize the list, removing focus from the clicked element.

Open Source

What is the Android Open Source Project?
We use the phrase “Android Open Source Project” or “AOSP” to refer to the people, the processes, and the source code that make up Android.
The people oversee the project and develop the actual source code. The processes refer to the tools and procedures we use to manage the development of the software. The net result is the source code that you can use to build cell phone and other devices.

Why did we open the Android source code?
Google started the Android project in response to our own experiences launching mobile apps. We wanted to make sure that there would always be an open platform available for carriers, OEMs, and developers to use to make their innovative ideas a reality. We also wanted to make sure that there was no central point of failure, so that no single industry player could restrict or control the innovations of any other. The single most important goal of the Android Open-Source Project (AOSP) is to make sure that the open-source Android software is implemented as widely and compatibly as possible, to everyone’s benefit.
You can find more information on this topic at our Project Philosophy page.

What kind of open-source project is Android?
Google oversees the development of the core Android open-source platform, and works to create robust developer and user communities. For the most part the Android source code is licensed under the permissive Apache Software License 2.0, rather than a “copyleft” license. The main reason for this is because our most important goal is widespread adoption of the software, and we believe that the ASL2.0 license best achieves that goal.
You can find more information on this topic at our Project Philosophy and Licensing pages.

Why is Google in charge of Android?
Launching a software platform is complex. Openness is vital to the long-term success of a platform, since openness is required to attract investment from developers and ensure a level playing field. However, the platform itself must also be a compelling product to end users.
That’s why Google has committed the professional engineering resources necessary to ensure that Android is a fully competitive software platform. Google treats the Android project as a full-scale product development operation, and strikes the business deals necessary to make sure that great devices running Android actually make it to market.
By making sure that Android is a success with end users, we help ensure the vitality of Android as a platform, and as an open-source project. After all, who wants the source code to an unsuccessful product?
Google’s goal is to ensure a successful ecosystem around Android, but no one is required to participate, of course. We opened the Android source code so anyone can modify and distribute the software to meet their own needs.

What is Google’s overall strategy for Android product development?
We focus on releasing great devices into a competitive marketplace, and then incorporate the innovations and enhancements we made into the core platform, as the next version.
In practice, this means that the Android engineering team typically focuses on a small number of “flagship” devices, and develops the next version of the Android software to support those product launches. These flagship devices absorb much of the product risk and blaze a trail for the broad OEM community, who follow up with many more devices that take advantage of the new features. In this way, we make sure that the Android platform evolves according to the actual needs of real-world devices.

How is the Android software developed?
Each platform version of Android (such as 1.5, 1.6, and so on) has a corresponding branch in the open-source tree. At any given moment, the most recent such branch will be considered the “current stable” branch version. This current stable branch is the one that manufacturers port to their devices. This branch is kept suitable for release at all times.
Simultaneously, there is also a “current experimental” branch, which is where speculative contributions, such as large next-generation features, are developed. Bug fixes and other contributions can be included in the current stable branch from the experimental branch as appropriate.
Finally, Google works on the next version of the Android platform in tandem with developing a flagship device. This branch pulls in changes from the experimental and stable branches as appropriate.
You can find more information on this topic at our Branches and Releases.

Why are parts of Android developed in private?
It typically takes over a year to bring a device to market, but of course device manufacturers want to ship the latest software they can. Developers, meanwhile, don’t want to have to constantly track new versions of the platform when writing apps. Both groups experience a tension between shipping products, and not wanting to fall behind.
To address this, some parts of the next version of Android including the core platform APIs are developed in a private branch. These APIs constitute the next version of Android. Our aim is to focus attention on the current stable version of the Android source code, while we create the next version of the platform as driven by flagship Android devices. This allows developers and OEMs to focus on a single version without having to track unfinished future work just to keep up. Other parts of the Android system that aren’t related to application compatibility are developed in the open, however. It’s our intention to move more of these parts to open development over time.

When are source code releases made?
When they are ready. Some parts of Android are developed in the open, so that source code is always available. Other parts are developed first in a private tree, and that source code is released when the next platform version is ready.
In some releases, core platform APIs will be ready far enough in advance that we can push the source code out for an early look in advance of the device’s release; however in others, this isn’t possible. In all cases, we release the platform source when we feel the version has stabilized enough, and when the development process permits. Releasing the source code is a fairly complex process.

What is involved in releasing the source code for a new Android version?
Releasing the source code for a new version of the Android platform is a significant process. First, the software gets built into a system image for a device, and put through various forms of certification, including government regulatory certification for the regions the phones will be deployed. It also goes through operator testing. This is an important phase of the process, since it helps shake out a lot of software bugs.
Once the release is approved by the regulators and operators, the manufacturer begins mass producing devices, and we turn to releasing the source code.
Simultaneous to mass production the Google team kicks off several efforts to prepare the open source release. These efforts include final API changes and documentation (to reflect any changes that were made during qualification testing, for example), preparing an SDK for the new version, and launching the platform compatibility information.
Also included is a final legal sign-off to release the code into open source. Just as open source contributors are required to sign a Contributors License Agreement attesting to their IP ownership of their contribution, Google too must verify that it is clear to make contributions.
Starting at the time mass production begins, the software release process usually takes around a month, which often roughly places source code releases around the same time that the devices reach users.

How does the AOSP relate to the Android Compatibility Program?
The Android Open-Source Project maintains the Android software, and develops new versions. Since it’s open-source, this software can be used for any purpose, including to ship devices that are not compatible with other devices based on the same source.
The function of the Android Compatibility Program is to define a baseline implementation of Android that is compatible with third-party apps written by developers. Devices that are “Android compatible” may participate in the Android ecosystem, including Android Market; devices that don’t meet the compatibility requirements exist outside that ecosystem.
In other words, the Android Compatibility Program is how we separate “Android compatible devices” from devices that merely run derivatives of the source code. We welcome all uses of the Android source code, but only Android compatible devices — as defined and tested by the Android Compatibility Program — may participate in the Android ecosystem.

How can I contribute to Android?
There are a number of ways you can contribute to Android. You can report bugs, write apps for Android, or contribute source code to the Android Open-Source Project.
There are some limits on the kinds of code contributions we are willing or able to accept. For instance, someone might want to contribute an alternative application API, such as a full C++-based environment. We would decline that contribution, since Android is focused on applications that run in the Dalvik VM. Alternatively, we won’t accept contributions such as GPL or LGPL libraries that are incompatible with our licensing goals.
We encourage those interested in contributing source code to contact us via the AOSP Community page prior to beginning any work. You can find more information on this topic at the Getting Involved page.

How do I become an Android committer?
The Android Open Source Project doesn’t really have a notion of a “committer”. All contributions — including those authored by Google employees — go through a web-based system known as “gerrit” that’s part of the Android engineering process. This system works in tandem with the git source code management system to cleanly manage source code contributions.
Once submitted, changes need to be accepted by a designated Approver. Approvers are typically Google employees, but the same approvers are responsible for all submissions, regardless of origin.
You can find more information on this topic at the Submitting Patches page.

Compatibility

What does “compatibility” mean?
We define an “Android compatible” device as one that can run any application written by third-party developers using the Android SDK and NDK. We use this as a filter to separate devices that can participate in the Android app ecosystem, and those that cannot. Devices that are properly compatible can seek approval to use the Android trademark. Devices that are not compatible are merely derived from the Android source code and may not use the Android trademark.
In other words, compatibility is a prerequisite to participate in the Android apps ecosystem. Anyone is welcome to use the Android source code, but if the device isn’t compatible, it’s not considered part of the Android ecosystem.

What is the role of Android Market in compatibility?
Devices that are Android compatible may seek to license the Android Market client software. This allows them to become part of the Android app ecosystem, by allowing users to download developers’ apps from a catalog shared by all compatible devices. This option isn’t available to devices that aren’t compatible.
What kinds of devices can be Android compatible?
The Android software can be ported to a lot of different kinds of devices, including some on which third-party apps won’t run properly. The Android Compatibility Definition Document (CDD) spells out the specific device configurations that will be considered compatible.
For example, though the Android source code could be ported to run on a phone that doesn’t have a camera, the CDD requires that in order to be compatible, all phones must have a camera. This allows developers to rely on a consistent set of capabilities when writing their apps.
The CDD will evolve over time to reflect market realities. For instance, the 1.6 CDD only allows cell phones, but the 2.1 CDD allows devices to omit telephony hardware, allowing for non-phone devices such as tablet-style music players to be compatible. As we make these changes, we will also augment Android Market to allow developers to retain control over where their apps are available. To continue the telephony example, an app that manages SMS text messages would not be useful on a media player, so Android Market allows the developer to restrict that app exclusively to phone devices.
If my device is compatible, does it automatically have access to Android Market and branding?
Android Market is a service operated by Google. Achieving compatibility is a prerequisite for obtaining access to the Android Market software and branding. Device manufacturers should contact Google to obtain access to Android Market.

If I am not a manufacturer, how can I get Android Market?
Android Market is only licensed to handset manufacturers shipping devices. For questions about specific cases, contact android-partnerships@google.com.

How can I get access to the Google apps for Android, such as Maps?
The Google apps for Android, such as YouTube, Google Maps and Navigation, Gmail, and so on are Google properties that are not part of Android, and are licensed separately. Contact android-partnerships@google.com for inquiries related to those apps.

Is compatibility mandatory?
No. The Android Compatibility Program is optional. Since the Android source code is open, anyone can use it to build any kind of device. However, if a manufacturer wishes to use the Android name with their product, or wants access to Android Market, they must first demonstrate that the device is compatible.

How much does compatibility certification cost?
There is no cost to obtain Android compatibility for a device. The Compatibility Test Suite is open-source and available to anyone to use to test a device.

How long does compatibility take?
The process is automated. The Compatibility Test Suite generates a report that can be provided to Google to verify compatibility. Eventually we intend to provide self-service tools to upload these reports to a public database.

Who determines what will be part of the compatibility definition?
Since Google is responsible for the overall direction of Android as a platform and product, Google maintains the Compatibility Definition Document for each release. We draft the CDD for a new Android version in consultation with a number of OEMs, who provide input on its contents.

How long will each Android version be supported for new devices?
Since Android’s code is open-source, we can’t prevent someone from using an old version to launch a device. Instead, Google chooses not to license the Android Market client software for use on versions that are considered obsolete. This allows anyone to continue to ship old versions of Android, but those devices won’t use the Android name and will exist outside the Android apps ecosystem, just as if they were non-compatible.
Can a device have a different user interface and still be compatible?
The Android Compatibility Program focuses on whether a device can run third-party applications. The user interface components shipped with a device (such as home screen, dialer, color scheme, and so on) does not generally have much effect on third-party apps. As such, device builders are free to customize the user interface as much as they like. The Compatibility Definition Document does restrict the degree to which OEMs may alter the system user interface for areas that do impact third-party apps.

When are compatibility definitions released for new Android versions?
Our goal is to release new versions of Android Compatibility Definition Documents (CDDs) once the corresponding Android platform version has converged enough to permit it. While we can’t release a final draft of a CDD for an Android software version before the first flagship device ships with that software, final CDDs will always be released after the first device. However, wherever practical we will make draft versions of CDDs available.

How are device manufacturers’ compatibility claims validated?
There is no validation process for Android device compatibility. However, if the device is to include Android Market, Google will typically validate the device for compatibility before agreeing to license the Market client software.

What happens if a device that claims compatibility is later found to have compatibility problems?
Typically, Google’s relationships with Android Market licensees allow us to ask them to release updated system images that fix the problems.

Compatibility Test Suite

What is the purpose of the CTS?
The Compatibility Test Suite is a tool used by device manufacturers to help ensure their devices are compatible, and to report test results for validations. The CTS is intended to be run frequently by OEMs throughout the engineering process to catch compatibility issues early.

What kinds of things does the CTS test?
The CTS currently tests that all of the supported Android strong-typed APIs are present and behave correctly. It also tests other non-API system behaviors such as application lifecycle and performance. We plan to add support in future CTS versions to test “soft” APIs such as Intents as well.

Will the CTS reports be made public?
Yes. While not currently implemented, Google intends to provide web-based self-service tools for OEMs to publish CTS reports so that they can be viewed by anyone. CTS reports can be shared as widely as manufacturers prefer.

How is the CTS licensed?
The CTS is licensed under the same Apache Software License 2.0 that the bulk of Android uses.

Does the CTS accept contributions?
Yes please! The Android Open-Source Project accepts contributions to improve the CTS in the same way as for any other component. In fact, improving the coverage and quality of the CTS test cases is one of the best ways to help out Android.

Can anyone use the CTS on existing devices?
The Compatibility Definition Document requires that compatible devices implement the ‘adb’ debugging utility. This means that any compatible device — including ones available at retail — must be able to run the CTS tests.

Some Tough question Remember that the GUI layer doesn't request data directly from the web; data is always loaded from a local database.
The service layer periodically updates the local database.

What is the risk in blocking the Main thread when performing a lengthy operation such as web access or heavy computation? Application_Not_Responding exception will be thrown which will crash and restart the application.

Why is List View not recommended to have active components? Clicking on the active text box will pop up the software keyboard but this will resize the list, removing focus from the clicked element.

For senior employees

Beyond a certain level of experience, the job interview questions cease to be "difference between abstract class and interface", and focus more on testing your technical acumen, collaboration and communication skills. A list of such questions, typically asked during interviews for senior positions is given below:

Explain the life cycle of an application development process you worked on previously.

What the interviewer looks for is communication of requirements, planning, modeling, construction and deployment on the back end.

Here's a hypothetical project. Explain how you would go about it.

They want to know how you would break your work down into tasks and how many weeks for each task. I'm really looking to find out about planning methods, their skill set and how quickly they can execute.

How do you respond to requirement changes in the middle of a cycle?

What type of methodology have you used in the past? What are its drawbacks?

What are different techniques for prototyping an application?

Similar question: Do you feel there is value in wireframing an application? Why?

How do you manage conflicts in Web applications when there are different people managing data?

Tell me something you learned from a team member in the last year.

What software testing procedures have you used to perform a QA?

Once the coding skills verified. Sample I

· The Activity life cycle is must. Ask about the different phases of Activity Life cycle. For example: when and how the activity comes to foreground?

· Check the knowledge on AndroidManifest file, For example: Why do we need this file, What is the role of this file in Android app development.

· Different Kinds of Intents

· Ask about different Kinds of context

· Ask about different Storage Methods in android

· Kinds of Log debugger and Debugger Configuration

· How to debug the application on real device.

· How do you ensure that the app design will be consistent across the different screen resolutions

· Thread concepts also plus points as we deal with the treads more.

· Can you able to build custom views and how?

· How to create flexible layouts, For example to place English, Chinese fonts.

· What is localization and how to achieve?

· What are 9-patch images

· How to avoid ANR status

· How to do Memory management

· Ask about IPC

· What is onCreate(Bundle savedInstanceState), Have you used savedInstanceState when and why?

· To check how updated the person is just ask about what are Fragments in an Activity

If this is an Android specific job, just ask the obvious stuff. Sample II

Application lifecycle

When to use a service

How to use a broadcast receiver and register it both in the manifest and in code

Intent filters

Stuff about what manifest attributes and tags mean

The types of flags to run an application

FLAG_ACTIVITY_NEW_TASK
FLAG_ACTIVITY_CLEAR_TOP
etc

How to do data intensive calculations using threads

Passing large objects (that can't be passed via intents and shouldn't be serialized) via a service

Binding to a service and the service lifecycle

How to persist data (both savedInstanceState and more permanent ways)

Just go through http://developer.android.com/guide/topics/fundamentals.html and see what sounds like it's important. Hopefully you're an android developer and know what all those things are, otherwise you're just waiting your interviewee's time =P

Display height and width

2012-11-21T14:53:00.002+05:30

DisplayMetrics metrics = new DisplayMetrics();
((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int width = metrics.widthPixels;

How to Add Smiley/Emojis in Edittext?

2012-11-15T17:04:00.000+05:30

How to Add Smiley/Emojis in Edittext?

Emoji.java :-

package com.android.emoji;

import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.text.Html;
import android.text.Html.ImageGetter;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class Emoji extends Activity implements OnClickListener {
    EditText edttxtemoji;
    Button btnsubmit, btnselectemoji;
    TextView txtviewdisplay;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        edttxtemoji = (EditText) findViewById(R.id.edttxtemoji);
        btnsubmit = (Button) findViewById(R.id.btnok);
        btnsubmit.setOnClickListener(this);
        btnselectemoji = (Button) findViewById(R.id.btnselect);
        btnselectemoji.setOnClickListener(this);
        txtviewdisplay = (TextView) findViewById(R.id.txtviewdisplay);
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
        if (v == btnsubmit) {
            txtviewdisplay.setText(edttxtemoji.getText());
        } else if (v == btnselectemoji) {
            Intent in = new Intent(this, Select_Emoji_Activity.class);
            startActivity(in);
        }
    }

    CharSequence cs;
    Custom_List_Emoji cstlistemoji;
    int index;

    @Override
    protected void onRestart() {
        // TODO Auto-generated method stub
        super.onRestart();

        cstlistemoji = new Custom_List_Emoji(this);
        @SuppressWarnings("static-access")
        SharedPreferences myPrefs = this.getSharedPreferences("myPrefs",
                this.MODE_WORLD_READABLE);
        index = myPrefs.getInt("key1", 0);
        System.out.println("Pref Data index is:- " + index);
        ImageGetter imageGetter = new ImageGetter() {
            public Drawable getDrawable(String source) {
                Drawable d = getResources().getDrawable(
                        cstlistemoji.images[index]);
                d.setBounds(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight());
                return d;
            }
        };
        cs = Html.fromHtml(
                "<img src='"
                        + getResources()
                                .getDrawable(cstlistemoji.images[index])
                        + "'/>", imageGetter, null);
        System.out.println("cs is:- " + cs);
        edttxtemoji.setText(cs);
    }
}

Select_Emoji_Activity.java :-

package com.android.emoji;

import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;

public class Select_Emoji_Activity extends Activity implements OnItemClickListener{
    ListView lstviewemojis;
    Custom_List_Emoji cstlistemoji;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.emojis);
        lstviewemojis=(ListView)findViewById(R.id.lstviewemojis);
        lstviewemojis.setOnItemClickListener(this);
        cstlistemoji=new Custom_List_Emoji(this);
        lstviewemojis.setAdapter(cstlistemoji);
    }
    @Override
    public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
        // TODO Auto-generated method stub
        SharedPreferences myPrefs = this.getSharedPreferences("myPrefs", MODE_WORLD_READABLE);
        SharedPreferences.Editor prefsEditor = myPrefs.edit();
        System.out.println("Emoji is:- " +arg2);
        prefsEditor.putInt("key1", arg2);
        prefsEditor.commit();
        finish();
    }
}

Custom_List_Emoji :-

package com.android.emoji;

import android.app.Activity;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class Custom_List_Emoji extends BaseAdapter {

    public Activity context;
    public LayoutInflater inflater;

    public Custom_List_Emoji(Activity context) {
        // TODO Auto-generated constructor stub
        this.context = context;
        this.inflater = (LayoutInflater) context
                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    }

    @Override
    public int getCount() {
        // TODO Auto-generated method stub
        return emojis.length;
    }

    @Override
    public Object getItem(int position) {
        // TODO Auto-generated method stub
        String temp = emojis[position];
        return temp;
    }

    @Override
    public long getItemId(int position) {
        // TODO Auto-generated method stub
        return 0;
    }

    TextView txtview1;
    ImageView image;

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        if (convertView == null) {
            convertView = inflater.inflate(R.layout.custom_emojis, null);
            txtview1 = (TextView) convertView.findViewById(R.id.txtviewemojis);
            image = (ImageView) convertView.findViewById(R.id.imgviewemoji);
        }

        image.setImageResource(images[position]);
        txtview1.setText(emojis[position]);
        return convertView;
    }

    public final int[] images = new int[] { R.drawable.emo_im_happy,
            R.drawable.emo_im_sad, R.drawable.emo_im_winking,
            R.drawable.emo_im_tongue_sticking_out, R.drawable.emo_im_surprised,
            R.drawable.emo_im_kissing, R.drawable.emo_im_yelling,
            R.drawable.emo_im_cool, R.drawable.emo_im_money_mouth,
            R.drawable.emo_im_foot_in_mouth, R.drawable.emo_im_embarrassed,
            R.drawable.emo_im_angel, R.drawable.emo_im_undecided,
            R.drawable.emo_im_crying, R.drawable.emo_im_lips_are_sealed,
            R.drawable.emo_im_laughing, R.drawable.emo_im_wtf };
    public final String[] _strEmoticonLabels = new String[] { "Happy", "Sad",
            "Winking", "Tongue sticking out", "Surprised", "Kissing",
            "Yelling", "Cool", "Money Mouth", "Foot in mouth", "Embarrased",
            "Angel", "Undecided", "Crying", "Lips are sealed", "Laughing",
            "Confused" };
    public final String[] emojis = new String[] { ":-)", ":-(", ";-)", ":-P",
            "=-O", ":-*", ":O", "B-)", ":-$", ":-!", ":-[", "O:-)", ":-\\",
            ":'(", ":-X", ":-D", "o_O" };

}

Main.xml :-

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent">
    <TextView android:layout_width="wrap_content" android:text="Dipak"
        android:layout_height="wrap_content" android:id="@+id/txtviewdisplay" />
    <EditText android:layout_width="fill_parent" android:layout_below="@+id/txtviewdisplay"
        android:layout_height="wrap_content" android:id="@+id/edttxtemoji" />
    <Button android:layout_width="wrap_content" android:layout_below="@+id/edttxtemoji"
        android:layout_height="wrap_content" android:id="@+id/btnok"
        android:text="Submit" />
    <Button android:layout_width="wrap_content" android:layout_below="@+id/edttxtemoji"
        android:layout_height="wrap_content" android:id="@+id/btnselect"
        android:text="select Emojis" android:layout_toRightOf="@+id/btnok"/>
</RelativeLayout>

emojis.xml :-

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent">
    <ListView android:layout_width="fill_parent"
        android:layout_height="wrap_content" android:id="@+id/lstviewemojis" />
</RelativeLayout>

custom_emojis.xml :-

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent">
    <RelativeLayout android:layout_width="fill_parent"
        android:layout_height="wrap_content" android:id="@+id/mRlayout1">
        <ImageView android:layout_width="wrap_content" android:id="@+id/imgviewemoji"
            android:layout_height="wrap_content" android:src="@drawable/icon"
            android:layout_centerVertical="true" android:layout_alignParentLeft="true"
            android:layout_marginLeft="10dip" />
        <TextView android:layout_width="wrap_content"
            android:layout_centerVertical="true" android:layout_marginRight="10dip"
            android:layout_height="wrap_content" android:text="Emoji"
            android:layout_alignParentRight="true" android:id="@+id/txtviewemojis" />
    </RelativeLayout>
</RelativeLayout>

Displaying Chart On Android

2012-10-31T12:47:00.001+05:30

In this tutorial, we are going to learn, how to display chart or bar graphs on android for your statistical data.

To begin with the tutorial, lets create new project.

FILE–>NEW–>Android Project

Now right click on the project in Package explorer and go to Properties.

Properties–>Java Build Path–>Libraries–>Add external JARs..

Once your API is linked, you are ready now for coding your program. Here is the link where from you can download the API http://www.kidroid.com/kichart/

Now lets code the program. This is the complete code of android chart sample.

package com.google.android.chartView;
import com.kidroid.kichart.model.Aitem;

import com.kidroid.kichart.view.LineView;

import android.app.Activity;

import android.graphics.Color;

import android.os.Bundle;
public class chartView extends Activity {

/** Called when the activity is first created. */

LineView lv;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

String xaxis[]=new String[4];

xaxis[0]=”2006″;

xaxis[1]=”2007″;

xaxis[2]=”2008″;

xaxis[3]=”2009″;

float line1[]=new float[4];

line1[0]=120;

line1[1]=240;

line1[2]=500;

line1[3]=100;

float line2[]=new float[4];

line2[0]=100;

line2[1]=650;

line2[2]=700;

line2[3]=300;

float line3[]=new float[4];

line3[0]=50;

line3[1]=180;

line3[2]=360;

line3[3]=900;

Aitem items[]=new Aitem[3];

items[0]= new Aitem(Color.BLUE,”pauOut”,line1);

items[1]= new Aitem(Color.GREEN,”pauOut”,line2);

items[2]= new Aitem(Color.YELLOW,”pauOut”,line3);

lv=new LineView(this);

lv.setTitle(“Yearly Budget”);

lv.setAxisValueX(xaxis);

lv.setItems(items);

setContentView(lv);

}

here is the final view of the chart module. After this demo, you should get stuff like this.

Shake Animation Example

2012-10-26T15:17:00.002+05:30

This example let you shake or animation your view on some event described.

Algorithm:

1.) Create a new project by File-> New -> Android Project name it ShakeAnimationExample.

2.) You will see some default code into your main.xml, strings.xml and android manifest file.

3.) Write following into main.xml file:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:padding="10dip"

    android:layout_width="fill_parent"

    android:layout_height="wrap_content">

    <TextView

        android:layout_width="fill_parent"

        android:layout_height="wrap_content"

        android:layout_marginBottom="10dip"

        android:text="Please enter your password:"

    />

    <EditText android:id="@+id/pw"

        android:layout_width="fill_parent"

        android:layout_height="wrap_content"

        android:clickable="true"

        android:singleLine="true"

        android:password="true"

    />

    <Button android:id="@+id/login"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="Login"

    />

</LinearLayout>

4.) Create and Write following into anim/shake.xml:

1

2

3

<translate xmlns:android="http://schemas.android.com/apk/res/android"

    android:fromXDelta="0" android:toXDelta="10" android:duration="1000"

    android:interpolator="@anim/cycle_7" />

5.) Create and Write following into anim/cycle_7.xml:

1	`<cycleInterpolator` `xmlns:android="http://schemas.android.com/apk/res/android"` `android:cycles="7"` `/>`

Steps:

1.) Create a project named ShakeAnimationExample and set the information as stated in the image.

Build Target: Android 1.6
Application Name: ShakeAnimationExample
Package Name: com.example. ShakeAnimation
Activity Name: ShakeAnimationExample
Min SDK Version: 4

2.) Open ShakeAnimationExample.java file and write following code there:

package com.example.ShakeAnimation;

import android.app.Activity;

import android.os.Bundle;

import android.view.View;

import android.view.animation.Animation;

import android.view.animation.AnimationUtils;

import android.widget.Toast;

public class ShakeAnimation extends Activity implements View.OnClickListener {

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        View loginButton = findViewById(R.id.login);

        loginButton.setOnClickListener(this);

    }

    public void onClick(View v) {

        Animation shake = AnimationUtils.loadAnimation(this, R.anim.shake);

        findViewById(R.id.pw).startAnimation(shake);

        Toast.makeText(this, "Wrong Password", Toast.LENGTH_SHORT).show();

    }

}

3.) Compile and build the project.

4.) Run on 1.6 simulator for the output.

Custom Expandable List Example

2012-10-26T15:15:00.001+05:30

Description:
This example shows how to create Expandable list using custom adapter.
Algorithm:

1.) Create a new project by File-> New -> Android Project name it CustomExpandableListExample.
2.) Run for output.

Steps:
1.) Create a project named CustomExpandableListExample and set the information as stated in the image.

Build Target: Android 2.3.3
Application Name: CustomExpandableListExample
Package Name: com.example
Activity Name: CustomExpandableListExampleActivity
Min SDK Version: 10

2.) Open CustomExpandableListExampleActivity.java file and write following code there:

package com.example;

import android.app.ExpandableListActivity;

import android.os.Bundle;

import android.view.ContextMenu;

import android.view.ContextMenu.ContextMenuInfo;

import android.view.Gravity;

import android.view.MenuItem;

import android.view.View;

import android.view.ViewGroup;

import android.widget.AbsListView;

import android.widget.BaseExpandableListAdapter;

import android.widget.ExpandableListAdapter;

import android.widget.ExpandableListView;

import android.widget.ExpandableListView.ExpandableListContextMenuInfo;

import android.widget.TextView;

import android.widget.Toast;

public class CustomExpandableListExampleActivity extends ExpandableListActivity {

    ExpandableListAdapter mAdapter;

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // Set up our adapter

        mAdapter = new MyExpandableListAdapter();

        setListAdapter(mAdapter);

        registerForContextMenu(getExpandableListView());

    }

    @Override

    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {

        menu.setHeaderTitle("Sample menu");

        menu.add(0, 0, 0, "Sample action");

    }

    @Override

    public boolean onContextItemSelected(MenuItem item) {

        ExpandableListContextMenuInfo info = (ExpandableListContextMenuInfo) item.getMenuInfo();

        String title = ((TextView) info.targetView).getText().toString();

        int type = ExpandableListView.getPackedPositionType(info.packedPosition);

        if (type == ExpandableListView.PACKED_POSITION_TYPE_CHILD) {

            int groupPos = ExpandableListView.getPackedPositionGroup(info.packedPosition); 

            int childPos = ExpandableListView.getPackedPositionChild(info.packedPosition); 

            Toast.makeText(this, title + ": Child " + childPos + " clicked in group " + groupPos,

                    Toast.LENGTH_SHORT).show();

            return true;

        } else if (type == ExpandableListView.PACKED_POSITION_TYPE_GROUP) {

            int groupPos = ExpandableListView.getPackedPositionGroup(info.packedPosition); 

            Toast.makeText(this, title + ": Group " + groupPos + " clicked", Toast.LENGTH_SHORT).show();

            return true;

        }

        return false;

    }

    public class MyExpandableListAdapter extends BaseExpandableListAdapter {

        // Sample data set.  children[i] contains the children (String[]) for groups[i].

        private String[] groups = { "Names", "Designation", "Gender", "Company" };

        private String[][] children = {

                { "abc", "xyz", "ash", "anu" },

                { "SSE", "TJ", "PM", "SE" },

                { "Male", "Female" },

                { "yyyyyy", "xxxxx" }

        };

        public Object getChild(int groupPosition, int childPosition) {

            return children[groupPosition][childPosition];

        }

        public long getChildId(int groupPosition, int childPosition) {

            return childPosition;

        }

        public int getChildrenCount(int groupPosition) {

            return children[groupPosition].length;

        }

        public TextView getGenericView() {

            // Layout parameters for the ExpandableListView

            AbsListView.LayoutParams lp = new AbsListView.LayoutParams(

                    ViewGroup.LayoutParams.MATCH_PARENT, 64);

            TextView textView = new TextView(CustomExpandableListExampleActivity.this);

            textView.setLayoutParams(lp);

            // Center the text vertically

            textView.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT);

            // Set the text starting position

            textView.setPadding(36, 0, 0, 0);

            return textView;

        }

        public View getChildView(int groupPosition, int childPosition, boolean isLastChild,

                View convertView, ViewGroup parent) {

            TextView textView = getGenericView();

            textView.setText(getChild(groupPosition, childPosition).toString());

            return textView;

        }

        public Object getGroup(int groupPosition) {

            return groups[groupPosition];

        }

        public int getGroupCount() {

            return groups.length;

        }

        public long getGroupId(int groupPosition) {

            return groupPosition;

        }

        public View getGroupView(int groupPosition, boolean isExpanded, View convertView,

                ViewGroup parent) {

            TextView textView = getGenericView();

            textView.setText(getGroup(groupPosition).toString());

            return textView;

        }

        public boolean isChildSelectable(int groupPosition, int childPosition) {

            return true;

        }

        public boolean hasStableIds() {

            return true;

        }

    }

}

3.) Compile and build the project.

Output