Android에서 SharedPreferences를 사용하여 값을 저장, 가져 오기 및 편집하는 방법 [닫기]


599

시간 값을 저장하고 검색하고 편집해야합니다. 이 작업을 어떻게 수행 할 수 SharedPreferences있습니까?


일반적인 SharedPreferences 래퍼를 구현했습니다. android-know-how-to.blogspot.co.il/2014/03/…
TacB0sS

단순화 된 접근 방식은 이 라이브러리를 사용하여이 될 것 github.com/viralypatel/Android-SharedPreferences-Helper 내에서 ... 확장 기술적 인 세부 사항 여기에 대답을 ...
AndroidMechanic - 바이러스 성 파텔

답변:


838

공유 환경 설정을 얻으려면 활동에서 다음 방법을 사용하십시오.

SharedPreferences prefs = this.getSharedPreferences(
      "com.example.app", Context.MODE_PRIVATE);

환경 설정을 읽으려면 :

String dateTimeKey = "com.example.app.datetime";

// use a default value using new Date()
long l = prefs.getLong(dateTimeKey, new Date().getTime()); 

환경 설정을 편집하고 저장하려면

Date dt = getSomeDate();
prefs.edit().putLong(dateTimeKey, dt.getTime()).apply();

android sdk의 샘플 디렉토리에는 공유 환경 설정을 검색하고 저장하는 예제가 포함되어 있습니다. 그것의 위치 :

<android-sdk-home>/samples/android-<platformversion>/ApiDemos directory

편집 ==>

나는 여기 commit()apply()여기에 차이를 쓰는 것이 중요하다는 것을 알았습니다 .

commit()true값이 성공적으로 저장되면을 반환 합니다 false. 값을 SharedPreferences에 동 기적으로 저장합니다 .

apply()2.3에 추가되었으며 성공 또는 실패에 대한 값을 반환하지 않습니다. 값을 SharedPreferences에 즉시 저장하지만 비동기 커밋을 시작합니다 . 자세한 내용은 여기 입니다.


다음에 사용자가 내 앱을 실행할 때 저장된 값이 이미 있으며 가져올 수 있습니다.
Muhammad Maqsoodur Rehman

4
(위의 내용을 읽는 사람에게는) 그렇습니다. 이 예에서는 "com.example.app.datetime"키를 사용하여 현재 날짜를 기본 설정으로 저장합니다.
MSpeed

1
this.getSharedPreferences다음과 같은 오류가 발생합니다 :The method getSharedPreferences(String, int) is undefined for the type MyActivity
Si8

15
SharedPreferences.Editor.apply ()는 2010 년 11 월 Gingerbread에서 소개되었습니다 (이 답변이 게시 된 후). apply ()가 더 효율적이므로 가능한 경우 commit () 대신 사용하십시오.
UpLate

4
Editor.apply ()에는 API 레벨 9 이상이 필요합니다. 그 사용 Editor.commit 아래 ()
레나 롤랑

283

공유 환경 설정에 값을 저장하려면 다음을 수행하십시오.

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Name","Harneet");
editor.apply();

공유 환경 설정에서 값을 검색하려면 다음을 수행하십시오.

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
String name = preferences.getString("Name", "");
if(!name.equalsIgnoreCase(""))
{
    name = name + "  Sethi";  /* Edit the value here*/
}

17
getDefaultSharedPreferences를 사용하기 때문에이 답변이 가장 좋습니다. 대부분의 사용자는 전체 앱에서 동일한 환경 설정에 액세스 할 수 있으며 환경 설정 파일의 이름을 지정할 필요가 없으므로이를 단순화합니다. 여기에 더 많은 것 : stackoverflow.com/a/6310080/1839500
Dick Lucas

동의합니다 ... 나는 머리카락을 꺼내서 왜 내가 받아 들인 대답의 방법을 사용하여 다른 활동에서 공유 환경 설정에 액세스 할 수 없었는지 알아 내려고 시도한 후에 이것을 발견했습니다. 정말 고마워!
당신은 AGitForNotUsingGit에

저장하고로드하는 데 어떻게 사용할 수 Map<DateTime, Integer>있습니까?
Dmitry

구현을 단순화하기 위해 github.com/AliEsaAssadi/Android-Power-Preference 를 사용하십시오
Ali Asadi

164

에서 데이터 를 편집 하려면sharedpreference

 SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();
 editor.putString("text", mSaved.getText().toString());
 editor.putInt("selection-start", mSaved.getSelectionStart());
 editor.putInt("selection-end", mSaved.getSelectionEnd());
 editor.apply();

에서 데이터 를 검색 하려면sharedpreference

SharedPreferences prefs = getPreferences(MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) 
{
  //mSaved.setText(restoredText, TextView.BufferType.EDITABLE);
  int selectionStart = prefs.getInt("selection-start", -1);
  int selectionEnd = prefs.getInt("selection-end", -1);
  /*if (selectionStart != -1 && selectionEnd != -1)
  {
     mSaved.setSelection(selectionStart, selectionEnd);
  }*/
}

편집하다

API 데모 샘플에서이 스 니펫을 가져 왔습니다. EditText거기 에 상자가 있었다. 이것 context에는 필요하지 않습니다. 나는 같은 의견을 말하고 있습니다.


12
+1이지만 getPreferences (MODE_PRIVATE)를 사용하십시오. getPreferences (0) 대신; 가독성.
Key

mSaved는 무엇입니까? 2 개의 문자열 값을 저장해야합니다.
Muhammad Maqsoodur Rehman

또한 mSaved가 무엇인지 알고 싶습니다. Nvm은 편집 상자를 생각합니다
karlstackoverflow

1
getInt에서 -1의 의미는 무엇입니까 ??
amr osama

1
키 (selection-start)가 공유 환경 설정에 존재하지 않으면 기본값이 반환됩니다.
DeRagan

39

쓰기 :

SharedPreferences preferences = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_WORLD_WRITEABLE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Authentication_Id",userid.getText().toString());
editor.putString("Authentication_Password",password.getText().toString());
editor.putString("Authentication_Status","true");
editor.apply();

읽다 :

SharedPreferences prfs = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_PRIVATE);
String Astatus = prfs.getString("Authentication_Status", "");

MODE_WORLD_WRITEABLE은 더 이상 사용되지 않습니다.
Christopher Smit

28

가장 쉬운 방법:

저장하려면 :

getPreferences(MODE_PRIVATE).edit().putString("Name of variable",value).commit();

검색하려면

your_variable = getPreferences(MODE_PRIVATE).getString("Name of variable",default value);

나는 활동 사이에 이것을 시도했지만 작동하지 않았다. var 이름에 패키지 구조가 포함되어야합니까?
Gaʀʀʏ

액티비티간에이 구조를 사용하려면 getPreferences (MODE_PRIVATE)를 PreferenceManager.getDefaultSharedPreferences (your ativity)로 바꾸십시오.
Lucian Novac

commit () 대신 apply ()를 사용하십시오.
Vaibhav

18

기본 설정의 값 설정 :

// MY_PREFS_NAME - a static String variable like: 
//public static final String MY_PREFS_NAME = "MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
 editor.putString("name", "Elena");
 editor.putInt("idName", 12);
 editor.commit();

환경 설정에서 데이터를 검색하십시오.

SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
  String name = prefs.getString("name", "No name defined");//"No name defined" is the default value.
  int idName = prefs.getInt("idName", 0); //0 is the default value.
}

더 많은 정보:

공유 환경 설정 사용

공유 환경 설정


MyPrefsFile은 무엇입니까? 환경 설정 활동의 XML?
Martin Erlic

17

싱글 톤 공유 환경 설정 클래스. 앞으로 다른 사람들에게 도움이 될 수 있습니다.

import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;

public class SharedPref
{
    private static SharedPreferences mSharedPref;
    public static final String NAME = "NAME";
    public static final String AGE = "AGE";
    public static final String IS_SELECT = "IS_SELECT";

    private SharedPref()
    {

    }

    public static void init(Context context)
    {
        if(mSharedPref == null)
            mSharedPref = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
    }

    public static String read(String key, String defValue) {
        return mSharedPref.getString(key, defValue);
    }

    public static void write(String key, String value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putString(key, value);
        prefsEditor.commit();
    }

    public static boolean read(String key, boolean defValue) {
        return mSharedPref.getBoolean(key, defValue);
    }

    public static void write(String key, boolean value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putBoolean(key, value);
        prefsEditor.commit();
    }

    public static Integer read(String key, int defValue) {
        return mSharedPref.getInt(key, defValue);
    }

    public static void write(String key, Integer value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putInt(key, value).commit();
    }
}

간단히 전화 SharedPref.init()MainActivity한 번

SharedPref.init(getApplicationContext());

데이터를 쓰려면

SharedPref.write(SharedPref.NAME, "XXXX");//save string in shared preference.
SharedPref.write(SharedPref.AGE, 25);//save int in shared preference.
SharedPref.write(SharedPref.IS_SELECT, true);//save boolean in shared preference.

데이터를 읽으려면

String name = SharedPref.read(SharedPref.NAME, null);//read string in shared preference.
int age = SharedPref.read(SharedPref.AGE, 0);//read int in shared preference.
boolean isSelect = SharedPref.read(SharedPref.IS_SELECT, false);//read boolean in shared preference.

15

정보를 저장하려면

SharedPreferences preferences = getSharedPreferences(PREFS_NAME,Context.MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("username", username.getText().toString());
editor.putString("password", password.getText().toString());
editor.putString("logged", "logged");
editor.commit();

기본 설정을 재설정하려면

SharedPreferences.Editor editor = preferences.edit();
editor.clear();
editor.commit();

12

팀의 다른 개발자와 함께 대규모 응용 프로그램을 만들고 흩어져있는 코드 나 다른 SharedPreferences 인스턴스없이 모든 것을 잘 정리하려는 경우 다음과 같이 할 수 있습니다.

//SharedPreferences manager class
public class SharedPrefs {

    //SharedPreferences file name
    private static String SHARED_PREFS_FILE_NAME = "my_app_shared_prefs";

    //here you can centralize all your shared prefs keys
    public static String KEY_MY_SHARED_BOOLEAN = "my_shared_boolean";
    public static String KEY_MY_SHARED_FOO = "my_shared_foo";

    //get the SharedPreferences object instance
    //create SharedPreferences file if not present


    private static SharedPreferences getPrefs(Context context) {
        return context.getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE);
    }

    //Save Booleans
    public static void savePref(Context context, String key, boolean value) {
        getPrefs(context).edit().putBoolean(key, value).commit();       
    }

    //Get Booleans
    public static boolean getBoolean(Context context, String key) {
        return getPrefs(context).getBoolean(key, false);
    }

    //Get Booleans if not found return a predefined default value
    public static boolean getBoolean(Context context, String key, boolean defaultValue) {
        return getPrefs(context).getBoolean(key, defaultValue);
    }

    //Strings
    public static void save(Context context, String key, String value) {
        getPrefs(context).edit().putString(key, value).commit();
    }

    public static String getString(Context context, String key) {
        return getPrefs(context).getString(key, "");
    }

    public static String getString(Context context, String key, String defaultValue) {
        return getPrefs(context).getString(key, defaultValue);
    }

    //Integers
    public static void save(Context context, String key, int value) {
        getPrefs(context).edit().putInt(key, value).commit();
    }

    public static int getInt(Context context, String key) {
        return getPrefs(context).getInt(key, 0);
    }

    public static int getInt(Context context, String key, int defaultValue) {
        return getPrefs(context).getInt(key, defaultValue);
    }

    //Floats
    public static void save(Context context, String key, float value) {
        getPrefs(context).edit().putFloat(key, value).commit();
    }

    public static float getFloat(Context context, String key) {
        return getPrefs(context).getFloat(key, 0);
    }

    public static float getFloat(Context context, String key, float defaultValue) {
        return getPrefs(context).getFloat(key, defaultValue);
    }

    //Longs
    public static void save(Context context, String key, long value) {
        getPrefs(context).edit().putLong(key, value).commit();
    }

    public static long getLong(Context context, String key) {
        return getPrefs(context).getLong(key, 0);
    }

    public static long getLong(Context context, String key, long defaultValue) {
        return getPrefs(context).getLong(key, defaultValue);
    }

    //StringSets
    public static void save(Context context, String key, Set<String> value) {
        getPrefs(context).edit().putStringSet(key, value).commit();
    }

    public static Set<String> getStringSet(Context context, String key) {
        return getPrefs(context).getStringSet(key, null);
    }

    public static Set<String> getStringSet(Context context, String key, Set<String> defaultValue) {
        return getPrefs(context).getStringSet(key, defaultValue);
    }
}

활동에서이 방법으로 SharedPreferences를 저장할 수 있습니다

//saving a boolean into prefs
SharedPrefs.savePref(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN, booleanVar);

이 방법으로 SharedPreferences를 검색 할 수 있습니다

//getting a boolean from prefs
booleanVar = SharedPrefs.getBoolean(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN);

12

모든 애플리케이션에는 PreferenceManager인스턴스 및 관련 메소드를 통해 액세스 할 수있는 기본 환경 설정이 있습니다 getDefaultSharedPreferences(Context).

으로 SharedPreference예를 하나가 가진 어떤 취향의 int 값 검색 할 수 있습니다 (defVal INT 문자열 키)의 getInt을 . 우리가이 경우에 관심있는 선호는 counter입니다.

우리의 경우 SharedPreferenceedit ()를 사용하여 인스턴스를 수정할 수 있고 putInt(String key, int newVal)우리는 응용 프로그램을 넘어서서 적절하게 표시되는 응용 프로그램의 수를 늘 렸습니다.

이를 더 데모하려면 다시 시작한 후 응용 프로그램을 다시 시작하면 응용 프로그램을 다시 시작할 때마다 개수가 증가한다는 것을 알 수 있습니다.

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>

8

로 로그인 값을 저장하는 방법에 대한 간단한 솔루션 SharedPreferences.

MainActivity"보관하려는 무언가의 가치"를 저장할 클래스 나 다른 클래스를 확장 할 수 있습니다 . 이것을 작가와 독자 수업에 넣으십시오.

public static final String GAME_PREFERENCES_LOGIN = "Login";

여기 InputClass에 입력과 OutputClass출력 클래스가 각각 있습니다.

// This is a storage, put this in a class which you can extend or in both classes:
//(input and output)
public static final String GAME_PREFERENCES_LOGIN = "Login";

// String from the text input (can be from anywhere)
String login = inputLogin.getText().toString();

// then to add a value in InputCalss "SAVE",
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
Editor editor = example.edit();
editor.putString("value", login);
editor.commit();

이제 다른 클래스처럼 다른 곳에서 사용할 수 있습니다. 다음은 OutputClass입니다.

SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
String userString = example.getString("value", "defValue");

// the following will print it out in console
Logger.getLogger("Name of a OutputClass".class.getName()).log(Level.INFO, userString);

8

SharedPreferences에 저장

SharedPreferences preferences = getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
Editor editor = preferences.edit();
editor.putString("name", name);
editor.commit();

SharedPreferences에서 가져 오기

SharedPreferences preferences=getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
String name=preferences.getString("name",null);

참고 : "temp"는 공유 환경 설정 이름이고 "name"은 입력 값입니다. 값이 종료되지 않으면 null을 반환


매우 훌륭하고 사용하기 쉬우지만 여기에 Context.MODE_PRIVATE not getApplicationContext (). MODE_PRIVATE
Maria Gheorghe

7

편집하다

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("yourValue", value);
editor.commit();

읽다

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
value= pref.getString("yourValue", "");

6

SharedPreferences의 기본 아이디어는 XML 파일에 항목을 저장하는 것입니다.

  1. xml 파일 경로를 선언하십시오. (이 파일이 없으면 Android가 해당 파일을 작성합니다.이 파일이 있으면 Android가 해당 파일에 액세스합니다.)

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  2. 공유 환경 설정에 값 쓰기

    prefs.edit().putLong("preference_file_key", 1010101).apply();

    preference_file_key공유 환경 설정 파일의 이름입니다. 그리고 1010101당신이 저장해야 할 가치입니다.

    apply()마지막으로 변경 사항을 저장하는 것입니다. 에서 오류가 발생하면 apply()로 변경하십시오 commit(). 이 대체 문장은

    prefs.edit().putLong("preference_file_key", 1010101).commit();
  3. 공유 환경 설정에서 읽기

    SharedPreferences sp = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
    long lsp = sp.getLong("preference_file_key", -1);

    lsp될 것입니다 -1경우 preference_file_key값이 없습니다. 'preference_file_key'에 값이 있으면이 값을 반환합니다.

작성을위한 전체 코드는

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    prefs.edit().putLong("preference_file_key", 1010101).apply();    // Write the value to key.

읽는 코드는

    SharedPreferences sf = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    long lsp = sp.getLong("preference_file_key", -1);    // Read the key and store in lsp

Editor.apply ()에는 API 레벨 9 이상이 필요합니다. 그 사용 Editor.commit 아래 ()
레나 롤랑

6

이 방법을 사용하여 가치를 저장할 수 있습니다.

public void savePreferencesForReasonCode(Context context,
    String key, String value) {
    SharedPreferences sharedPreferences = PreferenceManager
    .getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = sharedPreferences.edit();
    editor.putString(key, value);
    editor.commit();
    }

이 방법을 사용하면 SharedPreferences에서 가치를 얻을 수 있습니다.

public String getPreferences(Context context, String prefKey) {
  SharedPreferences sharedPreferences = PreferenceManager
 .getDefaultSharedPreferences(context);
 return sharedPreferences.getString(prefKey, "");
}

prefKey특정 값을 저장하는 데 사용한 키는 다음과 같습니다 . 감사.


부울은 어떻습니까?
Yousha Aleayoub

이 줄을 사용하여 저장 : editor.putString (key, value); 이 줄을 사용하십시오 : Boolean yourLocked = prefs.getBoolean ( "locked", false);
Md. Sajedul Karim

6
editor.putString("text", mSaved.getText().toString());

여기에, mSaved어떤 수 있습니다 TextView또는 EditText우리가 문자열을 추출 할 수 있습니다 곳에서. 단순히 문자열을 지정할 수 있습니다. 여기서 텍스트는 mSaved( TextView또는 EditText) 에서 얻은 값을 보유하는 키입니다 .

SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

또한 패키지 이름 (예 : "com.example.app")을 사용하여 기본 설정 파일을 저장할 필요가 없습니다. 선호하는 이름을 언급 할 수 있습니다. 도움이 되었기를 바랍니다 !


5

사람들이 SharedPreferences 를 사용하는 방법을 추천하는 방법에는 여러 가지가 있습니다 . 나는 여기서 데모 프로젝트를 만들었다 . 샘플의 요점은 ApplicationContext 및 단일 sharedpreferences 객체를 사용하는 것 입니다. 다음 기능과 함께 SharedPreferences 를 사용하는 방법을 보여줍니다 .

  • singelton 클래스를 사용하여 SharedPreferences 액세스 / 업데이트
  • 읽기 / 쓰기 SharedPreferences를 위해 항상 컨텍스트를 전달할 필요가 없습니다.
  • commit () 대신 apply ()를 사용합니다.
  • apply ()는 비동기 저장이며, 아무것도 반환하지 않으며, 먼저 메모리의 값을 업데이트하고 변경 사항은 나중에 비동기 적으로 디스크에 기록됩니다.
  • commit ()은 동기화 저장이며 결과에 따라 true / false를 반환합니다. 변경 사항은 디스크에 동 기적으로 기록됩니다
  • 안드로이드 2.3 이상 버전에서 작동

아래와 같은 사용 예 :-

MyAppPreference.getInstance().setSampleStringKey("some_value");
String value= MyAppPreference.getInstance().getSampleStringKey();

여기에 소스 코드를 가져 오기 및 자세한 API의의를 찾을 수 있습니다 여기 developer.android.com에


공유 환경 설정에 대한 질문이 있습니다. 대답 해 주시겠습니까? stackoverflow.com/questions/35713822/…
Ruchir Baronia 2017 년

5

모범 사례

PreferenceManager로 이름 지정된 인터페이스를 작성하십시오 .

// Interface to save values in shared preferences and also for retrieve values from shared preferences
public interface PreferenceManager {

    SharedPreferences getPreferences();
    Editor editPreferences();

    void setString(String key, String value);
    String getString(String key);

    void setBoolean(String key, boolean value);
    boolean getBoolean(String key);

    void setInteger(String key, int value);
    int getInteger(String key);

    void setFloat(String key, float value);
    float getFloat(String key);

}

Activity / Fragment 와 함께 사용하는 방법 :

public class HomeActivity extends AppCompatActivity implements PreferenceManager{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_home);
    }

    @Override
    public SharedPreferences getPreferences(){
        return getSharedPreferences("SP_TITLE", Context.MODE_PRIVATE);
    }

    @Override
    public SharedPreferences.Editor editPreferences(){
        return getPreferences().edit();
    }

    @Override
    public void setString(String key, String value) {
        editPreferences().putString(key, value).commit();
    }

    @Override
    public String getString(String key) {
        return getPreferences().getString(key, "");
    }

    @Override
    public void setBoolean(String key, boolean value) {
        editPreferences().putBoolean(key, value).commit();
    }

    @Override
    public boolean getBoolean(String key) {
        return  getPreferences().getBoolean(key, false);
    }

    @Override
    public void setInteger(String key, int value) {
        editPreferences().putInt(key, value).commit();
    }

    @Override
    public int getInteger(String key) {
        return getPreferences().getInt(key, 0);
    }

    @Override
    public void setFloat(String key, float value) {
        editPreferences().putFloat(key, value).commit();
    }

    @Override
    public float getFloat(String key) {
        return getPreferences().getFloat(key, 0);
    }
}

참고 : SharedPreference 키를 SP_TITLE바꾸십시오 .

예 :

문자열 저장shareperence를 :

setString("my_key", "my_value");

shareperence 에서 문자열을 가져 옵니다 .

String strValue = getString("my_key");

이것이 도움이되기를 바랍니다.


동일한 공유 기본 설정 개체를 사용하여 모든 것을 저장하거나 각 데이터 조각에 대해 새로운 공유 준비 개체를 생성합니까?
Ruchir Baronia

@Ruchir Baronia, 공유 환경 설정의 객체를 초기화 할 필요없이 다른 객체를 만들 필요가 없습니다. 위의 방법으로 저장할 수 있습니다. 내 편에서 필요한 것이 있으면 알려주세요.
Hiren Patel

괜찮 감사. 이것 좀 도와 줄래? stackoverflow.com/questions/35235759/…
Ruchir Baronia

@Ruchir Baronia, 스레드를 취소 할 수 있습니다. 이것이 도움이되기를 바랍니다.
Hiren Patel

아, 미안, 내가 잘못로 대답이 그에 대한 공유 설정 :)에 대해 물어 의미 넣어있어 stackoverflow.com/questions/35244256/issue-with-if-statement/...
Ruchir Baronia

5

공유 환경 설정에 값을 저장하려면 다음을 수행하십시오.

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = sp.edit();
editor.putString("Name","Jayesh");
editor.commit();

공유 환경 설정에서 값을 검색하려면 다음을 수행하십시오.

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
String name = sp.getString("Name", ""); // Second parameter is the default value.

4

저장

PreferenceManager.getDefaultSharedPreferences(this).edit().putString("VarName","your value").apply();

후퇴 :

String name = PreferenceManager.getDefaultSharedPreferences(this).getString("VarName","defaultValue");

기본값은 :이 환경 설정이 존재하지 않는 경우 리턴 할 값입니다.

경우에 따라 getActivity () 또는 getApplicationContext () 를 사용 하여 " this "를 변경할 수 있습니다


공유 환경 설정에 대한 질문이 있습니다. 대답 해 주시겠습니까? stackoverflow.com/questions/35713822/…
Ruchir Baronia 2017 년

그렇습니다, 나는 ... :)
Ruchir Baronia

3

공유 환경 설정에 대한 도우미 클래스를 작성합니다.

import android.content.Context;
import android.content.SharedPreferences;

/**
 * Created by mete_ on 23.12.2016.
 */
public class HelperSharedPref {

Context mContext;

public HelperSharedPref(Context mContext) {
    this.mContext = mContext;
}

/**
 *
 * @param key Constant RC
 * @param value Only String, Integer, Long, Float, Boolean types
 */
public void saveToSharedPref(String key, Object value) throws Exception {
    SharedPreferences.Editor editor = mContext.getSharedPreferences(key, Context.MODE_PRIVATE).edit();
    if (value instanceof String) {
        editor.putString(key, (String) value);
    } else if (value instanceof Integer) {
        editor.putInt(key, (Integer) value);
    } else if (value instanceof Long) {
        editor.putLong(key, (Long) value);
    } else if (value instanceof Float) {
        editor.putFloat(key, (Float) value);
    } else if (value instanceof Boolean) {
        editor.putBoolean(key, (Boolean) value);
    } else {
        throw new Exception("Unacceptable object type");
    }

    editor.commit();
}

/**
 * Return String
 * @param key
 * @return null default is null
 */
public String loadStringFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    String restoredText = prefs.getString(key, null);

    return restoredText;
}

/**
 * Return int
 * @param key
 * @return null default is -1
 */
public Integer loadIntegerFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Integer restoredText = prefs.getInt(key, -1);

    return restoredText;
}

/**
 * Return float
 * @param key
 * @return null default is -1
 */
public Float loadFloatFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Float restoredText = prefs.getFloat(key, -1);

    return restoredText;
}

/**
 * Return long
 * @param key
 * @return null default is -1
 */
public Long loadLongFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Long restoredText = prefs.getLong(key, -1);

    return restoredText;
}

/**
 * Return boolean
 * @param key
 * @return null default is false
 */
public Boolean loadBooleanFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Boolean restoredText = prefs.getBoolean(key, false);

    return restoredText;
}

}

3

이 예제를 간단하고 명확하게 사용하고 사용하십시오.

<?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>
public class MainActivity extends AppCompatActivity {
   EditText ed1,ed2,ed3;
   Button b1;

   public static final String MyPREFERENCES = "MyPrefs" ;
   public static final String Name = "nameKey";
   public static final String Phone = "phoneKey";
   public static final String Email = "emailKey";

   SharedPreferences sharedpreferences;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      ed1=(EditText)findViewById(R.id.editText);
      ed2=(EditText)findViewById(R.id.editText2);
      ed3=(EditText)findViewById(R.id.editText3);

      b1=(Button)findViewById(R.id.button);
      sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);

      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();

            SharedPreferences.Editor editor = sharedpreferences.edit();

            editor.putString(Name, n);
            editor.putString(Phone, ph);
            editor.putString(Email, e);
            editor.commit();
            Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
         }
      });
   }

}

2

간단한 라이브러리를 사용하여 다음 은 SharedPreferences를 호출하는 방법입니다.

TinyDB tinydb = new TinyDB(context);

tinydb.putInt("clickCount", 2);

tinydb.putString("userName", "john");
tinydb.putBoolean("isUserMale", true); 

tinydb.putList("MyUsers", mUsersArray);
tinydb.putImagePNG("DropBox/WorkImages", "MeAtlunch.png", lunchBitmap);

//These plus the corresponding get methods are all Included

2

이 질문에 대한 대부분의 스 니펫이 SharedPreferences를 사용할 때 MODE_PRIVATE와 같은 것을 갖기를 원합니다. MODE_PRIVATE는이 공유 환경 설정에 쓰는 내용은 응용 프로그램에서만 읽을 수 있음을 의미합니다.

getSharedPreferences () 메소드에 전달하는 키가 무엇이든, android는 해당 이름의 파일을 작성하고 환경 설정 데이터를 저장합니다. 또한 getSharedPreferences ()는 응용 프로그램에 여러 환경 설정 파일을 사용하려는 경우 사용되어야합니다. 단일 환경 설정 파일을 사용하고 모든 키-값 쌍을 저장하려면 getSharedPreference () 메소드를 사용하십시오. 왜 나 자신을 포함하여 모든 사람이 단순히 위의 두 차이점을 이해하지 않고 getSharedPreferences () 맛을 사용하는 것이 이상합니다.

다음 동영상 자습서는 https://www.youtube.com/watch?v=2PcAQ1NBy98에 도움이 됩니다.


2

간단하고 번거 로움 :: "Android-SharedPreferences-Helper"라이브러리

전보다 훨씬 늦습니다 . "Android-SharedPreferences-Helper"라이브러리 를 만들어 사용의 복잡성과 노력을 줄일 수 SharedPreferences있었습니다. 또한 일부 확장 기능을 제공합니다. 다음과 같은 기능이 제공됩니다.

  • 한 줄 초기화 및 설정
  • 기본 환경 설정을 사용할지 또는 사용자 정의 환경 설정 파일을 사용할지 쉽게 선택
  • 각 데이터 유형에 대해 사전 정의 된 (데이터 유형 기본값) 및 사용자 정의 가능한 (선택할 수있는) 기본값
  • 추가 매개 변수만으로 일회용으로 다른 기본값을 설정하는 기능
  • 기본 클래스와 마찬가지로 OnSharedPreferenceChangeListener를 등록 및 등록 해제 할 수 있습니다.
dependencies {
    ...
    ...
    compile(group: 'com.viralypatel.sharedpreferenceshelper', name: 'library', version: '1.1.0', ext: 'aar')
}

SharedPreferencesHelper 객체 선언 : (클래스 수준에서 권장)

SharedPreferencesHelper sph; 

SharedPreferencesHelper 객체의 인스턴스화 : (onCreate () 메소드에서 권장 됨)

// use one of the following ways to instantiate
sph = new SharedPreferencesHelper(this); //this will use default shared preferences
sph = new SharedPreferencesHelper(this, "myappprefs"); // this will create a named shared preference file
sph = new SharedPreferencesHelper(this, "myappprefs", 0); // this will allow you to specify a mode

공유 환경 설정에 값 넣기

상당히 간단합니다! 기본 방식 (SharedPreferences 클래스 사용시)과 달리 전화를 걸 .edit()거나 .commit()시간을 할애 할 필요가 없습니다 .

sph.putBoolean("boolKey", true);
sph.putInt("intKey", 123);
sph.putString("stringKey", "string value");
sph.putLong("longKey", 456876451);
sph.putFloat("floatKey", 1.51f);

// putStringSet is supported only for android versions above HONEYCOMB
Set name = new HashSet();
name.add("Viral");
name.add("Patel");
sph.putStringSet("name", name);

그게 다야! 값은 공유 환경 설정에 저장됩니다.

공유 환경 설정에서 값 가져 오기

다시 한 번, 키 이름을 가진 간단한 메소드 호출이 있습니다.

sph.getBoolean("boolKey");
sph.getInt("intKey");
sph.getString("stringKey");
sph.getLong("longKey");
sph.getFloat("floatKey");

// getStringSet is supported only for android versions above HONEYCOMB
sph.getStringSet("name");

다른 확장 기능이 많이 있습니다.

GitHub 리포지토리 페이지 에서 확장 기능, 사용법 및 설치 지침 등의 세부 사항을 확인하십시오 .


동일한 공유 기본 설정 개체를 사용하여 모든 것을 저장하거나 각 데이터 조각에 대해 새로운 공유 준비 개체를 생성합니까?
Ruchir Baronia

가능한 한 많이 사용하십시오. 이것이이 라이브러리를 만드는 요점입니다.
AndroidMechanic-바이러스 성 Patel

공유 환경 설정에 대한 질문이 있습니다. 대답 해 주시겠습니까? stackoverflow.com/questions/35713822/…
Ruchir Baronia

2
SharedPreferences.Editor editor = getSharedPreferences("identifier", 
MODE_PRIVATE).edit();
//identifier is the unique to fetch data from your SharedPreference.


editor.putInt("keyword", 0); 
// saved value place with 0.
//use this "keyword" to fetch saved value again.
editor.commit();//important line without this line your value is not stored in preference   

// fetch the stored data using ....

SharedPreferences prefs = getSharedPreferences("identifier", MODE_PRIVATE); 
// here both identifier will same

int fetchvalue = prefs.getInt("keyword", 0);
// here keyword will same as used above.
// 0 is default value when you nothing save in preference that time fetch value is 0.

AdapterClass 또는 기타에서 SharedPreferences를 사용해야합니다. 그때는이 선언을 사용하고 위와 동일한 것을 사용하십시오.

SharedPreferences.Editor editor = context.getSharedPreferences("idetifier", 
Context.MODE_PRIVATE).edit();
SharedPreferences prefs = context.getSharedPreferences("identifier", Context.MODE_PRIVATE);

//here context is your application context

문자열 또는 부울 값

editor.putString("stringkeyword", "your string"); 
editor.putBoolean("booleankeyword","your boolean value");
editor.commit();

위와 동일한 데이터를 가져옵니다

String fetchvalue = prefs.getString("keyword", "");
Boolean fetchvalue = prefs.getBoolean("keyword", "");

2

2. 예비 공유 저장

SharedPreferences.Editor editor = 
getSharedPreferences("DeviceToken",MODE_PRIVATE).edit();
                    editor.putString("DeviceTokenkey","ABABABABABABABB12345");
editor.apply();

동일한 사용을위한 2.For

    SharedPreferences prefs = getSharedPreferences("DeviceToken", 
 MODE_PRIVATE);
  String deviceToken = prefs.getString("DeviceTokenkey", null);

1

여기에 안드로이드 환경 설정을 사용하는 도우미 클래스를 만들었습니다.

이것은 도우미 클래스입니다.

public class PrefsUtil {

public static SharedPreferences getPreference() {
    return PreferenceManager.getDefaultSharedPreferences(Applicatoin.getAppContext());
}

public static void putBoolean(String key, boolean value) {
    getPreference().edit().putBoolean(key, value)
            .apply();
}

public static boolean getBoolean(String key) {
    return getPreference().getBoolean(key, false);
}

public static void putInt(String key, int value) {

    getPreference().edit().putInt(key, value).apply();

}

public static void delKey(String key) {

    getPreference().edit().remove(key).apply();

}

}

1

함수 방식으로 전역 변수를 저장하고 검색합니다. 테스트하려면 페이지에 Textview 항목이 있는지 확인하고 코드에서 두 줄의 주석 처리를 제거하고 실행하십시오. 그런 다음 두 줄을 다시 주석으로 달고 실행하십시오.
여기서 TextView의 ID는 사용자 이름 및 비밀번호입니다.

사용하려는 모든 클래스에서 끝에 두 가지 루틴을 추가하십시오. 이 루틴을 전역 루틴으로 만들고 싶지만 방법을 모릅니다. 작동합니다.

바리 벨은 어디에서나 사용할 수 있습니다. 변수를 "MyFile"에 저장합니다. 당신은 그것을 당신의 방식으로 바꿀 수 있습니다.

당신은 그것을 사용하여 그것을 호출

 storeSession("username","frans");
 storeSession("password","!2#4%");***

변수 username은 "frans"로, 비밀번호는 "! 2 # 4 %"로 채워집니다. 다시 시작한 후에도 사용할 수 있습니다.

그리고 당신은 그것을 사용하여 그것을 검색

 password.setText(getSession(("password")));
 usernames.setText(getSession(("username")));

내 그리드의 전체 코드 아래

    package nl.yentel.yenteldb2;
    import android.content.SharedPreferences;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.Snackbar;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.TextView;

    public class Grid extends AppCompatActivity {
    private TextView usernames;
    private TextView password;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_grid);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);

      ***//  storeSession("username","frans.eilering@gmail.com");
        //storeSession("password","mijn wachtwoord");***
        password = (TextView) findViewById(R.id.password);
        password.setText(getSession(("password")));
        usernames=(TextView) findViewById(R.id.username);
        usernames.setText(getSession(("username")));
    }

    public void storeSession(String key, String waarde) { 
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        editor.putString(key, waarde);
        editor.commit();
    }

    public String getSession(String key) {
//http://androidexample.com/Android_SharedPreferences_Basics/index.php?view=article_discription&aid=126&aaid=146
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        String output = pref.getString(key, null);
        return output;
    }

    }

아래에서 텍스트보기 항목을 찾으십시오.

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="usernames"
    android:id="@+id/username"
    android:layout_below="@+id/textView"
    android:layout_alignParentStart="true"
    android:layout_marginTop="39dp"
    android:hint="hier komt de username" />

 <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="password"
    android:id="@+id/password"
    android:layout_below="@+id/user"
    android:layout_alignParentStart="true"
    android:hint="hier komt het wachtwoord" />

1

내 인생을 쉽게하기 위해 도우미 클래스를 만들었습니다. 이것은 일반적인 클래스이며 공유 환경 설정, 이메일 유효성, 날짜 시간 형식과 같은 앱에서 일반적으로 사용되는 많은 메소드를 가지고 있습니다. 이 클래스를 코드에 복사하고 필요할 때마다 메서드에 액세스하십시오.

 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.SharedPreferences;
 import android.support.v4.app.FragmentActivity;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.EditText;
 import android.widget.Toast;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Random;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;

/**
* Created by Zohaib Hassan on 3/4/2016.
*/
 public class Helper {

private static ProgressDialog pd;

public static void saveData(String key, String value, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static void deleteData(String key, Context context){
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.remove(key);
    editor.commit();

}

public static String getSaveData(String key, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    String data = sp.getString(key, "");
    return data;

}




public static long dateToUnix(String dt, String format) {
    SimpleDateFormat formatter;
    Date date = null;
    long unixtime;
    formatter = new SimpleDateFormat(format);
    try {
        date = formatter.parse(dt);
    } catch (Exception ex) {

        ex.printStackTrace();
    }
    unixtime = date.getTime();
    return unixtime;

}

public static String getData(long unixTime, String formate) {

    long unixSeconds = unixTime;
    Date date = new Date(unixSeconds);
    SimpleDateFormat sdf = new SimpleDateFormat(formate);
    String formattedDate = sdf.format(date);
    return formattedDate;
}

public static String getFormattedDate(String date, String currentFormat,
                                      String desiredFormat) {
    return getData(dateToUnix(date, currentFormat), desiredFormat);
}




public static double distance(double lat1, double lon1, double lat2,
                              double lon2, char unit) {
    double theta = lon1 - lon2;
    double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
            + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
            * Math.cos(deg2rad(theta));
    dist = Math.acos(dist);
    dist = rad2deg(dist);
    dist = dist * 60 * 1.1515;
    if (unit == 'K') {
        dist = dist * 1.609344;
    } else if (unit == 'N') {
        dist = dist * 0.8684;
    }
    return (dist);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts decimal degrees to radians : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double deg2rad(double deg) {
    return (deg * Math.PI / 180.0);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts radians to decimal degrees : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double rad2deg(double rad) {
    return (rad * 180.0 / Math.PI);
}

public static int getRendNumber() {
    Random r = new Random();
    return r.nextInt(360);
}

public static void hideKeyboard(Context context, EditText editText) {
    InputMethodManager imm = (InputMethodManager) context
            .getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
}

public static void showLoder(Context context, String message) {
    pd = new ProgressDialog(context);

    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void showLoderImage(Context context, String message) {
    pd = new ProgressDialog(context);
    pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void dismissLoder() {
    pd.dismiss();
}

public static void toast(Context context, String text) {

    Toast.makeText(context, text, Toast.LENGTH_LONG).show();
}
/*
     public static Boolean connection(Context context) {
    ConnectionDetector connection = new ConnectionDetector(context);
    if (!connection.isConnectingToInternet()) {

        Helper.showAlert(context, "No Internet access...!");
        //Helper.toast(context, "No internet access..!");
        return false;
    } else
        return true;
}*/

public static void removeMapFrgment(FragmentActivity fa, int id) {

    android.support.v4.app.Fragment fragment;
    android.support.v4.app.FragmentManager fm;
    android.support.v4.app.FragmentTransaction ft;
    fm = fa.getSupportFragmentManager();
    fragment = fm.findFragmentById(id);
    ft = fa.getSupportFragmentManager().beginTransaction();
    ft.remove(fragment);
    ft.commit();

}

public static AlertDialog showDialog(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(message);

    builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            // TODO Auto-generated method stub

        }
    });

    return builder.create();
}

public static void showAlert(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle("Alert");
    builder.setMessage(message)
            .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    dialog.dismiss();
                }
            }).show();
}

public static boolean isURL(String url) {
    if (url == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern
                .compile(
                        "\\b(?:(https?|ftp|file)://|www\\.)?[-A-Z0-9+&#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]\\.[-A-Z0-9+&@#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]",
                        Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(url);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean atLeastOneChr(String string) {
    if (string == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern.compile("[a-zA-Z0-9]",
                Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(string);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean isValidEmail(String email, Context context) {
    String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        // Helper.toast(context, "Email is not valid..!");

        return false;
    }
}

public static boolean isValidUserName(String email, Context context) {
    String expression = "^[0-9a-zA-Z]+$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        Helper.toast(context, "Username is not valid..!");
        return false;
    }
}

public static boolean isValidDateSlash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/mm/yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-mm-yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDot(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd.mm.yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.