RSS

Monthly Archives: February 2012

Database Helper Class for Android

package com.my.first;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.graphics.Shader.TileMode;
import android.util.Log;

public class DBAdapter {
public static final String KEY_ROWID = "songId";
public static final String KEY_TITLE = "title";
public static final String KEY_TYPE = "type";
public static final String KEY_SIZE = "size";
private static final String TAG = "DBAdapter";
private static final String DATABASE_NAME = "music";
private static final String DATABASE_TABLE = "songs";
private static final int DATABASE_VERSION = 1;
private static final String DATABASE_CREATE =
"create table songs (songId integer primary key autoincrement, "
+ "title varchar not null, type varchar not null, "
+ "size float not null);";
private final Context context;
private DatabaseHelper DBHelper;
private SQLiteDatabase db;
public DBAdapter(Context ctx)
{
this.context = ctx;
DBHelper = new DatabaseHelper(context);
}

private  static class DatabaseHelper extends SQLiteOpenHelper
{

public DatabaseHelper(Context context) {
super(context,DATABASE_NAME,null,DATABASE_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 songs");
onCreate(db);
}



}

//---opens the database---
public DBAdapter open()
{
try
{
db = DBHelper.getWritableDatabase();

}
catch(SQLException ex)
{

}
return this;
}

//---closes the database---
public void close()
{
DBHelper.close();
}

//---insert a song into the database---
public long insertTitle(String title, String type, String size)
{
ContentValues initialValues = new ContentValues();
initialValues.put(KEY_TITLE, title);
initialValues.put(KEY_TYPE, type);
initialValues.put(KEY_SIZE, size);
return db.insert(DATABASE_TABLE, null, initialValues);
}

//---deletes a particular title---
public boolean deleteTitle(long rowId)
{
return db.delete(DATABASE_TABLE, KEY_ROWID +
"=" + rowId, null) > 0;
}

//---retrieves all the titles---
public Cursor getAllSongTitles()
{
return db.query(DATABASE_TABLE, new String[] {
KEY_ROWID,
KEY_TITLE,
KEY_TYPE,
KEY_SIZE},
null,
null,
null,
null,
null);
}

//---retrieves a particular title---
public Cursor getSongTitle(long rowId) throws SQLException
{
Cursor mCursor =
db.query(true, DATABASE_TABLE, new String[] {
KEY_ROWID,
KEY_TITLE,
KEY_TYPE,
KEY_SIZE
},
KEY_ROWID + "=" + rowId,
null,
null,
null,
null,
null);
if (mCursor != null) {
mCursor.moveToFirst();
}
return mCursor;
}


//---updates a title---
public boolean updateSongTitle(long rowId, String title,
String type, String size)
{
ContentValues args = new ContentValues();
args.put(KEY_TITLE, title);
args.put(KEY_TYPE, type);
args.put(KEY_SIZE, size);
return db.update(DATABASE_TABLE, args,
KEY_ROWID + "=" + rowId, null) > 0;
}

}


Advertisements
 
Leave a comment

Posted by on February 28, 2012 in Android

 

Tags: ,

Create SQLite Database in Android

package com.my.first;

import android.R.string;
 import android.app.Activity;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.os.Bundle;
 import android.util.Log;

public class DatabaseActivity extends Activity {

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

SQLiteDatabase db = openOrCreateDatabase("MyDB", MODE_PRIVATE, null);
 db.execSQL("CREATE TABLE IF NOT EXISTS MyTable (FirstName VARCHAR,LastName VARCHAR,Age INT(3))");
 db.execSQL("INSERT INTO MyTable VALUES('Josh','Fedric',23)");

Cursor c = db.rawQuery("SELECT * FROM MyTable", null);
 c.moveToFirst();
 String msg = c.getString(c.getColumnIndex("FirstName"));
 Log.d("Fname",msg);

}
 }

 
Leave a comment

Posted by on February 28, 2012 in Android

 

Tags: ,

Asynchronous communication with delegates

Compiler generate a new class for each delegate declaration. Following class is compiler-generated for the above delegate.

private sealed class MyDelegate : MulticastDelegate
{
public extern MyDelegate(object object, IntPtr method);
public extern virtual int Invoke(int x,int y);
public extern virtual IAsyncResult BeginInvoke(int x, int y
AsyncCallback callback, object object);
public extern virtual int Endinvoke((IAsyncResult result);
}

This class consists of delegate constructor MyDelegate(..) , Invoke (..) , BeginInvoke(..) and EndInvoke(..)

  • Delegate constructor runs when the delegate is instanciated. MyDelegate is instanciated as follows.

MyDelegate del;
This del reference is used to point a matching method.

  •   Invoke method accepts the same parameter list similar to the original function.
  •   BeginInvoke method requires all the in params , in-out params in the function definition. Furthermore, it needs AsyncCallback object and Object type reference.

calling BeginInvoke() causes to make an asynchronous call to the original method. The result is an IAsyncResult.

  •   After method execution completed, EndInvoke() is called passing all the in-out params , out params in the function definition. EndInvoke() requires the above IasyncResult.

Now let’s turn to asynchronius communication. When a delegate makes an asynchronius call to a method , the execution of the method does ont occur in the same thread. A separate thread is allocated for method execution. Caller thread waits until callie thread returns the result. These facts are justified by following code example.

using System;
 using System.Threading;
 public class Program {
 public delegate int TheDelegate( int x, int y);
 static int ShowSum( int x, int y ) {
 int sum = x + y;
 Console.WriteLine("Thread #{0}: ShowSum() Sum = {1}",
 Thread.CurrentThread.ManagedThreadId, sum);
 return sum;
 }
 public static void Main() {
 TheDelegate d = ShowSum;
 IAsyncResult ar = d.BeginInvoke(10, 10, null, null);
 int sum = d.EndInvoke(ar);
 Console.WriteLine("Thread #{0}: Main() Sum = {1}",
 Thread.CurrentThread.ManagedThreadId, sum);
 }
 }

 

 

 
Leave a comment

Posted by on February 15, 2012 in C#.Net

 

Tags: ,

Synchronous communication with delegates

Delegates are special types supported by the .NET Framework. It is a pointer to a function. A delegate pointing to a function has the same method signature as the function. Delegates are special classes. Delegates can be instanciated. Therefore we have delegate objects. A delegate object is a reference to one or more methods (static or instance).

In C# , delegate declaration as follows.

public delegate int MyDelegate(int x, int y);

This delegate can be used as reference to any method which accepts two integer parameters and has the return type of int.

An example that uses MyDelegate delegate


namespace del
{
public delegate int MyDelegate(int num1,int num2);
class A
{
public int sum(int num1, int num2)
{
return num1 + num2;
}
}

class Program
{
static void Main(string[] args)
{
A a = new A();
MyDelegate del = a.sum;
Console.ReadLine();
}
}
}

Here , delegate makes  a synchronous call to the function. In other words, function call is not asynchronous.
All the work related to calling sum(int a,int b) happens in the main thread.
Synchronous communication is based on single thread concept.
In above example, delegate calls sum(int a,int b)  and then the main thread blocks   until sum() method execution completes.   Therefore this thread can not execute any other code until method  execution is over.
It is obvious that synchronous communication is not preferred for User interfaces. In a user interface, UI responsiveness is highly considered. If all the work is maintained in a single thread, there is a chance for the UI to get stuck.

The following code verifies above function call is synchronous.  The resulting thread ids are similar.

namespace del
{
public delegate void MyDelegate();

class A
{
public void sum()
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}
}

class Program
{
static void Main(string[] args)
{
A a = new A();
MyDelegate del = a.sum;
del();
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
//IAsyncResult rs = del.BeginInvoke(20, 10, null, null);
//string ans  = del.EndInvoke(rs);
//Console.WriteLine("Answer is {0}", ans);
Console.ReadLine();
}
}
}
 
Leave a comment

Posted by on February 15, 2012 in C#.Net

 

Tags: ,