Android 10.0 sharedpereference保存数据断开电源数据丢失题目办理 ...

1.媒介

在10.0的系统rom定制化开发中，在用sharedpereference保存数据的时间，偶然候会出现在断电的情况下数据会丢失的功能， 接下来分析下数据保存流程，然后办理题目
2.sharedpereference保存数据断开电源数据丢失题目办理的焦点类

1. frameworks/base/core/java/android/content/SharedPreferences.java
2. frameworks/base/core/java/android/app/SharedPreferencesImpl.java

复制代码

3.sharedpereference保存数据断开电源数据丢失题目办理的焦点功能分析和实现

SharedPreferences是Android平台上一个轻量级的存储类，当程序中有一些少量数据需要持久化存储时，可以使用SharedPreferences举行存储。 一、SharedPreferences的数据操作 1、将数据存入SharedPreferences中 使用SharedPreferences存储数据时，起首需要调用getSharedPreferences()方法获取SharedPreferences的实例对象。由于该对象本身只能获取数据，不能对数据举行存储和修改，以是需要调用SharedPreferences的edit()方法获取到可编辑的Editor对象，最后通过Editor对象的putXxx()方法存储数据 SharedPreferences)是Android上的一个轻量级存储工具,存储布局是雷同map的key—value键值对情势。它主要用于保存app的基础设置
3.1 SharedPreferences.java的相干功能分析和实现

1、SharedPreferences 基本介绍 SharedPreferences 是 Android 的一个轻量级存储工具，它采用 key - value 的键值对方式举行存储 它允许保存和读取应用中的基本数据类型，例如，String、int、float、boolean 等 保存共享参数键值对信息的文件路径为：/data/data/【应用包名】/shared_prefs/【SharedPreferences 文件名】.xml

1. public interface SharedPreferences {
2.     /**
3.      * Interface definition for a callback to be invoked when a shared
4.      * preference is changed.
5.      */
6.     public interface OnSharedPreferenceChangeListener {
7.         /**
8.          * Called when a shared preference is changed, added, or removed. This
9.          * may be called even if a preference is set to its existing value.
10.          *
11.          * <p>This callback will be run on your main thread.
12.          *
13.          */
14.         void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);
15.     }
17.     /*public interface OnSharedPreferenceChangeListener {
18.         /**
19.          * Called when a shared preference is changed, added, or removed. This
20.          * may be called even if a preference is set to its existing value.
21.          *
22.          * <p>This callback will be run on your main thread.
23.          *
24.          * <p><em>Note: This callback will not be triggered when preferences are cleared via
25.          * {@link Editor#clear()}.</em>
26.          *
27.          * @param sharedPreferences The {@link SharedPreferences} that received
28.          *            the change.
29.          * @param key The key of the preference that was changed, added, or
30.          *            removed.
31.          */
32.         void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key);
33.     }*/
34.     /**
35.      * Interface used for modifying values in a {@link SharedPreferences}
36.      * object.  All changes you make in an editor are batched, and not copied
37.      * back to the original {@link SharedPreferences} until you call {@link #commit}
38.      * or {@link #apply}
39.      */
40.     public interface Editor {
41.         /**
42.          * Set a String value in the preferences editor, to be written back once
43.          * {@link #commit} or {@link #apply} are called.
44.          *
45.          * @param key The name of the preference to modify.
46.          * @param value The new value for the preference.  Passing {@code null}
47.          *    for this argument is equivalent to calling {@link #remove(String)} with
48.          *    this key.
49.          *
50.          * @return Returns a reference to the same Editor object, so you can
51.          * chain put calls together.
52.          */
53.         Editor putString(String key, @Nullable String value);
55.         /**
56.          * Set a set of String values in the preferences editor, to be written
57.          * back once {@link #commit} or {@link #apply} is called.
58.          *
59.          * @param key The name of the preference to modify.
60.          * @param values The set of new values for the preference.  Passing {@code null}
61.          *    for this argument is equivalent to calling {@link #remove(String)} with
62.          *    this key.
63.            * @return Returns a reference to the same Editor object, so you can
64.            * chain put calls together.
65.            */
66.           Editor putStringSet(String key, @Nullable Set<String> values);
67.   
68.           Editor putInt(String key, int value);
69.   
70.           Editor putLong(String key, long value);
72.           Editor putFloat(String key, float value);
74.           Editor putBoolean(String key, boolean value);
77.           Editor remove(String key);
79.           Editor clear();
81.           boolean commit();
82.   
83.           void apply();
84.       }
85. .....
86. }

复制代码

在实现sharedpereference保存数据断开电源数据丢失题目办理的焦点功能中，可以看到 SharedPreferences是个接口，实现了相干保存数据的方法，具体保存数据是在Editor 的commit()和apply()方法中，

1. //add core start
2.     //do sync
3.     public static void fileSync() {
4.         new Thread(new Runnable() {
5.             @Override
6.             public void run() {
7.                 try {
8.                     Thread.sleep(1000);
9.                 } catch (InterruptedException e) {
10.                     e.printStackTrace();
11.                 }
12.                
13.                 //sync
14.                 Runtime runtime = Runtime.getRuntime();
15.                 try {
16.                     runtime.exec("sync");
17.                 } catch (IOException e) {
18.                     e.printStackTrace();
19.                 }
20.             }
21.         }).start();
22.       
23.     }
24. //add core end
25.         @Override
26.           public Editor clear() {
27.               synchronized (mEditorLock) {
28.                   mClear = true;
29.                   return this;
30.               }
31.           }
32.   
33.           @Override
34.           public void apply() {
35.               final long startTime = System.currentTimeMillis();
36.   
37.               final MemoryCommitResult mcr = commitToMemory();
38.               final Runnable awaitCommit = new Runnable() {
39.                       @Override
40.                       public void run() {
41.                           try {
42.                               mcr.writtenToDiskLatch.await();
43.                           } catch (InterruptedException ignored) {
44.                           }
45.   
46.                           if (DEBUG && mcr.wasWritten) {
47.                               Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
48.                                       + " applied after " + (System.currentTimeMillis() - startTime)
49.                                       + " ms");
50.                           }
51.                       }
52.                   };
53.   
54.               QueuedWork.addFinisher(awaitCommit);
55.   
56.               Runnable postWriteRunnable = new Runnable() {
57.                       @Override
58.                       public void run() {
59.                           awaitCommit.run();
60.                           QueuedWork.removeFinisher(awaitCommit);
61.                       }
62.                   };
63.   
64.               SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
65.   
66.               // Okay to notify the listeners before it's hit disk
67.               // because the listeners should always get the same
68.               // SharedPreferences instance back, which has the
69.               // changes reflected in memory.
70.               notifyListeners(mcr);
71. + fileSync();
72.           }
74.          @Override
75.           public boolean commit() {
76.               long startTime = 0;
77.   
78.               if (DEBUG) {
79.                   startTime = System.currentTimeMillis();
80.               }
81.   
82.               MemoryCommitResult mcr = commitToMemory();
83.   
84.               SharedPreferencesImpl.this.enqueueDiskWrite(
85.                   mcr, null /* sync write on this thread okay */);
86.               try {
87.                   mcr.writtenToDiskLatch.await();
88.               } catch (InterruptedException e) {
89.                   return false;
90.               } finally {
91.                   if (DEBUG) {
92.                       Log.d(TAG, mFile.getName() + ":" + mcr.memoryStateGeneration
93.                               + " committed after " + (System.currentTimeMillis() - startTime)
94.                               + " ms");
95.                   }
96.               }
97.               notifyListeners(mcr);
98. + fileSync();
99.               return mcr.writeToDiskResult;
100.           }

复制代码

在实现sharedpereference保存数据断开电源数据丢失题目办理的焦点功能中，在SharedPreferencesImpl.java中 具体实现保存数据的功能，以是在EditorImpl的commit()和apply()方法中,添加sync的相干方法来同步数据到 磁盘中来实现数据的保存

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。