android.content.SharedPreferences.OnSharedPreferenceChangeListener Java Examples

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

/**
 * Remove all OnSharedPreferenceChangedListener's. This should be done in
 * onDestroy.
 */
public void removeAllListeners()
{
    synchronized (mLock)
    {
        for (OnSharedPreferenceChangeListener listener : mSharedPreferenceListeners)
        {
            mDefaultPreferences.unregisterOnSharedPreferenceChangeListener(listener);

            if (mCustomPreferences != null)
            {
                mCustomPreferences.unregisterOnSharedPreferenceChangeListener(listener);
            }
        }
        mSharedPreferenceListeners.clear();
        mListeners.clear();
    }
}
 

/**
 * 检查当token信息与配置文件是否保持一致，若不一致则对当前的token信息进行初始化
 */
private void compareWithConfig() {
    if (this.context == null) {
        return;
    }

    /**
     * 对配置的权限信息进行监控，保持多个AccessTokenManager对象之间的，权限信息一致。
     */
    final SharedPreferences sp = this.context.getSharedPreferences(BAIDU_OAUTH_CONFIG, Context.MODE_PRIVATE);
    sp.registerOnSharedPreferenceChangeListener(new OnSharedPreferenceChangeListener() {

        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
            String acToken = sp.getString(OauthConfig.PrefenenceKey.SP_ACCESS_TOKEN, null);
            if (accessToken != null && !accessToken.equals(acToken)) {
                initToken();
            }
        }
    });
}
 

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

/**
 * Open a SharedPreferences file by custom scope.
 * Also registers any known SharedPreferenceListeners on this
 * SharedPreferences instance.
 */
protected SharedPreferences openPreferences(String scope)
{
    synchronized (mLock)
    {
        SharedPreferences preferences;
        preferences = mContext.getSharedPreferences(
                mPackageName + scope, Context.MODE_PRIVATE);

        for (OnSharedPreferenceChangeListener listener : mSharedPreferenceListeners)
        {
            preferences.registerOnSharedPreferenceChangeListener(listener);
        }
        return preferences;
    }
}
 

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

@Override
public void onCreate() {
	super.onCreate();
	
	mSharedPreferences = MultiprocessSharedPreferences.getSharedPreferences(this, SP_NAME, Context.MODE_PRIVATE);
	Log.d(TAG, "onCreate." + SP_KEY + " = " + mSharedPreferences.getString(SP_KEY, null));
	mOnSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
		@Override
		public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
			String msg = "onSharedPreferenceChanged." + SP_KEY + " = " + sharedPreferences.getString(SP_KEY, null);
			Log.d(TAG, msg);
			Toast.makeText(CoreService.this, msg, Toast.LENGTH_SHORT).show();
		}
	};
	mSharedPreferences.registerOnSharedPreferenceChangeListener(mOnSharedPreferenceChangeListener);
}
 

public BroadcastEventBridge(Context context,
                            String prefName,
                            CacheCandidateProvider cacheCandidateProvider,
                            CacheProvider cacheProvider,
                            SerializerFactory serializerFactory,
                            TaskExecutor taskExecutor,
                            ValueEncryption valueEncryption,
                            DirectoryProvider directoryProvider,
                            Map<String, List<OnSharedPreferenceChangeListener>> allListeners) {
    this.context = context;
    this.prefName = prefName;
    this.cacheCandidateProvider = cacheCandidateProvider;
    this.cacheProvider = cacheProvider;
    this.serializerFactory = serializerFactory;
    this.taskExecutor = taskExecutor;
    this.valueEncryption = valueEncryption;
    this.updateActionName = createUpdateActionName(directoryProvider);
    this.removeActionName = createRemoveActionName(directoryProvider);
    this.currentListeners = putIfAbsentListeners(prefName, allListeners);
    this.updateReceiver = createUpdateReceiver();
    this.removeReceiver = createRemoveReceiver();
    this.processId = Process.myPid();
}
 

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSharedPreferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(final SharedPreferences prefs, final String key) {
            final SubScreenFragment fragment = SubScreenFragment.this;
            final Context context = fragment.getActivity();
            if (context == null || fragment.getPreferenceScreen() == null) {
                final String tag = fragment.getClass().getSimpleName();
                // TODO: Introduce a static function to register this class and ensure that
                // onCreate must be called before "onSharedPreferenceChanged" is called.
                Log.w(tag, "onSharedPreferenceChanged called before activity starts.");
                return;
            }
            new BackupManager(context).dataChanged();
            fragment.onSharedPreferenceChanged(prefs, key);
        }
    };
    getSharedPreferences().registerOnSharedPreferenceChangeListener(
            mSharedPreferenceChangeListener);
}
 

public void registerOnSharedPreferenceChangeListener(final OnSharedPreferenceChangeListener listener, boolean decryptKeys) {
    if (decryptKeys) {
        OnSharedPreferenceChangeListener secureListener = new OnSharedPreferenceChangeListener() {
            private OnSharedPreferenceChangeListener mInsecureListener = listener;

            public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
                try {
                    String decryptedKey = SecurePreferencesOld.decrypt(key);
                    if (decryptedKey != null) {
                        this.mInsecureListener.onSharedPreferenceChanged(sharedPreferences, decryptedKey);
                    }
                } catch (Exception e) {
                    Log.w(SecurePreferencesOld.TAG, "Unable to decrypt key: " + key);
                }
            }
        };
        sOnSharedPreferenceChangeListeners.put(listener, secureListener);
        sFile.registerOnSharedPreferenceChangeListener(secureListener);
        return;
    }
    registerOnSharedPreferenceChangeListener(listener);
}
 

private List<OnSharedPreferenceChangeListener> putIfAbsentListeners(String prefName, Map<String,
        List<OnSharedPreferenceChangeListener>> allListeners) {
    if (allListeners.containsKey(prefName)) {
        return allListeners.get(prefName);
    }
    List<OnSharedPreferenceChangeListener> listeners = new ArrayList<>();
    allListeners.put(prefName, listeners);
    return listeners;
}
 

/**
 * Add an OnSettingChangedListener to the SettingsManager, which will
 * execute onSettingsChanged when any SharedPreference has been updated.
 */
public void addListener(final OnSettingChangedListener listener)
{
    synchronized (mLock)
    {
        if (listener == null)
        {
            throw new IllegalArgumentException("OnSettingChangedListener cannot be null.");
        }

        if (mListeners.contains(listener))
        {
            return;
        }

        mListeners.add(listener);
        OnSharedPreferenceChangeListener sharedPreferenceListener =
                getSharedPreferenceListener(listener);
        mSharedPreferenceListeners.add(sharedPreferenceListener);
        mDefaultPreferences.registerOnSharedPreferenceChangeListener(sharedPreferenceListener);

        if (mCustomPreferences != null)
        {
            mCustomPreferences.registerOnSharedPreferenceChangeListener(
                    sharedPreferenceListener);
        }
        Log.v(TAG, "listeners: " + mListeners);
    }
}
 

@Override
public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
    if (currentListeners.isEmpty()) {
        subscribeReceivers();
    }
    currentListeners.add(listener);
}
 

@Override
public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
    currentListeners.remove(listener);
    if (currentListeners.isEmpty()) {
        unSubscribeReceivers();
    }
}
 

private OnSharedPreferenceChangeListener getSharedPreferenceListener(
        final OnSettingChangedListener listener)
{
    return new OnSharedPreferenceChangeListener()
    {
        @Override
        public void onSharedPreferenceChanged(
                SharedPreferences sharedPreferences, String key)
        {
            listener.onSettingChanged(SettingsManager.this, key);
        }
    };
}
 

/**
 * Remove a specific SettingsListener. This should be done in onPause if a
 * listener has been set.
 */
public void removeListener(OnSettingChangedListener listener)
{
    synchronized (mLock)
    {
        if (listener == null)
        {
            throw new IllegalArgumentException();
        }

        if (!mListeners.contains(listener))
        {
            return;
        }

        int index = mListeners.indexOf(listener);
        mListeners.remove(listener);

        OnSharedPreferenceChangeListener sharedPreferenceListener =
                mSharedPreferenceListeners.get(index);
        mSharedPreferenceListeners.remove(index);
        mDefaultPreferences.unregisterOnSharedPreferenceChangeListener(
                sharedPreferenceListener);

        if (mCustomPreferences != null)
        {
            mCustomPreferences.unregisterOnSharedPreferenceChangeListener(
                    sharedPreferenceListener);
        }
    }
}
 

void notifyListeners(final String key) {
	final List<OnSharedPreferenceChangeListener> listeners;
	synchronized (this) {
		listeners = new ArrayList<>(mListeners.keySet());
	}
	for (final OnSharedPreferenceChangeListener listener : listeners) {
		Log.d(CrossProcessSharedPreferences.TAG, "Notify listener: " + listener);
		listener.onSharedPreferenceChanged(this, key);
	}
}
 

private List<OnSharedPreferenceChangeListener> putIfAbsentListeners(String prefName, Map<String, List<OnSharedPreferenceChangeListener>> allListeners) {
    if (allListeners.containsKey(prefName)) {
        return allListeners.get(prefName);
    }
    List<OnSharedPreferenceChangeListener> listeners = new ArrayList<>();
    allListeners.put(prefName, listeners);
    return listeners;
}
 

private void notifyListeners(final String key) {
    handler.post(new Runnable() {
        @Override
        public void run() {
            List<OnSharedPreferenceChangeListener> temp = new ArrayList<>(currentListeners);
            for (OnSharedPreferenceChangeListener listener : temp) {
                listener.onSharedPreferenceChanged(null, key);
            }
        }
    });
}
 

private List<OnSharedPreferenceChangeListener> initListeners(String prefName) {
    if (allListeners.containsKey(prefName)) {
        return allListeners.get(prefName);
    }
    List<OnSharedPreferenceChangeListener> listeners = new ArrayList<>();
    allListeners.put(prefName, listeners);
    return listeners;
}
 

@Override
protected void tearDown() throws Exception {
  AndroidMock.reset(dataSource);

  // Expect everything to be unregistered.
  dataSource.unregisterContentObserver(isA(ContentObserver.class));
  AndroidMock.expectLastCall().times(3);
  dataSource.unregisterOnSharedPreferenceChangeListener(
      isA(OnSharedPreferenceChangeListener.class));
  AndroidMock.replay(dataSource);

  trackDataHub.stop();
  trackDataHub = null;
  super.tearDown();
}
 

public OAuthManagerStore(Context ctx, String name, int mode) {
  // setup credential store
  this.context = ctx;
  this.prefs = ctx.getSharedPreferences(name, Context.MODE_PRIVATE);
  editor = this.prefs.edit();
  listener = new SharedPreferences.OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
      Log.d(TAG, "Preferences changed: " + key);
    }
  };
  prefs.registerOnSharedPreferenceChangeListener(listener);
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Fabric.with(this, new Crashlytics());
    prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
    checkEula();
    new IdempotentMigrations(getApplicationContext()).performAll();

    startService(new Intent(getApplicationContext(), DataCollectionService.class));
    PreferenceManager.setDefaultValues(this, R.xml.pref_general, false);
    PreferenceManager.setDefaultValues(this, R.xml.pref_bg_notification, false);

    preferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
            invalidateOptionsMenu();
        }
    };

    prefs.registerOnSharedPreferenceChangeListener(preferenceChangeListener);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Intent intent = new Intent();
        String packageName = getPackageName();
        Log.d(this.getClass().getName(), "Maybe ignoring battery optimization");
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        if (!pm.isIgnoringBatteryOptimizations(packageName) &&
                !prefs.getBoolean("requested_ignore_battery_optimizations", false)) {
            Log.d(this.getClass().getName(), "Requesting ignore battery optimization");

            prefs.edit().putBoolean("requested_ignore_battery_optimizations", true).apply();
            intent.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
            intent.setData(Uri.parse("package:" + packageName));
            startActivity(intent);
        }
    }
}
 

@Before
public void setUp() {
  initMocks(this);
  sharedPreferenceListenerCaptor =
      ArgumentCaptor.forClass(OnSharedPreferenceChangeListener.class);
  doNothing().when(sharedPreferences).registerOnSharedPreferenceChangeListener(
      sharedPreferenceListenerCaptor.capture());
  updatable = mockUpdatable();
  secondUpdatable = mockUpdatable();
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Fabric.with(this, new Crashlytics());
    prefs = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
    checkEula();
    new IdempotentMigrations(getApplicationContext()).performAll();

    startService(new Intent(getApplicationContext(), DataCollectionService.class));
    PreferenceManager.setDefaultValues(this, R.xml.pref_general, false);
    PreferenceManager.setDefaultValues(this, R.xml.pref_bg_notification, false);

    preferenceChangeListener = new OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
            invalidateOptionsMenu();
        }
    };

    prefs.registerOnSharedPreferenceChangeListener(preferenceChangeListener);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Intent intent = new Intent();
        String packageName = getPackageName();
        Log.d(this.getClass().getName(), "Maybe ignoring battery optimization");
        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        if (!pm.isIgnoringBatteryOptimizations(packageName) &&
                !prefs.getBoolean("requested_ignore_battery_optimizations", false)) {
            Log.d(this.getClass().getName(), "Requesting ignore battery optimization");

            prefs.edit().putBoolean("requested_ignore_battery_optimizations", true).apply();
            intent.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
            intent.setData(Uri.parse("package:" + packageName));
            startActivity(intent);
        }
    }
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	// Load the preferences from an XML resource
	addPreferencesFromResource(R.xml.user_prefs);

	// Get the username Preference
	mUserNamePreference = (Preference) getPreferenceManager()
			.findPreference(USERNAME);

	// Attach a listener to update summary when username changes
	mListener = new OnSharedPreferenceChangeListener() {
		@Override
		public void onSharedPreferenceChanged(
				SharedPreferences sharedPreferences, String key) {
			mUserNamePreference.setSummary(sharedPreferences.getString(
					USERNAME, "None Set"));
		}
	};

	// Get SharedPreferences object managed by the PreferenceManager for
	// this Fragment
	SharedPreferences prefs = getPreferenceManager()
			.getSharedPreferences();

	// Register a listener on the SharedPreferences object
	prefs.registerOnSharedPreferenceChangeListener(mListener);

	// Invoke callback manually to display the current username
	mListener.onSharedPreferenceChanged(prefs, USERNAME);

}
 

@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	// Load the preferences from an XML resource
	addPreferencesFromResource(R.xml.user_prefs);

	// Get the username Preference
	mUserNamePreference = getPreferenceManager()
			.findPreference(USERNAME);

	// Attach a listener to update summary when username changes
	mListener = new OnSharedPreferenceChangeListener() {
		@Override
		public void onSharedPreferenceChanged(
				SharedPreferences sharedPreferences, String key) {
			mUserNamePreference.setSummary(sharedPreferences.getString(
					USERNAME, "None Set"));
		}
	};

	// Get SharedPreferences object managed by the PreferenceManager for
	// this Fragment
	SharedPreferences prefs = getPreferenceManager()
			.getSharedPreferences();

	// Register a listener on the SharedPreferences object
	prefs.registerOnSharedPreferenceChangeListener(mListener);

	// Invoke callback manually to display the current username
	mListener.onSharedPreferenceChanged(prefs, USERNAME);

}
 

@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);

	// Load the preferences from an XML resource
	addPreferencesFromResource(R.xml.user_prefs);

	// Get the username Preference
	mUserNamePreference = (Preference) getPreferenceManager()
			.findPreference(USERNAME);

	// Attach a listener to update summary when username changes
	mListener = new OnSharedPreferenceChangeListener() {
		@Override
		public void onSharedPreferenceChanged(
				SharedPreferences sharedPreferences, String key) {
			mUserNamePreference.setSummary(sharedPreferences.getString(
					USERNAME, "None Set"));
		}
	};

	// Get SharedPreferences object managed by the PreferenceManager for
	// this Fragment
	SharedPreferences prefs = getPreferenceManager()
			.getSharedPreferences();

	// Register a listener on the SharedPreferences object
	prefs.registerOnSharedPreferenceChangeListener(mListener);

	// Invoke callback manually to display the current username
	mListener.onSharedPreferenceChanged(prefs, USERNAME);

}