Java 从SD卡播放音乐在emulator上工作，但在手机上不工作

我正在创建一个android应用程序来播放用户的音乐。我已经让它在模拟器上正常工作了，但当我把它安装在手机上时，它就不工作了，它在这行崩溃了：

int songIndex = new Random().nextInt(songsList.size());

因为songList.size（）返回0，因为在手机上运行时似乎找不到音乐。我在手机里放了一张Micro SD卡，并将音乐加载到它（根文件夹中）。我使用以下方法获取路径：

final String MEDIA_PATH = Environment.getExternalStorageDirectory().getAbsolutePath();

在emulator和手机上，返回的字符串都是/mnt/sdcard。但它只在模拟器上工作。我还将以下权限包括在清单文件中：

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

有什么想法吗

编辑：

我没有包括这个，因为我认为它不会有多大帮助，但这是我用来获取歌曲列表的代码：

public ArrayList<HashMap<String, String>> getPlaylist(){
    File home = new File(MEDIA_PATH);

    if(home.listFiles(new FileExtensionFilter()).length > 0) {
        for(File file : home.listFiles(new FileExtensionFilter())){
            HashMap<String, String> song = new HashMap<String, String>();
            song.put("songTitle", file.getName().substring(0, (file.getName().length() -4)));
            song.put("songPath", file.getPath());

            //Add song to song list
            songsList.add(song);
        }
    }

    return songsList;
}

public ArrayList getPlaylist（）{
文件主目录=新文件（媒体路径）；
if（home.listFiles（新文件扩展筛选器（））.length>0）{
对于（文件：home.listFiles（新的FileExtensionFilter（）））{
HashMap宋=新HashMap（）；
song.put（“songTitle”，file.getName（）.substring（0，（file.getName（）.length（）-4））；
put（“songPath”，file.getPath（））；
//将歌曲添加到歌曲列表
歌曲列表。添加（歌曲）；
}
}
返回歌曲列表；
}

怎么样

return Environment.getExternalStorageDirectory().toString() + "/Music";

这将返回内部SD装载点的路径，如“/mnt/sdcard”

这是一种比路径中的硬编码更好的编码方式

编辑

为了让它在所有设备上运行，请尝试下面的代码，他们在这里讨论了安卓除了外部存储之外没有“外部SD”的概念。OP然后根据所有的答案和评论为他的问题提出了以下解决方案

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

import android.os.Environment;
import android.util.Log;

public class ExternalStorage {

public static final String SD_CARD = "sdCard";
public static final String EXTERNAL_SD_CARD = "externalSdCard";

/**
 * @return True if the external storage is available. False otherwise.
 */
public static boolean isAvailable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state) || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        return true;
    }
    return false;
}

public static String getSdCardPath() {
    return Environment.getExternalStorageDirectory().getPath() + "/";
}

/**
 * @return True if the external storage is writable. False otherwise.
 */
public static boolean isWritable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state)) {
        return true;
    }
    return false;

}

/**
 * @return A map of all storage locations available
 */
public static Map<String, File> getAllStorageLocations() {
    Map<String, File> map = new HashMap<String, File>(10);

    List<String> mMounts = new ArrayList<String>(10);
    List<String> mVold = new ArrayList<String>(10);
    mMounts.add("/mnt/sdcard");
    mVold.add("/mnt/sdcard");

    try {
        File mountFile = new File("/proc/mounts");
        if(mountFile.exists()){
            Scanner scanner = new Scanner(mountFile);
            while (scanner.hasNext()) {
                String line = scanner.nextLine();
                if (line.startsWith("/dev/block/vold/")) {
                    String[] lineElements = line.split(" ");
                    String element = lineElements[1];

                    // don't add the default mount path
                    // it's already in the list.
                    if (!element.equals("/mnt/sdcard"))
                        mMounts.add(element);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        File voldFile = new File("/system/etc/vold.fstab");
        if(voldFile.exists()){
            Scanner scanner = new Scanner(voldFile);
            while (scanner.hasNext()) {
                String line = scanner.nextLine();
                if (line.startsWith("dev_mount")) {
                    String[] lineElements = line.split(" ");
                    String element = lineElements[2];

                    if (element.contains(":"))
                        element = element.substring(0, element.indexOf(":"));
                    if (!element.equals("/mnt/sdcard"))
                        mVold.add(element);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }


    for (int i = 0; i < mMounts.size(); i++) {
        String mount = mMounts.get(i);
        if (!mVold.contains(mount))
            mMounts.remove(i--);
    }
    mVold.clear();

    List<String> mountHash = new ArrayList<String>(10);

    for(String mount : mMounts){
        File root = new File(mount);
        if (root.exists() && root.isDirectory() && root.canWrite()) {
            File[] list = root.listFiles();
            String hash = "[";
            if(list!=null){
                for(File f : list){
                    hash += f.getName().hashCode()+":"+f.length()+", ";
                }
            }
            hash += "]";
            if(!mountHash.contains(hash)){
                String key = SD_CARD + "_" + map.size();
                if (map.size() == 0) {
                    key = SD_CARD;
                } else if (map.size() == 1) {
                    key = EXTERNAL_SD_CARD;
                }
                mountHash.add(hash);
                map.put(key, root);
            }
        }
    }

    mMounts.clear();

    if(map.isEmpty()){
             map.put(SD_CARD, Environment.getExternalStorageDirectory());
    }
    return map;
}
}

导入java.io.File；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.Scanner；
导入android.os.Environment；
导入android.util.Log；
公共类外部存储{
公共静态最终字符串SD_CARD=“sdCard”；
公共静态最终字符串EXTERNAL\u SD\u CARD=“externalSdCard”；
/**
*@如果外部存储器可用，则返回True。否则返回False。
*/
公共静态布尔值isAvailable（）{
String state=Environment.getExternalStorageState（）；
if（Environment.MEDIA_MOUNTED.equals（state）| Environment.MEDIA_MOUNTED_READ_ONLY.equals（state））{
返回true；
}
返回false；
}
公共静态字符串getSdCardPath（）{
返回Environment.getExternalStorageDirectory（）.getPath（）+“/”；
}
/**
*@如果外部存储器可写，则返回True；否则返回False。
*/
公共静态布尔值可写（）{
String state=Environment.getExternalStorageState（）；
if（环境、介质、安装等于（状态））{
返回true；
}
返回false；
}
/**
*@返回所有可用存储位置的地图
*/
公共静态映射getAllStorageLocations（）{
Map Map=新的HashMap（10）；
列表mMounts=新的ArrayList（10）；
List mVold=new ArrayList（10）；
mMounts.add（“/mnt/sdcard”）；
mVold.add（“/mnt/sdcard”）；
试一试{
File mountFile=新文件（“/proc/mounts”）；
if（mountFile.exists（））{
扫描仪=新扫描仪（挂载文件）；
while（scanner.hasNext（））{
字符串行=scanner.nextLine（）；
if（行.startsWith（“/dev/block/vold/”）{
String[]lineElements=line.split（“”）；
String元素=lineElements[1]；
//不要添加默认装载路径
//它已经在列表中了。
如果（！element.equals（“/mnt/sdcard”））
mMounts.add（元素）；
}
}
}
}捕获（例外e）{
e、 printStackTrace（）；
}
试一试{
File voldFile=新文件（“/system/etc/vold.fstab”）；
if（voldFile.exists（））{
扫描仪=新扫描仪（voldFile）；
while（scanner.hasNext（））{
字符串行=scanner.nextLine（）；
if（line.startsWith（“dev_mount”））{
String[]lineElements=line.split（“”）；
String元素=lineElements[2]；
if（element.contains（“：”）
element=element.substring（0，element.indexOf（“：”）；
如果（！element.equals（“/mnt/sdcard”））
mVold.add（元素）；
}
}
}
}捕获（例外e）{
e、 printStackTrace（）；
}
对于（int i=0；i

用法

Map<String, File> externalLocations = ExternalStorage.getAllStorageLocations();
File sdCard = externalLocations.get(ExternalStorage.SD_CARD);
File externalSdCard = externalLocations.get(ExternalStorage.EXTERNAL_SD_CARD);

Map externalLocations=ExternalStorage.getAllStorageLocations（）；
文件sdCard=externalLocations.get（ExternalStorage.SD_-CARD）；
文件交换