For check whether , the device has internal storage, external storage or both, use this:

if (Environment.MEDIA_MOUNTED.equals(state)) {
    mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
    mExternalStorageAvailable = true;
    mExternalStorageWriteable = false;
} else {
    mExternalStorageAvailable = mExternalStorageWriteable = false;
}

if (mExternalStorageAvailable) {
    File path = new File(Environment.getExternalStorageDirectory()
                                    .getAbsolutePath()
                         + "/EMD Systems/Append");
    if (!path.exists()) {
        path.mkdirs();
    }
    f = path;
} else {
    File dir1 = getApplicationContext().getDir("EMD Systems", Context.MODE_PRIVATE);
    File dir = new File(dir1 + "/Append");
    if (!dir.exists()) {
        dir.mkdirs();
    }
    f = dir;
}

Read More

            File dir1 = getApplicationContext().getDir("your directory",
                Context.MODE_PRIVATE);

              // list the folder under the directory

        for (File fdir : dir1.listFiles()) {
            if (fdir.isDirectory()) {

                //list of file under the folder

                for (File wavfile : fdir
                        .listFiles()) {
                    String str = wavfile.getName().toString();

                    if (str.equals("your delete file"))) {

                        wavfile.delete();
                    }
                }
            }

Read More

as doc says about Context.getDir (String name, int mode) :

Retrieve, creating if needed, a new directory in which the application can place its own custom data files. You can use the returned File object to create and access files in this directory. Note that files created through a File object will only be accessible by your own application; you can only set the mode of the entire directory, not of individual files.

means instead of passing file name with file separator u will need to pass only folder(Dir) name as first paramter to getDir methods as ":

File dir_path = getApplicationContext().getDir(
                        getResources().getString(R.string.app_name), MODE_PRIVATE);

EDIT:

to create Dir on external SDCARD. change your code as :

File onsdcarddir = new File(Environment.getExternalStorageDirectory() +
                               "/" +getResources().getString(R.string.app_name));

if (!onsdcarddir.exists()) {
   onsdcarddir.mkdir(); // create dir here
}

also add SDCARD permission in AndroidManifest.xml :

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

Read More

I have used the below class to implement the Lazy loading of the images it works awesome for me . You try it also.

ImageLoader

   /**
      * This is class for display image in lazy-loading way.
      */
   public class ImageLoader
   {
private static final String TAG = ImageLoader.class.getSimpleName();
private InputStream m_is = null;
private OutputStream m_os = null;
private Bitmap m_bitmap = null;
private String m_imagePath;
private File m_cacheDir;
private WeakHashMap<String, Bitmap> m_cache = new WeakHashMap<String, Bitmap>();
/**
 * Makes the background thread low priority. This way it will not affect the
 * UI performance.<br>
 * Checks the Device SD card exits or not and assign path according this
 * condition.
 * 
 * @param p_context
 *            activity context
 */
public ImageLoader(Context p_context)
{
    /**
     * Make the background thread low priority. This way it will not affect
     * the UI performance
     */
    m_imageLoaderThread.setPriority(Thread.NORM_PRIORITY - 1);
    /**
     * Check the Device SD card exits or not and assign path according this
     * condition.
     */
    if (android.os.Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED))
    {
        m_imagePath = Environment.getExternalStorageDirectory() + "/Android/data/" + p_context.getPackageName();
        m_cacheDir = new File(m_imagePath);
    }
    else
    {
        m_cacheDir = new File(p_context.getDir("Cache", Context.MODE_PRIVATE), "Cache");
    }
    if (!m_cacheDir.exists())
        m_cacheDir.mkdirs();
}
/**
 * Check Image exits on HashMap or not.If exist then set image to ImageView
 * else send request in the queue.
 * 
 * @param p_url
 *            image Url
 * @param p_imageView
 *            image container
 * @param p_prgBar
 *            progressbar that is displayed till image is not download from
 *            server.
 */
public void DisplayImage(String p_url, ImageView p_imageView, ProgressBar p_prgBar) throws CustomException
{
    if (m_cache.containsKey(p_url))
    {
        p_prgBar.setVisibility(View.GONE);
        p_imageView.setVisibility(View.VISIBLE);
        p_imageView.setImageBitmap(m_cache.get(p_url));
    }
    else
    {
        queueImage(p_url, p_imageView, p_prgBar);
    }
}
/**
 * Clear old task from the queue and add new image downloading in the queue.
 * 
 * @param p_url
 *            image Url
 * @param p_imageView
 *            image container
 * @param p_prgBar
 *            progressbar that is displayed till image is not download from
 *            server.
 */
private void queueImage(String p_url, ImageView p_imageView, ProgressBar p_prgBar) throws CustomException
{
    try
    {
        m_imagesQueue.Clean(p_imageView);
        ImageToLoad m_photoObj = new ImageToLoad(p_url, p_imageView, p_prgBar);
        synchronized (m_imagesQueue.m_imagesToLoad)
        {
            m_imagesQueue.m_imagesToLoad.push(m_photoObj);
            m_imagesQueue.m_imagesToLoad.notifyAll();
        }
        /**
         * start thread if it's not started yet
         */
        if (m_imageLoaderThread.getState() == Thread.State.NEW)
            m_imageLoaderThread.start();
    }
    catch (CustomException c)
    {
        throw c;
    }
    catch (Throwable t)
    {
        CustomLogHandler.printErrorlog(t);
        throw new CustomException(TAG + " Error in queueImage(String p_url, ImageView p_imageView, ProgressBar p_prgBar) of ImageLoader", t);
    }
}
/**
 * Checks in SD card for cached file.If bitmap is not available then will
 * download it from Url.
 * 
 * @param p_url
 *            imgae Url
 * @return bitmap from Cache or from server.
 */
private Bitmap getBitmap(String p_url) throws CustomException
{
    System.gc();
    String m_fileName = String.valueOf(p_url.hashCode());
    File m_file = new File(m_cacheDir, m_fileName);
    // from SD cache
    m_bitmap = decodeFile(m_file);
    if (m_bitmap != null)
        return m_bitmap;
    // from web
    try
    {
        Bitmap m_bitmap = null;
        int m_connectionCode = 0;
        m_connectionCode = HttpConnection.getHttpUrlConnection(p_url).getResponseCode();
        if (m_connectionCode == HttpURLConnection.HTTP_OK)
        {
            m_is = new URL(p_url).openStream();
            m_os = new FileOutputStream(m_file);
            FileIO.copyStream(m_is, m_os);
            m_os.close();
            m_os = null;
            m_bitmap = decodeFile(m_file);
            m_is.close();
            m_is = null;
            HttpConnection.getHttpUrlConnection(p_url).disconnect();
        }
        return m_bitmap;
    }
    catch (CustomException c)
    {
        throw c;
    }
    catch (Throwable t)
    {
        CustomLogHandler.printErrorlog(t);
        throw new CustomException(TAG + " Error in getBitmap(String p_url) of ImageLoader", t);
    }
}
/**
 * Decodes the Image file to bitmap.
 * 
 * @param p_file
 *            Image file object
 * @return decoded bitmap
 */
private Bitmap decodeFile(File p_file) throws CustomException
{
    try
    {
        // decode image size
        Bitmap m_retBmp = null;
        System.gc();
        int m_scale = 1;
        if (p_file.length() > 400000)
        {
            m_scale = 4;
        }
        else if (p_file.length() > 100000 && p_file.length() < 400000)
        {
            m_scale = 3;
        }
        // decode with inSampleSize
        if (p_file.exists())
        {
            BitmapFactory.Options m_o2 = new BitmapFactory.Options();
            m_o2.inSampleSize = m_scale;
            m_retBmp = BitmapFactory.decodeFile(p_file.getPath(), m_o2);
        }
        return m_retBmp;
    }
    catch (Throwable t)
    {
        CustomLogHandler.printErrorlog(t);
        throw new CustomException(TAG + " Error in decodeFile(File p_file) of ImageLoader", t);
    }
}
/**
 * Stores image information
 */
private class ImageToLoad
{
    public String m_url;
    public ImageView m_imageView;
    public ProgressBar m_prgBar;
    public ImageToLoad(String p_str, ImageView p_img, ProgressBar p_prgBar)
    {
        m_url = p_str;
        m_imageView = p_img;
        m_imageView.setTag(p_str);
        m_prgBar = p_prgBar;
    }
}
ImagesQueue m_imagesQueue = new ImagesQueue();
/**
 * This is method to stop current running thread.
 */
public void stopThread()
{
    m_imageLoaderThread.interrupt();
}
/**
 * Stores list of image to be downloaded in stack.
 */
class ImagesQueue
{
    private Stack<ImageToLoad> m_imagesToLoad = new Stack<ImageToLoad>();
    /**
     * Removes all instances of this ImageView
     * 
     * @param p_ivImage
     *            imageView
     */
    public void Clean(ImageView p_ivImage) throws CustomException
    {
        try
        {
            for (int m_i = 0; m_i < m_imagesToLoad.size();)
            {
                if (m_imagesToLoad.get(m_i).m_imageView == p_ivImage)
                    m_imagesToLoad.remove(m_i);
                else
                    m_i++;
            }
        }
        catch (Throwable t)
        {
            CustomLogHandler.printErrorlog(t);
            throw new CustomException(TAG + " Error in Clean(ImageView p_image) of ImageLoader", t);
        }
    }
}
/**
 * 
 * This is class waits until there are any images to load in the queue.
 */
class ImagesLoader extends Thread
{
    public void run()
    {
        try
        {
            while (true)
            {
                if (m_imagesQueue.m_imagesToLoad.size() == 0)
                    synchronized (m_imagesQueue.m_imagesToLoad)
                    {
                        m_imagesQueue.m_imagesToLoad.wait();
                    }
                if (m_imagesQueue.m_imagesToLoad.size() != 0)
                {
                    ImageToLoad m_imageToLoadObj;
                    synchronized (m_imagesQueue.m_imagesToLoad)
                    {
                        m_imageToLoadObj = m_imagesQueue.m_imagesToLoad.pop();
                    }
                    Bitmap m_bmp = getBitmap(m_imageToLoadObj.m_url);
                    m_cache.put(m_imageToLoadObj.m_url, m_bmp);
                    if (((String) m_imageToLoadObj.m_imageView.getTag()).equals(m_imageToLoadObj.m_url))
                    {
                        BitmapDisplayer m_bmpdisplayer = new BitmapDisplayer(m_bmp, m_imageToLoadObj.m_imageView, m_imageToLoadObj.m_prgBar);
                        Activity m_activity = (Activity) m_imageToLoadObj.m_imageView.getContext();
                        m_activity.runOnUiThread(m_bmpdisplayer);
                    }
                }
                if (Thread.interrupted())
                    break;
            }
        }
        catch (InterruptedException e)
        {
            /*
             * allow thread to exit
             */
        }
        catch (Throwable t)
        {
            CustomLogHandler.printErrorlog(t);
        }
    }
}
ImagesLoader m_imageLoaderThread = new ImagesLoader();
/**
 * This class Used to display bitmap in the UI thread
 */
class BitmapDisplayer implements Runnable
{
    Bitmap m_bmp;
    ImageView m_imageView;
    ProgressBar m_prgBar;
    public BitmapDisplayer(Bitmap p_bmp, ImageView p_imgview, ProgressBar p_prgBar)
    {
        m_bmp = p_bmp;
        m_imageView = p_imgview;
        m_prgBar = p_prgBar;
    }
    public void run()
    {
        if (m_bmp != null)
        {
            m_imageView.setImageBitmap(m_bmp);
            m_prgBar.setVisibility(View.GONE);
            m_imageView.setVisibility(View.VISIBLE);
        }
    }
}
  }

Use the above class as below:

First you need to put the ProgressBar in your custom layout where you have your ImageView as below:

   <RelativeLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" 
    android:id="@+id/RelativeImagelayout"> 
      <ProgressBar android:id="@+id/Progress"
                android:layout_height="wrap_content"
                android:layout_width="wrap_content"
                android:layout_marginTop="10dp"/>
    <ImageView
        android:id="@+id/ivImage"
        android:layout_width="80dp"
        android:layout_height="90dp"
        android:layout_marginTop="10dp"
        android:clickable="false"/>
</RelativeLayout>

In your adapter class create the instance of the ImageLoader class and use it as below in your getView method:

   ImageView m_ibImage = (ImageView) v.findViewById(R.id.ivImage);
 ProgressBar m_pbProgress = (ProgressBar) v.findViewById(R.id.Progress);
        if (products.get(arg0).getImage().toString().equals(null)
                || products.get(arg0).getImage().toString().equals(""))
        {
            m_pbProgress.setVisibility(View.INVISIBLE);
            m_ibImage.setVisibility(View.VISIBLE);
        }
        else if (!products.get(arg0).getImage().toString().equals(null))
        {
            m_imgLoader.DisplayImage(products.get(arg0).getImage(), m_ibImage,
                    m_pbProgress);
        }

I hope it will help you.

Thanks

Read More

I got the solution for this problem. Below are the solution

public boolean sendEmail() {
    String destLocation = "";
    String FILE = Environment.getExternalStorageDirectory()+"";
    destLocation =  FILE + "/" + Global.FILENAME;


    boolean success = false;
    Intent intentSendMail = new Intent(Intent.ACTION_SEND);

    File mydir = getApplicationContext().getDir(Global.FOLDERNAME, Context.MODE_PRIVATE); 
    File fileWithinMyDir = new File(mydir, Global.FILENAME);

    copyFile(Uri.fromFile(fileWithinMyDir).toString(),destLocation);

    if (!fileWithinMyDir.exists() || !fileWithinMyDir.canRead()) {
        Toast.makeText(this, "Attachment Error", Toast.LENGTH_SHORT).show();
        success = false;
    } else {
        intentSendMail.setType("application/csv");
        intentSendMail.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://"+destLocation));

        intentSendMail.putExtra(Intent.EXTRA_SUBJECT,
                "Test Play file.");
        intentSendMail.putExtra(Intent.EXTRA_TEXT, "");

        startActivity(Intent.createChooser(intentSendMail, "E-mail"));

        success = true;
    }
    return success;
}

Read More