A vCard parser library written in Java

https://code.google.com/p/ez-vcard/wiki/TypeList

https://code.google.com/p/ez-vcard/wiki/WhatIsAVCard

try
  {

   ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
   int rawContactInsertIndex = ops.size();

   ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
     .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null).withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null).build());

   VCard vcard = Ezvcard.parse(savedVCard).first();
   String name = null;
   try
   {
    if (vcard.getFormattedName() != null)
    {
     name = vcard.getFormattedName().getValue();
    }
   }
   catch (Exception e3)
   {
    e3.printStackTrace();
   }

   // Names
   if (name != null)
   {
    ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
      .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
      .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
      .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, name).build());
   }

   // Telephone number
   List<Telephone> telePhonevcard = vcard.getTelephoneNumbers();
   if (telePhonevcard != null)
   {
    for (Telephone telephone : telePhonevcard)
    {
     // ------------------------------------------------------ Home Numbers
     if (telephone.getTypes().toArray()[0].equals(TelephoneType.CELL))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE).build());
     }
     else if (telephone.getTypes().toArray()[0].equals(TelephoneType.WORK))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_WORK).build());
     }
     else if (telephone.getTypes().toArray()[0].equals(TelephoneType.HOME))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_HOME).build());
     }
     else if (telephone.getTypes().toArray()[0].equals(TelephoneType.PREF))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MAIN).build());
     }
     else if (telephone.getTypes().toArray()[0].equals(TelephoneType.VOICE))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER).build());
     }
     else
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, telephone.getText())
        .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER).build());
     }

    }
   }
   // Photo
   try
   {
    byte[] data = null;
    List<Photo> photos = vcard.getPhotos();
    for (Photo photo : photos)
    {
     ImageType contentType = photo.getContentType(); // e.g. "image/jpeg"

     String url = photo.getUrl();
     if (url != null)
     {
      // property value is a URL
      continue;
     }

     data = photo.getData();
     if (data != null)
     {
      // INSERT imAGE
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Photo.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Photo.PHOTO, data).build());
      continue;
     }
    }
   }
   catch (Exception e2)
   {
    e2.printStackTrace();
   }

   String street = null;
   String city = null;
   String state = null;
   String zipcode = null;
   String country = null;

   // Get Address
   for (Address adr : vcard.getAddresses())
   {
    street = adr.getStreetAddress();
    city = adr.getLocality();
    state = adr.getRegion();
    zipcode = adr.getPostalCode();
    country = adr.getCountry();
    if (adr.getTypes().size() > 0)
    {
     if (adr.getTypes().toArray()[0].equals(AddressType.HOME))
     {
      ops.add(ContentProviderOperation
        .newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, null)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.TYPE,
          ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, zipcode)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country)
        // .withValue(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK)
        .build());
     }
     else if (adr.getTypes().toArray()[0].equals(AddressType.WORK))
     {
      ops.add(ContentProviderOperation
        .newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, null)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.TYPE,
          ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, zipcode)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country)
        // .withValue(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK)
        .build());
     }
     else
     {
      ops.add(ContentProviderOperation
        .newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, null)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.TYPE,
          ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, zipcode)
        .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country)
        // .withValue(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK)
        .build());
     }

    }
    else
    {
     ops.add(ContentProviderOperation
       .newInsert(ContactsContract.Data.CONTENT_URI)
       .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
       .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, null)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.TYPE,
         ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, zipcode)
       .withValue(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country)
       // .withValue(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK)
       .build());
    }

   }

   // Email address
   List<Email> emails = vcard.getEmails();
   for (Email email : emails)
   {
    if (email.getTypes().size() > 0)
    {
     if (email.getTypes().toArray()[0].equals(EmailType.HOME))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Email.DATA, email.getValue())
        .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_HOME).build());
     }
     else if (email.getTypes().toArray()[0].equals(EmailType.WORK))
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Email.DATA, email.getValue())
        .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_WORK).build());
     }
     else
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Email.DATA, email.getValue())
        .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_CUSTOM).build());
     }
    }
    else
    {
     ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
       .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
       .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
       .withValue(ContactsContract.CommonDataKinds.Email.DATA, email.getValue())
       .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_OTHER).build());
    }
   }
   // Address
   Organization organization = null;
   try
   {
    organization = vcard.getOrganization();
    // ------------------------------------------------------ Organization
    if (organization != null && organization.getPids() != null)
    {
     ops.add(ContentProviderOperation
       .newInsert(ContactsContract.Data.CONTENT_URI)
       .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
       .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
       .withValue(ContactsContract.CommonDataKinds.Organization.COMPANY,
         organization.getPids().get(0) == null ? "" : organization.getPids().get(0))
       .withValue(ContactsContract.CommonDataKinds.Organization.TYPE, ContactsContract.CommonDataKinds.Organization.TYPE_WORK)
       .withValue(ContactsContract.CommonDataKinds.Organization.TITLE,
         organization.getPids().get(1) == null ? "" : organization.getPids().get(1))
       .withValue(ContactsContract.CommonDataKinds.Organization.TYPE, ContactsContract.CommonDataKinds.Organization.TYPE_WORK)
       .build());

    }
   }
   catch (Exception e1)
   {
    e1.printStackTrace();
   }
   // Website
   try
   {

    if (vcard.getUrls() != null)
    {
     List<Url> urls = vcard.getUrls();
     for (Url url : urls)
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Website.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Website.URL, url.getValue())
        .withValue(ContactsContract.CommonDataKinds.Website.TYPE, ContactsContract.CommonDataKinds.Website.TYPE_WORK).build());

     }

    }
   }
   catch (Exception e1)
   {
    e1.printStackTrace();
   }
   // Note
   try
   {

    if (vcard.getNotes() != null)
    {
     List<Note> notes = vcard.getNotes();
     for (Note note : notes)
     {
      ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
        .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE)
        .withValue(ContactsContract.CommonDataKinds.Note.NOTE, note.getValue()).build());
     }

    }
   }
   catch (Exception e1)
   {
    e1.printStackTrace();
   }
   // Asking the Contact provider to create a new contact
   try
   {
    context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
    Toast.makeText(context.getApplicationContext(), "Contact saved successfully", Toast.LENGTH_SHORT).show();
   }
   catch (Exception e)
   {
    e.printStackTrace();
    // Toast.makeText(getApplicationContext(),"Exception: " + e.getMessage(), Toast.LENGTH_LONG).show();
   }

   // Instance Messanger RawProperty
   List<Impp> impps = vcard.getImpps();
   for (Impp impp : impps)
   {
    ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
      .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
      .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Im.CONTENT_ITEM_TYPE)
      .withValue(ContactsContract.CommonDataKinds.Im.PROTOCOL, impp.toString())
      .withValue(ContactsContract.CommonDataKinds.Im.TYPE, ContactsContract.CommonDataKinds.Im.TYPE_WORK).build());
   }

   // Address of the contact
    ContentResolver cr = context.getContentResolver();
    Cursor cur = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
    cur.moveToLast();
    String contactID = cur.getString(cur.getColumnIndex(ContactsContract.Contacts._ID));
    Intent intent = new Intent(Intent.ACTION_VIEW);
    Uri uri = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_URI, String.valueOf(contactID));
    intent.setData(uri);
    context.startActivity(intent);

   // Intent i = new Intent(Intent.ACTION_INSERT_OR_EDIT);
   // i.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
   // i.putExtra(ContactsContract.Intents.Insert.NAME, name);
   // context.startActivity(i);

   //context.getContentResolver().registerContentObserver(ContactsContract.Contacts.CONTENT_URI, true, new MyContentObserver());
  }
  catch (Exception e1)
  {
   e1.printStackTrace();
  }

Image Compression algorithm

 /**
  * Resize image according to device resolution
  * 
  * @param imagePath
  * @param context
  * @return
  */
 public static String compressImage(String imagePath, Context context)
 {
  String resizeImagePath = null;
  String filePath = imagePath;
  CustomLogHandler.printDebug(TAG, "resizeImagePath:" + imagePath);
  Bitmap scaledBitmap = null;
  int imageScal = 1;

  // File size greater then 2mb
  DecimalFormat df = new DecimalFormat("0.00");
  File imgFile = new File(filePath);
  double bytes = imgFile.length();
  double kilobytes = (bytes / 1024);
  double megabytes = (kilobytes / 1024);

  AppConfig.makeLog(TAG, "image size in mb:" + df.format(megabytes), 0);

  double filesize = Double.parseDouble(df.format(megabytes));
  if (filesize >= 2.00f)
  {

   for (int i = 0; i < filesize; i = i + 2)
   {

    imageScal++;
   }
   int remind = imageScal / 2;
   if (remind != 0)
   {
    imageScal = imageScal + 1;
   }

   makeLog(TAG, "image scale:" + imageScal, 0);

   BitmapFactory.Options options = new BitmapFactory.Options();
   options.inJustDecodeBounds = true;
   Bitmap bmp = BitmapFactory.decodeFile(filePath, options);

   int actualHeight = options.outHeight;
   int actualWidth = options.outWidth;
   float maxHeight = 4000;
   float maxWidth = 6000;
   // float imgRatio = actualWidth / actualHeight;
   // float maxRatio = maxWidth / maxHeight;

   if (actualHeight > maxHeight)
   {
    imageScal = imageScal + 4;
   }

   if (actualWidth > maxWidth)
   {
    imageScal = imageScal + 8;
   }

   // if (actualHeight > maxHeight || actualWidth > maxWidth)
   // {
   // if (imgRatio < maxRatio)
   // {
   // imgRatio = maxHeight / actualHeight;
   // actualWidth = (int) (imgRatio * actualWidth);
   // actualHeight = (int) maxHeight;
   //
   // }
   // else if (imgRatio > maxRatio)
   // {
   // imgRatio = maxWidth / actualWidth;
   // actualHeight = (int) (imgRatio * actualHeight);
   // actualWidth = (int) maxWidth;
   // }
   // else
   // {
   // actualHeight = (int) maxHeight;
   // actualWidth = (int) maxWidth;
   //
   // }
   // }

   // options.inSampleSize = utils.calculateInSampleSize(options, actualWidth, actualHeight);
   options.inSampleSize = imageScal;
   options.inJustDecodeBounds = false;
   options.inDither = true;
   options.inPurgeable = true;
   options.inInputShareable = true;
   options.inTempStorage = new byte[16 * 1024];

   try
   {
    bmp = BitmapFactory.decodeFile(filePath, options);
    bmp = decodeFile(bmp, filePath);
   }
   catch (OutOfMemoryError exception)
   {
    CustomLogHandler.printDebug(TAG, "Error bmp");
    exception.printStackTrace();

   }
   boolean done = false;

   while (!done)
   {
    try
    {
     scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888);
     done = true;
    }
    catch (OutOfMemoryError exception)
    {
     // 15923 × 1790
     // 5616 × 3744
     // 8150 × 9154
     actualWidth = actualWidth - ((actualWidth * 2) / 100);
     actualHeight = actualHeight - ((actualHeight * 2) / 100);
     // scaledBitmap = Bitmap.createBitmap(5616, 3744, Bitmap.Config.ARGB_8888);
     exception.printStackTrace();
    }

   }

   float ratioX = actualWidth / (float) options.outWidth;
   float ratioY = actualHeight / (float) options.outHeight;
   float middleX = actualWidth / 2.0f;
   float middleY = actualHeight / 2.0f;

   Matrix scaleMatrix = new Matrix();
   scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);

   Canvas canvas = new Canvas(scaledBitmap);
   canvas.setMatrix(scaleMatrix);
   canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));

   // Resize image stored in sdcard
   FileOutputStream out = null;
   // filename =AppConfig.fileTosaveMedia(context, FileType.IMAGE, true).getAbsolutePath();
   int compress = 100;
   try
   {
    do
    {
     imgFile = AppConfig.fileTosaveMedia(context, FileType.IMAGE, true);
     out = new FileOutputStream(imgFile);
     scaledBitmap.compress(Bitmap.CompressFormat.JPEG, compress, out);

     resizeImagePath = imgFile.getAbsolutePath();

     // Thread.sleep(15000);
     // imgFile = new File(filename);
     bytes = imgFile.length();
     kilobytes = (bytes / 1024);
     megabytes = (kilobytes / 1024);
     System.out.println("resized image size in mb:" + df.format(megabytes));

     filesize = Double.parseDouble(df.format(megabytes));
     if (filesize >= 2.00f)
     {
      compress = 50;
     }
    } while (filesize > 2.00f);
    scaledBitmap.recycle();
   }
   catch (Exception e)
   {
    e.printStackTrace();
   }
  }
  else
  {

   FileOutputStream out = null;
   // FileInputStream in = null;
   imgFile = AppConfig.fileTosaveMedia(context, FileType.IMAGE, true);
   resizeImagePath = imgFile.getAbsolutePath();
   InputStream in = null;
   OutputStream outTemp = null;
   try
   {

    // create output directory if it doesn't exist

    in = new FileInputStream(filePath);
    outTemp = new FileOutputStream(resizeImagePath);

    byte[] buffer = new byte[1024];
    int read;
    while ((read = in.read(buffer)) != -1)
    {
     outTemp.write(buffer, 0, read);
    }
    in.close();
    in = null;

    // write the output file (You have now copied the file)
    outTemp.flush();
    outTemp.close();
    outTemp = null;

   }
   catch (FileNotFoundException fnfe1)
   {
    Log.e("tag", fnfe1.getMessage());
   }
   catch (Exception e)
   {
    Log.e("tag", e.getMessage());
   }

   // try
   // {
   // Bitmap bmp = decodeFile(filePath);
   // // in = new FileInputStream(new File(imagePath));
   // // persistImage(bitmap, name);
   // out = new FileOutputStream(resizeImagePath);
   // bmp.compress(Bitmap.CompressFormat.JPEG, 100, out);
   // out.flush();
   // out.close();
   // // FileIO.copyStream(in, out);
   // }
   // catch (Exception e)
   // {
   // e.printStackTrace();
   // }
  }
  CustomLogHandler.printDebug(TAG, "resizeImagePath:" + resizeImagePath);
  return resizeImagePath;
 }

---------------------------------------------

public static Bitmap decodeFile(Bitmap pBitmap, String path)
 {
  int orientation;
  try
  {
   if (path == null)
   {
    return null;
   }
   // decode image size
   // o.inJustDecodeBounds = true;
   BitmapFactory.Options o2 = new BitmapFactory.Options();
   // o2.inSampleSize = 4;
   // Bitmap bm = BitmapFactory.decodeFile(path, o2);
   Bitmap bitmap = null;

   ExifInterface exif = new ExifInterface(path);
   orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

   Matrix m = new Matrix();

   if (orientation == ExifInterface.ORIENTATION_NORMAL || orientation == ExifInterface.ORIENTATION_UNDEFINED)
   {

   }
   else if ((orientation == ExifInterface.ORIENTATION_ROTATE_180))
   {
    m.postRotate(180);
   }
   else if (orientation == ExifInterface.ORIENTATION_ROTATE_90)
   {
    m.postRotate(90);
   }
   else if (orientation == ExifInterface.ORIENTATION_ROTATE_270)
   {
    m.postRotate(270);
   }
   else
    m.postRotate(90);

   bitmap = Bitmap.createBitmap(pBitmap, 0, 0, pBitmap.getWidth(), pBitmap.getHeight(), m, true);
   return bitmap;
  }
  catch (Exception e)
  {
   return null;
  }
 }