SharedPreferences小探

The single SharedPreferences instance that can be used to retrieve and modify the preference values.

//ContextImpl.java
724     @Override
725     public SharedPreferences getSharedPreferences(String name, int mode) {
726         SharedPreferencesImpl sp;
727         synchronized (ContextImpl.class) {
728             if (sSharedPrefs == null) {
729                 sSharedPrefs = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>();
730             }
731 
732             final String packageName = getPackageName();
733             ArrayMap<String, SharedPreferencesImpl> packagePrefs = sSharedPrefs.get(packageName);
734             if (packagePrefs == null) {
735                 packagePrefs = new ArrayMap<String, SharedPreferencesImpl>();
736                 sSharedPrefs.put(packageName, packagePrefs);
737             }
738 
739             // At least one application in the world actually passes in a null
740             // name.  This happened to work because when we generated the file name
741             // we would stringify it to "null.xml".  Nice.
742             if (mPackageInfo.getApplicationInfo().targetSdkVersion <
743                     Build.VERSION_CODES.KITKAT) {
744                 if (name == null) {
745                     name = "null";
746                 }
747             }
748 
749             sp = packagePrefs.get(name);
750             if (sp == null) {
751                 File prefsFile = getSharedPrefsFile(name);
752                 sp = new SharedPreferencesImpl(prefsFile, mode);
753                 packagePrefs.put(name, sp);
754                 return sp;
755             }
756         }
757         if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
758             getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
759             // If somebody else (some other process) changed the prefs
760             // file behind our back, we reload it.  This has been the
761             // historical (if undocumented) behavior.
762             sp.startReloadIfChangedUnexpectedly();
763         }
764         return sp;
765     }

//SharedPreferencesImpl.java

52 final class More ...SharedPreferencesImpl implements SharedPreferences {
53     private static final String TAG = "SharedPreferencesImpl";
54     private static final boolean DEBUG = false;
55 
56     // Lock ordering rules:
57     //  - acquire SharedPreferencesImpl.this before EditorImpl.this
58     //  - acquire mWritingToDiskLock before EditorImpl.this
59 
60     private final File mFile;
61     private final File mBackupFile;
62     private final int mMode;
63 
64     private Map<String, Object> mMap;     // guarded by 'this'

//SharedPreferencesImpl.java

273    public Editor edit() {
274        // TODO: remove the need to call awaitLoadedLocked() when
275        // requesting an editor.  will require some work on the
276        // Editor, but then we should be able to do:
277        //
278        //      context.getSharedPreferences(..).edit().putString(..).apply()
279        //
280        // ... all without blocking.
281        synchronized (this) {
282            awaitLoadedLocked();
283        }
284
285        return new EditorImpl();
286    }

303    public final class EditorImpl implements Editor {
304        private final Map<String, Object> mModified = Maps.newHashMap();
305        private boolean mClear = false;
306
307        public Editor putString(String key, String value) {
308            synchronized (this) {
309                mModified.put(key, value);
310                return this;
311            }
312        }

388        // Returns true if any changes were made
389        private MemoryCommitResult commitToMemory() {
390            MemoryCommitResult mcr = new MemoryCommitResult();
391            synchronized (SharedPreferencesImpl.this) {
392                // We optimistically don't make a deep copy until
393                // a memory commit comes in when we're already
394                // writing to disk.
395                if (mDiskWritesInFlight > 0) {
396                    // We can't modify our mMap as a currently
397                    // in-flight write owns it.  Clone it before
398                    // modifying it.
399                    // noinspection unchecked
400                    mMap = new HashMap<String, Object>(mMap);
401                }
402                mcr.mapToWriteToDisk = mMap;
403                mDiskWritesInFlight++;
404
405                boolean hasListeners = mListeners.size() > 0;
406                if (hasListeners) {
407                    mcr.keysModified = new ArrayList<String>();
408                    mcr.listeners =
409                            new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
410                }
411
412                synchronized (this) {
413                    if (mClear) {
414                        if (!mMap.isEmpty()) {
415                            mcr.changesMade = true;
416                            mMap.clear();
417                        }
418                        mClear = false;
419                    }
420
421                    for (Map.Entry<String, Object> e : mModified.entrySet()) {
422                        String k = e.getKey();
423                        Object v = e.getValue();
424                        if (v == this) {  // magic value for a removal mutation
425                            if (!mMap.containsKey(k)) {
426                                continue;
427                            }
428                            mMap.remove(k);
429                        } else {
430                            boolean isSame = false;
431                            if (mMap.containsKey(k)) {
432                                Object existingValue = mMap.get(k);
433                                if (existingValue != null && existingValue.equals(v)) {
434                                    continue;
435                                }
436                            }
437                            mMap.put(k, v);
438                        }
439
440                        mcr.changesMade = true;
441                        if (hasListeners) {
442                            mcr.keysModified.add(k);
443                        }
444                    }
445
446                    mModified.clear();
447                }
448            }
449            return mcr;
450        }

452        public boolean commit() {
453            MemoryCommitResult mcr = commitToMemory();
454            SharedPreferencesImpl.this.enqueueDiskWrite(
455                mcr, null /* sync write on this thread okay */);
456            try {
457                mcr.writtenToDiskLatch.await();
458            } catch (InterruptedException e) {
459                return false;
460            }
461            notifyListeners(mcr);
462            return mcr.writeToDiskResult;
463        }

564    private void writeToFile(MemoryCommitResult mcr) {
565        // Rename the current file so it may be used as a backup during the next read
566        if (mFile.exists()) {
567            if (!mcr.changesMade) {
568                // If the file already exists, but no changes were
569                // made to the underlying map, it's wasteful to
570                // re-write the file.  Return as if we wrote it
571                // out.
572                mcr.setDiskWriteResult(true);
573                return;
574            }
575            if (!mBackupFile.exists()) {
576                if (!mFile.renameTo(mBackupFile)) {
577                    Log.e(TAG, "Couldn't rename file " + mFile
578                          + " to backup file " + mBackupFile);
579                    mcr.setDiskWriteResult(false);
580                    return;
581                }
582            } else {
583                mFile.delete();
584            }
585        }
586
587        // Attempt to write the file, delete the backup and return true as atomically as
588        // possible.  If any exception occurs, delete the new file; next time we will restore
589        // from the backup.
590        try {
591            FileOutputStream str = createFileOutputStream(mFile);
592            if (str == null) {
593                mcr.setDiskWriteResult(false);
594                return;
595            }
596            XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
597            FileUtils.sync(str);
598            str.close();
599            ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
600            try {
601                final StructStat stat = Libcore.os.stat(mFile.getPath());
602                synchronized (this) {
603                    mStatTimestamp = stat.st_mtime;
604                    mStatSize = stat.st_size;
605                }
606            } catch (ErrnoException e) {
607                // Do nothing
608            }
609            // Writing was successful, delete the backup file if there is one.
610            mBackupFile.delete();
611            mcr.setDiskWriteResult(true);
612            return;
613        } catch (XmlPullParserException e) {
614            Log.w(TAG, "writeToFile: Got exception:", e);
615        } catch (IOException e) {
616            Log.w(TAG, "writeToFile: Got exception:", e);
617        }
618        // Clean up an unsuccessfully written file
619        if (mFile.exists()) {
620            if (!mFile.delete()) {
621                Log.e(TAG, "Couldn't clean up partially-written file " + mFile);
622            }
623        }
624        mcr.setDiskWriteResult(false);
625    }

97     private void More ...loadFromDiskLocked() {
98         if (mLoaded) {
99             return;
100        }
101        if (mBackupFile.exists()) {
102            mFile.delete();
103            mBackupFile.renameTo(mFile);
104        }
105
106        // Debugging
107        if (mFile.exists() && !mFile.canRead()) {
108            Log.w(TAG, "Attempt to read preferences file " + mFile + " without permission");
109        }
110
111        Map map = null;
112        StructStat stat = null;
113        try {
114            stat = Libcore.os.stat(mFile.getPath());
115            if (mFile.canRead()) {
116                BufferedInputStream str = null;
117                try {
118                    str = new BufferedInputStream(
119                            new FileInputStream(mFile), 16*1024);
120                    map = XmlUtils.readMapXml(str);
121                } catch (XmlPullParserException e) {
122                    Log.w(TAG, "getSharedPreferences", e);
123                } catch (FileNotFoundException e) {
124                    Log.w(TAG, "getSharedPreferences", e);
125                } catch (IOException e) {
126                    Log.w(TAG, "getSharedPreferences", e);
127                } finally {
128                    IoUtils.closeQuietly(str);
129                }
130            }
131        } catch (ErrnoException e) {
132        }
133        mLoaded = true;
134        if (map != null) {
135            mMap = map;
136            mStatTimestamp = stat.st_mtime;
137            mStatSize = stat.st_size;
138        } else {
139            mMap = new HashMap<String, Object>();
140        }
141        notifyAll();
142    }