Pages

Subscribe:

Labels

Tuesday, 4 October 2011

Create Database using exiting database


In this tutorial, I am going to create the database by using the existing database. In order to do this , place your existing database into the “assets”  folder. The DBAdapter.java file is as follows.

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
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.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;

public class DBAdapter extends SQLiteOpenHelper {
                private static String DB_PATH = "";
                private static final String DB_NAME = "game.db";
                private SQLiteDatabase myDataBase;
                private final Context myContext;

                private static DBAdapter mDBConnection;
                private DBAdapter(Context context) {
                                super(context, DB_NAME, null, 1);
                                this.myContext = context;
                                DB_PATH = "/data/data/"+ context.getApplicationContext().getPackageName()            + "/databases/";
                }
                public static synchronized DBAdapter getDBAdapterInstance(Context context) {
                                if (mDBConnection == null) {
                                                mDBConnection = new DBAdapter(context);
                                }
                                return mDBConnection;
                }

                public void createDataBase() throws IOException {
                                boolean dbExist = checkDataBase();
                                if (dbExist) {
                                                // do nothing - database already exist
                                } else {
                                                // By calling following method
                                                // 1) an empty database will be created into the default system path of your application
                                                // 2) than we overwrite that database with our database.
                                                this.getReadableDatabase();
                                                try {
                                                                copyDataBase();
                                                } catch (IOException e) {
                                                                throw new Error("Error copying database");
                                                }
                                }
                }

                private boolean checkDataBase() {
                                SQLiteDatabase checkDB = null;
                                try {
                                                String myPath = DB_PATH + DB_NAME;
                                                checkDB = SQLiteDatabase.openDatabase(myPath, null,              SQLiteDatabase.OPEN_READONLY);

                                } catch (SQLiteException e) {
                                                // database does't exist yet.
                                }
                                if (checkDB != null) {
                                                checkDB.close();
                                }
                                return checkDB != null ? true : false;
                }

                private void copyDataBase() throws IOException {
                                    // Open your local db as the input stream
                                InputStream myInput = myContext.getAssets().open(DB_NAME);
                                    // Path to the just created empty db
                                String outFileName = DB_PATH + DB_NAME;
                                    // Open the empty db as the output stream
                                OutputStream myOutput = new FileOutputStream(outFileName);
                                    // transfer bytes from the inputfile to the outputfile
                                byte[] buffer = new byte[1024];
                                int length;
                                while ((length = myInput.read(buffer)) > 0) {
                                                myOutput.write(buffer, 0, length);
                                }
                                    // Close the streams
                                myOutput.flush();
                                myOutput.close();
                                myInput.close();
                }

                public void openDataBase() throws SQLException {
                                String myPath = DB_PATH + DB_NAME;
                                myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
                }

                @Override
                public synchronized void close() {
                                if (myDataBase != null)
                                                myDataBase.close();
                                super.close();
                }

                @Override
                public void onCreate(SQLiteDatabase db) {
                }

                @Override
                public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
                }

                // ----------------------- DATABASE Operations ------------------------------
               
                 public long insertPuzzle(String problem,String solution,String level, int status)
                 {
                                 ContentValues initialValues = new ContentValues();
                                 initialValues.put("problem", problem);
                                 initialValues.put("solution",solution);
                                 initialValues.put("level",level);
                                 initialValues.put("status",status);
                                 return myDataBase.insert("puzzles", null, initialValues);
                 }
}


In the Activity class call like this


private DBAdapter db=null;
db=DBAdapter.getDBAdapterInstance(this);
/*try {
db.createDataBase();
} catch (IOException e) {
e.printStackTrace();
}*/
db.openDataBase();
db.insertPuzzle(..,..,..);

Monday, 3 October 2011

Store the Image into SQLite Database


In this tutorial, I used the BLOB data type to store the image into the SQLite  database.
BLOB --> Binary Large Object.
This data type is used to store the values in the binary format. This type is used to store the images ,audio and video file.
Here I am going to store the image .So that ,
1.I have to convert the image to byte[].
2.This byte[] is going to be stored in the database.
Example:

The DBAdapter .java file

import java.io.ByteArrayOutputStream;

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.SQLiteOpenHelper;
import android.database.sqlite.SQLiteStatement;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

public class DBAdapter {         
    private static final String DATABASE_NAME = "myDatabase.db";
    private static final int DATABASE_VERSION = 1;

    private static final String USERDETAILS=
                "create table userdetails(usersno integer primary key autoincrement,userid text not null ,username text not null,password text not null,photo BLOB,visibility text 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     {
        DatabaseHelper(Context context)         {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }
        public void onCreate(SQLiteDatabase db)         {
                db.execSQL(USERDETAILS);
        }
        public void onUpgrade(SQLiteDatabase db, int oldVersion,    int newVersion)         {
                db.execSQL("DROP TABLE IF EXISTS users");
            onCreate(db);
        }
    }   
 
    public DBAdapter open() throws SQLException
    {
        db = DBHelper.getWritableDatabase();
        return this;
    }
  
    public void close()     {
                DBHelper.close();
    }
    public long insertUserDetails(String uname,String userid, String pass, byte[] photo,String visibility)     {
        ContentValues initialValues = new ContentValues();
        initialValues.put("username", uname);
        initialValues.put("userid",userid);
        initialValues.put("password", pass);
        initialValues.put("photo",photo);
        initialValues.put("visibility",visibility);
        return db.insert("userdetails", null, initialValues);
    }
  
 public Cursor getUserDetails(String userid)    {
                return db.rawQuery("select username,userid,photo,visibility ,usersno from userdetails where userid='"+userid+"'",null);
    }
    public int updateUserDetails(String userid,String username,byte[] photo,String visibility)    {
                ContentValues args = new ContentValues();
        args.put("username", username);
        args.put("photo",photo);
        args.put("visibility",visibility);
        return db.update("userdetails", args,"userid='" +userid+"'", null);
    }  
    public Cursor searchFriends(String username,String to_userid)    {
                return db.rawQuery("select userid,username,photo,usersno from userdetails where username LIKE '%"+username+"%' AND userid <>'"+to_userid+"' AND userid NOT IN (select request_destinationid from requestdetails where request_sourceid='"+to_userid+"' and status=1)",null);
    }
    public void deleteFriend(int l_userid,int dest_userid)   {
                db.delete("requestdetails","request_sourceid="+l_userid+" and request_destinationid="+dest_userid+" and status=1", null);
                db.delete("requestdetails","request_sourceid="+dest_userid+" and request_destinationid="+l_userid+" and status=1", null);
    }
}



In  the Activity class write like this
To Store into the DB..
private DBAdapter db=new DBAdaptet(this);
db.open();
ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
Bitmap bitmap = (BitmapDrawable)getResources().getDrawable(R.drawable.common)).getBitmap();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);  
byte[] photo = baos.toByteArray();
db.insertUserDetails(fullName,userid, password, photo,visibility);


Retrieve from DB..
byte[]  photo=cursor.getBlob(..);
ByteArrayInputStream imageStream = new ByteArrayInputStream(photo);
Bitmap theImage= BitmapFactory.decodeStream(imageStream);
image_view.setImageBitmap(theImage);






Friday, 30 September 2011

Genarate KeyStore to create a Signed APK and Google Maps in Android

To generate the keystore:
==================

----------------------------------------------------------------------------------------------------------------------------------
keytool -genkey -v -keystore myCertificate.keystore -alias myKey -keyalg RSA -keysize 2048 -validity 20000
----------------------------------------------------------------------------------------------------------------------------------

>>Fill the Details:

Enter Keystore Password :- ********
Re-enter new Password    :- ********
What is your first and last Name? :-kkbrothers
What is the name of your organizational unit?:- Elites
What is the name of your organization?:-kkbrothers
What is the name of your City or Locality?:-Hyd
What is the name of your State or Province?:-Ap
What is the two-letter country code for this unit?:- IND



Enter key password for <myKey>
        (RETURN if same as keystore password):-*******
Re-enter new password:-*******







 



For GoogleMaps:
============
Some of the Links link1 , link2

E:\keystore>keytool.exe -list -alias androiddebugkey -keystore "E:\keystore\debu
g.keystore" -storepass android -keypass android
androiddebugkey, Nov 26, 2010, PrivateKeyEntry,
Certificate fingerprint (MD5): FB:93:B3:1D:16:A8:DB:84:B3:1B:0F:5D:EA:51:FB:BA


Your key is:urkey



This key is good for all apps signed with your certificate whose fingerprint is:

FB:93:B3:1D:16:A8:DB:84:B3:1B:0F:5D:EA:51:FB:BA

Here is an example xml layout to get you started on your way to mapping glory:

              <com.google.android.maps.MapView
                 android:layout_width="fill_parent"
                 android:layout_height="fill_parent"
                 android:apiKey="urkey"
                 />