Develop Reference

How to get path of directory which is in SD Card?

I want to create directory in SD card same as in the internal storage.
My internal storage path is "sdcard/<my_directory_name>/"
I want to create the same directory in root of SD card.
I have try the following ways to find the path of directory.
sdcard1/<my_directory_name>/
Environment.getExternalStorageDirectory() +"/<my_directory_name>/"
Please suggest the way to find SD card path.

You do not have arbitrary access to removable storage on Android 4.4+. Hence, there is no useful path, from a filesystem standpoint. You are welcome to use getExternalFilesDirs() and kin -- if they return 2+ locations, the second and subsequent ones are on removable storage, and you can read and write to those locations.

Although as CommonsWare answered, you cannot read or write in Secondary External Storage, here's a way to generate it's path.
System.getenv("SECONDARY_STORAGE"); //returns /storage/extSdCard
You can also use String path = "/storage/extSdCard"; but again you cannot write files there.
Edit: As #CommonsWare commented, there is no guarantee of this method. Though when I tested it, it worked, but again, if he says there's no guarantee, you can take his word.

Where in Android file system are directories created?

I am working on Android app that has to save data to files. To make the files accessible for all apps and also transfer to computer through USB, the files should be saved in a folder called "ABC". I manually created the folder "ABC" on both external storage card and internal storage. I was able to get full path of that folder on external storage card through code and was able to write and read from it.
String path = Environment.getExternalStorageDirectory().toString() + "/ABC";
But the internal storage turns out to be more elusive because I could not get the full path of "ABC" folder on the internal storage. Is there a way to programmatically determine where folders are created on internal storage? Generally, under what partion are folders created on internal storage in Android?
Edit:
Internal storage - I mean non-removable storage
External Storage - I mean Removable storage

I manually created the folder "ABC" on both external storage card and internal storage.
You might have created this directory on external storage. Unless you are testing on a device or emulator, you did not create this directory on internal storage, as you do not have access to it. A "card" would imply removable storage, which is something else entirely, for the vast majority of Android devices.
I was able to get full path of that folder on external storage card through code and was able to write and read from it.
Your code is for external storage. On very few devices is that a "card".
But the internal storage turns out to be more elusive because I could not get the full path of "ABC" folder on the internal storage.
There is no "ABC" folder on internal storage, insofar as you cannot create a /ABC directory off of the device root, or even off of /data. You can only work for your app's portion of internal storage, using methods like getFilesDir(). And, again, unless you are testing on an emulator or a rooted device, you have no means of creating such an "ABC" directory by hand.
Is there a way to programmatically determine where folders are created on internal storage?
Um, well, you are certainly welcome to examine the path in the File object that you created to point to some location (e.g., new File(getFilesDir(), "ABC")).
Generally, under what partion are folders created on internal storage in Android?
/data.

How can I specify a file path using openFileOutput()?

I've created a program where a user can create an arrayList, and then that list is saved into a text file on the storage device. I used this code from https://developer.android.com/training/basics/data-storage/files.html :
String filename = "myfile";
String string = "Hello world!";
FileOutputStream outputStream;
try {
outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
outputStream.write(string.getBytes());
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
I want to find a way to put this onto external storage. I know what you're thinking: Why not just do it like the way they have posted? Well I don't have an external sdcard in my phone, and I use the internal storage, which is still an sd card (When I go to storage settings it shows user application space and internal sd card storage, there is an external sd card storage- I just don't have an sdcard). I know there is an Environment.get... but that is for external. When I use Context.MODE_PRIVATE, it is storing it in the app's folder, but I need the user to be able to access this file, and copy it onto a computer after.

Well I don't have an external sdcard in my phone
That is not external storage. That is removable storage.
When I go to storage settings it shows user application space and internal sd card storage
What an Android device reports to the user, and what the Android SDK reports to you, are different. Internal storage and external storage are both part of the on-board flash. The only difference is that external storage is something that the user (and other apps) can access, while each app's portion of internal storage is inaccessible to most users.
I know there is an Environment.get... but that is for external
getExternalStoragePublicDirectory() on Environment, and getExternalFilesDir() on Context are for external storage. External storage is not removable storage.
When I use Context.MODE_PRIVATE, it is storing it in the app's folder, but I need the user to be able to access this file, and copy it onto a computer after.
Then use getExternalStoragePublicDirectory() on Environment if it fits one of those types of public directories. Otherwise, use getExternalFilesDir() on Context. Both point to locations on external storage, which the user can access (e.g., mount the device as a drive in Windows).

How to access External Micro SD card of the phone?

Does anyone know how can I get SD card of the phone?
I know that someone will tell me its getExternalStorageDirectory() or Environment.getExternalStoragePublicDirectory().
But unfortunately it doesn't always point to the external SD card in all the models. For example I tried in one model of samsung it works fine but another not, LG not. And also according to the documentation also its not always external SD card.
Here it is,
*"don't be confused by the word "external" here.
This directory can better be thought as media/shared storage. It is a filesystem that can hold a relatively large amount of data and that is shared across all applications (does not enforce permissions).
Traditionally this is an SD card, but it may also be implemented as built-in storage in a device that is distinct from the protected internal storage and can be mounted as a filesystem on a computer."*
In my application I want user to use SD card only.
How can I overcome with this?

Check out the answer by CommonsWare on the same topic https://stackoverflow.com/a/5695129/582571
He mention that we can not distinguish between mobile's inbuilt external storage and removable external storage.
But by Aleadam answer https://stackoverflow.com/a/6049446/582571 we can only check that is the External Storage is removable or not with isExternalStorageRemovable() function.
I hope you will get idea.

You can below condition to check whether SDCard is available or not
if (android.os.Environment.getExternalStorageState().equals(
android.os.Environment.MEDIA_MOUNTED)) {
//Check for the file
File appFolder = new File(Environment.getExternalStorageDirectory() + File.separator
+ context.getString(R.string.app_name));
boolean exist = appFolder.exists();
}

I was facing the same problem. I didn't know how to access external sd card location. I was developing an app wherein I had to access the external sd card to read and write some stuff. I tried different methods including the pre-defined android libraries. These are the methods I used:-
These were the misses:-
File path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
File myFile = new File(path, "test.txt");
File root = Environment.getExternalStorageDirectory();
File dir = new File(root.getAbsolutePath()+"/Download");
File f = getExternalFilesDir(null);
File file = new File(f,"test.txt");
These all were accessing internal storage "/storage/sdcard0" or "/storage/emulated/0". The reason being in the android device the portion of the internal storage acts as an external storage. So in case you have internal storage of around 16 Gb or more and there is an option to expand the device with sd card, then this is the only way i guess to access the external sd card because even the built-in functions and libraries of the android studio will access internal storage as external storage.
Finally I used this:-
String extFilePath = "/storage/sdcard1/Download";
File myFile = new File(extFilePath, "test.txt");
and it worked. So you see where pre-defined android libraries/functions fail, I was able to do the task with the simple String.
Apart from this if you want to check the path for external storage your device, try this:-
String sdpath,sd1path,usbdiskpath,sd0path;
if(new File("/storage/extSdCard/").exists())
{sdpath="/storage/extSdCard/";
Log.i("Sd Cardext Path", sdpath);}
if(new File("/storage/sdcard1/").exists())
{sd1path="/storage/sdcard1/";
Log.i("Sd Card1 Path",sd1path);}
if(new File("/storage/usbcard1/").exists())
{usbdiskpath="/storage/usbcard1/";
Log.i("USB Path",usbdiskpath);}
if(new File("/storage/sdcard0/").exists())
{sd0path="/storage/sdcard0/";
Log.i("Sd Card0 Path",sd0path);}
Checking these might help you know what path to choose while accessing external sd card. I hope this helps others.

Removable storage path is diff in device to device.
The example of Removable path are:
1. mnt/ext
2. mnt/externalsd
3. mnt/external_sd
My device use mnt/external_sd.
you can check the path of your file from vold.fstab file.
this file is under systems folder.
The path of file is:
"/etc/vold.fstab"

I was facing the same problem with my latest device. Then I found that removable SD card can be accessed at /mnt/ext_sdcard/. and it worked for me. I was able to list all the files stored in removable external sd card at this location.
Following is the code:
new File("/mnt/ext_sdcard/").listFiles();

You can get the path like the following way.....
File sdCardRoot = Environment.getExternalStorageDirectory();
PATH = sdCardRoot.toString();
If the path not exist, then you have to make the path by mkdir().....
private File getTempFile(Context context) {
final File path = new File(Environment.getExternalStorageDirectory(),
context.getPackageName());
if (!path.exists()) {
path.mkdir();
}
return new File(path, "new.png");
}
The above function will return the file...

storing android application data on SD Card

Is there a way to store android application data on the SD card instead of in the internal memory?
I know how to transfer the application sqlite database from the internal memory to the SDCard, but what if the internal memory gets full in the first place? How does everyone handle this?

It's better practice to use Environment.getExternalStorageDirectory() than to hard code "/sdcard"
It's not always certain that the folder name will be called that. Also, the Environment class offers a getExternalStorageState() method to check on if the external storage is even available.

To begin:
Depending on the model/os, you can access the sd card root directory with:
File externalStorage = Environment.getExternalStorageDirectory();
This will refer to the internal sd storage or internal sd memory.
externalStorage.getAbsolutePath()
will return one of the following values
"/sdcard/" or "/mnt/sdcard/"
To access the external sd memory or micro SD, that you usually plug from the outside of the phone/tablet, you must use one of the following folders that android creates to point to the external memory:
"/mnt/sdcard/sd"
"/mnt/sdcard/external_sd"
"/sdcard/external_sd"
"/sdcard/sd"
"/mnt/sdcard/"
ps: you can notice an empty folder external_sd or sd on the internal sdcard
memory, this folder is empty and its used to point to external micro sd card.
at the end make sure that you have read/write access to the sd card android.permission.WRITE_EXTERNAL_STORAGE in the android manifest xml.
finally you must specify the file name and your ready
private SQLiteDatabase DB = null;
private static final String DATABASE_NAME = "MyDb.db";
////////////
File sdcard = Environment.getExternalStorageDirectory();
String dbfile = sdcard.getAbsolutePath() + File.separator+ "external_sd" + File.separator + DATABASE_NAME;
DB = SQLiteDatabase.openDatabase(dbfile, null,SQLiteDatabase.NO_LOCALIZED_COLLATORS);
///////////
and your ready to go ...

Here is another neat little trick.
The Application has a number of methods which are called to acquire paths.
In particular the application has the method getDatabasePath with is used by SQLiteOpenHelper to construct the path.
A custom application class can override these methods to provide different paths including paths in the getExternalStorageDirectory.
The external storage is either application specific or public.
There are methods, replacing the getExternalStorageDirectory mechanism,
getExternalFilesDir() and getExternalStoragePublicDirectory() respectively.

Warning: This answer is out-dated. You should use Environment.getExternalStorageDirectory() to get the root path of the SD card as mentioned in the answers below.
Old Answer so the comments on this make sense:
Adding /sdcard/ to the root your path should direct your Android application to use the SD card (at least it works that way with the G1). Android's file system objects give you the ability to check file sizes... so it should be possible (if tricky) to write some fail-over code. This code would adjust your root path if the internal memory filled up.

some device use /mnt/sdcard as root point to SD Card.

The problem with using the SDCard is that you cannot reliably assume that it will be present always when your application needs it. This is not the case with internal memory. As long as your application does not rely on this data to run it should be fine.