9- Shared
Preferences
https://developer.android.com/training/basics/data-storage/shared-preferences.html
https://www.tutorialspoint.com/android/android_shared_preferences.htm
http://www.programcreek.com/java-api-examples/index.php?class=android.app.Activity&method=getSharedPreferences
http://androidopentutorials.com/android-sharedpreferences-tutorial-and-example/
If you have a relatively small
collection of key-values that you'd like to save, you should use the
SharedPreferences APIs.
Android provides many ways of storing
data of an application. One of this way is called Shared Preferences. Shared
Preferences allow you to save and retrieve data in the form of key, value pair.
SharedPreferences provides general
framework to save and retrieve persistent data in key-pairs value of primitives
data type.
You can use SharedPreferences to save any primitives data
type like strings,ints,booleans,floats,longs.
( Eğer uygulamamızdaki az sayıda bir key-value çiftlisini
memory'ye kaydetmek(memory'de tutmak) istiyorsak, SharedPreferences API
kullanmalıyız. SharedPreferences API kullanarak verileri bir xml dosyasında
key-value çiftleri halinde saklayabilir ve getirebiliriz. )
A SharedPreferences object points to a
file containing key-value pairs and provides simple methods to read and write
them. Each SharedPreferences file is managed by the framework and can be
private or shared.( Bir SharedPreferences object,
key-value çiftlerini(pair'larını) içeren bir dosyaya point eder. Yani
SharedPreferences object'i kullanarak, bir dosyaya erişiriz, bu dosyadan
key-value çiftlerini(pair'larını) okuruz veya yazarız veya update ederiz,
SharedPreferences object point ettiği object'e yazmak,okumak,update etmek için
gerekli method'lara sahiptir.
Bir
SharedPreferences dosyası private olabilir, bu durumda sadece bir activity
tarafından kullanılabilir; veya shared olabilir bu durumda ortaklaşa
kullanılabilir bu durumda birden fazla activity tarafından ortaklaşa
kullanılabilir.)
In this lesson you will learn how to use
the SharedPreferences APIs to store and retrieve simple values. Note:
The SharedPreferences APIs are only for reading and writing key-value pairs and
you should not confuse them with the Preference APIs, which help you build a
user interface for your app settings (although they use SharedPreferences as
their implementation to save the app settings). For information about using the
Preference APIs, see the Settings guide.
( SharedPreferences API ve Preference API'ı birbirine
karıştırma!
SharedPreferences API : bir dosyaya key-value pair'larını yazmak,
ve bu pair'ları dosyadan okumak için kullanılır.
Preference API : Uygulamamızın ayarları için bir user
interface(kullanıcı arayüzü) geliştirmek için bu API kullanılır. Bu API'ın
implementation'ında, uygulama ayarlarını kaydetmek için SharedPreferences
kullanılır. Mesela bir ayar açık mı değil mi bunu sharedpreference'ı kullanarak
bir dosyada tutar. )
Get
a Handle to a SharedPreferences
You can create a new shared preference
file or access an existing one by calling one of two methods:
( getSharedPreferences() veya getPreferences() method'larını
çağırdığımızda varolan bir shared preference dosyasına erişilir, eğer böyle bir
dosya yoksa otomatik olarak yaratılır. )
getSharedPreferences()
— Use this if you need multiple shared preference files identified by name,
which you specify with the first parameter. You can call this from any Context
in your app. getSharedPreferences() method belongs to Context class. (
- Uygulamamızdaki herhangi bir context'den
getSharedPreferences() method'unu çağırabiliriz.
- Eğer birden fazla sharedPreferences dosyasına ihtiyacımız
varsa bu method'u kullanmalıyız.
- Bu method'u çağırdığımızda varolan bir dosya kullanılır, böyle
bir dosya yoksa belirttiğimiz isimle yeni bir dosya yaratılır.
- Bu method'u kullanarak yaratmak istediğimiz shared preference
dosyasına istediğimiz ismi verebiliriz.
- Uygulamamızdaki diğer component'ler(e.g.service) activity'ler
bu dosyaya erişebilir. )
getPreferences()
— Use this from an Activity if you need to use only one shared preference file
for the activity. Because this retrieves a default shared preference file that
belongs to the activity, you don't need to supply a name. If you do not need to
share the preferences with other components and want to have activity private
preferences you can do that with the help of getPreferences() method of the
activity.
The
getPreference() method uses the getSharedPreferences() method with the name of
the activity class for the preference file name.
( - Uygulamamızdaki sadece activity kodunun içerisinden
getSharedPreferences() method'unu çağırabiliriz.
- Eğer sadece 1 tane sharedPreferences dosyasına ihtiyacımız
varsa bu method'u kullanmalıyız.
- Bu method'u çağırdığımızda varolan bir dosya kullanılır, böyle
bir dosya yoksa default bir isimle yeni bir sharedpreference dosyası yaratılır.
- sharedpreference dosyamızın ismini bilen diğer uygulamalar, bu
dosyaya erişebilirler dosyanın mod'una bağlı olarak.
- Uygulamamızdaki diğer activity'ler bu dosyaya erişebilirler
mi? Çoğu kaynakta erişemezler diye geçer, çünkü bu activity'ye özeldir. Ancak
bu uygulama içersinde activity'nin ismini bilen diğer component'ler bu
sharedpreferences dosyasına erişebilirler.
- getPreference() method'u çağırılınca activity class'ının
isminde bir sharedpreferences dosyası yaratılır. )
Bu 2 method
kullanılarak yaratılan sharedPreferences dosyalarına diğer uygulamalardan
erişilip erişilemeyeceğini belirleyen şey nedir? Dosyayı hangi modla
yarattığımız bir sharedpreference dosyası .xml uzantılıdır.
----
For example, the following code is
executed inside a Fragment. It accesses the shared preferences file that's
identified by the resource string R.string.preference_file_key and opens it
using the private mode so the file is accessible by only your app.
Context
context = getActivity();
SharedPreferences
sharedPref = context.getSharedPreferences(
getString(R.string.preference_file_key), Context.MODE_PRIVATE );
When
naming your shared preference files, you should use a name that's uniquely
identifiable to your app, such as "com.example.myapp.PREFERENCE_FILE_KEY"
( Bu 2 satırlık kod Fragment içerisinde çalıştırılmıştır,
fragment nedir ne demek istemiş fragment içerisinde getactivity() method'unu
çağırarak activity'yi mi elde etmiş anlamadım.
getSharedPreferences() method'unun ilk parametresi,
sharedPreferences dosyasının ismini alır. string.xml içerisinde tanımladığımız
preference_file_key isimli variable'ın değerini almıştır bu örnekte. Ve private
mod ile yaratılmıştır dolayısıyla başka uygulamalar bu shared preferences
dosyasına erişemez.
Bir shared preference dosyasına isim verirken uygulamamız içinde
unique olacak bir isim vermeye dikkat etmeliyiz. örneğin şu gibi :
com.example.myapp.PREFERENCE_FILE_KEY )
--------
Alternatively,
if you need just one shared preference file for your activity, you can use the
getPreferences() method:
( Eğer activity'niz için sadece 1 tane shared preference'a
ihtiyacınız varsa, getPreferences() method'unu kullanmalısınız. )
SharedPreferences sharedPref =
getActivity().getPreferences(Context.MODE_PRIVATE); // kodu anlamadım getActivity() nedir,
getPreferences sadece activity.java kodu içinden çağırılmıyor muydu bu nedemek
tekrar bak.
Caution: If you create a shared
preferences file with MODE_WORLD_READABLE or MODE_WORLD_WRITEABLE, then any
other apps that know the file identifier can access your data.
( Eğer bir sharedPreferences dosyasını MODE_WORLD_READABLE veya
MODE_WORLD_WRITEABLE moduyla yaratırsanız, sharedPreferences dosyanızın ismini
bilen diğer uygulamalar bu dosyaya erişebilirler. )
--------
Write
to Shared Preferences
To
save something in the sharedpreferences file , create a
SharedPreferences.Editor by calling edit() on your SharedPreferences.
( Bir shared preferences dosyasına yazmak için
SharedPreferences.Editor class'ından (yani SharedPreferences class'ının sahip
olduğu inner class olan Editor class'ından ) bir object elde etmeliyiz.
Bu object'i nasıl elde ederiz? sharedPref
class'ının edit() method'unu çağırarak. Elde ettiğimiz SharedPreferences.Editor
object'in putInt() ve putString() gibi method'larını çağırarak shared
preference dosyasına yeni key-value değerleri yazabiliriz.
Sonra ise değişiklikleri kaydetmek için commit() method'unu
çağırmak zorundayız. )
Pass the keys and values you want to
write with methods such as putInt() and putString(). Then call commit() to save
the changes.
Örnek
1:
SharedPreferences
sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE); // getActivity() method'unu araştır nerede ne için kullanılır?
SharedPreferences.Editor
editor = sharedPref.edit();
editor.putInt(getString(R.string.saved_high_score),
newHighScore);
editor.commit();
Örnek
2: bu örnekte SharedPreferences.Editor class import
edilmiştir daha önce dikkat!
Editor
editor = sharedpreferences.edit();
editor.putString("key",
"value");
editor.commit();
Apart from the putString method , there
are methods available in the editor class that allows manipulation of data
inside shared preferences. They are listed as follows: (
Sharedpreferences class'ı, putString() method'una ek olarak, shared preferences
dosyasındaki verileri manipulate etmek için kullanılan şu method'ları içerir. )
1 - apply() (apply ve commit method'ları arasındaki fark nedir?)
It is an abstract method. It will commit
your changes back from editor to the sharedPreference object you are calling.
2 - clear()
It will remove all values from the
editor. ( sharedpreference dosyasındaki tanımlı tüm
key-value pair'larını silmek için kullanılır. )
3 - remove(String key)
It
will remove the value whose key has been passed as a parameter. (sharedpreference dosyasındaki tanımlı key'e karşılık
gelen key-value pair'ını silmek için kullanılır. )
4 - putLong(String key, long value)
It
will save a long value in a preference editor (
sharedpreference dosyasına bir long value eklemek için bu method çağırılır. )
5 - putInt(String key, int value)
It
will save a integer value in a preference editor (
sharedpreference dosyasına bir int value eklemek için bu method çağırılır. )
6 - putFloat(String key, float value)
It
will save a float value in a preference editor (
sharedpreference dosyasına bir float value eklemek için bu method çağırılır. )
Yukarıdaki değişiklikler preference editor'de değişiklik yapar.
Bu değişikliği kaydetmek için commit() etmek gerekir.
--------
Read
from Shared Preferences
To retrieve values from a shared
preferences file, call methods such as getInt() and getString(), providing the
key for the value you want, and optionally a default value to return if the key
isn't present.
For
example:
SharedPreferences
sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE); getActivity() method'u için çağırılır.
int
defaultValue = getResources().getInteger(R.string.saved_high_score_default); // getResources().getInteger() method'u
için çağırılır.
long
highScore = sharedPref.getInt(getString(R.string.saved_high_score),
defaultValue);
( Bir shared preferences dosyasını okumak için(bu dosyadaki
key-value'leri okumak için sharedPreferences object'in getInt() ve getString()
gibi method'larını çağırırız.
string.xml dosyasında tanımlı saved_high_score isimli
variable'ın değeri ile aynı isimdeki key'in ilgili sharedPreferences
dosyasındaki değerini okuyup bu değeri defaultValue isimli variable'a set
ederiz. )
-----------
In order to use shared preferences , you
have to call a method getSharedPreferences() that returns a SharedPreference
instance pointing to the file that contains the values of preferences.
SharedPreferences
sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);
The first parameter is the name of
sharedpreference file and the second parameter is the MODE. Apart from private
there are other modes available that are listed below:
( Shared preferences' kullanmak için getSharedPreferences()
method'unu çağırabiliriz, bu method bir sharedpreferences object return eder.
Bu object, key-value pair'larını içeren bir sharedpreferences dosyasına point
eder. )
Bir sharedpreferences dosyası yukarıdaki kodda private mod ile
açılmıştır. Bir sharedpreferences dosyasının açılabileceği tüm mod'lar
şunlardır : )
1 - MODE_APPEND
This
will append the new preferences with the already existing preferences
2 - MODE_ENABLE_WRITE_AHEAD_LOGGING
Database
open flag. When it is set , it would enable write ahead logging by default
3 - MODE_MULTI_PROCESS
This
method will check for modification of preferences even if the sharedpreference
instance has already been loaded
4 - MODE_PRIVATE
By
setting this mode , the file can only be accessed using calling application
5 - MODE_WORLD_READABLE
This
mode allow other application to read the preferences
6 - MODE_WORLD_WRITEABLE
This
mode allow other application to write the preferences
--------
Summary :
You
can create Object of SharedPreferences using two methods,
1 - getSharedPreferences()
: Using
this methods you can create Multiple
SharedPreferences and its first parameters in name of SharedPreferences.
2 - getPreferences()
: Using
this method you can create Single SharedPreferences.
Now
how to save,retrieve,remove or clear all data of SharedPreferences ?.
Save
Data(key-value pair) into SharedPreferences ::
// mypref.xml isimli SharedPreferences
dosyasına point eden bir SharedPreferences object elde edelim.
SharedPreferences sharedPref=
getSharedPreferences("mypref", 0);
//SharedPreferences.Editor object elde
edelim.
SharedPreferences.Editor editor=
sharedPref.edit();
//put your value
editor.putString("name",
strName);
editor.putString("pwd",
strPass);
//commits your edits
editor.commit();
Using
putString(),putBoolean(),putInt(),putFloat(),putLong() you can save primitives
data type.
Don't forget to commit SharedPreferences,
Otherwise data is not saved.
Retrieve
Data from Shared Preferences
SharedPreferences sharedPref=
getSharedPreferences("mypref", 0);
String name =
sharedPref.getString("name", "");
String password =
sharedPref.getString("pwd", "");
here
you get data from SharedPreferences, you can check first time when your
OnCreate() method is called and its never generates any exception even if data
is inserted you just check value of your primitives data type.
Clear
ALL key-value pairs from SharedPreferences :
SharedPreferences sharedPref=
getSharedPreferences("mypref",0);
SharedPreferences.Editor editor =
sharedPref.edit();
editor.clear(); //its clear all data.
editor.commit(); //Don't forgot to commit SharedPreferences.
Remove
Single key-value pair from SharedPreferences :
SharedPreferences sharedPref=
getSharedPreferences("mypref",0);
SharedPreferences.Editor editor =
sharedPref.edit();
editor.remove("name");//its remove
name field from your SharedPreferences
editor.commit(); //Don't forgot to commit SharedPreferences.
Note
: It stores data until you clear data from the app or uninstall app.(sharedpreference dosyasındaki veriler ne zamana kadar
tutulur,saklanır? Biz bunları manual olarak silene kadar veya uygulamayı
telefonumuzdan silene kadar. )
--------
Örnek:
This
example demonstrates the use of the Shared Preferences. It display a screen
with some text fields , whose value are saved when the application is closed
and brought back when it is opened again .
( Bu örnekte ekranda text field'lar vardır. Bu text field'lara
girilen değerler uygulama kapatılırken sharedpreference kullanılarak
kaydedilir. Uygulama açılırken sharedpreference kullanılarak bu veriler elde
edilir. )
MainActivity.java :
package
com.example.sairamkrishna.myapplication;
import
android.content.Context;
import
android.content.SharedPreferences;
import
android.support.v7.app.ActionBarActivity;
import
android.os.Bundle;
import
android.view.Menu;
import
android.view.MenuItem;
import
android.view.View;
import
android.widget.Button;
import
android.widget.EditText;
import
android.widget.Toast;
public
class MainActivity extends ActionBarActivity {
EditText ed1,ed2,ed3;
Button b1;
public static final String MyPREFERENCES =
"MyPrefs" ; //sharedpreferences
dosyamızın ismi bu olacak.
public static final String Name =
"nameKey"; //sharedpreferences
dosyamızda tutacağımız bir pair'ın key'i.
public static final String Phone =
"phoneKey"; //sharedpreferences
dosyamızda tutacağımız bir pair'ın key'i.
public static final String Email =
"emailKey"; //sharedpreferences
dosyamızda tutacağımız bir pair'ın key'i.
SharedPreferences sharedpreferences;
@Override
protected void onCreate(Bundle
savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ed1=(EditText)findViewById(R.id.editText); editText id'li editText view
object'i elde ettik.
ed2=(EditText)findViewById(R.id.editText2); editText2 id'li editText view
object'i elde ettik.
ed3=(EditText)findViewById(R.id.editText3); editText3 id'li editText view
object'i elde ettik.
b1=(Button)findViewById(R.id.button); button
id'li Button view object'i elde ettik.
sharedpreferences =
getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);
// "MyPrefs.xml" isimli bir sharedpreferences dosyası
yarattık. getSharedPreferences() method'unu kullandığımız için bu dosya birden
fazla activity tarafından kullanılabilir.
// Private mod kullandığımız için bu dosyaya sadece bu
uygulamadan erişilebilir.
(button id'li butona tıklayınca olacakları
tanımlıyoruz : )
b1.setOnClickListener(new
View.OnClickListener() {
@Override
public void onClick(View v) {
String n = ed1.getText().toString();
String ph = ed2.getText().toString();
String e = ed3.getText().toString();
( edittext
alanlarına girilen input'lar elde edilir.
)
SharedPreferences.Editor editor =
sharedpreferences.edit();
editor.putString(Name, n);
editor.putString(Phone, ph);
editor.putString(Email, e);
editor.commit();
(
SharedPreferences.Editor object elde edilir. Bu object kullanılarak,
SharedPreferences dosyasına 3 tane key-value pair koyulur. Bu pair'ların
değeri, edittext'lerden alınan değerlerdir. )
Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
(
Ekranda Thanks yazan bir toast mesajı gösterilir. )
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu
menu) {
// Inflate the menu; this adds items to
the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean
onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here.
The action bar will
// automatically handle clicks on the
Home/Up button, so long
// as you specify a parent activity in
AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
res/layout/activiy_main.xml
:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Shared Preference
"
android:id="@+id/textView"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:textSize="35dp" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Tutorials Point"
android:id="@+id/textView2"
android:layout_below="@+id/textView"
android:layout_centerHorizontal="true"
android:textSize="35dp"
android:textColor="#ff16ff01"
/>
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText"
android:layout_below="@+id/textView2"
android:layout_marginTop="67dp"
android:hint="Name"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText2"
android:layout_below="@+id/editText"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:hint="Pass" />
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText3"
android:layout_below="@+id/editText2"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:hint="Email" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Save"
android:id="@+id/button"
android:layout_below="@+id/editText3"
android:layout_centerHorizontal="true"
android:layout_marginTop="50dp"
/>
</RelativeLayout>
res/values/strings.xml
:
<resources>
<string name="app_name">My
Application</string>
<string
name="hello_world">Hello world!</string>
<string
name="action_settings">Settings</string>
</resources>
AndroidManifest.xml
:
<?xml
version="1.0" encoding="utf-8"?>
<manifest
xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.sairamkrishna.myapplication" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme"
>
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN"
/>
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Now
just put in some text in the field.
Now
when you press save button , the text will be saved in the shared preferences.
Now press back button and exit the application.
Now
open it again and you will see all the text you have written back in your
application.
(
Uygulamayı çalıştıralım. Textfield'ları dolduralım sonra kaydet butonuna
basalım. Butona basınca textfield'lara girdiğimiz değerler shared preferences
dosyasına kaydedilir.
Uygulamayı
kapatıp tekrar açınca, biraz önce shared preferences dosyasına kaydettiğimiz
verileri ekranda gözüktüğünü görürüz.
Yani
uygulama kapatılsa bir sharedpreference dosyasında veriler tutulmaya devam
eder. ta ki biz onları manual olarak silene kadar. )
----------
3 -
http://stackoverflow.com/questions/3624280/how-to-use-sharedpreferences-in-android-to-store-fetch-and-edit-values
What
is the difference between commit() and apply() methods in SharedPreferences.
commit()
returns true if value saved successfully otherwise false. It saves values to
SharedPreferences synchronously.
apply()
was added in 2.3 and doesn't return any value either on success or failure. It
saves values to SharedPreferences immediately but starts an asynchronous
commit. If you are on the ui thread you should call apply() which is
asynchronous.
(
commit() :
- senkron çalışır, yani commit() method'undan bir sonraki satıra
geçmek için commit() method'unun return etmesi beklenir.
- kaydetme başarılı ise true return eder.
apply() :
- Asenkron çalışır. Yani apply() method'undan bir sonraki satıra
geçmek için commit() method'unun return etmesi beklenmez.
- kaydetme başarılı olsa da olmasa da herhangi bir şey return
etmez. UI thread'de isek, apply() method'unu çağırmalıyız. What is ui thread?
main_activity'yi set ettiğimiz class'ın olduğu thread main thread'dir. )
----
Difference
between getDefaultSharedPreferences and getSharedPreferences
http://stackoverflow.com/questions/5946135/difference-between-getdefaultsharedpreferences-and-getsharedpreferences
getDefaultSharedPreferences
will use a default name like "com.example.something_preferences", but
getSharedPreferences will require a name.
getDefaultSharedPreferences
in fact uses Context.getSharedPreferences (below is directly from the Android
source):
public
static SharedPreferences getDefaultSharedPreferences(Context context) {
return
context.getSharedPreferences(getDefaultSharedPreferencesName(context),
getDefaultSharedPreferencesMode());
}
private
static String getDefaultSharedPreferencesName(Context context) {
return context.getPackageName() +
"_preferences";
}
private
static int getDefaultSharedPreferencesMode() {
return Context.MODE_PRIVATE;
}
( getDefaultSharedPreferences() method'u çağırıldığında default
isimli bir SharedPreferences dosyası yaratılır.
getDefaultSharedPreferences() method'u implementation'ında
Context.getSharedPreferences() method'u zaten çağırır.
getDefaultSharedPreferences() method'unun implementation'ı aşağıdadır.
Implementation'da
getSharedPreferences() method'unun hangi argumentlerle
çağırıldığına dikkat edelim. 1.argument'i getDefaultSharedPreferencesName
isimli private bir method'un output'u belirler. default isim şudur :
packageismi_preferences. )
Yani aslında getDefaultSharedPreferences() ve
Context.getSharedPreferences() arasında fark yoktur.
getDefaultSharedPreferences() method'u, Context.getSharedPreferences()
method'unun default parameter'lar ile çağırılmış halidir.)
-------
getDefaultSharedPreferences()
can be safely used without going into the confusion of multiple preference file
names that are prone to typos and confusion,
unless
you want that different modules in your app will use different preference
files. Normally this is not needed.
If
an app needs to save a lot of parameters, probably using external database will
be better as it offers also better data protection.
( Eğer birden fazla sharedpreferences dosyasına ihtiyacımız
yoksa(ki genellikle byle bir ihtiyaç yoktur) getDefaultSharedPreferences()
method'unu kullanırız. Böylece farklı isim karmaşasından kurtulmuş oluruz. Eğer
uygulamamızda çok sayıda pair kaydetmek istiyorsak, db kullanmalıyız,
sharedPreferences değil. )
------
In
any application, there are default preferences that can be accessed through the
PreferenceManager instance and its related method
getDefaultSharedPreferences(Context).
(Tüm uygulamalar bazı default preference'lara sahiptir, yani bir
SharedPreference dosyasında kayıtlı bazı default pair'lar vardır tüm
uygulamalar için.
Bunlara PreferenceManager class'ının bir instance'ının
getDefaultSharedPreferences(Context) method'unu çağırarak erişebiliriz. )
With
the SharedPreference instance one can retrieve the int value of the any
preference with the getInt(String key, int defVal). The preference we are
interested in this case is counter.
(Bazı Kaynaklarda, SharedPreference dosyasına kaydettiğimiz
pair'lardan preference diye bahsedilmektedir. Yani SharedPreference dosyasına
yeni bir preference kaydetmek, eklemek,getirmek vs. gibi.)
In
the below example, we obtain SharedPreference instance by invoking
PreferenceManager.getDefaultSharedPreferences(this).
Then
we obtain SharedPreferences.Editor by invoking edit() method of
SharedPreferences object. Then we update the counter variable by calling
putInt(String key, int newVal).
We
increased the count for our application that persist beyond the application and
displayed accordingly.
To
further demo this, restart and you application again, you will notice that the
count will increase each time you restart the application.
( Aşağıdaki örnekte bir SharedPreference object'i elde edip,
bunu kullanarak ilgili SharedPreference dosyasındaki counter
variable'ının(key'inin) değerini okuruz.
Ekrandaki bir textview alanında counter variable'ının değerini
gösteririz. Sonra counter variable'ının değerini arttırırız. Uygulamamızı
kapatıp açtıkça bu counter değerinin arttığını görürüz.)
PreferencesDemo.java
package
org.example.preferences;
import
android.app.Activity;
import
android.content.SharedPreferences;
import
android.os.Bundle;
import
android.preference.PreferenceManager;
import
android.widget.TextView;
public
class PreferencesDemo extends Activity {
/** Called when the activity is first
created. */
@Override
public
void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
// Get the app's shared preferences
SharedPreferences app_preferences =
PreferenceManager.getDefaultSharedPreferences(this);
// Get the value for the run counter
int counter =
app_preferences.getInt("counter", 0);
// Update the TextView
TextView text = (TextView)
findViewById(R.id.text);
text.setText("This app has been
started " + counter + " times.");
// Increment the counter
SharedPreferences.Editor editor =
app_preferences.edit();
editor.putInt("counter",
++counter);
editor.commit(); // Very important
}
}
main.xml
<?xml version="1.0"
encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:id="@+id/text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"/>
</LinearLayout>
-*-*-*-*-*
getPreferences()
:
SharedPreferences
getPreferences (int mode)
Retrieve
a SharedPreferences object for accessing preferences that are private to this
activity.
This
simply calls the underlying getSharedPreferences(String, int) method by passing
in this activity's class name as the preferences name.
Parameters
mode int: Operating mode. Use MODE_PRIVATE
for the default operation.
Returns
SharedPreferences Returns the single SharedPreferences
instance that can be used to retrieve and modify the preference values.
https://www.safatunc.com.tr
YanıtlaSil