How to get Hash Key for integarte facebook SDK in android application

Hello Everyone today I am posting to get Hash Key for Facebook integration.

There is a two way to get Hash Key.

1. Using CMD

keytool -exportcert -alias androiddebugkey -keystore "C:\Users\User\.android\debug.keystore" | openssl sha1 -binary | openssl base64

and then press Enter. Insert password: android

 - You will get your hash key for debug.keystore.

 - When you export a signed APK and you create keystore for application, just replace in cmd debugkeystore alias with your alias for app, keystore path with path to your new created keystore for app and insert password for your app.keystore and you will get a new hash key for your signed app.

2. Just Copy below code in Activity class:

Open up the Your Activity class and make the following temporary change to the onCreate() method:
This is easy to use other then ssl and so.

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import android.app.Activity;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.Signature;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;

public class MainActivity extends Activity
{
 @Override
 public void onCreate(Bundle savedInstanceState) 
 {
  super.onCreate(savedInstanceState);

  // Add code to print out the key hash
  try {
   
   PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
   
   for (Signature signature : info.signatures) 
   {
    MessageDigest md = MessageDigest.getInstance("SHA");
    md.update(signature.toByteArray());
    Log.d("KeyHash:", Base64.encodeToString(md.digest(), Base64.DEFAULT));
   }
   
  } catch (NameNotFoundException e) {
   Log.e("name not found", e.toString());
  } catch (NoSuchAlgorithmException e) {
   Log.e("no such an algorithm", e.toString());
  }
 }
}

If you Run app without signed APK then You will get your hash key for debug.keystore.
When you export a signed APK, just signed APK with your keystore and Run the Application.

You can delete the code after knowing the key ;)

enjoy !

Note :- If you getting below error in Facebook integration.
A non-native Login Dialog is displayed that includes an error message at the top:

''..App is Misconfigured for facebook login...''.

Besides double checking your key hash generation steps.

Used your existing SQLite database file in Android Application

Here, I am posting to how to use existing SQLite database file in android application. follow below steps.

1. Make the SQLite database file.

If you don't have a sqlite manager I recommend you to download the opensource SQLite Database Browser available for Win/Linux/Mac. Make database file.

2. Use this database in your Android application.

Now put your database file in the "assets" folder of your project and create a Database Helper class by extending the SQLiteOpenHelper class

public class Databasehelper extends SQLiteOpenHelper
{
      private SQLiteDatabase myDataBase;
      private final Context myContext;
      private static final String DATABASE_NAME = "db.sqlite";
      public final static String DATABASE_PATH = "";
      public static final int DATABASE_VERSION = 1;
      //public static final int DATABASE_VERSION_old = 1;
      //Constructor

      public Databasehelper(Context context)
      {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
            this.myContext = context;
            DATABASE_PATH = myContext.getDatabasePath(DATABASE_NAME).toString();
      }

      //Create a empty database on the system
      public void createDatabase() throws IOException
      {
           boolean dbExist = checkDataBase();
            if(dbExist)
            {
                  Log.v("DB Exists", "db exists");
                  // By calling this method here onUpgrade will be called on a
                  // writeable database, but only if the version number has been
                  // bumped
                  //onUpgrade(myDataBase, DATABASE_VERSION_old, DATABASE_VERSION);
           }         
            boolean dbExist1 = checkDataBase();
            if(!dbExist1)
            {
                  this.getReadableDatabase();
                  try
                  {
                        this.close();    
                        copyDataBase();
                  }
                  catch (IOException e)
                  {
                        throw new Error("Error copying database");
                  }
            }
      }

      //Check database already exist or not
      private boolean checkDataBase()
      {
            boolean checkDB = false;
            try
            {
                  String myPath = DATABASE_PATH;
                  File dbfile = new File(myPath);
                  checkDB = dbfile.exists();
            }
            catch(SQLiteException e)
            {
            }
            return checkDB;
      }

      //Copies your database from your local assets-folder to the just created empty database in the system folder

      private void copyDataBase() throws IOException
      {
            String outFileName = DATABASE_PATH;
            OutputStream myOutput = new FileOutputStream(outFileName);
            InputStream myInput = myContext.getAssets().open(DATABASE_NAME);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInput.read(buffer)) > 0)
            {
                  myOutput.write(buffer, 0, length);
            }
            myInput.close();
            myOutput.flush();
            myOutput.close();
      }

      //delete database
      public void db_delete()
      {
            File file = new File(DATABASE_PATH);
            if(file.exists())
            {
                  file.delete();
                  System.out.println("delete database file.");
            }
      }

      //Open database
      public void openDatabase() throws SQLException
      {
            String myPath = DATABASE_PATH;
            myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
      }

      public synchronized void closeDataBase()throws SQLException
      {
            if(myDataBase != null)
                  myDataBase.close();
            super.close();
      }

      public void onCreate(SQLiteDatabase db)
      {
      }

      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
      {    
            if (newVersion > oldVersion)
            {
                  Log.v("Database Upgrade", "Database version higher than old.");
                  db_delete();
            }
      }
      //add your public methods for insert, get, delete and update data in database.
}

Now you can create a new instance of this DataBaseHelper class and call the createDataBase() and openDataBase() methods.

DataBaseHelper myDbHelper = new DataBaseHelper();
    myDbHelper = new DataBaseHelper(this);
    try {
          myDbHelper.createDataBase();
    } catch (IOException ioe) {
          throw new Error("Unable to create database");
    }
    try {
          myDbHelper.openDataBase();
    }catch(SQLException sqle){
          throw sqle;
    }