Persistent Storage in Android Applications
MODE_PRIVATE
By setting this mode, the file can only be accessed using calling application
MODE_ENABLE_WRITE_AHEAD_LOGGING
Database open flag. When it is set , it would enable write ahead logging by default
apply()
Editor class method: It is an abstract method. It will commit your changes back from editor to the sharedPreference object you are calling
clear()
Editor class method: It will remove all values from the editor
remove(String key)
Editor class method: It will remove the value whose key has been passed as a parameter
putFloat(String key, float value)
Editor class method: It will save a float value in a preference editor
putInt(String key, int value)
Editor class method: It will save a integer value in a preference editor
putLong(String key, long value)
Editor class method: It will save a long value in a preference editor
read(byte[) buffer, int byteOffset, int byteCount)
FileInputStream Methods: This method reads at most length bytes from this stream and stores them in the byte array b starting at offset
available()
FileInputStream Methods: This method returns an estimated number of bytes that can be read or skipped without blocking for more input
reading file
FileOutputStream Methods: FileInputStream fin = openFileInput(file); int c; String temp = ""; while( (c = fin.read()) != -1) { temp = temp + Character.toString((char)c); } //string temp contains all the data of the file. fin.close();
write(byte[) buffer, int byteOffset, int byteCount)
FileOutputStream Methods: This method Writes count bytes from the byte array buffer starting at position offset to this stream
FileOutputStream(File file, boolean append)
FileOutputStream Methods: This method constructs a new FileOutputStream that writes to file.
FileInputStream Methods: getChannel()
This method returns a read-only FileChannel that shares its position with this stream
FileOutputStream Methods: getChannel()
This method returns a write-only FileChannel that shares its position with this stream
FileInputStream Methods: getFD()
This method returns the underlying file descriptor
FileOutputStream Methods: getFD()
This method returns the underlying file descriptor
MODE_MULTI_PROCESS
This method will check for modification of preferences even if the shared preference instance has already been loaded
MODE_WORLD_READABLE
This mode allow other application to read the preferences
MODE_WORLD_WRITEABLE
This mode allow other application to write the preferences
MODE_APPEND
This will append the new preferences with the already existing preferences
Public Files
— Files that should be freely available to other apps and to the end user. Example: photos captured by your app or other downloaded files — not deleted when user uninstalls the app
Shared Preferences
— Store private primitive data in key-value pairs — use to save any primitive data: boolean, float, int, long, and string which will persist across user sessions (even if your application is killed) — Generally used to store small amount of data, that may be required frequently
Context.MODE_APPEND
keep appending data to the existing contents
getExternalFilesDir()
method to store private files on external storage
SharedPreferences class
provides a general framework that allows you to save and retrieve persistent key-value pairs of primitive data types
getExternalCacheDir()
store cache files on external storage that are removed when the app is uninstalled and not accessible when SD card is removed
getExternalStorageDirectory()
to get to the root of the external storage in API < 7
Private Files
— Files that rightfully belong to your app and should be deleted when the user uninstalls your app. They don't provide value to the user outside your app. Example: Other resources downloaded by your app. — deleted when user uninstalls the app
writing file
String FILENAME = "mytext.txt"; String string = "hello world!"; FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE); byte[] buf = string.getBytes(); fos.write(buf); fos.close();
Network Connection
Store data on the web with your own network server
External Storage
Store private data on the device external memory
SQLite Database
Store structured data in a private database
Context.MODE_PRIVATE
cannot be read by others
getExternalStorageFilesDir(String type)
create files specific to your app that are removed when your app is uninstalled.
Writing to External Storage
—Add permission statement to your manifest file. WRITE_EXTERNAL_STORAGE —Check the external storage to see if its MOUNTED, READ_ONLY, or FAILURE using getExternalStorageState() method. —Get the files directory by calling getExternalStorageFilesDir(String type) or getExternalStoragePublicDirectory(String type) or getExternalStorageDirectory() —Use a (FileInputStream) and (FileOutputStream) to do the required operations.
Internal Storage comparison
—It's always available. —Files saved here are accessible by only your app. —When the user uninstalls your app, the system removes all your app's files from internal storage. —Less memory available. —Access speed is more or less the same.
External Storage comparison
—It's not always available, because the user can mount the external storage as USB storage and in some cases remove it from the device. —It's world-readable, so files saved here may be read outside of your control. —When the user uninstalls your app, the system removes your app's files only if you save them in the directory returned by getExternalFilesDir(). —Larger memory size. Asst. Prof. Alex A. Santos
Internal Storage
—Store private data on the device memory —allows reading and writing to files which are associated with each application's internal memory —files are private to the application by default, hence they can only be accessed by the application who created them —files are automatically deleted once the host application is uninstalled —other apps and users cannot browse your internal directories and don't have read/write access unless you explicitly set the files to be readable/writable —when you use MODE_PRIVATE for your files on the internal storage, they are never accessible to other apps — best when you want to be sure that neither the user nor other apps can access your files
Internal/External Storage
—Storing data and files to the phone's external Secure Digital (SD) card. —Less efficient
SharedPreferences
—Storing data internally in XML files. —More efficient due to less read/write overhead. —Stores only primitive types and at most, arrays of Strings
public static File getExternalFilesDir(String type)
—returns the absolute path to the directory on the primary external where the application can place persistent files it owns. —these files are private to the applications, and not typically visible to the user as media —type = may be null for the root of the files directory or one of the following Environment constants for a subdirectory: DIRECTORY_MUSIC, DIRECTORY_PODCASTS, DIRECTORY_RINGTONES, DIRECTORY_ALARMS, DIRECTORY_NOTIFICATIONS, DIRECTORY_DOWNLOADS, DIRECTORY_PICTURES, DIRECTORY_MOVIES. —if type in not null, the returned file will a path to a sub-directory of the given type —get a top-level public external storage directory for placing files of a particular type —user will typically place and manage their own files, so you should be careful about what put here to ensure your don't erase their files or get in the way of their own organization. —on devices with multiple users, each user has their own isolated external storage. —applications only have access to the external storage for the currently active user.
getExternalStoragePublicDirectory()
—store files not specific to your app and should not be deleted when your app is uninstalled. —method to store public files on external storage
Cache Storage
—files stored in the files folder are persistent and remain until they are deleted —files can be stored temporarily (caching) —use getCacheDir() or getExternalCacheDir() to get a reference to the absolute path of your app's cache directory —use the File class to create a file inside the cache folder —the files are stored in data/data/<package-name>/cache folder —when the device is low on internal storage space, Android may delete these cache files to recover space —do not rely on the system to clean up these files
Methods to access External Storage
• getExternalStorageDirectory() • getExternalStorageFilesDir(String type) • getExternalCacheDir() • getExternalStoragePublicDirectory()