Database creation using sqlite database

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DBController extends SQLiteOpenHelper {

/**
* Instantiates a new DB controller.
*/
public DBController(Context context) {
super(context, "xyz.db", null, 1);
}

// Creates Table
/*
* (non-Javadoc)
*
* @see
* android.database.sqlite.SQLiteOpenHelper#onCreate(android.database.sqlite
* .SQLiteDatabase)
*/
@Override
public void onCreate(SQLiteDatabase database) {
String query;
query = "CREATE TABLE cart (id INTEGER PRIMARY KEY AUTOINCREMENT,productId TEXT,productName TEXT,price TEXT,qty TEXT)";
database.execSQL(query);

database.execSQL(query);
}

/*
* (non-Javadoc)
*
* @see
* android.database.sqlite.SQLiteOpenHelper#onUpgrade(android.database.sqlite
* .SQLiteDatabase, int, int)
*/
@Override
public void onUpgrade(SQLiteDatabase database, int version_old,
int current_version) {
String query;
query = "DROP TABLE IF EXISTS cart";
database.execSQL(query);

onCreate(database);
}

/**
* Inserts User into SQLite DB.
*
* @param queryValues
*            the query values
*/
public void insertProductInCart(HashMap<String, String> queryValues) {

String productId = queryValues.get("productId");

if (!isProductExist(productId)) {
SQLiteDatabase database = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put("productId", productId);
values.put("productName", queryValues.get("product_name"));
values.put("price", queryValues.get("price"));
values.put("qty", queryValues.get("qty"));
database.insert("cart", null, values);
database.close();
} else {
int qty = 0;
String selectQuery = "SELECT qty FROM cart where productId='"
+ productId + "'";
SQLiteDatabase database = this.getWritableDatabase();
Cursor cursor = null;
try {
cursor = database.rawQuery(selectQuery, null);
if (cursor.moveToFirst()) {
do {
qty = Integer.parseInt(cursor.getString(0));
} while (cursor.moveToNext());
}
} finally {
if (cursor != null)
cursor.close();
}
qty = qty + 1;
String query = "update cart set qty='" + qty
+ "' where productId='" + productId + "'";
database.execSQL(query);

database.close();

}
}

public boolean isProductExist(String productId) {

boolean flag = false;
String selectQuery = "SELECT * FROM cart where productId='" + productId
+ "'";
SQLiteDatabase database = this.getReadableDatabase();
Cursor cursor = null;
try {
cursor = database.rawQuery(selectQuery, null);
if (cursor.moveToFirst()) {
do {
flag = true;
} while (cursor.moveToNext());
}
} finally {
if (cursor != null)
cursor.close();
}

database.close();

return flag;
}
}

Standard class for calling webservices

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URLEncoder;
import java.util.*;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;

enum RequestMethod
{
GET,
POST
}
public class RestClient {

    private ArrayList <NameValuePair> params;
    private ArrayList <NameValuePair> headers;

    private String url;

    private int responseCode;
    private String message;

    private String response;

    public String getResponse() {
        return response;
    }

    public String getErrorMessage() {
        return message;
    }

    public int getResponseCode() {
        return responseCode;
    }

    public RestClient(String url)
    {
        this.url = url;
        params = new ArrayList<NameValuePair>();
        headers = new ArrayList<NameValuePair>();
    }

    public void AddParam(String name, String value)
    {
        params.add(new BasicNameValuePair(name, value));
    }
   
    public void AddHeader(String name, String value)
    {
        headers.add(new BasicNameValuePair(name, value));
    }

    public void Execute(RequestMethod method) throws Exception
    {
        switch(method) {
            case GET:
            {
                //add parameters
                String combinedParams = "";
                if(!params.isEmpty()){
                    combinedParams += "?";
                    for(NameValuePair p : params)
                    {
                        String paramString = p.getName() + "=" + URLEncoder.encode(p.getValue(),"UTF-8");
                        if(combinedParams.length() > 1)
                        {
                            combinedParams  +=  "&" + paramString;
                        }
                        else
                        {
                            combinedParams += paramString;
                        }
                    }
                }

                HttpGet request = new HttpGet(url + combinedParams);

                //add headers
                for(NameValuePair h : headers)
                {
                    request.addHeader(h.getName(), h.getValue());
                }

                executeRequest(request, url);
                break;
            }
            case POST:
            {
                HttpPost request = new HttpPost(url);

                //add headers
                for(NameValuePair h : headers)
                {
                    request.addHeader(h.getName(), h.getValue());
                }

                if(!params.isEmpty()){
                    request.setEntity(new UrlEncodedFormEntity(params,HTTP.UTF_8));
                   
                }

                executeRequest(request, url);
                break;
            }
        }
    }

    private void executeRequest(HttpUriRequest request, String url)
    {
        HttpClient client = new DefaultHttpClient();

        HttpResponse httpResponse;

        try {
            httpResponse = client.execute(request);
            responseCode = httpResponse.getStatusLine().getStatusCode();
            message = httpResponse.getStatusLine().getReasonPhrase();

            HttpEntity entity = httpResponse.getEntity();

            if (entity != null) {

                InputStream instream = entity.getContent();
                response = convertStreamToString(instream);

                // Closing the input stream will trigger connection release
                instream.close();
            }

        } catch (ClientProtocolException e)  {
            client.getConnectionManager().shutdown();
            e.printStackTrace();
        } catch (IOException e) {
            client.getConnectionManager().shutdown();
            e.printStackTrace();
        }
    }

    private static String convertStreamToString(InputStream is) {

        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
}

Auto Detect Mobile SMS through Broadcast Receiver

BroadcastReceiver smsBroadCastReceiver = new BroadcastReceiver() {

final SmsManager sms = SmsManager.getDefault();

public void onReceive(Context context, Intent intent) {

// Retrieves a map of extended data from the intent.
final Bundle bundle = intent.getExtras();

try {

if (bundle != null) {

final Object[] pdusObj = (Object[]) bundle.get("pdus");

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

SmsMessage currentMessage = SmsMessage
.createFromPdu((byte[]) pdusObj[i]);
String phoneNumber = currentMessage
.getDisplayOriginatingAddress();

String senderNum = phoneNumber;
String message = currentMessage
.getDisplayMessageBody();

Log.i("SmsReceiver", "senderNum: " + senderNum
+ "; message: " + message);

String msg = message.split(":")[1].trim();

if (msg.equalsIgnoreCase(randomCode)) {

if (mobileNo != null) {
<Write code authentication service call>
}
}
/*
* // Show Alert int duration = Toast.LENGTH_LONG;
* Toast toast = Toast.makeText(context,
* "senderNum: "+ senderNum + ", message: " +
* message, duration); toast.show();
*/

} // end for loop
} // bundle is null

} catch (Exception e) {
Log.e("SmsReceiver", "Exception smsReceiver" + e);

}
}
};
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("android.provider.Telephony.SMS_RECEIVED");
registerReceiver(smsBroadCastReceiver, intentFilter);

What is SharedPreferences ?

Android provides many ways of storing data of an application. One of this way is called Shared Preferences. Shared Preferences allow you to save and retrieve data in the form of key,value pair.

In order to use shared preferences , you have to call a method getSharedPreferences() that returns a SharedPreference instance pointing to the file that contains the values of preferences.

SharedPreferences sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE); 

Editor editor = sharedpreferences.edit();

editor.putString("key", "value");

editor.commit();

GPS Tracker sample code

import android.app.AlertDialog;

import android.app.Service;

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.os.IBinder;

import android.provider.Settings;

import android.util.Log;

public class GPSTracking extends Service implements LocationListener {

    private final Context mContext;

    // flag for GPS status

    boolean isGPSEnabled = false;

    // flag for network status

    boolean isNetworkEnabled = false;

    // flag for GPS status

    boolean canGetLocation = false;

    Location location; // location

    double latitude; // latitude

    double longitude; // longitude

    // The minimum distance to change Updates in meters

    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters

    // The minimum time between updates in milliseconds

    private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute

    // Declaring a Location Manager

    protected LocationManager locationManager;

    public GPSTracking(Context context) {

        this.mContext = context;

        getLocation();

    }

    public Location getLocation() {

        try {

            locationManager = (LocationManager) mContext

                    .getSystemService(LOCATION_SERVICE);

            // getting GPS status

            isGPSEnabled = locationManager

                    .isProviderEnabled(LocationManager.GPS_PROVIDER);

            // getting network status

            isNetworkEnabled = locationManager

                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            if (!isGPSEnabled && !isNetworkEnabled) {

                // no network provider is enabled

            } else {

                this.canGetLocation = true;

                // First get location from Network Provider

                if (isNetworkEnabled) {

                    locationManager.requestLocationUpdates(

                            LocationManager.NETWORK_PROVIDER,

                            MIN_TIME_BW_UPDATES,

                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                    Log.d("Network", "Network");

                    if (locationManager != null) {

                        location = locationManager

                                .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

                        if (location != null) {

                            latitude = location.getLatitude();

                            longitude = location.getLongitude();

                        }

                    }

                }

                // if GPS Enabled get lat/long using GPS Services

                if (isGPSEnabled) {

                    if (location == null) {

                        locationManager.requestLocationUpdates(

                                LocationManager.GPS_PROVIDER,

                                MIN_TIME_BW_UPDATES,

                                MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                        Log.d("GPS Enabled", "GPS Enabled");

                        if (locationManager != null) {

                            location = locationManager

                                    .getLastKnownLocation(LocationManager.GPS_PROVIDER);

                            if (location != null) {

                                latitude = location.getLatitude();

                                longitude = location.getLongitude();

                            }

                        }

                    }

                }

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return location;

    }

     

    /**

     * Stop using GPS listener

     * Calling this function will stop using GPS in your app

     * */

    public void stopUsingGPS(){

        if(locationManager != null){

            locationManager.removeUpdates(GPSTracker.this);

        }      

    }

     

    /**

     * Function to get latitude

     * */

    public double getLatitude(){

        if(location != null){

            latitude = location.getLatitude();

        }

         

        // return latitude

        return latitude;

    }

     

    /**

     * Function to get longitude

     * */

    public double getLongitude(){

        if(location != null){

            longitude = location.getLongitude();

        }

         

        // return longitude

        return longitude;

    }

     

    /**

     * Function to check GPS/wifi enabled

     * @return boolean

     * */

    public boolean canGetLocation() {

        return this.canGetLocation;

    }

     

    /**

     * Function to show settings alert dialog

     * On pressing Settings button will lauch Settings Options

     * */

    public void showSettingsAlert(){

        AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);

      

        // Setting Dialog Title

        alertDialog.setTitle("GPS is settings");

  

        // Setting Dialog Message

        alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu?");

  

        // On pressing Settings button

        alertDialog.setPositiveButton("Settings", new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog,int which) {

                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);

                mContext.startActivity(intent);

            }

        });

  

        // on pressing cancel button

        alertDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {

            public void onClick(DialogInterface dialog, int which) {

            dialog.cancel();

            }

        });

  

        // Showing Alert Message

        alertDialog.show();

    }

    @Override

    public void onLocationChanged(Location location) {

    }

    @Override

    public void onProviderDisabled(String provider) {

    }

    @Override

    public void onProviderEnabled(String provider) {

    }

    @Override

    public void onStatusChanged(String provider, int status, Bundle extras) {

    }

    @Override

    public IBinder onBind(Intent arg0) {

        return null;

    }

}


Follow below steps for implementation of that code in your own code.

1. Check GPS is enabled or not :

GPSTracking gps = new GPSTracking(this);
if(gps.canGetLocation()){

}

2. Get lat, lng of current location :

gps.getLatitude();
gps.getLongitude();