Thursday, 5 September 2013

Download Audio File From Server in Android

XML FILE

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
        <TextView
                android:id="@+id/status_text_label"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="@string/status_text_default"
            />
        <EditText
                android:id="@+id/url_input"
                android:text="http://"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                />
        <Button
                android:text="Download"
                android:id="@+id/download_button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                />
</LinearLayout>


MAINACTIVITY.JAVA

package com.example.download;

import android.app.Activity;
import android.app.ProgressDialog;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener
{
       // Used to communicate state changes in the DownloaderThread
       public static final int MESSAGE_DOWNLOAD_STARTED = 1000;
       public static final int MESSAGE_DOWNLOAD_COMPLETE = 1001;
       public static final int MESSAGE_UPDATE_PROGRESS_BAR = 1002;
       public static final int MESSAGE_DOWNLOAD_CANCELED = 1003;
       public static final int MESSAGE_CONNECTING_STARTED = 1004;
       public static final int MESSAGE_ENCOUNTERED_ERROR = 1005;
     
       // instance variables
       private MainActivity thisActivity;
       private Thread downloaderThread;
       private ProgressDialog progressDialog;
     
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState)
   {
       super.onCreate(savedInstanceState);
       thisActivity = this;
       downloaderThread = null;
       progressDialog = null;
       setContentView(R.layout.activity_main);
       Button button = (Button) this.findViewById(R.id.download_button);
       button.setOnClickListener(this);
   }

   /** Called when the user clicks on something. */
       @Override
       public void onClick(View view)
       {
               EditText urlInputField = (EditText) this.findViewById(R.id.url_input);
               String urlInput ="http://www.ipottechnologies.com/android/songs/demo.mp3"; /*urlInputField.getText().toString();*/
               downloaderThread = new DownloaderThread(thisActivity, urlInput);
               downloaderThread.start();
       }
     
       /**
        * This is the Handler for this activity. It will receive messages from the
        * DownloaderThread and make the necessary updates to the UI.
        */
       public Handler activityHandler = new Handler()
       {
               public void handleMessage(Message msg)
               {
                       switch(msg.what)
                       {
                               /*
                                * Handling MESSAGE_UPDATE_PROGRESS_BAR:
                                * 1. Get the current progress, as indicated in the arg1 field
                                *    of the Message.
                                * 2. Update the progress bar.
                                */
                               case MESSAGE_UPDATE_PROGRESS_BAR:
                                       if(progressDialog != null)
                                       {
                                               int currentProgress = msg.arg1;
                                               progressDialog.setProgress(currentProgress);
                                       }
                                       break;
                             
                               /*
                                * Handling MESSAGE_CONNECTING_STARTED:
                                * 1. Get the URL of the file being downloaded. This is stored
                                *    in the obj field of the Message.
                                * 2. Create an indeterminate progress bar.
                                * 3. Set the message that should be sent if user cancels.
                                * 4. Show the progress bar.
                                */
                               case MESSAGE_CONNECTING_STARTED:
                                       if(msg.obj != null && msg.obj instanceof String)
                                       {
                                               String url = (String) msg.obj;
                                               // truncate the url
                                               if(url.length() > 16)
                                               {
                                                       String tUrl = url.substring(0, 15);
                                                       tUrl += "...";
                                                       url = tUrl;
                                               }
                                               String pdTitle = thisActivity.getString(R.string.progress_dialog_title_connecting);
                                               String pdMsg = thisActivity.getString(R.string.progress_dialog_message_prefix_connecting);
                                               pdMsg += " " + url;
                                             
                                               dismissCurrentProgressDialog();
                                               progressDialog = new ProgressDialog(thisActivity);
                                               progressDialog.setTitle(pdTitle);
                                               progressDialog.setMessage(pdMsg);
                                               progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
                                               progressDialog.setIndeterminate(true);
                                               // set the message to be sent when this dialog is canceled
                                               Message newMsg = Message.obtain(this, MESSAGE_DOWNLOAD_CANCELED);
                                               progressDialog.setCancelMessage(newMsg);
                                               progressDialog.show();
                                       }
                                       break;
                                     
                               /*
                                * Handling MESSAGE_DOWNLOAD_STARTED:
                                * 1. Create a progress bar with specified max value and current
                                *    value 0; assign it to progressDialog. The arg1 field will
                                *    contain the max value.
                                * 2. Set the title and text for the progress bar. The obj
                                *    field of the Message will contain a String that
                                *    represents the name of the file being downloaded.
                                * 3. Set the message that should be sent if dialog is canceled.
                                * 4. Make the progress bar visible.
                                */
                               case MESSAGE_DOWNLOAD_STARTED:
                                       // obj will contain a String representing the file name
                                       if(msg.obj != null && msg.obj instanceof String)
                                       {
                                               int maxValue = msg.arg1;
                                               String fileName = (String) msg.obj;
                                               String pdTitle = thisActivity.getString(R.string.progress_dialog_title_downloading);
                                               String pdMsg = thisActivity.getString(R.string.progress_dialog_message_prefix_downloading);
                                               pdMsg += " " + fileName;
                                             
                                               dismissCurrentProgressDialog();
                                               progressDialog = new ProgressDialog(thisActivity);
                                               progressDialog.setTitle(pdTitle);
                                               progressDialog.setMessage(pdMsg);
                                               progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                                               progressDialog.setProgress(0);
                                               progressDialog.setMax(maxValue);
                                               // set the message to be sent when this dialog is canceled
                                               Message newMsg = Message.obtain(this, MESSAGE_DOWNLOAD_CANCELED);
                                               progressDialog.setCancelMessage(newMsg);
                                               progressDialog.setCancelable(true);
                                               progressDialog.show();
                                       }
                                       break;
                             
                               /*
                                * Handling MESSAGE_DOWNLOAD_COMPLETE:
                                * 1. Remove the progress bar from the screen.
                                * 2. Display Toast that says download is complete.
                                */
                               case MESSAGE_DOWNLOAD_COMPLETE:
                                       dismissCurrentProgressDialog();
                                       displayMessage(getString(R.string.user_message_download_complete));
                                       break;
                                     
                               /*
                                * Handling MESSAGE_DOWNLOAD_CANCELLED:
                                * 1. Interrupt the downloader thread.
                                * 2. Remove the progress bar from the screen.
                                * 3. Display Toast that says download is complete.
                                */
                               case MESSAGE_DOWNLOAD_CANCELED:
                                       if(downloaderThread != null)
                                       {
                                               downloaderThread.interrupt();
                                       }
                                       dismissCurrentProgressDialog();
                                       displayMessage(getString(R.string.user_message_download_canceled));
                                       break;
                             
                               /*
                                * Handling MESSAGE_ENCOUNTERED_ERROR:
                                * 1. Check the obj field of the message for the actual error
                                *    message that will be displayed to the user.
                                * 2. Remove any progress bars from the screen.
                                * 3. Display a Toast with the error message.
                                */
                               case MESSAGE_ENCOUNTERED_ERROR:
                                       // obj will contain a string representing the error message
                                       if(msg.obj != null && msg.obj instanceof String)
                                       {
                                               String errorMessage = (String) msg.obj;
                                               dismissCurrentProgressDialog();
                                               displayMessage(errorMessage);
                                       }
                                       break;
                                     
                               default:
                                       // nothing to do here
                                       break;
                       }
               }
       };
     
       /**
        * If there is a progress dialog, dismiss it and set progressDialog to
        * null.
        */
       public void dismissCurrentProgressDialog()
       {
               if(progressDialog != null)
               {
                       progressDialog.hide();
                       progressDialog.dismiss();
                       progressDialog = null;
               }
       }
     
       /**
        * Displays a message to the user, in the form of a Toast.
        * @param message Message to be displayed.
        */
       public void displayMessage(String message)
       {
               if(message != null)
               {
                       Toast.makeText(thisActivity, message, Toast.LENGTH_SHORT).show();
               }
       }
}

DOWNLOADERTHREAD.JAVA

package com.example.download;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

import android.os.Environment;
import android.os.Message;

/**
 * Downloads a file in a thread. Will send messages to the
 * AndroidFileDownloader activity to update the progress bar.
 */
public class DownloaderThread extends Thread
{
        // constants
        private static final int DOWNLOAD_BUFFER_SIZE = 4096;
       
        // instance variables
        private MainActivity parentActivity;
        private String downloadUrl;
       
        /**
         * Instantiates a new DownloaderThread object.
         * @param parentActivity Reference to AndroidFileDownloader activity.
         * @param inUrl String representing the URL of the file to be downloaded.
         */
        public DownloaderThread(MainActivity inParentActivity, String inUrl)
        {
                downloadUrl = "";
                if(inUrl != null)
                {
                        downloadUrl = inUrl;
                }
                parentActivity = inParentActivity;
        }
       
        /**
         * Connects to the URL of the file, begins the download, and notifies the
         * AndroidFileDownloader activity of changes in state. Writes the file to
         * the root of the SD card.
         */
        @Override
        public void run()
        {
                URL url;
                URLConnection conn;
                int fileSize, lastSlash;
                String fileName;
                BufferedInputStream inStream;
                BufferedOutputStream outStream;
                File outFile;
                FileOutputStream fileStream;
                Message msg;
               
                // we're going to connect now
                msg = Message.obtain(parentActivity.activityHandler,
                MainActivity.MESSAGE_CONNECTING_STARTED,
                                0, 0, downloadUrl);
                parentActivity.activityHandler.sendMessage(msg);
               
                try
                {
                        url = new URL(downloadUrl);
                        conn = url.openConnection();
                        conn.setUseCaches(false);
                        fileSize = conn.getContentLength();
                       
                        // get the filename
                        lastSlash = url.toString().lastIndexOf('/');
                        fileName = "file.bin";
                        if(lastSlash >=0)
                        {
                                fileName = url.toString().substring(lastSlash + 1);
                        }
                        if(fileName.equals(""))
                        {
                                fileName = "file.bin";
                        }
                       
                        // notify download start
                        int fileSizeInKB = fileSize / 1024;
                        msg = Message.obtain(parentActivity.activityHandler,
                        MainActivity.MESSAGE_DOWNLOAD_STARTED,
                                        fileSizeInKB, 0, fileName);
                        parentActivity.activityHandler.sendMessage(msg);
                       
                        // start download
                        inStream = new BufferedInputStream(conn.getInputStream());
                        outFile = new File(Environment.getExternalStorageDirectory() + "/" + fileName);
                        fileStream = new FileOutputStream(outFile);
                        outStream = new BufferedOutputStream(fileStream, DOWNLOAD_BUFFER_SIZE);
                        byte[] data = new byte[DOWNLOAD_BUFFER_SIZE];
                        int bytesRead = 0, totalRead = 0;
                        while(!isInterrupted() && (bytesRead = inStream.read(data, 0, data.length)) >= 0)
                        {
                                outStream.write(data, 0, bytesRead);
                               
                                // update progress bar
                                totalRead += bytesRead;
                                int totalReadInKB = totalRead / 1024;
                                msg = Message.obtain(parentActivity.activityHandler,
                                MainActivity.MESSAGE_UPDATE_PROGRESS_BAR,
                                                totalReadInKB, 0);
                                parentActivity.activityHandler.sendMessage(msg);
                        }
                       
                        outStream.close();
                        fileStream.close();
                        inStream.close();
                       
                        if(isInterrupted())
                        {
                                // the download was canceled, so let's delete the partially downloaded file
                                outFile.delete();
                        }
                        else
                        {
                                // notify completion
                                msg = Message.obtain(parentActivity.activityHandler,
                                MainActivity.MESSAGE_DOWNLOAD_COMPLETE);
                                parentActivity.activityHandler.sendMessage(msg);
                        }
                }
                catch(MalformedURLException e)
                {
                        String errMsg = parentActivity.getString(R.string.error_message_bad_url);
                        msg = Message.obtain(parentActivity.activityHandler,
                        MainActivity.MESSAGE_ENCOUNTERED_ERROR,
                                        0, 0, errMsg);
                        parentActivity.activityHandler.sendMessage(msg);
                }
                catch(FileNotFoundException e)
                {
                        String errMsg = parentActivity.getString(R.string.error_message_file_not_found);
                        msg = Message.obtain(parentActivity.activityHandler,
                        MainActivity.MESSAGE_ENCOUNTERED_ERROR,
                                        0, 0, errMsg);
                        parentActivity.activityHandler.sendMessage(msg);
                }
                catch(Exception e)
                {
                        String errMsg = parentActivity.getString(R.string.error_message_general);
                        msg = Message.obtain(parentActivity.activityHandler,
                        MainActivity.MESSAGE_ENCOUNTERED_ERROR,
                                        0, 0, errMsg);
                        parentActivity.activityHandler.sendMessage(msg);
                }
        }
       
}


ADD FOLLOWING USES PERMISSION

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



No comments:

Post a Comment