ProxyFileUtils.java

package com.wm.remusic.proxy.utils;

import android.content.Context;
import android.util.Log;

import com.wm.remusic.proxy.db.CacheFileInfoDao;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URI;

public class ProxyFileUtils {
    private static final String LOG_TAG = ProxyFileUtils.class.getSimpleName();

    private static ProxyFileUtils fileUtilsByMediaPlayer;
    private static ProxyFileUtils fileUtilsByPreLoader;

    public static ProxyFileUtils getInstance(Context context, URI uri, boolean isUseByMediaPlayer) {
        // 如果文件名有错误，返回空Utils
        String name = getValidFileName(uri);
        if (name == null || name.length() <= 0) {
            ProxyFileUtils utils = new ProxyFileUtils(context, null);
            utils.setEnableFalse();
            return utils;
        }
        // 如果是预加载，如果MediaPlayer正在使用文件，则不预加载，返回空Utils
        if (!isUseByMediaPlayer) {
            if (fileUtilsByMediaPlayer != null && fileUtilsByMediaPlayer.getFileName().equals(name)) {
                ProxyFileUtils utils = new ProxyFileUtils(context, null);
                utils.setEnableFalse();
                return utils;
            }
        }
        // 创建Utils，关闭之前Util。如果是MediaPlayer使用文件Preloader也在使用，则关闭Preloader的Utils
        if (isUseByMediaPlayer) {
            if (fileUtilsByPreLoader != null && fileUtilsByPreLoader.getFileName().equals(name)) {
                close(fileUtilsByPreLoader, false);
            }
            close(fileUtilsByMediaPlayer, true);
            fileUtilsByMediaPlayer = new ProxyFileUtils(context, name);
            return fileUtilsByMediaPlayer;
        } else {
            close(fileUtilsByPreLoader, false);
            fileUtilsByPreLoader = new ProxyFileUtils(context, name);
            return fileUtilsByPreLoader;
        }
    }

    private boolean isEnable;

    private FileOutputStream outputStream;
    private RandomAccessFile randomAccessFile;
    private File file;

    /**
     * 判断存储是否可用
     *
     * @return
     */
    private boolean isSdAvaliable() {
        // 判断外部存储器是否可用
        File dir = new File(Constants.DOWNLOAD_PATH);
        if (!dir.exists()) {
            dir.mkdirs();
            if (!dir.exists()) {
                return false;
            }
        }
        // 删除部分缓存文件
        ProxyUtils.asynRemoveBufferFile(Constants.CACHE_FILE_NUMBER);
        // 可用空间大小是否大于SD卡预留最小值
        long freeSize = ProxyUtils.getAvailaleSize(Constants.DOWNLOAD_PATH);
        if (freeSize > Constants.SD_REMAIN_SIZE) {
            return true;
        } else {

            return false;
        }
    }

    private ProxyFileUtils(Context context, String name) {
        if (name == null || name.length() <= 0) {
            isEnable = false;
            return;
        }

        if (!isSdAvaliable()) {
            isEnable = false;
            return;
        }

        try {
            //Log.e("path","/");
            file = new File(context.getCacheDir().getPath() + name);
            if (!file.exists()) {
                File dir = new File(Constants.DOWNLOAD_PATH);
                dir.mkdirs();
                file.createNewFile();
            }
            randomAccessFile = new RandomAccessFile(file, "r");
            outputStream = new FileOutputStream(file, true);
            isEnable = true;
        } catch (IOException e) {
            isEnable = false;
            Log.e(LOG_TAG, "文件操作失败，无SD？", e);
        }
    }

    public String getFileName() {
        return file.getName();
    }

    public boolean isEnable() {
        return isEnable;
    }

    public void setEnableFalse() {
        isEnable = false;
    }

    public int getLength() {
        if (isEnable) {
            return (int) file.length();
        } else {
            return -1;
        }
    }

    public boolean delete() {
        return file.delete();
    }

    public byte[] read(int startPos) {
        if (isEnable) {
            int byteCount = (int) (getLength() - startPos);
            byte[] tmp = new byte[byteCount];
            try {
                randomAccessFile.seek(startPos);
                randomAccessFile.read(tmp);
                return tmp;
            } catch (IOException e) {
                Log.e(LOG_TAG, "缓存读取失败", e);
                return null;
            }
        } else {
            return null;
        }
    }

    public byte[] read(int startPos, int length) {
        if (isEnable) {
            int byteCount = (int) (getLength() - startPos);
            if (byteCount > length) {
                byteCount = length;
            }
            byte[] tmp = new byte[byteCount];
            try {
                randomAccessFile.seek(startPos);
                randomAccessFile.read(tmp);
                return tmp;
            } catch (IOException e) {
                Log.e(LOG_TAG, "缓存读取失败", e);
                return null;
            }
        } else {
            return null;
        }
    }

    public void write(byte[] buffer, int byteCount) {
        if (isEnable) {
            try {
                outputStream.write(buffer, 0, byteCount);
                outputStream.flush();
            } catch (IOException e) {
                Log.e(LOG_TAG, "缓存写入失败", e);
            }
        }
    }

    public static void close(ProxyFileUtils fileUtils, boolean isUseByMediaPlayer) {
        if (isUseByMediaPlayer) {
            if (fileUtilsByMediaPlayer != null && fileUtilsByMediaPlayer == fileUtils) {
                fileUtilsByMediaPlayer.setEnableFalse();
                fileUtilsByMediaPlayer = null;
            }
        } else {
            if (fileUtilsByPreLoader != null && fileUtilsByPreLoader == fileUtils) {
                fileUtilsByPreLoader.setEnableFalse();
                fileUtilsByPreLoader = null;
            }
        }
    }

    public static void deleteFile(String url) {
        URI uri = URI.create(url);
        String name = getValidFileName(uri);
        boolean isSuccess = new File(name).delete();
        if (isSuccess) {
            CacheFileInfoDao.getInstance().delete(name);
        }
    }

    public static boolean isFinishCache(String url) {
        URI uri = URI.create(url);
        String name = getValidFileName(uri);
        File f = new File(name);

        if (!f.exists()) {
            return false;
        }
        if (f.length() != CacheFileInfoDao.getInstance().getFileSize(name)) {
            return false;
        }
        return true;
    }

    /**
     * 获取有效的文件名
     *
     * @param url
     * @return
     */
    static protected String getValidFileName(URI uri) {
        String path = uri.getRawPath();
        String name = path.substring(path.lastIndexOf("/"));
        name = name.replace("\\", "");
        name = name.replace("/", "");
        name = name.replace(":", "");
        name = name.replace("*", "");
        name = name.replace("?", "");
        name = name.replace("\"", "");
        name = name.replace("<", "");
        name = name.replace(">", "");
        name = name.replace("|", "");
        name = name.replace(" ", "_"); // 前面的替换会产生空格,最后将其一并替换掉
        return name;
    }
}