SAVING SIMPLE APPLICATION DATA

Transcription

1 1

2 DATA PERSISTENCE

3 OBJECTIVES In this chapter, you will learn how to persist data in your Android applications. Persisting data is an important topic in application development, as users typically expect to reuse data in the future. How to save simple data using the SharedPreferences object Enabling users to modify preferences using a PreferenceActivity class How to write and read fi les in internal and external storage Creating and using a SQLite database

4 SAVING SIMPLE APPLICATION DATA Three data-persistence techniques : Shared Preferences Key/values pairs. can be shared among application components. not available to other applications. Saved Application State a pair of event handlers used for saving Activity instance details. Files It s not pretty Android lets you create and load files on the device s internal or external media.

5 5 SAVING SIMPLE APPLICATION DATA Both Shared Preferences and Saved Application State use a name/value pair (NVP) mechanism to store simple primitive values. Shared Preferences support the primitive types Boolean, string, float, long, and integer, making them an ideal means of quickly storing default values, class instance variables, the current UI state, and user preferences

6 CREATING AND SAVING PREFERENCES To create or modify a Shared Preference, call getsharedpreferences on the application Context, passing in the name of the Shared Preference to change. Shared Preferences are shared across an application s components, but aren t available to other applications.(saved in app. sandbox) To modify a Shared Preference use the SharedPreferences.Editor class.

7 RETRIEVING SHARED PREFERENCES getsharedpreferences method. To Accessing Shared Preferences, like editing and saving them. Pass in the name of the Shared Preference you want to access, and use the type-safe get<type> methods to extract saved values. Each getter takes a key and a default value (used when no value has yet been saved for that key)

8 Main.xml EXAMPLE

9 EXAMPLE (CONTINUE ) MainActivity.java

10 EXAMPLE (CONTINUE )

11 The default preference file name: <PackageName>_preferences Example: net.learn2develop.usingpreferences_preferences To change the default name use: PreferenceManager prefmgr = getpreferencemanager(); prefmgr.setsharedpreferencesname( apppreferences );

12

13 ACCESSING PREFERENCES USING AN ACTIVITY Android offers an XML-driven framework to create systemstyle preference screens for your applications. The Preference Activity framework consists of three parts: Preference Screen Layout An XML file that defines the hierarchy displayed in your Preference Activity. Preference Activity An extension of PreferenceActivity that will be used to host your application preference screens. Shared Preference Change Listener An implementation of the onsharedpreferencechangelistener class used to listen for changes to Shared Preferences.

14 PREFERENCE SCREEN LAYOUT IN XML The most important part of the Preference Activity is the XML layout. Preference definitions are stored in the res/xml resources folder. Preference Screen layouts use a specialized set of controls designed to create preference screens. Each preference layout is defined as a hierarchy, beginning with a single PreferenceScreen element:

15 PREFERENCE SCREEN LAYOUT IN XML Within each Preference Screen you can include any combination of PreferenceCategory and Preference<control> elements. Preference Category elements, shown in the following snippet, are used to break each Preference Screen into subcategories using a title bar separator:

16 PREFERENCE SCREEN LAYOUT IN XML The specific attributes available for each preference : android:key : android:title The Shared Preference key the selected value will be recorded against The text displayed to represent the preference android:summary The longer text description displayed in a smaller font below the title text. android:defaultvalue will be displayed if no preference value has been assigned to this preference key.

17 NATIVE PREFERENCE CONTROLS CheckBoxPreference A standard preference checkbox control. Used to set preferences to true or false. EditTextPreference Allows users to enter a string value as a preference ListPreference display a dialog box containing a list of values from which to select. RingtonePreference A specialized List Preference that presents the list of available ringtones for user selection. 17

18 EXAMPLE myapppreferences.xml

19 EXAMPLE(CONTINUE )

20 EXAMPLE(CONTINUE ) AppPreferenceActivity.java

21 EXAMPLE(CONTINUE ) AndroidManifest.xml

22 main.xml EXAMPLE(CONTINUE )

23 EXAMPLE(CONTINUE ) UsingPreferencesActivity.java

24 EXAMPLE(CONTINUE )

25 EXAMPLE(CONTINUE )

26 EXAMPLE(CONTINUE )

27 ANDROID FILES Android largely uses Java file I/O for local files e.g., File, InputStream, OutputWriter, etc. Represents a file system entity identified by a pathname Limitations where you can create, read, & write files Storage areas classified as internal vs. external Internal storage refers to an application s portion of the on-board, always-available flash storage Usually used for application private files External storage can be mounted by the user as a drive in Windows et al. Usually used for public files that are visible to all apps & users

28 USING THE INTERNAL STORAGE files saved to the internal storage are private to your application and other applications cannot access them. To create and write a private file to the internal storage: Call openfileoutput() with the name of the file and the operating mode. Write to the file with write(). Close the stream with close().

29 EXAMPLE

30 WRITING TO INTERNAL STORAGE

31 WRITING TO INTERNAL STORAGE MODE_WORLD_READABLE MODE_PRIVATE (the file can only be accessed by the application that created it) MODE_APPEND (for appending to an existing file) MODE_WORLD_WRITEABLE (all other applications have write access to the file).

32 WRITING TO INTERNAL STORAGE To convert a character stream into a byte stream, you use an instance of the OutputStreamWriter class, by passing it an instance of the FileOutputStream object You then use its write() method to write the string to the file. To ensure that all the bytes are written to the file, use the flush() method. Finally, use the close() method to close the file:

33 READING FROM INTERNAL STORAGE

34 READING FROM INTERNAL STORAGE To read the content of a file, you use the FileInputStream class, together with the InputStreamReader class:

35 READING FROM INTERNAL STORAGE Because you do not know the size of the fi le to read, the content is read in blocks of 100 characters into a buffer (character array). The characters read are then copied into a String object:

36 USING THE INTERNAL STORAGE When testing this application on the Android emulator, you can use the DDMS perspective to verify that the application did indeed save the file into the application s files directory. The entire path is /data/data/net.learn2develop.files/files

37 SAVING TO EXTERNAL STORAGE (SD CARD) use the getexternalstoragedirectory() method to return the full path to the SD card You then create a directory called MyFiles in the SD card. Finally, you save the file into this directory.

38 SAVING TO EXTERNAL STORAGE (SD CARD) To load the file from the external storage Note that in order to write to the external storage, you need to add the WRITE_EXTERNAL_STORAGE permission in your AndroidManifest.xml file:

39 USING STATIC RESOURCES it is also possible to add files to your package during design time so that you can use it during runtime you can add the files to your package s res/raw folder (you need to create this folder yourself). To make use of the file in code, use the getresources() method to return a Resources object, and then use its openrawresource() method to open the file contained in the res/raw folder

40 EXAMPLE

41 END Any Questions?