public View getView(int position, View convertView, ViewGroup parent) {
  ...
  holder.imgView.setHeightRatio(feedEntry.image.ratio);
  holder.imgView.setTag(pos);
  mImageLoader.get(feedEntry.image.url_medium, new ImageListener(pos, holder.imgView, null));
  ...
}

public static int calculateInSampleSize(BitmapFactory.Options options,
            int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            while (((halfHeight / inSampleSize) > reqHeight)
                    || ((halfWidth / inSampleSize) > reqWidth)) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    public static Bitmap decodeSampledBitmap(String imgPath, int reqWidth, int reqHeight) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(imgPath, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(imgPath, options);
    }

    public String getThumbURI(String strMediaStoreID) {
        ContentResolver cr = mContext.getContentResolver();
        String strThumbUri = "";
        Cursor cursorThumb = cr.query(MediaStore.Images.Thumbnails.EXTERNAL_CONTENT_URI,
                new String[]{MediaStore.Images.Thumbnails.DATA},
                MediaStore.Images.Thumbnails.IMAGE_ID + "= ?",
                new String[]{strMediaStoreID}, null);
        if( cursorThumb != null && cursorThumb.getCount() > 0 ) {
            cursorThumb.moveToFirst();
            strThumbUri = cursorThumb.getString(
                    cursorThumb.getColumnIndex( MediaStore.Images.Thumbnails.DATA ));
        }
        cursorThumb.close();
        return strThumbUri;
    }

    public static final void getUserProfileRequest (Context context, String[] userIds,
            final Response.Listener<HashMap<String, UserProfile>> responseListener,
            final Response.ErrorListener errorListener) {
        HashMap<String, String> headers = makeHTTPHeaders();
        String strIdHeader = userIds.length > 0 ? userIds[0] : "";
        for (int i = 1; i < userIds.length; i++) strIdHeader = strIdHeader + "," + userIds[i];
        headers.put(Constants.KEY_ID, strIdHeader);
        Log.d(LOG_TAG, "Get user profile request");
        StringRequest request = new StringRequest(Request.Method.GET,
            Constants.SERVER_URL + Constants.SERVER_PATH_USER, "", headers,
            new Response.Listener<String>() {
                @Override
                public void onResponse(String response) {
                    Log.d(LOG_TAG, response);
                    Type type = new TypeToken<ServerResponse
                            <HashMap<String, UserProfile>>>(){}.getType();
                    try {
                        ServerResponse<HashMap<String, UserProfile>> res =
                                gson.fromJson(response, type);
                        if (res != null && res.isSuccess() && res.data != null
                                && responseListener != null)
                            responseListener.onResponse(res.data);
                        else if (responseListener != null)
                            responseListener.onResponse(new HashMap<String, UserProfile>());
                    } catch (Exception e) {
                        if (responseListener != null)
                            responseListener.onResponse(new HashMap<String, UserProfile>());
                    }
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if ((error != null) && (error.networkResponse != null)
                            && (error.networkResponse.data != null))
                        Log.d(LOG_TAG, "Error: " +
                                new String(error.networkResponse.data));
                    if (errorListener != null) errorListener.onErrorResponse(error);
                }
            }
        );
        VolleySingleton.getInstance(context).addToRequestQueue(request);
    }

public class VolleySingleton {
...
    public <T> void addToRequestQueue(Request<T> req) {
        int socketTimeout = 90000;
        RetryPolicy policy = new DefaultRetryPolicy(socketTimeout,
                DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                DefaultRetryPolicy.DEFAULT_BACKOFF_MULT);
        req.setRetryPolicy(policy);
        getRequestQueue().add(req);
    }
...
}

public class FriendsDataSource {
    private SQLiteDatabase database;
    private SQLiteHelper dbHelper;
    private String[] allColumns = { SQLiteHelper.COLUMN_ID,SQLiteHelper.COLUMN_NAME,
            SQLiteHelper.COLUMN_CONTACT_KEY, SQLiteHelper.COLUMN_USER_ID,
            SQLiteHelper.COLUMN_AVATAR, SQLiteHelper.COLUMN_STATUS};
...
    public FriendEntry createFriend(String Name, String ContactKey, String UserId,
                String Avatar, int Status) {
        //Add new FriendEntry
        ContentValues cv = new ContentValues();
        cv.put(dbHelper.COLUMN_CONTACT_KEY,ContactKey);
        cv.put(dbHelper.COLUMN_NAME,Name);
        cv.put(dbHelper.COLUMN_USER_ID,UserId);
        cv.put(dbHelper.COLUMN_AVATAR,Avatar);
        cv.put(dbHelper.COLUMN_STATUS,Status);
        cv.put(dbHelper.COLUMN_TYPE,FriendEntry.INT_TYPE_PERSON);

        database.insert(dbHelper.TABLE_FRIENDS, null, cv);
        return null;
    }

    public ArrayList<FriendEntry> getFriendsByStatus(int StatusSet[]) {
        String selection = dbHelper.COLUMN_STATUS + " IN (?";
        String values[] = new String[StatusSet.length];
        values[0] = String.valueOf(StatusSet[0]);
        for (int i = 1; i < StatusSet.length; i++) {
            selection = selection + ",?";
            values[i] = String.valueOf(StatusSet[i]);
        }
        selection = selection + ") ";

        selection = selection + " AND "
                + SQLiteHelper.COLUMN_TYPE + " = " + FriendEntry.INT_TYPE_PERSON;

        String orderBy =  SQLiteHelper.COLUMN_NAME + " ASC";

        Cursor cursor = database.query(dbHelper.TABLE_FRIENDS,
                null, selection, values, null, null, orderBy);

        ArrayList<FriendEntry> listFriends = new ArrayList<FriendEntry>();

        if (cursor == null) {
            return listFriends;
        } else if (!cursor.moveToFirst()) {
            cursor.close();
            return listFriends;
        }

        do{
            listFriends.add(cursorToFriendEntry(cursor));
        }while (cursor.moveToNext());

        cursor.close();
        return listFriends;
    }

    private FriendEntry cursorToFriendEntry(Cursor cursor) {

        FriendEntry friend = new FriendEntry();
        friend.setId(cursor.getInt(idColIndex));
        friend.setName(cursor.getString(nameColIndex));
        friend.setUserId(cursor.getString(userIdColIndex));
        friend.setAvatar(cursor.getString(avatarColIndex));
        friend.setStatus(cursor.getInt(statusColIndex));
        friend.setType(cursor.getInt(typeColIndex));
        friend.setContactKey(cursor.getString(ContactKeyColIndex));

        return friend;
    }
...
}