Android provides a number of support classes that allow you to manage large amounts of data. Applications will typically use the SharedPreferences class, when they want to store small amounts of primitive data. External storage is used when you want to store larger amounts of non-private data. And your application will typically use databases, when you intend to store small to large amounts of private structured data.
Android provides a number of support classes that allow you to manage large amounts of data. Applications will typically use the SharedPreferences class, when they want to store small amounts of primitive data. External storage is used when you want to store larger amounts of non-private data. And your application will typically use databases, when you intend to store small to large amounts of private structured data.
Android provides a number of support classes that allow you to manage large amounts of data. Applications will typically use the SharedPreferences class, when they want to store small amounts of primitive data. External storage is used when you want to store larger amounts of non-private data. And your application will typically use databases, when you intend to store small to large amounts of private structured data.
Programming Mobile Applications for Android Handheld Systems. Handheld systems can generate and manipulate large amounts of data. So Android provides a number of support classes that allow you to manage data across multiple application sessions. In today's lesson, I'll talk about several of these support classes. I'll begin by talking about the SharedPreferences class, which allows applications to store and manage small amounts of primitive data. Next, I'll talk about writing files to both internal and external storage. And, lastly, I'll finish up by discussing the creation and use of complex SQLite databases. Let's briefly discuss each of these storage options, one at a time. Your applications will typically use the Shared Preferences class, when you want to store small amounts of primitive data, such as a user name. Your applications will typically use internal device storage, when you need to manage small to medium amounts of data that should remain private to the application, such as temporary files that are used by the application. Your applications will typically use external storage when you want to store larger amounts of non-private data, such as songs or video files. And your application will typically use databases, when you intend to store small to large to amounts of private structured data. SharedPreferences are essentially persistent maps, and like any map, they hold key value pairs of simple data types, things like strings and floats. And SharedPreferences are automatically persisted across application sessions. And this allows a user to create information during one use of an application, exit the application, restart it later, and still have access to the information they created earlier. SharedPreferences are often used for long-term storage of customizable application data. Including things like a username, favorite WiFi networks, or specific user options or preferences. To get a SharedPreferences object, that is associated with a given activity, you can use the Activity.getPreferences method, passing in an access mode as a parameter. For example, this mode can be mode_private, indicating that the data is private to the calling application. If you want a SharedPreferences object, that is not associated with a specific activity, then you can use the context.getSharedPreferences method, to retrieve a named shared preferences object. And with this method, you pass in a name for the SharedPreferences object and you pass in an access mode, such as the mode_private that we saw earlier. Once you've acquired a SharedPreferences object, you can edit that object, by calling SharedPreferences.edit, and this method returns a SharedPreferences.Editor instance. You can then add or change the values of the SharedPreferences object, using methods such as putInt, putString, and remove. And after you've made whatever changes you wanted to, you can then make those changes permanent by calling the SharedPreferences.Editor.commit method. And at this point, the SharedPreferences object is saved, and applications can exit, knowing that their data can be retrieved during later application sessions. If an application later wants to read these values, it can get the SharedPreferences object again, and then use various methods to read out the values that are stored within the object. For instance, it can call getAll to get the SharedPreferences values. It can call getBoolean to get a particular Boolean value. Or, it can call getString to get a particular String value. Our first example application in this lesson, is called DataManagementSharedPreferences. This application has a button labeled Play. And when the user presses the Play button, the application displays a random number. The application keeps track of the highest number seen so far, and saves that number across different user sessions. Let's run this application now. So here is my device. Now, I'll start the Data Management Shared Preferences application. When this application starts, it shows that the high score is currently zero. When I press the Play button, you'll see that a new number is now displayed in the center of the screen. And since that number was higher than the previous high score, the high score display has been updated to show the new number. Now, remember this high score. I'm going to now quit this application, and now I'll restart it. And as you can see, the current high score is the same high score that we saw from the last time we ran the application. Now let me hit the Play button a few more times. So I'll increase the high score. There we go. And now I'll stop the application again, and restart it. And again, you can see that the application displays the high score, that was set in the previous use of the application. Now I can also hit the Reset button, to reset that high score to 0. Let's look at the source code for this application. So, here's the application, open in the IDE. Now, I'll open the main activity. In onCreate, the code acquires the SharedPreferences object for this activity. Next, when the user clicks the Play button, the code generates a new score, which it stores in a variable called Val. After that, the code calls getInt on the Preferences object, to retrieve the current high score. If Val is greater than the current high score, then we need to update the high score. So the code calls the Edit method on the Preferences object, which returns a SharedPreferences.Editor object. Next, the code calls the, calls putInt on the editor object to update the high score, to the current value. And finally, the code calls commit on the editor, to save the current high score. As I said earlier, the Shared Preferences class is often used to store an application's user preferences. To make this easier, Android provides a class called PreferenceFragment, that applications can use to display and modify user preferences. Our next example application is called DataManagement PreferenceFragment. This application uses a PreferenceFragment to display and modify an application's user preferences. In this case, the preference is the name that the application will use when addressing the user. Let's take a look at that application. So here's my device. Now, I'll start the Data Management Preference Fragment application. This application starts up. It presents a single button, labeled View User Name. When I click on this button, the Preference Fragment will appear, allowing me to view my current user name, and to change it if I wish. Let me do that now. Now as you can see, my User Name has not yet been set. So I'll click on this area, and now a dialog box pops up, asking me to enter my User Name. Let me do that now. Now, I'll click on the Submit button to accept this new User Name. The dialog box closes, and here you can see that my User Name is now the name that I just entered. Now I'll close the application, and restart it. I'll click again on the View User Name button, and as you can see, my User Name is still Adam. So, the information does indeed persist across user sessions. Let's take a look at the source code for this application. So here's the application open in the IDE. Now, I'll open the ViewAndUpdatePreferencesActivity. This activity is the one that is started when the user clicks the View User Name button. The onCreate method first call setContentView, passing in an XML file called User _prefs_fragment.xml. And this layout file instantiates and displays an instance of the User Preference Fragment class, which is defined in this file. Let's look at that class now. This class's onCreate method first calls the AddPreferencesFromResource method, passing in the user_preps.xml file, that's in the res/.xml directory. Let's open that file. As you can see, this file defines a preference screen resource. This preference screen, contains one preference, that's displayed in an edit text box. And that preference has a key, the string you name, and is displayed with the title User Name. When the user clicks on the edit text box to change the User Name, a dialog box pops up, with the title Change User Name. A subtitle, or message, saying enter your User Name, and two buttons labelled Cancel and Submit. In addition to preferences, Android supports the use of files. File is a class that represents a file system entity identified by a path name. In Android, storage areas are classified as being either internal or external. Historically, this distinguished between the internal flash memory on a device, and the removable external memory cards attached to the device. Nowadays however, not all external memory is removable. Internal memory, is usually used for smaller data sets that are private to an application. External memory, in contrast, is usually reserved for larger non-private data sets. Things like music files and pictures. The example applications that we'll look in just a second, access and use files to store information. Two of the methods they use to do this, are the OpenFileOutput method which opens a private file for writing. And this method will create a physical file, if it doesn't already exist, and there's also that OpenFileInput, method which opens a private file for reading. And there are, of course, many other file related methods, so please look at the documentation for more information. The next example application is called Data Management File Internal Memory. When this application starts up, it checks whether a particular text file exists. And if it does not, the application then creates that file, and writes some text into it. After that, the application opens that file, reads the text from it, and displays that text on the display. Let's take a look at this application. So here's my device. Now, I'll open the Data Management File Internal Memory application. As you can see, the application has displayed some text on the screen. Let's look at the source code for this application, to find out where that text came from. So here's the application, open in the IDE. Now, I'll open the main activity for this application. And here in the onCreate method, the code first gets the file string path associated with the file name, TestFile.txt. And if that file does not exist, then the code goes on to call the WriteFile method. Let's scroll down and look at that method. Now this method first calls the OpenFileOutput method, which returns a file output stream. The code then continues, by writing three lines of text to that text file, and finally it closes the file. Now let's scroll back up to the onCreate method. [BLANK_AUDIO] Now the code continues, by calling the readFile method, passing in a linear layout on which to display the text. The readFile method now opens the text file for input, and then begins to read each line out of the file. And each of these lines is then placed into a text view, and added to the linear layout. [BLANK_AUDIO]