반응형
이동식 SD 카드의 위치 찾기
외장 SD 카드의 위치를 찾을 수 있는 보편적인 방법이 있습니까?
Environment.getExternalStorageState() 내부 SD 마운트 지점의 경로를 반환합니다./mnt/sdcard그러나 문제는 외부 SD에 관한 것입니다.다음과 같은 경로를 얻으려면 어떻게 해야 합니까?/mnt/sdcard/external_sd(장치마다 다를 수 있음)?
마지막으로 출력의 필터링으로 마무리하겠습니다.mount파일 시스템 이름별 명령입니다.하지만 저는 이 방법이 충분히 견고한지 확신할 수 없습니다.
Environment.getExternalStorageState()"/mnt/sdcard"와 같은 합니다.
아니요.Environment.getExternalStorageDirectory()장치 제조업체가 "외부 스토리지"로 간주한 모든 것을 말합니다.일부 장치에서는 SD 카드와 같은 이동식 미디어입니다.일부 장치에서는 장치 플래시의 일부입니다.여기서 "외부 스토리지"는 적어도 Android 1.x 및 2.x의 경우 "호스트 시스템에 마운트되었을 때 USB 대용량 스토리지 모드를 통해 액세스할 수 있는 것"을 의미합니다.
그러나 문제는 외부 SD에 관한 것입니다."/mnt/sdcard/external_sd"(기기마다 다를 수 있음)와 같은 경로를 얻는 방법은 무엇입니까?
Android는 위에서 설명한 바와 같이 외장 스토리지를 제외하고는 "외부 SD"라는 개념이 없습니다.
장치 제조업체에서 외부 스토리지를 온보드 플래시로 선택하고 SD 카드도 함께 사용하도록 선택한 경우 해당 제조업체에 문의하여 SD 카드를 사용할 수 있는지 여부(보증되지 않음)와 SD 카드 사용에 대한 규칙(사용 경로 등)을 결정해야 합니다.
갱신하다
최근 주목해야 할 두 가지 사항:
4 미디어 " SD에 대한 권한이 . 단, 첫째, Android 4.4+에서예이 ("외부 SD")에서 할 수 됩니다.getExternalFilesDirs()그리고.getExternalCacheDirs()특히 낮은 수준의 세부사항을 원하는 경우 이에 대한 Dave Smith의 훌륭한 분석을 참조하십시오.
둘째, 이동식 미디어 액세스가 Android SDK의 일부인지 여부에 대해 누구도 트집을 잡지 않도록 Dianne Hackborn의 평가를 들어보겠습니다.
...참고: Android 4.4 이전까지 공식 Android 플랫폼은 두 가지 특수한 경우를 제외하고는 SD 카드를 전혀 지원하지 않았습니다. 즉, 외부 스토리지가 SD 카드인 기존 학교 스토리지 레이아웃(오늘날에도 플랫폼에서 지원됨)과 Android 3에 작은 기능이 추가되었습니다.0에서는 추가 SD 카드를 스캔하여 미디어 공급자에 추가하고 앱에서 파일에 대한 읽기 전용 액세스 권한을 부여합니다(오늘날에도 이 플랫폼에서 지원됨).
Android 4.4는 애플리케이션이 실제로 SD 카드를 저장용으로 사용할 수 있도록 허용한 플랫폼의 첫 번째 릴리스입니다.그 이전에는 지원되지 않는 비공개 API를 통해 액세스했습니다.이제 플랫폼에는 애플리케이션이 이전보다 더 나은 방식으로 SD 카드를 지원되는 방식으로 사용할 수 있는 매우 풍부한 API가 있습니다. 애플리케이션에 아무런 권한이 필요하지 않고 애플리케이션별 스토리지 영역을 자유롭게 사용할 수 있으며 fi를 통과하는 한 SD 카드의 다른 파일에 액세스할 수 있습니다.lee picker(특별한 권한 없이 다시 선택).
저는 여기서 발견된 몇 가지 답변을 바탕으로 다음과 같은 해결책을 생각해냈습니다.
코드:
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;
}
}
용도:
Map<String, File> externalLocations = ExternalStorage.getAllStorageLocations();
File sdCard = externalLocations.get(ExternalStorage.SD_CARD);
File externalSdCard = externalLocations.get(ExternalStorage.EXTERNAL_SD_CARD);
나는 사용하는 애플리케이션이 있었습니다.ListPreference저장할 위치를 선택해야 합니다.
그 앱에서, 나는 스캔했습니다./proc/mounts그리고./system/etc/vold.fstabpoints.sdcard 파일 이름입니다.는 각 를 두 의 별도의 각파의마지두개개의저파다장으로 했습니다.ArrayLists의
그런 다음 한 리스트를 다른 리스트와 비교하여 두 리스트에 없는 아이템을 폐기했습니다.각 sdcard에 대한 루트 경로 목록을 제공했습니다.
거기서부터, 나는 그 경로들을 테스트했습니다.File.exists(),File.isDirectory(),그리고.File.canWrite()만약 그 테스트들 중 하나가 거짓이라면, 저는 그 경로를 목록에서 해당 경로를 삭제했습니다.
목록에 남아 있던 것이 무엇이든 간에, 나는 로 변환했습니다.String[]을 사용할 수 .ListPreferencevalues 속성.
여기서 코드를 볼 수 있습니다.
ContextCompat.getExternalFilesDirs()라는 지원 라이브러리 함수를 사용해 볼 수 있습니다.
final File[] appsDir=ContextCompat.getExternalFilesDirs(getActivity(),null);
final ArrayList<File> extRootPaths=new ArrayList<>();
for(final File file : appsDir)
extRootPaths.add(file.getParentFile().getParentFile().getParentFile().getParentFile());
첫 번째는 기본 외부 스토리지이고 나머지는 실제 SD 카드 경로입니다.
다중 ".getParentFile()"의 이유는 원래 경로가 다음과 같기 때문에 다른 폴더로 이동하기 위해서입니다.
.../Android/data/YOUR_APP_PACKAGE_NAME/files/
편집: sd-card 경로를 얻기 위해 제가 만든 더 포괄적인 방법은 다음과 같습니다.
/**
* returns a list of all available sd cards paths, or null if not found.
*
* @param includePrimaryExternalStorage set to true if you wish to also include the path of the primary external storage
*/
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static List<String> getSdCardPaths(final Context context, final boolean includePrimaryExternalStorage)
{
final File[] externalCacheDirs=ContextCompat.getExternalCacheDirs(context);
if(externalCacheDirs==null||externalCacheDirs.length==0)
return null;
if(externalCacheDirs.length==1)
{
if(externalCacheDirs[0]==null)
return null;
final String storageState=EnvironmentCompat.getStorageState(externalCacheDirs[0]);
if(!Environment.MEDIA_MOUNTED.equals(storageState))
return null;
if(!includePrimaryExternalStorage&&VERSION.SDK_INT>=VERSION_CODES.HONEYCOMB&&Environment.isExternalStorageEmulated())
return null;
}
final List<String> result=new ArrayList<>();
if(includePrimaryExternalStorage||externalCacheDirs.length==1)
result.add(getRootOfInnerSdCardFolder(externalCacheDirs[0]));
for(int i=1;i<externalCacheDirs.length;++i)
{
final File file=externalCacheDirs[i];
if(file==null)
continue;
final String storageState=EnvironmentCompat.getStorageState(file);
if(Environment.MEDIA_MOUNTED.equals(storageState))
result.add(getRootOfInnerSdCardFolder(externalCacheDirs[i]));
}
if(result.isEmpty())
return null;
return result;
}
/** Given any file/folder inside an sd card, this will return the path of the sd card */
private static String getRootOfInnerSdCardFolder(File file)
{
if(file==null)
return null;
final long totalSpace=file.getTotalSpace();
while(true)
{
final File parentFile=file.getParentFile();
if(parentFile==null||parentFile.getTotalSpace()!=totalSpace||!parentFile.canRead())
return file.getAbsolutePath();
file=parentFile;
}
}
편집: 더 나은 솔루션:
https://stackoverflow.com/a/27197248/878126
모든 외부 저장소(SD 카드 또는 내부 비이동식 저장소)를 검색하려면 다음 코드를 사용할 수 있습니다.
final String state = Environment.getExternalStorageState();
if ( Environment.MEDIA_MOUNTED.equals(state) || Environment.MEDIA_MOUNTED_READ_ONLY.equals(state) ) { // we can read the External Storage...
//Retrieve the primary External Storage:
final File primaryExternalStorage = Environment.getExternalStorageDirectory();
//Retrieve the External Storages root directory:
final String externalStorageRootDir;
if ( (externalStorageRootDir = primaryExternalStorage.getParent()) == null ) { // no parent...
Log.d(TAG, "External Storage: " + primaryExternalStorage + "\n");
}
else {
final File externalStorageRoot = new File( externalStorageRootDir );
final File[] files = externalStorageRoot.listFiles();
for ( final File file : files ) {
if ( file.isDirectory() && file.canRead() && (file.listFiles().length > 0) ) { // it is a real directory (not a USB drive)...
Log.d(TAG, "External Storage: " + file.getAbsolutePath() + "\n");
}
}
}
}
또는 시스템을 사용할 수 있습니다.getenv("EXTERNAL_STORAGE")를 눌러 기본 외부 스토리지 디렉토리(예: "/storage/sdcard0")와 시스템을 검색합니다.getenv("Secondary_STORY")를 눌러 모든 보조 디렉터리의 목록을 가져옵니다(예: "/storage/extSdCard:/storage/UsbDriveA:/storage/UsbDriveB").이 경우에도 USB 드라이브를 제외하기 위해 보조 디렉터리 목록을 필터링할 수 있습니다.
어떤 경우에도 하드 코딩된 경로를 사용하는 것은 항상 나쁜 접근 방식입니다(특히 모든 제조업체가 원하는 대로 경로를 변경할 수 있는 경우).
Richard처럼 /proc/mounts 파일을 사용하여 사용 가능한 스토리지 옵션 목록을 가져옵니다.
public class StorageUtils {
private static final String TAG = "StorageUtils";
public static class StorageInfo {
public final String path;
public final boolean internal;
public final boolean readonly;
public final int display_number;
StorageInfo(String path, boolean internal, boolean readonly, int display_number) {
this.path = path;
this.internal = internal;
this.readonly = readonly;
this.display_number = display_number;
}
public String getDisplayName() {
StringBuilder res = new StringBuilder();
if (internal) {
res.append("Internal SD card");
} else if (display_number > 1) {
res.append("SD card " + display_number);
} else {
res.append("SD card");
}
if (readonly) {
res.append(" (Read only)");
}
return res.toString();
}
}
public static List<StorageInfo> getStorageList() {
List<StorageInfo> list = new ArrayList<StorageInfo>();
String def_path = Environment.getExternalStorageDirectory().getPath();
boolean def_path_internal = !Environment.isExternalStorageRemovable();
String def_path_state = Environment.getExternalStorageState();
boolean def_path_available = def_path_state.equals(Environment.MEDIA_MOUNTED)
|| def_path_state.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
boolean def_path_readonly = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);
BufferedReader buf_reader = null;
try {
HashSet<String> paths = new HashSet<String>();
buf_reader = new BufferedReader(new FileReader("/proc/mounts"));
String line;
int cur_display_number = 1;
Log.d(TAG, "/proc/mounts");
while ((line = buf_reader.readLine()) != null) {
Log.d(TAG, line);
if (line.contains("vfat") || line.contains("/mnt")) {
StringTokenizer tokens = new StringTokenizer(line, " ");
String unused = tokens.nextToken(); //device
String mount_point = tokens.nextToken(); //mount point
if (paths.contains(mount_point)) {
continue;
}
unused = tokens.nextToken(); //file system
List<String> flags = Arrays.asList(tokens.nextToken().split(",")); //flags
boolean readonly = flags.contains("ro");
if (mount_point.equals(def_path)) {
paths.add(def_path);
list.add(0, new StorageInfo(def_path, def_path_internal, readonly, -1));
} else if (line.contains("/dev/block/vold")) {
if (!line.contains("/mnt/secure")
&& !line.contains("/mnt/asec")
&& !line.contains("/mnt/obb")
&& !line.contains("/dev/mapper")
&& !line.contains("tmpfs")) {
paths.add(mount_point);
list.add(new StorageInfo(mount_point, false, readonly, cur_display_number++));
}
}
}
}
if (!paths.contains(def_path) && def_path_available) {
list.add(0, new StorageInfo(def_path, def_path_internal, def_path_readonly, -1));
}
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (buf_reader != null) {
try {
buf_reader.close();
} catch (IOException ex) {}
}
}
return list;
}
}
판독을 통해 추가 SD 카드가 장착된 위치를 찾을 수 있습니다./proc/mounts(표준 Linux 파일) 및 볼트 데이터에 대한 교차 검사(/system/etc/vold.conf 및 에서하십시오.Environment.getExternalStorageDirectory()Vold 구성에는 표시되지 않을 수 있지만(일부 장치에서는 마운트 해제할 수 없는 내부 스토리지) 여전히 목록에 포함되어야 합니다.하지만 우리는 사용자에게 그것들을 설명할 좋은 방법을 찾지 못했습니다.
이번에는 이 주제에 포함된 모든 솔루션을 시도합니다.그러나 하나의 외장(이동식) 카드와 하나의 내장(이동식) 카드가 있는 장치에서는 모두 제대로 작동하지 않았습니다.'mount' 명령, 'proc/mounts' 파일 등에서 외부 카드 경로를 가져올 수 없습니다.
그리고 저는 (Paulo Luan의) 저만의 해결책을 만듭니다.
String sSDpath = null;
File fileCur = null;
for( String sPathCur : Arrays.asList( "ext_card", "external_sd", "ext_sd", "external", "extSdCard", "externalSdCard")) // external sdcard
{
fileCur = new File( "/mnt/", sPathCur);
if( fileCur.isDirectory() && fileCur.canWrite())
{
sSDpath = fileCur.getAbsolutePath();
break;
}
}
fileCur = null;
if( sSDpath == null) sSDpath = Environment.getExternalStorageDirectory().getAbsolutePath();
보면를드의 ,android.os.EnvironmentAndroid는 경로에 대한 환경 변수에 크게 의존한다는 것을 알게 될 것입니다.2차_스토리지 환경 변수를 사용하여 이동식 sd 카드의 경로를 찾을 수 있습니다.
/**
* Get a file using an environmental variable.
*
* @param variableName
* The Environment variable name.
* @param paths
* Any paths to the file if the Environment variable was not found.
* @return the File or {@code null} if the File could not be located.
*/
private static File getDirectory(String variableName, String... paths) {
String path = System.getenv(variableName);
if (!TextUtils.isEmpty(path)) {
if (path.contains(":")) {
for (String _path : path.split(":")) {
File file = new File(_path);
if (file.exists()) {
return file;
}
}
} else {
File file = new File(path);
if (file.exists()) {
return file;
}
}
}
if (paths != null && paths.length > 0) {
for (String _path : paths) {
File file = new File(_path);
if (file.exists()) {
return file;
}
}
}
return null;
}
사용 예:
public static final File REMOVABLE_STORAGE = getDirectory("SECONDARY_STORAGE");
다음과 같이 간단히 사용할 수:
String primary_sd = System.getenv("EXTERNAL_STORAGE");
if(primary_sd != null)
Log.i("EXTERNAL_STORAGE", primary_sd);
String secondary_sd = System.getenv("SECONDARY_STORAGE");
if(secondary_sd != null)
Log.i("SECONDARY_STORAGE", secondary_sd)
외장 SD 카드의 위치를 찾을 수 있는 보편적인 방법이 있습니까?
보편적인 방법으로, 만약 당신이 공식적인 방법을 의미한다면; 네, 있습니다.
버전 4Kitkat에서는 레벨 19, 즉로 4.4 캣은다추그다니습가했음을들을 했습니다.File[] getExternalFilesDirs (String type)Context앱이 마이크로 SD 카드에 데이터/파일을 저장할 수 있는 클래스입니다.
Android 4.4는 실제로 앱이 저장을 위해 SD 카드를 사용할 수 있도록 허용한 플랫폼의 첫 번째 릴리스입니다.API 레벨 19 이전의 SD 카드에 대한 액세스는 지원되지 않는 비공개 API를 통해 이루어졌습니다.
getExternalFilesDirs(문자열 유형)는 모든 공유/외부 스토리지 장치의 애플리케이션별 디렉터리에 대한 절대 경로를 반환합니다.즉, 내부 메모리와 외부 메모리 모두에 경로를 반환합니다.일반적으로 두 번째로 반환되는 경로는 microSD 카드(있는 경우)의 저장 경로입니다.
하지만 주의하세요,
사용자가 이동식 미디어를 꺼낼 수 있기 때문에 공유 저장소를 항상 사용할 수 있는 것은 아닙니다.다음을 사용하여 미디어 상태를 확인할 수 있습니다.
getExternalStorageState(File).이 파일에는 보안이 적용되지 않습니다.를 들어, 를들어케, 애리이보류중을 보유한 응용 .
WRITE_EXTERNAL_STORAGE이 파일에 쓸 수 있습니다.
Google/Android 공식 문서에 따르면 내부 및 외부 스토리지 용어는 우리가 생각하는 것과 상당히 다릅니다.
외부 카드를 찾기 위해 사용하는 방법은 다음과 같습니다.mount cmd return을 사용한 다음 vfat 부분을 구문 분석합니다.
String s = "";
try {
Process process = new ProcessBuilder().command("mount")
.redirectErrorStream(true).start();
process.waitFor();
InputStream is = process.getInputStream();
byte[] buffer = new byte[1024];
while (is.read(buffer) != -1) {
s = s + new String(buffer);
}
is.close();
} catch (Exception e) {
e.printStackTrace();
}
//用行分隔mount列表
String[] lines = s.split("\n");
for(int i=0; i<lines.length; i++) {
//如果行内有挂载路径且为vfat类型，说明可能是内置或者外置sd的挂载点
if(-1 != lines[i].indexOf(path[0]) && -1 != lines[i].indexOf("vfat")) {
//再用空格分隔
String[] blocks = lines[i].split("\\s");
for(int j=0; j<blocks.length; j++) {
//判断是否是挂载为vfat类型
if(-1 != blocks[j].indexOf(path[0])) {
//Test if it is the external sd card.
}
}
}
}
이 솔루션은 다음과 같은 사실을 처리합니다.System.getenv("SECONDARY_STORAGE")마시멜로는 아무 소용이 없습니다.
테스트 및 작업:
- 삼성 갤럭시 탭 2 (Android 4.1.1 - 재고)
- 삼성 갤럭시 노트 8.0 (Android 4.2.2 - 재고)
- 삼성 갤럭시S4 (Android 4.4 - 재고)
- 삼성 갤럭시S4 (안드로이드 5.1.1 - 사이아노젠모드)
삼성 갤럭시 탭 A (Android 6.0.1 - 재고)
/** * Returns all available external SD-Card roots in the system. * * @return paths to all available external SD-Card roots in the system. */ public static String[] getStorageDirectories() { String [] storageDirectories; String rawSecondaryStoragesStr = System.getenv("SECONDARY_STORAGE"); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { List<String> results = new ArrayList<String>(); File[] externalDirs = applicationContext.getExternalFilesDirs(null); for (File file : externalDirs) { String path = file.getPath().split("/Android")[0]; if((Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && Environment.isExternalStorageRemovable(file)) || rawSecondaryStoragesStr != null && rawSecondaryStoragesStr.contains(path)){ results.add(path); } } storageDirectories = results.toArray(new String[0]); }else{ final Set<String> rv = new HashSet<String>(); if (!TextUtils.isEmpty(rawSecondaryStoragesStr)) { final String[] rawSecondaryStorages = rawSecondaryStoragesStr.split(File.pathSeparator); Collections.addAll(rv, rawSecondaryStorages); } storageDirectories = rv.toArray(new String[rv.size()]); } return storageDirectories; }
위의 원래 답변 이후로 스캔 볼트는 더 이상 다양한 제조업체에서 사용할 수 없습니다.
저는 더 신뢰할 수 있고 직접적인 방법을 개발했습니다.
File mnt = new File("/storage");
if (!mnt.exists())
mnt = new File("/mnt");
File[] roots = mnt.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isDirectory() && pathname.exists()
&& pathname.canWrite() && !pathname.isHidden()
&& !isSymlink(pathname);
}
});
roots에는 usb에 연결된 모든 usb 장치를 포함하여 시스템의 모든 쓰기 가능한 루트 디렉토리가 포함됩니다.
참고: canWrite 메서드에는 Android가 필요합니다.허가.WRITE_EXTERNAL_스토리지 권한입니다.
이동식 SD 카드를 찾는 방법은 다음과 같습니다.복잡하고 일부 상황에서는 과도한 기능을 수행할 수도 있지만, 지난 몇 년간 테스트한 다양한 Android 버전과 장치 제조업체에서 작동합니다.API 레벨 15 이후로 SD 카드가 장착되어 있으면 SD 카드를 찾을 수 없는 장치를 저는 모릅니다.대부분의 경우, 특히 검색할 알려진 파일의 이름을 지정한 경우에는 잘못된 긍정을 반환하지 않습니다.
혹시 안 되는 경우가 있으면 알려주시기 바랍니다.
import android.content.Context;
import android.os.Build;
import android.os.Environment;
import android.support.v4.content.ContextCompat;
import android.text.TextUtils;
import android.util.Log;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Locale;
import java.util.regex.Pattern;
public class SDCard {
private static final String TAG = "SDCard";
/** In some scenarios we can expect to find a specified file or folder on SD cards designed
* to work with this app. If so, set KNOWNFILE to that filename. It will make our job easier.
* Set it to null otherwise. */
private static final String KNOWNFILE = null;
/** Common paths for microSD card. **/
private static String[] commonPaths = {
// Some of these taken from
// https://stackoverflow.com/questions/13976982/removable-storage-external-sdcard-path-by-manufacturers
// These are roughly in order such that the earlier ones, if they exist, are more sure
// to be removable storage than the later ones.
"/mnt/Removable/MicroSD",
"/storage/removable/sdcard1", // !< Sony Xperia Z1
"/Removable/MicroSD", // Asus ZenPad C
"/removable/microsd",
"/external_sd", // Samsung
"/_ExternalSD", // some LGs
"/storage/extSdCard", // later Samsung
"/storage/extsdcard", // Main filesystem is case-sensitive; FAT isn't.
"/mnt/extsd", // some Chinese tablets, e.g. Zeki
"/storage/sdcard1", // If this exists it's more likely than sdcard0 to be removable.
"/mnt/extSdCard",
"/mnt/sdcard/external_sd",
"/mnt/external_sd",
"/storage/external_SD",
"/storage/ext_sd", // HTC One Max
"/mnt/sdcard/_ExternalSD",
"/mnt/sdcard-ext",
"/sdcard2", // HTC One M8s
"/sdcard1", // Sony Xperia Z
"/mnt/media_rw/sdcard1", // 4.4.2 on CyanogenMod S3
"/mnt/sdcard", // This can be built-in storage (non-removable).
"/sdcard",
"/storage/sdcard0",
"/emmc",
"/mnt/emmc",
"/sdcard/sd",
"/mnt/sdcard/bpemmctest",
"/mnt/external1",
"/data/sdext4",
"/data/sdext3",
"/data/sdext2",
"/data/sdext",
"/storage/microsd" //ASUS ZenFone 2
// If we ever decide to support USB OTG storage, the following paths could be helpful:
// An LG Nexus 5 apparently uses usb://1002/UsbStorage/ as a URI to access an SD
// card over OTG cable. Other models, like Galaxy S5, use /storage/UsbDriveA
// "/mnt/usb_storage",
// "/mnt/UsbDriveA",
// "/mnt/UsbDriveB",
};
/** Find path to removable SD card. */
public static File findSdCardPath(Context context) {
String[] mountFields;
BufferedReader bufferedReader = null;
String lineRead = null;
/** Possible SD card paths */
LinkedHashSet<File> candidatePaths = new LinkedHashSet<>();
/** Build a list of candidate paths, roughly in order of preference. That way if
* we can't definitively detect removable storage, we at least can pick a more likely
* candidate. */
// Could do: use getExternalStorageState(File path), with and without an argument, when
// available. With an argument is available since API level 21.
// This may not be necessary, since we also check whether a directory exists and has contents,
// which would fail if the external storage state is neither MOUNTED nor MOUNTED_READ_ONLY.
// I moved hard-coded paths toward the end, but we need to make sure we put the ones in
// backwards order that are returned by the OS. And make sure the iterators respect
// the order!
// This is because when multiple "external" storage paths are returned, it's always (in
// experience, but not guaranteed by documentation) with internal/emulated storage
// first, removable storage second.
// Add value of environment variables as candidates, if set:
// EXTERNAL_STORAGE, SECONDARY_STORAGE, EXTERNAL_SDCARD_STORAGE
// But note they are *not* necessarily *removable* storage! Especially EXTERNAL_STORAGE.
// And they are not documented (API) features. Typically useful only for old versions of Android.
String val = System.getenv("SECONDARY_STORAGE");
if (!TextUtils.isEmpty(val)) addPath(val, null, candidatePaths);
val = System.getenv("EXTERNAL_SDCARD_STORAGE");
if (!TextUtils.isEmpty(val)) addPath(val, null, candidatePaths);
// Get listing of mounted devices with their properties.
ArrayList<File> mountedPaths = new ArrayList<>();
try {
// Note: Despite restricting some access to /proc (http://stackoverflow.com/a/38728738/423105),
// Android 7.0 does *not* block access to /proc/mounts, according to our test on George's Alcatel A30 GSM.
bufferedReader = new BufferedReader(new FileReader("/proc/mounts"));
// Iterate over each line of the mounts listing.
while ((lineRead = bufferedReader.readLine()) != null) {
Log.d(TAG, "\nMounts line: " + lineRead);
mountFields = lineRead.split(" ");
// columns: device, mountpoint, fs type, options... Example:
// /dev/block/vold/179:97 /storage/sdcard1 vfat rw,dirsync,nosuid,nodev,noexec,relatime,uid=1000,gid=1015,fmask=0002,dmask=0002,allow_utime=0020,codepage=cp437,iocharset=iso8859-1,shortname=mixed,utf8,errors=remount-ro 0 0
String device = mountFields[0], path = mountFields[1], fsType = mountFields[2];
// The device, path, and fs type must conform to expected patterns.
if (!(devicePattern.matcher(device).matches() &&
pathPattern.matcher(path).matches() &&
fsTypePattern.matcher(fsType).matches()) ||
// mtdblock is internal, I'm told.
device.contains("mtdblock") ||
// Check for disqualifying patterns in the path.
pathAntiPattern.matcher(path).matches()) {
// If this mounts line fails our tests, skip it.
continue;
}
// TODO maybe: check options to make sure it's mounted RW?
// The answer at http://stackoverflow.com/a/13648873/423105 does.
// But it hasn't seemed to be necessary so far in my testing.
// This line met the criteria so far, so add it to candidate list.
addPath(path, null, mountedPaths);
}
} catch (IOException ignored) {
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException ignored) {
}
}
}
// Append the paths from mount table to candidate list, in reverse order.
if (!mountedPaths.isEmpty()) {
// See https://stackoverflow.com/a/5374346/423105 on why the following is necessary.
// Basically, .toArray() needs its parameter to know what type of array to return.
File[] mountedPathsArray = mountedPaths.toArray(new File[mountedPaths.size()]);
addAncestors(candidatePaths, mountedPathsArray);
}
// Add hard-coded known common paths to candidate list:
addStrings(candidatePaths, commonPaths);
// If the above doesn't work we could try the following other options, but in my experience they
// haven't added anything helpful yet.
// getExternalFilesDir() and getExternalStorageDirectory() typically something app-specific like
// /storage/sdcard1/Android/data/com.mybackuparchives.android/files
// so we want the great-great-grandparent folder.
// This may be non-removable.
Log.d(TAG, "Environment.getExternalStorageDirectory():");
addPath(null, ancestor(Environment.getExternalStorageDirectory()), candidatePaths);
// Context.getExternalFilesDirs() is only available from API level 19. You can use
// ContextCompat.getExternalFilesDirs() on earlier APIs, but it only returns one dir anyway.
Log.d(TAG, "context.getExternalFilesDir(null):");
addPath(null, ancestor(context.getExternalFilesDir(null)), candidatePaths);
// "Returns absolute paths to application-specific directories on all external storage
// devices where the application can place persistent files it owns."
// We might be able to use these to deduce a higher-level folder that isn't app-specific.
// Also, we apparently have to call getExternalFilesDir[s](), at least in KITKAT+, in order to ensure that the
// "external files" directory exists and is available.
Log.d(TAG, "ContextCompat.getExternalFilesDirs(context, null):");
addAncestors(candidatePaths, ContextCompat.getExternalFilesDirs(context, null));
// Very similar results:
Log.d(TAG, "ContextCompat.getExternalCacheDirs(context):");
addAncestors(candidatePaths, ContextCompat.getExternalCacheDirs(context));
// TODO maybe: use getExternalStorageState(File path), with and without an argument, when
// available. With an argument is available since API level 21.
// This may not be necessary, since we also check whether a directory exists,
// which would fail if the external storage state is neither MOUNTED nor MOUNTED_READ_ONLY.
// A "public" external storage directory. But in my experience it doesn't add anything helpful.
// Note that you can't pass null, or you'll get an NPE.
final File publicDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC);
// Take the parent, because we tend to get a path like /pathTo/sdCard/Music.
addPath(null, publicDirectory.getParentFile(), candidatePaths);
// EXTERNAL_STORAGE: may not be removable.
val = System.getenv("EXTERNAL_STORAGE");
if (!TextUtils.isEmpty(val)) addPath(val, null, candidatePaths);
if (candidatePaths.isEmpty()) {
Log.w(TAG, "No removable microSD card found.");
return null;
} else {
Log.i(TAG, "\nFound potential removable storage locations: " + candidatePaths);
}
// Accept or eliminate candidate paths if we can determine whether they're removable storage.
// In Lollipop and later, we can check isExternalStorageRemovable() status on each candidate.
if (Build.VERSION.SDK_INT >= 21) {
Iterator<File> itf = candidatePaths.iterator();
while (itf.hasNext()) {
File dir = itf.next();
// handle illegalArgumentException if the path is not a valid storage device.
try {
if (Environment.isExternalStorageRemovable(dir)
// && containsKnownFile(dir)
) {
Log.i(TAG, dir.getPath() + " is removable external storage");
return dir;
} else if (Environment.isExternalStorageEmulated(dir)) {
Log.d(TAG, "Removing emulated external storage dir " + dir);
itf.remove();
}
} catch (IllegalArgumentException e) {
Log.d(TAG, "isRemovable(" + dir.getPath() + "): not a valid storage device.", e);
}
}
}
// Continue trying to accept or eliminate candidate paths based on whether they're removable storage.
// On pre-Lollipop, we only have singular externalStorage. Check whether it's removable.
if (Build.VERSION.SDK_INT >= 9) {
File externalStorage = Environment.getExternalStorageDirectory();
Log.d(TAG, String.format(Locale.ROOT, "findSDCardPath: getExternalStorageDirectory = %s", externalStorage.getPath()));
if (Environment.isExternalStorageRemovable()) {
// Make sure this is a candidate.
// TODO: Does this contains() work? Should we be canonicalizing paths before comparing?
if (candidatePaths.contains(externalStorage)
// && containsKnownFile(externalStorage)
) {
Log.d(TAG, "Using externalStorage dir " + externalStorage);
return externalStorage;
}
} else if (Build.VERSION.SDK_INT >= 11 && Environment.isExternalStorageEmulated()) {
Log.d(TAG, "Removing emulated external storage dir " + externalStorage);
candidatePaths.remove(externalStorage);
}
}
// If any directory contains our special test file, consider that the microSD card.
if (KNOWNFILE != null) {
for (File dir : candidatePaths) {
Log.d(TAG, String.format(Locale.ROOT, "findSdCardPath: Looking for known file in candidate path, %s", dir));
if (containsKnownFile(dir)) return dir;
}
}
// If we don't find the known file, still try taking the first candidate.
if (!candidatePaths.isEmpty()) {
Log.d(TAG, "No definitive path to SD card; taking the first realistic candidate.");
return candidatePaths.iterator().next();
}
// If no reasonable path was found, give up.
return null;
}
/** Add each path to the collection. */
private static void addStrings(LinkedHashSet<File> candidatePaths, String[] newPaths) {
for (String path : newPaths) {
addPath(path, null, candidatePaths);
}
}
/** Add ancestor of each File to the collection. */
private static void addAncestors(LinkedHashSet<File> candidatePaths, File[] files) {
for (int i = files.length - 1; i >= 0; i--) {
addPath(null, ancestor(files[i]), candidatePaths);
}
}
/**
* Add a new candidate directory path to our list, if it's not obviously wrong.
* Supply path as either String or File object.
* @param strNew path of directory to add (or null)
* @param fileNew directory to add (or null)
*/
private static void addPath(String strNew, File fileNew, Collection<File> paths) {
// If one of the arguments is null, fill it in from the other.
if (strNew == null) {
if (fileNew == null) return;
strNew = fileNew.getPath();
} else if (fileNew == null) {
fileNew = new File(strNew);
}
if (!paths.contains(fileNew) &&
// Check for paths known not to be removable SD card.
// The antipattern check can be redundant, depending on where this is called from.
!pathAntiPattern.matcher(strNew).matches()) {
// Eliminate candidate if not a directory or not fully accessible.
if (fileNew.exists() && fileNew.isDirectory() && fileNew.canExecute()) {
Log.d(TAG, " Adding candidate path " + strNew);
paths.add(fileNew);
} else {
Log.d(TAG, String.format(Locale.ROOT, " Invalid path %s: exists: %b isDir: %b canExec: %b canRead: %b",
strNew, fileNew.exists(), fileNew.isDirectory(), fileNew.canExecute(), fileNew.canRead()));
}
}
}
private static final String ANDROID_DIR = File.separator + "Android";
private static File ancestor(File dir) {
// getExternalFilesDir() and getExternalStorageDirectory() typically something app-specific like
// /storage/sdcard1/Android/data/com.mybackuparchives.android/files
// so we want the great-great-grandparent folder.
if (dir == null) {
return null;
} else {
String path = dir.getAbsolutePath();
int i = path.indexOf(ANDROID_DIR);
if (i == -1) {
return dir;
} else {
return new File(path.substring(0, i));
}
}
}
/** Returns true iff dir contains the special test file.
* Assumes that dir exists and is a directory. (Is this a necessary assumption?) */
private static boolean containsKnownFile(File dir) {
if (KNOWNFILE == null) return false;
File knownFile = new File(dir, KNOWNFILE);
return knownFile.exists();
}
private static Pattern
/** Pattern that SD card device should match */
devicePattern = Pattern.compile("/dev/(block/.*vold.*|fuse)|/mnt/.*"),
/** Pattern that SD card mount path should match */
pathPattern = Pattern.compile("/(mnt|storage|external_sd|extsd|_ExternalSD|Removable|.*MicroSD).*",
Pattern.CASE_INSENSITIVE),
/** Pattern that the mount path should not match.
* 'emulated' indicates an internal storage location, so skip it.
* 'asec' is an encrypted package file, decrypted and mounted as a directory. */
pathAntiPattern = Pattern.compile(".*(/secure|/asec|/emulated).*"),
/** These are expected fs types, including vfat. tmpfs is not OK.
* fuse can be removable SD card (as on Moto E or Asus ZenPad), or can be internal (Huawei G610). */
fsTypePattern = Pattern.compile(".*(fat|msdos|ntfs|ext[34]|fuse|sdcard|esdfs).*");
}
추신.
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />【例레】【例고】API 23 이상는반시checkSelfPermission/requestPermissions.- SD 카드에서 찾을 수 있는 파일이나 폴더가 있으면 KNOWNFILE="myappfile"을 설정합니다.그러면 탐지의 정확성이 높아집니다.
- 여러분은 분히당가캐싶것을입다니의 을 캐시하고 입니다.
findSdCardPath(),필요할 때마다 다시 계산하는 것이 아니라, - 벌목벌목)
Log.d()) 위의 코드에서.올바른 경로를 찾을 수 없는 경우를 진단하는 데 도움이 됩니다.로깅을 원하지 않으면 주석을 달아야 합니다.
너무 늦었지만 마침내 안드로이드 2.2+에서 작동하는 대부분의 장치(제조업체 및 안드로이드 버전별)를 테스트했습니다. 작동하지 않는 것을 발견하면 장치 이름으로 설명하십시오.제가 고칠게요. 관심 있는 사람이 있다면 어떻게 작동하는지 설명해 드릴게요.
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import android.util.Log;
/**
* @author ajeet
*05-Dec-2014 2014
*
*/
public class StorageUtil {
public boolean isRemovebleSDCardMounted() {
File file = new File("/sys/class/block/");
File[] files = file.listFiles(new MmcblkFilter("mmcblk\\d$"));
boolean flag = false;
for (File mmcfile : files) {
File scrfile = new File(mmcfile, "device/scr");
if (scrfile.exists()) {
flag = true;
break;
}
}
return flag;
}
public String getRemovebleSDCardPath() throws IOException {
String sdpath = null;
File file = new File("/sys/class/block/");
File[] files = file.listFiles(new MmcblkFilter("mmcblk\\d$"));
String sdcardDevfile = null;
for (File mmcfile : files) {
Log.d("SDCARD", mmcfile.getAbsolutePath());
File scrfile = new File(mmcfile, "device/scr");
if (scrfile.exists()) {
sdcardDevfile = mmcfile.getName();
Log.d("SDCARD", mmcfile.getName());
break;
}
}
if (sdcardDevfile == null) {
return null;
}
FileInputStream is;
BufferedReader reader;
files = file.listFiles(new MmcblkFilter(sdcardDevfile + "p\\d+"));
String deviceName = null;
if (files.length > 0) {
Log.d("SDCARD", files[0].getAbsolutePath());
File devfile = new File(files[0], "dev");
if (devfile.exists()) {
FileInputStream fis = new FileInputStream(devfile);
reader = new BufferedReader(new InputStreamReader(fis));
String line = reader.readLine();
deviceName = line;
}
Log.d("SDCARD", "" + deviceName);
if (deviceName == null) {
return null;
}
Log.d("SDCARD", deviceName);
final File mountFile = new File("/proc/self/mountinfo");
if (mountFile.exists()) {
is = new FileInputStream(mountFile);
reader = new BufferedReader(new InputStreamReader(is));
String line = null;
while ((line = reader.readLine()) != null) {
// Log.d("SDCARD", line);
// line = reader.readLine();
// Log.d("SDCARD", line);
String[] mPonts = line.split("\\s+");
if (mPonts.length > 6) {
if (mPonts[2].trim().equalsIgnoreCase(deviceName)) {
if (mPonts[4].contains(".android_secure")
|| mPonts[4].contains("asec")) {
continue;
}
sdpath = mPonts[4];
Log.d("SDCARD", mPonts[4]);
}
}
}
}
}
return sdpath;
}
static class MmcblkFilter implements FilenameFilter {
private String pattern;
public MmcblkFilter(String pattern) {
this.pattern = pattern;
}
@Override
public boolean accept(File dir, String filename) {
if (filename.matches(pattern)) {
return true;
}
return false;
}
}
}
제가 찾은 유일한 해결책은 반사를 사용하는 것이었습니다.
/**
* Get external sd card path using reflection
* @param mContext
* @param is_removable is external storage removable
* @return
*/
private static String getExternalStoragePath(Context mContext, boolean is_removable) {
StorageManager mStorageManager = (StorageManager) mContext.getSystemService(Context.STORAGE_SERVICE);
Class<?> storageVolumeClazz = null;
try {
storageVolumeClazz = Class.forName("android.os.storage.StorageVolume");
Method getVolumeList = mStorageManager.getClass().getMethod("getVolumeList");
Method getPath = storageVolumeClazz.getMethod("getPath");
Method isRemovable = storageVolumeClazz.getMethod("isRemovable");
Object result = getVolumeList.invoke(mStorageManager);
final int length = Array.getLength(result);
for (int i = 0; i < length; i++) {
Object storageVolumeElement = Array.get(result, i);
String path = (String) getPath.invoke(storageVolumeElement);
boolean removable = (Boolean) isRemovable.invoke(storageVolumeElement);
if (is_removable == removable) {
return path;
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
Google은 외부 sd 카드 경로를 가져오고 앱의 가비지로부터 sd 카드 디렉터리를 보호하기 위한 권한 수준을 추가하기 위한 많은 옵션을 차단했습니다.제가 시도한 모든 솔루션이 외장형 및 이동식 SD 카드 경로를 얻을 수 있는 충분한 방법을 제공하지 못했습니다.
그렇게 말한 후, 구글은 앱이 작성할 수 있는 외부 경로를 얻고 제거 가능한지 여부를 확인할 수 있는 방법을 제공했습니다.
이 간단한 API를 사용하면 올바른 쓰기/읽기 권한과 함께 이동식 외부 디렉토리에 대한 경로를 얻을 수 있습니다.
File[] files = getExternalFilesDirs(null);
for(File file : files){
if(Environment.isExternalStorageRemovable(file)){
return file;
}
}
이유는 모르겠지만 공용 저장소 디렉터리에 생성된 파일에서 .createNewFile()을 호출한 후 사용해야 합니다.프레임워크에서 그 방법에 대한 의견은 유용하지 않다고 말합니다.여기 샘플이 있습니다...
String myPath = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PODCASTS) + File.separator + "My Directory"; final File myDir = new File(myPath); try { myDir.mkdirs(); } catch (Exception ex) { Toast.makeText(this, "error: " + ex.getMessage(), Toast.LENGTH_LONG).show(); }String fname = "whatever"; File newFile = new File(myDir, fname); Log.i(TAG, "File exists --> " + newFile.exists()) //will be false try { if (newFile.createNewFile()) { //continue } else { Log.e(TAG, "error creating file"); } } catch (Exception e) { Log.e(TAG, e.toString()); }
기기에서 SD 카드를 사용할 수 있는지 확인하고, 사용할 수 있으면 기기에서 SD 카드 경로를 얻을 수 있는 utils 방법을 만들었습니다.
아래 두 가지 메소드를 프로젝트 클래스에 복사할 수 있습니다.이상입니다.
public String isRemovableSDCardAvailable() {
final String FLAG = "mnt";
final String SECONDARY_STORAGE = System.getenv("SECONDARY_STORAGE");
final String EXTERNAL_STORAGE_DOCOMO = System.getenv("EXTERNAL_STORAGE_DOCOMO");
final String EXTERNAL_SDCARD_STORAGE = System.getenv("EXTERNAL_SDCARD_STORAGE");
final String EXTERNAL_SD_STORAGE = System.getenv("EXTERNAL_SD_STORAGE");
final String EXTERNAL_STORAGE = System.getenv("EXTERNAL_STORAGE");
Map<Integer, String> listEnvironmentVariableStoreSDCardRootDirectory = new HashMap<Integer, String>();
listEnvironmentVariableStoreSDCardRootDirectory.put(0, SECONDARY_STORAGE);
listEnvironmentVariableStoreSDCardRootDirectory.put(1, EXTERNAL_STORAGE_DOCOMO);
listEnvironmentVariableStoreSDCardRootDirectory.put(2, EXTERNAL_SDCARD_STORAGE);
listEnvironmentVariableStoreSDCardRootDirectory.put(3, EXTERNAL_SD_STORAGE);
listEnvironmentVariableStoreSDCardRootDirectory.put(4, EXTERNAL_STORAGE);
File externalStorageList[] = null;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
externalStorageList = getContext().getExternalFilesDirs(null);
}
String directory = null;
int size = listEnvironmentVariableStoreSDCardRootDirectory.size();
for (int i = 0; i < size; i++) {
if (externalStorageList != null && externalStorageList.length > 1 && externalStorageList[1] != null)
directory = externalStorageList[1].getAbsolutePath();
else
directory = listEnvironmentVariableStoreSDCardRootDirectory.get(i);
directory = canCreateFile(directory);
if (directory != null && directory.length() != 0) {
if (i == size - 1) {
if (directory.contains(FLAG)) {
Log.e(getClass().getSimpleName(), "SD Card's directory: " + directory);
return directory;
} else {
return null;
}
}
Log.e(getClass().getSimpleName(), "SD Card's directory: " + directory);
return directory;
}
}
return null;
}
/**
* Check if can create file on given directory. Use this enclose with method
* {@link BeginScreenFragement#isRemovableSDCardAvailable()} to check sd
* card is available on device or not.
*
* @param directory
* @return
*/
public String canCreateFile(String directory) {
final String FILE_DIR = directory + File.separator + "hoang.txt";
File tempFlie = null;
try {
tempFlie = new File(FILE_DIR);
FileOutputStream fos = new FileOutputStream(tempFlie);
fos.write(new byte[1024]);
fos.flush();
fos.close();
Log.e(getClass().getSimpleName(), "Can write file on this directory: " + FILE_DIR);
} catch (Exception e) {
Log.e(getClass().getSimpleName(), "Write file error: " + e.getMessage());
return null;
} finally {
if (tempFlie != null && tempFlie.exists() && tempFlie.isFile()) {
// tempFlie.delete();
tempFlie = null;
}
}
return directory;
}
아래 코드를 작성하면 위치를 알 수 있습니다.
/storage/663D-554E/Android/data/app_package_name/files/
앱 데이터를 sd_card 내의 /sd/data 위치에 저장합니다.
File[] list = ContextCompat.getExternalFilesDirs(MainActivity.this, null);
list[1]+"/fol"
내부의 경우 위치가 0이고 sdcard to file array의 경우 1입니다.
저는 이 코드를 motog4 plus와 Samsung 기기에서 테스트했습니다 (모든 것이 정상적으로 작동합니다).
이것이 도움이 되기를 바랍니다.
모든 외부 장치에 대해 작동하지만 외부 장치 폴더 이름만 가져온 다음 파일 클래스를 사용하여 지정된 위치에서 파일을 가져와야 합니다.
public static List<String> getExternalMounts() {
final List<String> out = new ArrayList<>();
String reg = "(?i).*vold.*(vfat|ntfs|exfat|fat32|ext3|ext4).*rw.*";
String s = "";
try {
final Process process = new ProcessBuilder().command("mount")
.redirectErrorStream(true).start();
process.waitFor();
final InputStream is = process.getInputStream();
final byte[] buffer = new byte[1024];
while (is.read(buffer) != -1) {
s = s + new String(buffer);
}
is.close();
} catch (final Exception e) {
e.printStackTrace();
}
// parse output
final String[] lines = s.split("\n");
for (String line : lines) {
if (!line.toLowerCase(Locale.US).contains("asec")) {
if (line.matches(reg)) {
String[] parts = line.split(" ");
for (String part : parts) {
if (part.startsWith("/"))
if (!part.toLowerCase(Locale.US).contains("vold"))
out.add(part);
}
}
}
}
return out;
}
호출:
List<String> list=getExternalMounts();
if(list.size()>0)
{
String[] arr=list.get(0).split("/");
int size=0;
if(arr!=null && arr.length>0) {
size= arr.length - 1;
}
File parentDir=new File("/storage/"+arr[size]);
if(parentDir.listFiles()!=null){
File parent[] = parentDir.listFiles();
for (int i = 0; i < parent.length; i++) {
// get file path as parent[i].getAbsolutePath());
}
}
}
외부 스토리지에 액세스하는 중
외부 스토리지에서 파일을 읽거나 쓰려면 앱이 READ_EXTERNAL_STORAGE 또는 WRITE_EXTERNAL_STORAGE 시스템 권한을 획득해야 합니다.예:
<manifest ...>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
...
</manifest>
이것이 외부 스토리지의 경로를 찾는 방법입니다.
public static String getExternalStoragePath(Context context){
File[] f = ContextCompat.getExternalFilesDirs(context, null);
String internalPath = Environment.getExternalStorageDirectory().getAbsolutePath();
String excessive = "";
String externalPath = "";
for (File file : f) {
if (file.getAbsolutePath().startsWith(internalPath)) {
excessive = file.getAbsolutePath().replaceAll(internalPath, "");
}
}
for (File file : f) {
if (!file.getAbsolutePath().startsWith(excessive)) {
externalPath = file.getAbsolutePath().replaceAll(excessive, "");
}
}
return externalPath;
}
/sdcard => 내부 스토리지(심링크이지만 작동해야 함)
/mnt/extSdCard => 외부 SdCard
이것은 삼성 갤럭시 S3를 위한 것입니다.
대부분의 경우 이 말이 사실이라고 믿으실 수 있을 겁니다하지만 두 번 확인!
언급URL : https://stackoverflow.com/questions/5694933/find-location-of-a-removable-sd-card
반응형
'programing' 카테고리의 다른 글
| SQL select 문에서 Order By 1의 목적은 무엇입니까? (0) | 2023.08.04 |
|---|---|
| jQuery를 사용하여 드롭다운의 선택한 인덱스 설정 (0) | 2023.08.04 |
| asp.net 의 GridView에서 인덱스가 아닌 열 이름으로 셀 값을 가져오는 방법 (0) | 2023.08.04 |
| 오류 코드: 1215.외부 키 제약 조건(외부 키)을 추가할 수 없습니다. (0) | 2023.07.30 |
| 변수가 있지만 "INTO"가 없는 단순 "SELECT" (0) | 2023.07.30 |