Converting file to byte array slowing down the app

Question

I'm using this library: https://github.com/alxrm/audiowave-progressbar to give an audio wave effect like Soundcloud music player.

This is how I implemented:

byte[] data = convert(songsList.get(currentSongIndex).get("songPath"));

final AudioWaveView waveView = (AudioWaveView) findViewById(R.id.wave);

waveView.setScaledData(data);
waveView.setRawData(data, new OnSamplingListener() {
    @Override
    public void onComplete() {

    }
});

waveView.setOnProgressListener(new OnProgressListener() {
    @Override
    public void onStartTracking(float progress) {

    }

    @Override
    public void onStopTracking(float progress) {

    }

    @Override
    public void onProgressChanged(float progress, boolean byUser) {

    }
});

This is the method that converts the file to byte array using the said file's path

public byte[] convert(String path) throws IOException {

    FileInputStream fis = new FileInputStream(path);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    byte[] b = new byte[1024];

    for (int readNum; (readNum = fis.read(b)) != -1;) {
        bos.write(b, 0, readNum);
    }

    byte[] bytes = bos.toByteArray();

    return bytes;
}

Maybe the problem is due to not getting the array asynchronously, but I'm not sure.

Can anyone help me with this?

EDIT: As @commonsware suggested correctly, I did this:

 class AudioWave extends AsyncTask<String,Integer,String>{
     private Context mContext;
     private View rootView;
     public MusicPlayerActivity m;
     final AudioWaveView waveView = (AudioWaveView) m.findViewById(R.id.wave);

     public AudioWave(MusicPlayerActivity m1){
         m = m1;
     }
     // Runs in UI before background thread is called
     @Override
     protected void onPreExecute() {
         super.onPreExecute();

         // Do something like display a progress bar
     }
    byte[] b2;
     // This is run in a background thread
     @Override
     protected String doInBackground(String... params){
         // get the string from params, which is an array
         String path = params[0];
         try {
             FileInputStream fis = new FileInputStream(path);
             ByteArrayOutputStream bos = new ByteArrayOutputStream();
             byte[] b = new byte[1024];
             try {
                 for (int readNum; (readNum = fis.read(b)) != -1; ) {
                     bos.write(b, 0, readNum);
                 }

             }catch(IOException e){

             }

         byte[] bytes = bos.toByteArray();
             b2=bytes;
             new MusicPlayerActivity().setData(b2);
         }
         catch (FileNotFoundException e){

         }
         return "lol";
     }

     // This is called from background thread but runs in UI
     @Override
     protected void onProgressUpdate(Integer... values) {

         super.onProgressUpdate(values);

         // Do things like update the progress bar
     }

     // This runs in UI when background thread finishes
     @Override
     protected void onPostExecute(String result) {
         waveView.setScaledData(b2);
         waveView.setRawData(b2, new OnSamplingListener() {
             @Override
             public void onComplete() {

             }
         });

         waveView.setOnProgressListener(new OnProgressListener() {
             @Override
             public void onStartTracking(float progress) {

             }

             @Override
             public void onStopTracking(float progress) {

             }

             @Override
             public void onProgressChanged(float progress, boolean byUser) {

             }
         });

         super.onPostExecute(result);
         // Do things like hide the progress bar or change a TextView
     }
 }

Answer 1

Loading a local file the way you do is totally inefficient:

1. You are using a very small buffer of 1024 bytes. The larger a buffer is the better speed you get, especially considering that a Smartphone uses flash memory which uses larger memory blocks internally.

2. You are using ByteArrayOutputStream. This is a dynamically growing byte array. Every time it grows beyond the size of the current buffer everything has do be copied from the old buffer to the new buffer. As it is a local file you know the file size and hence you could initialize the buffer with the full size. But then you don't need ByteArrayOutputStream anymore.

Hence you can simply load the file using one read command:

File f = new File(path);
int size = (int) g.length();
byte[] fileData = new byte[size];
try (DataInputStream in = new DatInpuStream(FileInputStream(f)))) {
    in.readFully(fileData);
}

Anyway this will work only for "small" files as you load it completely into memory. If you AudioWaveView supports it you should with a streaming approach: wrap an FileInputStream with an BufferedInputStream with it's buffer size set to 512KB or so.

Answer 2

Doing I/O on the main application thread will freeze your UI for the duration of that I/O, meaning that your UI will be unresponsive. Moving I/O to a background thread is necessary for a well-behaved UI.

Android's insistence that we can only safely update the UI from the main application thread means that you need to use an AsyncTask, a Thread and stuff like runOnUiThread(), RxJava/RxAndroid, or other approaches to arrange both the background work and updating the UI when that background work is done.

In your case, doing the convert() logic on a background thread, and updating the waveView on the main application thread, should help.

Answer 3

Please use this function to improve performance---

private static byte[] readBytesFromFile(String filePath) {

        FileInputStream fileInputStream = null;
        byte[] bytesArray = null;

        try {

            File file = new File(filePath);
            bytesArray = new byte[(int) file.length()];

            //read file into bytes[]
            fileInputStream = new FileInputStream(file);
            fileInputStream.read(bytesArray);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        return bytesArray;

    }