Android Mobile Application Development: Android Content Provider / Preferences/Sqlite db (CURD)/ Feed Example

In this Given Example there is a scope to learn about lot of things like RSSfeeds + content providers +Sqlit db executions+ shared preferences + the perfect object orientation with Java.

i learnt this example from the popular android book Professional Android by Reto Meier, i picked this example from the same book as well and there is no great modification is there. please make an Android project and copy the following given code there

1) src/com/jitesh/earthquake/Earthquake.java (Main activity class)

package com.jitesh.earthquake;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.location.Location;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.View;
import android.view.MenuItem;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.AdapterView.OnItemClickListener;

public class Earthquake extends Activity {

static final private int MENU_UPDATE = Menu.FIRST;
static final private int MENU_PREFERENCES = Menu.FIRST+1;
static final private int QUAKE_DIALOG = 1;
private static final int SHOW_PREFERENCES = 1;

ListView earthquakeListView;
ArrayAdapter<Quake> aa;
ArrayList<Quake> earthquakes = new ArrayList<Quake>();

Quake selectedQuake;

int minimumMagnitude = 0;
boolean autoUpdate = false;
int updateFreq = 0;

@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);

earthquakeListView = (ListView)this.findViewById(R.id.earthquakeListView);

earthquakeListView.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView _av, View _v, int _index, long arg3) {
selectedQuake = earthquakes.get(_index);
showDialog(QUAKE_DIALOG);
}
});

int layoutID = android.R.layout.simple_list_item_1;
aa = new ArrayAdapter<Quake>(this, layoutID , earthquakes);
earthquakeListView.setAdapter(aa);

loadQuakesFromProvider();

updateFromPreferences();
refreshEarthquakes();
}

private void refreshEarthquakes() {
// Get the XML
URL url;
try {
String quakeFeed = getString(R.string.quake_feed);
url = new URL(quakeFeed);

URLConnection connection;
connection = url.openConnection();

HttpURLConnection httpConnection = (HttpURLConnection)connection;
int responseCode = httpConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {
InputStream in = httpConnection.getInputStream();

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();

// Parse the earthquake feed.
Document dom = db.parse(in);
Element docEle = dom.getDocumentElement();

// Clear the old earthquakes
earthquakes.clear();
loadQuakesFromProvider();

// Get a list of each earthquake entry.
NodeList nl = docEle.getElementsByTagName("entry");
if (nl != null && nl.getLength() > 0) {
for (int i = 0 ; i < nl.getLength(); i++) {
Element entry = (Element)nl.item(i);
Element title = (Element)entry.getElementsByTagName("title").item(0);
Element g = (Element)entry.getElementsByTagName("georss:point").item(0);
Element when = (Element)entry.getElementsByTagName("updated").item(0);
Element link = (Element)entry.getElementsByTagName("link").item(0);

String details = title.getFirstChild().getNodeValue();
String hostname = "http://earthquake.usgs.gov";
String linkString = hostname + link.getAttribute("href");

String point = g.getFirstChild().getNodeValue();
String dt = when.getFirstChild().getNodeValue();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");
Date qdate = new GregorianCalendar(0,0,0).getTime();
try {
qdate = sdf.parse(dt);
} catch (ParseException e) {
e.printStackTrace();
}

String[] location = point.split(" ");
Location l = new Location("dummyGPS");
l.setLatitude(Double.parseDouble(location[0]));
l.setLongitude(Double.parseDouble(location[1]));

String magnitudeString = details.split(" ")[1];
int end = magnitudeString.length()-1;
double magnitude = Double.parseDouble(magnitudeString.substring(0, end));

details = details.split(",")[1].trim();

Quake quake = new Quake(qdate, details, l, magnitude, linkString);

// Process a newly found earthquake
addNewQuake(quake);
}
}
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
}
finally {
}
}

private void addNewQuake(Quake _quake) {
ContentResolver cr = getContentResolver();
// Construct a where clause to make sure we donÕt already have this
// earthquake in the provider.
String w = EarthquakeProvider.KEY_DATE + " = " + _quake.getDate().getTime();

// If the earthquake is new, insert it into the provider.
if (cr.query(EarthquakeProvider.CONTENT_URI, null, w, null, null).getCount()==0){
ContentValues values = new ContentValues();

values.put(EarthquakeProvider.KEY_DATE, _quake.getDate().getTime());
values.put(EarthquakeProvider.KEY_DETAILS, _quake.getDetails());

double lat = _quake.getLocation().getLatitude();
double lng = _quake.getLocation().getLongitude();
values.put(EarthquakeProvider.KEY_LOCATION_LAT, lat);
values.put(EarthquakeProvider.KEY_LOCATION_LNG, lng);
values.put(EarthquakeProvider.KEY_LINK, _quake.getLink());
values.put(EarthquakeProvider.KEY_MAGNITUDE, _quake.getMagnitude());

cr.insert(EarthquakeProvider.CONTENT_URI, values);
earthquakes.add(_quake);

addQuakeToArray(_quake);
}
}

private void addQuakeToArray(Quake _quake) {
if (_quake.getMagnitude() > minimumMagnitude) {
// Add the new quake to our list of earthquakes.
earthquakes.add(_quake);

// Notify the array adapter of a change.
aa.notifyDataSetChanged();
}
}

private void loadQuakesFromProvider() {
// Clear the existing earthquake array
earthquakes.clear();

ContentResolver cr = getContentResolver();

// Return all the saved earthquakes
Cursor c = cr.query(EarthquakeProvider.CONTENT_URI, null, null, null, null);

if (c.moveToFirst()) {
do {
// Extract the quake details.
Long datems = c.getLong(EarthquakeProvider.DATE_COLUMN);
String details = c.getString(EarthquakeProvider.DETAILS_COLUMN);
Float lat = c.getFloat(EarthquakeProvider.LATITUDE_COLUMN);
Float lng = c.getFloat(EarthquakeProvider.LONGITUDE_COLUMN);
Double mag = c.getDouble(EarthquakeProvider.MAGNITUDE_COLUMN);
String link = c.getString(EarthquakeProvider.LINK_COLUMN);

Location location = new Location("dummy");
location.setLongitude(lng);
location.setLatitude(lat);

Date date = new Date(datems);

Quake q = new Quake(date, details, location, mag, link);
addQuakeToArray(q);
} while(c.moveToNext());
}
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);

menu.add(0, MENU_UPDATE, Menu.NONE, R.string.menu_update);
menu.add(0, MENU_PREFERENCES, Menu.NONE, R.string.menu_preferences);

return true;
}

public boolean onOptionsItemSelected(MenuItem item) {
super.onOptionsItemSelected(item);

switch (item.getItemId()) {
case (MENU_UPDATE): {
refreshEarthquakes();
return true;
}
case (MENU_PREFERENCES): {
Intent i = new Intent(this, Preferences.class);
startActivityForResult(i, SHOW_PREFERENCES);
return true;
}
}
return false;
}

@Override
public Dialog onCreateDialog(int id) {
switch(id) {
case (QUAKE_DIALOG) :
LayoutInflater li = LayoutInflater.from(this);
View quakeDetailsView = li.inflate(R.layout.quake_details, null);

AlertDialog.Builder quakeDialog = new AlertDialog.Builder(this);
quakeDialog.setTitle("Quake Time");
quakeDialog.setView(quakeDetailsView);
return quakeDialog.create();
}
return null;
}

@Override
public void onPrepareDialog(int id, Dialog dialog) {
switch(id) {
case (QUAKE_DIALOG) :
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
String dateString = sdf.format(selectedQuake.getDate());
String quakeText = "Magnitude " + selectedQuake.getMagnitude() +
"\n" + selectedQuake.getDetails() + "\n" +
selectedQuake.getLink();

AlertDialog quakeDialog = (AlertDialog)dialog;
quakeDialog.setTitle(dateString);
TextView tv = (TextView)quakeDialog.findViewById(R.id.quakeDetailsTextView);
tv.setText(quakeText);

break;
}
}

private void updateFromPreferences() {
Context context = getApplicationContext();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);

minimumMagnitude = Integer.parseInt(prefs.getString(Preferences.PREF_MIN_MAG, "0"));
updateFreq = Integer.parseInt(prefs.getString(Preferences.PREF_UPDATE_FREQ, "0"));
autoUpdate = prefs.getBoolean(Preferences.PREF_AUTO_UPDATE, false);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);

if (requestCode == SHOW_PREFERENCES)
if (resultCode == Activity.RESULT_OK) {
updateFromPreferences();
refreshEarthquakes();
}
}
}

2) src/com/jitesh/earthquake/EarthquakeProvider.java (Content Provider)

package com.jitesh.earthquake;

import android.content.*;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteQueryBuilder;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.net.Uri;
import android.text.TextUtils;
import android.util.Log;

public class EarthquakeProvider extends ContentProvider {

public static final Uri CONTENT_URI = Uri
.parse("content://com.jitesh.provider.earthquake/earthquakes");

@Override
public boolean onCreate() {
Context context = getContext();

earthquakeDatabaseHelper dbHelper = new earthquakeDatabaseHelper(
context, DATABASE_NAME, null, DATABASE_VERSION);
earthquakeDB = dbHelper.getWritableDatabase();
return (earthquakeDB == null) ? false : true;
}

@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sort) {

SQLiteQueryBuilder qb = new SQLiteQueryBuilder();

qb.setTables(EARTHQUAKE_TABLE);

// If this is a row query, limit the result set to the passed in row.
switch (uriMatcher.match(uri)) {
case QUAKE_ID:
qb.appendWhere(KEY_ID + "=" + uri.getPathSegments().get(1));
break;
default:
break;
}

// If no sort order is specified sort by date / time
String orderBy;
if (TextUtils.isEmpty(sort)) {
orderBy = KEY_DATE;
} else {
orderBy = sort;
}

// Apply the query to the underlying database.
Cursor c = qb.query(earthquakeDB, projection, selection, selectionArgs,
null, null, orderBy);

// Register the contexts ContentResolver to be notified if
// the cursor result set changes.
c.setNotificationUri(getContext().getContentResolver(), uri);

// Return a cursor to the query result.
return c;
}

@Override
public Uri insert(Uri _uri, ContentValues _initialValues) {
// Insert the new row, will return the row number if
// successful.
long rowID = earthquakeDB.insert(EARTHQUAKE_TABLE, "quake",
_initialValues);

// Return a URI to the newly inserted row on success.
if (rowID > 0) {
Uri uri = ContentUris.withAppendedId(CONTENT_URI, rowID);
getContext().getContentResolver().notifyChange(uri, null);
return uri;
}
throw new SQLException("Failed to insert row into " + _uri);
}

@Override
public int delete(Uri uri, String where, String[] whereArgs) {
int count;

switch (uriMatcher.match(uri)) {
case QUAKES:
count = earthquakeDB.delete(EARTHQUAKE_TABLE, where, whereArgs);
break;

case QUAKE_ID:
String segment = uri.getPathSegments().get(1);
count = earthquakeDB.delete(EARTHQUAKE_TABLE,
KEY_ID
+ "="
+ segment
+ (!TextUtils.isEmpty(where) ? " AND (" + where
+ ')' : ""), whereArgs);
break;

default:
throw new IllegalArgumentException("Unsupported URI: " + uri);
}

getContext().getContentResolver().notifyChange(uri, null);
return count;
}

@Override
public int update(Uri uri, ContentValues values, String where,
String[] whereArgs) {
int count;
switch (uriMatcher.match(uri)) {
case QUAKES:
count = earthquakeDB.update(EARTHQUAKE_TABLE, values, where,
whereArgs);
break;

case QUAKE_ID:
String segment = uri.getPathSegments().get(1);
count = earthquakeDB.update(EARTHQUAKE_TABLE, values,
KEY_ID
+ "="
+ segment
+ (!TextUtils.isEmpty(where) ? " AND (" + where
+ ')' : ""), whereArgs);
break;

default:
throw new IllegalArgumentException("Unknown URI " + uri);
}

getContext().getContentResolver().notifyChange(uri, null);
return count;
}

@Override
public String getType(Uri uri) {
switch (uriMatcher.match(uri)) {
case QUAKES:
return "vnd.android.cursor.dir/vnd.jitesh.earthquake";
case QUAKE_ID:
return "vnd.android.cursor.item/vnd.jitesh.earthquake";
default:
throw new IllegalArgumentException("Unsupported URI: " + uri);
}
}

// Create the constants used to differentiate between the different URI
// requests.
private static final int QUAKES = 1;
private static final int QUAKE_ID = 2;

private static final UriMatcher uriMatcher;

// Allocate the UriMatcher object, where a URI ending in 'earthquakes' will
// correspond to a request for all earthquakes, and 'earthquakes' with a
// trailing '/[rowID]' will represent a single earthquake row.
static {
uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
uriMatcher
.addURI("com.jitesh.provider.Earthquake", "earthquakes", QUAKES);
uriMatcher.addURI("com.jitesh.provider.Earthquake", "earthquakes/#",
QUAKE_ID);
}

// The underlying database
private SQLiteDatabase earthquakeDB;

private static final String TAG = "EarthquakeProvider";
private static final String DATABASE_NAME = "earthquakes.db";
private static final int DATABASE_VERSION = 1;
private static final String EARTHQUAKE_TABLE = "earthquakes";

// Column Names
public static final String KEY_ID = "_id";
public static final String KEY_DATE = "date";
public static final String KEY_DETAILS = "details";
public static final String KEY_LOCATION_LAT = "latitude";
public static final String KEY_LOCATION_LNG = "longitude";
public static final String KEY_MAGNITUDE = "magnitude";
public static final String KEY_LINK = "link";

// Column indexes
public static final int DATE_COLUMN = 1;
public static final int DETAILS_COLUMN = 2;
public static final int LONGITUDE_COLUMN = 3;
public static final int LATITUDE_COLUMN = 4;
public static final int MAGNITUDE_COLUMN = 5;
public static final int LINK_COLUMN = 6;

// Helper class for opening, creating, and managing database version control
private static class earthquakeDatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_CREATE = "create table "
+ EARTHQUAKE_TABLE + " (" + KEY_ID
+ " integer primary key autoincrement, " + KEY_DATE
+ " INTEGER, " + KEY_DETAILS + " TEXT, " + KEY_LOCATION_LAT
+ " FLOAT, " + KEY_LOCATION_LNG + " FLOAT, " + KEY_MAGNITUDE
+ " FLOAT, " + KEY_LINK + " TEXT);";

public earthquakeDatabaseHelper(Context context, String name,
CursorFactory factory, int version) {
super(context, name, factory, version);
}

@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(DATABASE_CREATE);
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");

db.execSQL("DROP TABLE IF EXISTS " + EARTHQUAKE_TABLE);
onCreate(db);
}
}
}

3) src/com/jitesh/earthquake/Preferences.java (Shared Preferences Use)

package com.jitesh.earthquake;

import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceActivity;

public class Preferences extends PreferenceActivity {

public static final String PREF_AUTO_UPDATE = "PREF_AUTO_UPDATE";
public static final String PREF_MIN_MAG = "PREF_MIN_MAG";
public static final String PREF_UPDATE_FREQ = "PREF_UPDATE_FREQ";

SharedPreferences prefs;

@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
addPreferencesFromResource(R.xml.userpreferences);
}
}

4) src/com/jitesh/earthquake/Quake.java ( supporting Quake setter and getter java class)

package com.jitesh.earthquake;

import java.util.Date;

import java.text.SimpleDateFormat;

import android.location.Location;

public class Quake {

private Date date;

private String details;

private Location location;

private double magnitude;

private String link;

public Date getDate() { return date; }

public String getDetails() { return details; }

public Location getLocation() { return location; }

public double getMagnitude() { return magnitude; }

public String getLink() { return link; }

public Quake(Date _d, String _det, Location _loc, double _mag, String _link) {

date = _d;

details = _det;

location = _loc;

magnitude = _mag;

link = _link;

}

@Override

public String toString() {

SimpleDateFormat sdf = new SimpleDateFormat("HH.mm");

String dateString = sdf.format(date);

return dateString + "<=> " + magnitude + "<=>" + details;

}

5) res/layout/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">

<ListView

android:id="@+id/earthquakeListView"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

</LinearLayout>

6) res/layout/quake_details.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"

android:padding="10dp">

<TextView

android:id="@+id/quakeDetailsTextView"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:textSize="14sp"

android:autoLink="all"

</LinearLayout>

7)res/values/arrays.xml

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

<string-array name="update_freq_options">

<item>Every Minute</item>

<item>5 minutes</item>

<item>10 minutes</item>

<item>15 minutes</item>

<item>Every Hour</item>

</string-array>

<string-array name="magnitude">

</string-array>

<string-array name="magnitude_options">

</string-array>

<string-array name="update_freq_values">

</string-array>

</resources>

8) res/values/strings.xml

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

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

http://earthquake.usgs.gov/eqcenter/catalogs/1day-M2.5.xml

</string>

<string name="menu_update">Refresh Earthquakes</string>

<string name="auto_update_prompt">Auto Update?</string>

<string name="update_freq_prompt">Update Frequency</string>

<string name="min_quake_mag_prompt">Minimum Quake Magnitude</string>

<string name="menu_preferences">Preferences</string>

</resources>

9)res/xml/userpreferences.xml

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

<PreferenceScreen

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

<CheckBoxPreference

android:key="PREF_AUTO_UPDATE"

android:title="Auto refresh"

android:summary="Select to turn on automatic updating"

android:defaultValue="true"

<ListPreference

android:key="PREF_UPDATE_FREQ"

android:title="Refresh frequency"

android:summary="Frequency at which to refresh earthquake list"

android:entries="@array/update_freq_options"

android:entryValues="@array/update_freq_values"

android:dialogTitle="Refresh frequency"

android:defaultValue="60"

<ListPreference

android:key="PREF_MIN_MAG"

android:title="Minimum magnitude"

android:summary="Select the minimum magnitude earthquake to report"

android:entries="@array/magnitude_options"

android:entryValues="@array/magnitude"

android:dialogTitle="Magnitude"

android:defaultValue="3"

</PreferenceScreen>

10) maifest file configurations

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

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

package="com.jitesh.earthquake"

android:versionCode="1"

android:versionName="1.0">

<intent-filter>

</intent-filter>

</activity>

<activity android:name=".Preferences"

android:label="Earthquake Preferences">

</activity>

<provider android:name=".EarthquakeProvider"

android:authorities="com.jitesh.provider.earthquake" />

</application>

<uses-sdk android:minSdkVersion="7" />

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

</manifest>

after running the application on emulator we can see the output as follows as per the given below screen shots

Android Mobile Application Development

Sunday, January 27, 2013

Android Content Provider / Preferences/Sqlite db (CURD)/ Feed Example

No comments:

Post a Comment