Uniwersalny sposób zapisu na zewnętrzną kartę SD na Androidzie

Wierzę, że istnieją dwie metody, aby to osiągnąć:

Metoda 1: (czy Nie działa na 6.0 i nowszych, ze względu na zmiany uprawnień)

Używam tej metody od lat na wielu wersjach urządzeń bez żadnego problemu. uznanie należy się oryginalnemu źródłu, ponieważ to nie ja go napisałem.

Zwróci wszystkie zamontowane nośniki (w tym prawdziwe karty SD) w liście lokalizacji katalogów ciągów. Z listy można następnie zapytać użytkownika, Gdzie Zapisz, itp.

Można go nazwać następującym:

 HashSet<String> extDirs = getStorageDirectories();

Metoda:

/**
 * Returns all the possible SDCard directories
 */
public static HashSet<String> getStorageDirectories() {
    final HashSet<String> out = new HashSet<String>();
    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().contains("asec")) {
            if (line.matches(reg)) {
                String[] parts = line.split(" ");
                for (String part : parts) {
                    if (part.startsWith("/"))
                        if (!part.toLowerCase().contains("vold"))
                            out.add(part);
                }
            }
        }
    }
    return out;
}

Metoda 2:

Użyj biblioteki wsparcia v4

import android.support.v4.content.ContextCompat;

 File[] list = ContextCompat.getExternalFilesDirs(myContext, null);

Lokalizacje różnią się jednak w użyciu.

Zwraca bezwzględne ścieżki do katalogów specyficznych dla aplikacji na wszystkich zewnętrzne urządzenia pamięci masowej, w których aplikacja może umieszczać pliki trwałe jest właścicielem. Te pliki są wewnętrzne do aplikacji, a nie zazwyczaj widoczne dla użytkownika jako nośnik.

Zewnętrzne urządzenia pamięci masowej zwracane tutaj są uważane za stałą część urządzenie, w tym zarówno emulowane Pamięci zewnętrzne, jak i nośniki fizyczne gniazda, takie jak karty SD w komorze baterii. Zwrócone ścieżki do nie obejmuje urządzeń przejściowych, takich jak pamięci flash USB.

Aplikacja może przechowywać dane na dowolnym lub wszystkich zwracanych urządzeniach. Na przykład, aplikacja może wybrać przechowywanie dużych plików na urządzeniu z większość dostępnej przestrzeni

Więcej informacji na temat ContextCompat

Są jak pliki specyficzne dla aplikacji. Ukryte przed innymi aplikacjami.

Kolejna odpowiedź. Ta odpowiedź pokazuje tylko 5.0+, ponieważ uważam, że zamieszczona tutaj odpowiedź Doomknight jest najlepszym sposobem na Androida 4.4 i poniżej.

To jest pierwotnie opublikowany tutaj (czy istnieje sposób, aby uzyskać rozmiar karty SD w Androidzie?) przez mnie, aby uzyskać rozmiar zewnętrznej karty SD na Androida 5.0 +

Aby uzyskać zewnętrzną kartę SD jako File:

public File getExternalSdCard() {
    File externalStorage = null;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        File storage = new File("/storage");

        if(storage.exists()) {
            File[] files = storage.listFiles();

            for (File file : files) {
                if (file.exists()) {
                    try {
                        if (Environment.isExternalStorageRemovable(file)) {
                            externalStorage = file;
                            break;
                        }
                    } catch (Exception e) {
                        Log.e("TAG", e.toString());
                    }
                }
            }
        }
    } else {
        // do one of many old methods
        // I believe Doomsknight's method is the best option here
    }

    return externalStorage;
}

Uwaga: dostaję tylko" pierwszą " zewnętrzną kartę sd, jednak można ją zmodyfikować i zwrócić ArrayList<File> zamiast File i pozwolić pętla kontynuuje zamiast wywoływać break Po znalezieniu pierwszej.

Oprócz wszystkich innych miłych odpowiedzi, mógłbym dodać trochę więcej do tego pytania, aby mogło dać szerszy zasięg dla czytelników. W mojej odpowiedzi tutaj, chciałbym użyć 2 policzalne zasoby do prezentacji zewnętrznej pamięci masowej.

Książka opisuje podstawowe i zewnętrzne metody plików i katalogów. Postaram się zrobić CV z tego, co może być istotne dla Twojego pytanie.

Następująca część książki:

Pamięć Zewnętrzna

Twoje zdjęcie potrzebuje więcej niż miejsca na ekranie. Pełnowymiarowe zdjęcia są zbyt duże, aby trzymać się wewnątrz Bazy danych SQLite, a tym bardziej Intent. Będą potrzebować miejsca do zamieszkania w systemie plików Twojego urządzenia. Zwykle umieszczasz je w prywatnym magazynie. Przypomnij sobie, że korzystałeś z prywatnego magazynu aby zapisać bazę danych SQLite. Metodami takimi jak Context.getFileStreamPath(String) i Context.getFilesDir(), możesz zrobić to samo ze zwykłymi plikami (które będą żyły w podfolder sąsiadujący z podfolderem bazy danych, w którym mieszka twoja baza danych SQLite)

Podstawowe metody plików i katalogów w kontekście

| Method                                                                                |
|---------------------------------------------------------------------------------------|
|File etFilesDir()                                                                      |
| - Returns a handle to the directory for private application files.                    |
|                                                                                       |
|FileInputStream openFileInput(String name)                                             |
| - Opens an existing file for input (relative to the files directory).                 |
|                                                                                       |
|FileOutputStream openFileOutput(String name, int mode)                                 |
| - Opens a file for output, possibly creating it (relative to the files directory).    |
|                                                                                       |
|File getDir(String name, int mode)                                                     |
| - Gets (and possibly creates) a subdirectory within the files directory.              |
|                                                                                       |
|String[] fileList()                                                                    |
| - Gets a list of file names in the main files directory, such as for use with         |
|   openFileInput(String).                                                              |
|                                                                                       |
|File getCacheDir()                                                                     |
| - Returns a handle to a directory you can use specifically for storing cache files.   |
|   You should take care to keep this directory tidy and use as little space as possible|

Jeśli przechowujesz pliki, z których musi korzystać tylko twoja obecna aplikacja, te metody są dokładnie tym, co potrzebujesz.

Z drugiej strony, jeśli potrzebujesz innej aplikacji do zapisu do tych plików, masz pecha: podczas gdy jest Context.MODE_WORLD_READABLE flaga, którą możesz przekazać openFileOutput(String, int), to na przestarzały i nie do końca niezawodny w działaniu na nowszych urządzeniach. Jeśli przechowujesz pliki do udostępnienia z innymi aplikacjami lub odbierającymi pliki z innych aplikacji( pliki takie jak zapisane zdjęcia), musisz je przechowywać w zamiast tego pamięć zewnętrzna.

Istnieją dwa rodzaje pamięci zewnętrznej: podstawowa i wszystko inne. Wszystkie urządzenia z Androidem mają w co najmniej jedna lokalizacja dla pamięci zewnętrznej: lokalizacja podstawowa, która znajduje się w folderze zwracanym przez Environment.getExternalStorageDirectory(). Może to być karta SD, ale obecnie jest to bardziej powszechnie zintegrowane z samym urządzeniem. Niektóre urządzenia mogą mieć dodatkową pamięć zewnętrzną. Że spadnie pod "Wszystko inne."

Context zapewnia również kilka metod uzyskiwania z pamięci zewnętrznej. Metody te zapewniają łatwe sposoby, aby dostać się do podstawowej pamięci zewnętrznej, i tak jakby-łatwe sposoby, aby dostać się do wszystkiego innego. Wszystkie metody te przechowują pliki również w publicznie dostępnych miejscach, więc uważaj na nie.

Plik zewnętrzny i metody katalogowe w kontekście

| Method                                                                                |
| --------------------------------------------------------------------------------------|
|File getExternalCacheDir()                                                             |
| - Returns a handle to a cache folder in primary external storage. Treat it like you do|
|   getCacheDir(), except a little more carefully. Android is even less likely to clean |
|   up this folder than the private storage one.                                        |
|                                                                                       |
|File[] getExternalCacheDirs()                                                          |
| - Returns cache folders for multiple external storage locations.                      |
|                                                                                       |
|File getExternalFilesDir(String)                                                       |
| - Returns a handle to a folder on primary external storage in which to store regular  |
|   files. If you pass in a type String, you can access a specific subfolder dedicated  |
|   to a particular type of content. Type constants are defined in Environment, where   |
|   they are prefixed with DIRECTORY_.                                                  |
|   For example, pictures go in Environment.DIRECTORY_PICTURES.                         |
|                                                                                       |
|File[] getExternalFilesDirs(String)                                                    |
| - Same as getExternalFilesDir(String), but returns all possible file folders for the  |
|   given type.                                                                         |
|                                                                                       |
|File[] getExternalMediaDirs()                                                          |
| - Returns handles to all the external folders Android makes available for storing     |
|   media – pictures, movies, and music. What makes this different from calling         |
|   getExternalFilesDir(Environment.DIRECTORY_PICTURES) is that the media scanner       |
|   automatically scans this folder. The media scanner makes files available to         |
|   applications that play music, or browse movies and photos, so anything that you     |
|   put in a folder returned by getExternalMediaDirs() will automatically appear in     |
|   those apps.                                                                         |

Technicznie rzecz biorąc, zewnętrzne foldery podane powyżej mogą nie być dostępne, ponieważ niektóre urządzenia używają wymiennej karty SD do przechowywania zewnętrznego. W praktyce rzadko jest to problemem, ponieważ prawie wszystkie nowoczesne urządzenia mają nieusuwalną pamięć wewnętrzną na "zewnętrzną" pamięć masową. Nie warto więc posuwać się do skrajnych kroków, aby to wyjaśnić. Ale nie zaleca się w tym prosty kod, aby chronić przed możliwością, które można zrobić w chwila.

Pozwolenie na przechowywanie zewnętrzne

Ogólnie rzecz biorąc, potrzebujesz uprawnień do zapisu lub odczytu z pamięci zewnętrznej. Uprawnienia są dobrze znanymi wartościami łańcuchowymi, które umieszczasz w manifeście za pomocą znacznika <uses-permission>. Mówią Androidowi, że chcesz zrobić coś, o co Android chce poprosić o pozwolenie.

Tutaj Android oczekuje, że poprosisz o pozwolenie, ponieważ chce wyegzekwować pewną odpowiedzialność. Mówisz Androidowi, że musisz uzyskać dostęp do zewnętrznej pamięci masowej, a Android powie użytkownikowi, że jest to jedna z rzeczy, które robi Twoja aplikacja, gdy próbuje ją zainstalować. W ten sposób nikt nie jest zaskoczony, gdy zaczniesz zapisywać rzeczy na karcie SD.

Dodaj wiersz do manifestu, który żąda uprawnień do odczytu pamięci zewnętrznej, ale tylko do listy API 16.5 żądającej uprawnień pamięci zewnętrznej (AndroidManifest.xml)

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.bignerdranch.android.criminalintent" >
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="18" />

Atrybut maxSdkVersion sprawia, że aplikacja prosi o to pozwolenie tylko w wersjach Androida, które są starsze niż API 19, Android KitKat. Zwróć uwagę, że prosisz tylko o odczyt pamięci zewnętrznej. Istnieje również WRITE_EXTERNAL_STORAGE pozwolenie, ale nie potrzebujesz tego. Nie będziesz zapisywać niczego do pamięci zewnętrznej: aplikacja aparatu zrobi to za ciebie

Drugim zasobem jest link przeczytaj wszystko, ale możesz również przejść do Za pomocą sekcji External Storage.

Numer referencyjny:

• opcje przechowywania Androida: https://developer.android.com/guide/topics/data/data-storage.html
• Strona książki: https://www.bignerdranch.com/we-write/android-programming

Czytaj więcej rzeczy:

• https://developer.android.com/reference/android/os/Environment.html#getExternalStoragePublicDirectory%28java.lang.String%29
• https://developer.android.com/reference/android/os/Environment.html#DIRECTORY_PICTURES
• https://developer.android.com/reference/android/os/Environment.html#DIRECTORY_MOVIES
• jak Mogę uzyskać zewnętrzną ścieżkę karty SD dla Androida 4.0+?

Zastrzeżenie: Ta informacja została zaczerpnięta z Android Programming: The Big Nerd Ranch Guide za zgodą autorów. Aby uzyskać więcej informacji na temat tej książki lub kupić kopię, odwiedź bignerdranch.com.

Ten temat jest trochę stary, ale szukałem rozwiązania i po kilku badaniach przyszedłem z poniższym kodem, aby pobrać listę dostępnych "zewnętrznych" punktów montowania, które, zgodnie z moją wiedzą, działają na wielu różnych urządzeniach.

Zasadniczo odczytuje dostępne punkty montowania, odfiltrowuje nieprawidłowe, testuje Pozostałe, jeśli są dostępne i dodaje je, jeśli wszystkie warunki są spełnione.

Oczywiście wymagane uprawnienia muszą być przyznane zanim kod zostanie / align = "left" /

// Notice: FileSystemDevice is just my own wrapper class. Feel free to replace it with your own. 

private List<FileSystemDevice> getDevices() {

    List<FileSystemDevice> devices = new ArrayList<>();

    // Add default external storage if available.
    File sdCardFromSystem = null;
    switch(Environment.getExternalStorageState()) {
        case Environment.MEDIA_MOUNTED:
        case Environment.MEDIA_MOUNTED_READ_ONLY:
        case Environment.MEDIA_SHARED:
            sdCardFromSystem = Environment.getExternalStorageDirectory();
            break;
    }

    if (sdCardFromSystem != null) {
        devices.add(new FileSystemDevice(sdCardFromSystem));
    }

    // Read /proc/mounts and add all mount points that are available
    // and are not "special". Also, check if the default external storage
    // is not contained inside the mount point. 
    try {
        FileInputStream fs = new FileInputStream("/proc/mounts");
        String mounts = IOUtils.toString(fs, "UTF-8");
        for(String line : mounts.split("\n")) {
            String[] parts = line.split(" ");

            // parts[0] - mount type
            // parts[1] - mount point
            if (parts.length > 1) {
                try {

                    // Skip "special" mount points and mount points that can be accessed
                    // directly by Android's functions. 
                    if (parts[0].equals("proc")) { continue; }
                    if (parts[0].equals("rootfs")) { continue; }
                    if (parts[0].equals("devpts")) { continue; }
                    if (parts[0].equals("none")) { continue; }
                    if (parts[0].equals("sysfs")) { continue; }
                    if (parts[0].equals("selinuxfs")) { continue; }
                    if (parts[0].equals("debugfs")) { continue; }
                    if (parts[0].equals("tmpfs")) { continue; }
                    if (parts[1].equals(Environment.getRootDirectory().getAbsolutePath())) { continue; }
                    if (parts[1].equals(Environment.getDataDirectory().getAbsolutePath())) { continue; }
                    if (parts[1].equals(Environment.getExternalStorageDirectory().getAbsolutePath())) { continue; }

                    // Verify that the mount point is accessible by listing its content. 
                    File file = new File(parts[1]);
                    if (file.listFiles() != null) {
                        try {

                            // Get canonical path for case it's just symlink to another mount point.
                            String devPath = file.getCanonicalPath();

                            for(FileSystemDevice device : devices) {

                                if (!devices.contains(devPath)) {                        
                                    devices.add(new FileSystemDevice(new File(devPath)));
                                }

                            }
                        } catch (Exception e) {
                            // Silently skip the exception as it can only occur if the mount point is not valid. 
                            e.printStackTrace();
                        }
                    }
                } catch (Exception e) {
                    // Silently skip the exception as it can only occur if the mount point is not valid. 
                    e.printStackTrace();
                }
            }
        }

        fs.close();
    } catch (FileNotFoundException e) {
        // Silently skip the exception as it can only occur if the /proc/mounts file is unavailable. 
        // Possibly, another detection method can be called here.
        e.printStackTrace();
    } catch (IOException e) {
        // Silently skip the exception as it can only occur if the /proc/mounts file is unavailable.
        // Possibly, another detection method can be called here.
        e.printStackTrace();            
    }

    return devices;
}

Oto sposób tworzenia nowego pliku w pamięci zewnętrznej (SDCard, jeśli jest obecny w urządzeniu lub pamięci zewnętrznej urządzenia, jeśli nie). Wystarczy zastąpić "foldername "nazwą wybranego folderu docelowego i" filename " nazwą pliku, który zapisujesz. Oczywiście tutaj możesz zobaczyć, jak zapisać plik generyczny, teraz możesz wyszukać, jak zapisać obrazy może tutaj lub cokolwiek w pliku.

try {
            File dir =  new File(Environment.getExternalStorageDirectory() + "/foldername/");
            if (!dir.exists()){
                dir.mkdirs();
            }
            File sdCardFile = new File(Environment.getExternalStorageDirectory() + "/foldername/" + fileName );
            int num = 1;
            String fileNameAux = fileName;
            while (sdCardFile.exists()){
                fileNameAux = fileName+"_"+num;
                sdCardFile = new File(Environment.getExternalStorageDirectory() + "/foldername/" + fileNameAux);
                num++;
            }

To również kontroluje, że plik istnieje i dodaje liczbę na końcu nazwa nowego pliku do zapisania.

EDIT: Przepraszam, zapomniałem, że musisz poprosić o <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> w manifeście (lub programowo, jeśli wolisz od Marshmallow)

 
`Log.d(TAG, System.getenv("SECONDARY_STORAGE"));`

Wyjście:

`D/MainActivity: /storage/extSdCard`

Pracuje nad Note 3 Android 5.0.

Dla wersji poniżej Marshmallow możesz bezpośrednio nadać uprawnienia w manifeście.

Ale dla urządzeń z Marshmallow i powyżej musisz przyznać uprawnienia na czas uruchomienia.

Za pomocą

Environment.getExternalStorageDirectory();

Można bezpośrednio uzyskać dostęp do zewnętrznej karty SD (zamontowanej) Mam nadzieję, że to pomoże.