Sharedpreference多进程实现

最新推荐文章于 2021-12-08 11:50:31 发布
最新推荐文章于 2021-12-08 11:50:31 发布
阅读量669 收藏
点赞数 1
分类专栏： Android 文章标签： sharedpreference
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangfanxiao/article/details/104006878
版权

在我们要保存一些数据量小且需要持久化的数据时，我们通常会使用SharedPreference来保存。正常情况下
是没有任何问题的。但我们知道SharedPreference保存实际上是保存一份XML文件。
我们访问SharedPreference资源：
   首次访问会读取xml文件，把所有内容读入缓存。之后在该进程中都是从缓存中拿。
写入：Editor & apply
    都是先写入缓存：
    但是 Editor 是同步的：    写入缓存后提交写入Xml文件，完成后返回结果
        apply：    写入缓存后 把写文件操作放入单线程池直接返回 QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable）

因为Android在系统中进程间的内存是不能共享的，所以SharedPreference在进程间是无法直接公用的。下面我们就来讲下

SharedPreference的跨进程使用。

思路： 通常跨进程通行的方式有：

 

 

 

我这选用 ContentProvider

public class TestActivity extends Activity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        ((TextView)findViewById(R.id.title)).setText("Activity1");
        findViewById(R.id.btn0).setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {
                startActivity(new Intent(TestActivity.this, TestActivity2.class));
            }
        });

        findViewById(R.id.btn1).setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {
                putValues(TestActivity.this);
            }
        });
        findViewById(R.id.btn2).setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {

                int pid = android.os.Process.myPid();
                Log.e("getValues", "pid:" + pid + " +  processName:" + getAppName(TestActivity.this, pid));
                getValues(TestActivity.this);
            }
        });
        findViewById(R.id.btn3).setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {
                testOther(TestActivity.this);
            }
        });
    }

    private static void putValues(Context ctx) {
        SharedPreferences preferences = PreferenceUtil.getSharedPreference(ctx, "test");
        Set<String> set = new HashSet<>();
        set.add("well");
        preferences.edit().putString("key1", "ok")
                .putStringSet("key2", set)
                .putLong("key3",30231L)
                .putBoolean("key4", true)
                .putFloat("key5", 0.3f)
                .putInt("key6", 6)
                .apply();
        int pid = android.os.Process.myPid();
        Log.e("getValues", "pid:" + pid);
    }

    private static void getValues(Context ctx) {
        SharedPreferences preferences = PreferenceUtil.getSharedPreference(ctx, "test");
        Log.e("getValues", "Values:" + preferences.getString("key1", "xxx")
        + "/n" + "key3:"  + preferences.getLong("key3", 0L)
                        + "/n" +        "key4:"  +  preferences.getBoolean("key4", false)
                        + "/n" +   "key5:"  +  preferences.getFloat("key5", 0.f)
                        + "/n" +   "key6:"  + preferences.getInt("key6", 1)

        );
    }

    private static void testOther(Context ctx) {
        //2 Test clear and default
        SharedPreferences preferences = PreferenceUtil.getSharedPreference(ctx, "test");
        preferences.edit().clear().commit();
        Assert.assertEquals("xxx", preferences.getString("key1", "xxx"));
        Assert.assertEquals(null, preferences.getStringSet("key2", null));
        Assert.assertEquals(2L, preferences.getLong("key3", 2L));
        Assert.assertEquals(false, preferences.getBoolean("key4", false));
        Assert.assertEquals(0.4f, preferences.getFloat("key5", 0.4f));
        Assert.assertEquals(1, preferences.getInt("key6", 1));

        //3 Test remove
        preferences.edit().putInt("key6", 4).commit();
        Assert.assertEquals(4, preferences.getInt("key6", 1));
        preferences.edit().remove("key6").apply();
        Assert.assertEquals(3, preferences.getInt("key6", 3));
    }

    private static void ChangeValues(Context ctx) {
        SharedPreferences preferences = PreferenceUtil.getSharedPreference(ctx, "test");
        Set<String> set = new HashSet<>();
        set.add("well");
        preferences.edit().putString("key1", "no")
                .putStringSet("key2", set)
                .putLong("key3",60262L)
                .putBoolean("key4", false)
                .putFloat("key5", 0.6f)
                .putInt("key6", 12)
                .apply();
        int pid = android.os.Process.myPid();
        Log.e("ChangeValues", "pid:" + pid);
    }
    /**
     * Activity in another process, the same with SharedPreferenceProvider
     */
    public static class TestActivity2 extends Activity{
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            ((TextView)findViewById(R.id.title)).setText("Activity2");
            findViewById(R.id.btn0).setVisibility(View.GONE);
            findViewById(R.id.btn1).setOnClickListener(new View.OnClickListener(){
                @Override
                public void onClick(View v) {
                    ChangeValues(TestActivity2.this);
                }
            });
            findViewById(R.id.btn2).setOnClickListener(new View.OnClickListener(){
                @Override
                public void onClick(View v) {
                    int pid = android.os.Process.myPid();

                    Log.e("getValues", "pid:" + pid + "  processName:" + getAppName(TestActivity2.this, pid));
                    getValues(TestActivity2.this);
                }
            });
            findViewById(R.id.btn3).setOnClickListener(new View.OnClickListener(){
                @Override
                public void onClick(View v) {
                    testOther(TestActivity2.this);
                }
            });
        }
    }


    /**
     2  * 根据Pid获取当前进程的名字，一般就是当前app的包名
     3  *
     4  * @param context 上下文
     5  * @param pid 进程的id
     6  * @return 返回进程的名字
     7  */
  private static String getAppName(Context context, int pid)
  {
             ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
             List list = activityManager.getRunningAppProcesses();
             Iterator i = list.iterator();
             while (i.hasNext())
                 {
                    ActivityManager.RunningAppProcessInfo info = (ActivityManager.RunningAppProcessInfo) (i.next());
                    try
                     {
                         if (info.pid == pid)
                                 {
                                     // 根据进程的信息获取当前进程的名字
                                     return info.processName;
                                 }
                         }
                     catch (Exception e)
                     {
                             e.printStackTrace();
                         }
                 }
             // 没有匹配的项，返回为null
             return null;
         }
}

 

package com.lain.prefercene;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.Process;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.util.ArrayMap;

import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

public class SharedPreferenceProxy implements SharedPreferences {
    private static Map<String, SharedPreferenceProxy> sharedPreferenceProxyMap;

    /**
     * Flag whether caller process is the same with provider
     * 0: unknown
     * 1: the same
     * -1: not the same
     */
    private static AtomicInteger processFlag = new AtomicInteger(0);

    private Context ctx;
    private String preferName;

    private SharedPreferenceProxy(Context ctx, String name) {
        this.ctx = ctx.getApplicationContext();
        this.preferName = name;
    }

    @Override
    public Map<String, ?> getAll() {
        throw new UnsupportedOperationException("Not support method getAll");
    }

    @Nullable
    @Override
    public String getString(String key, @Nullable String defValue) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setStringValue(defValue));
        return result == null ? defValue : result.getStringValue(defValue);
    }

    @Nullable
    @Override
    public Set<String> getStringSet(String key, @Nullable Set<String> defValues) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setStringSettingsValue(defValues));
        if (result == null) {
            return defValues;
        }
        Set<String> set = result.getStringSet();
        if (set == null) {
            return defValues;
        }
        return set;
    }

    @Override
    public int getInt(String key, int defValue) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setIntValue(defValue));
        return result == null ? defValue : result.getIntValue(defValue);
    }

    @Override
    public long getLong(String key, long defValue) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setLongValue(defValue));
        return result == null ? defValue : result.getLongValue(defValue);
    }

    @Override
    public float getFloat(String key, float defValue) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setFloatValue(defValue));
        return result == null ? defValue : result.getFloatValue(defValue);
    }

    @Override
    public boolean getBoolean(String key, boolean defValue) {
        OpEntry result = getResult(OpEntry.obtainGetOperation(key).setBooleanValue(defValue));
        return result == null ? defValue : result.getBooleanValue(defValue);
    }

    @Override
    public boolean contains(String key) {
        Bundle input = new Bundle();
        input.putString(OpEntry.KEY_KEY, key);
        try {
            Bundle res = ctx.getContentResolver().call(PreferenceUtil.URI
                    , PreferenceUtil.METHOD_CONTAIN_KEY
                    , preferName
                    , input);
            return res.getBoolean(PreferenceUtil.KEY_VALUES);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public Editor edit() {
        return new EditorImpl();
    }

    @Override
    public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
        throw new UnsupportedOperationException();
    }

    private OpEntry getResult(@NonNull OpEntry input) {
        try {
            Bundle res = ctx.getContentResolver().call(PreferenceUtil.URI
                    , PreferenceUtil.METHOD_QUERY_VALUE
                    , preferName
                    , input.getBundle());
            return new OpEntry(res);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public class EditorImpl implements Editor {
        private ArrayList<OpEntry> mModified = new ArrayList<>();

        @Override
        public Editor putString(String key, @Nullable String value) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setStringValue(value);
            return addOps(entry);
        }

        @Override
        public Editor putStringSet(String key, @Nullable Set<String> values) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setStringSettingsValue(values);
            return addOps(entry);
        }

        @Override
        public Editor putInt(String key, int value) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setIntValue(value);
            return addOps(entry);
        }

        @Override
        public Editor putLong(String key, long value) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setLongValue(value);
            return addOps(entry);
        }

        @Override
        public Editor putFloat(String key, float value) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setFloatValue(value);
            return addOps(entry);
        }

        @Override
        public Editor putBoolean(String key, boolean value) {
            OpEntry entry = OpEntry.obtainPutOperation(key).setBooleanValue(value);
            return addOps(entry);
        }

        @Override
        public Editor remove(String key) {
            OpEntry entry = OpEntry.obtainRemoveOperation(key);
            return addOps(entry);
        }

        @Override
        public Editor clear() {
            return addOps(OpEntry.obtainClear());
        }

        @Override
        public boolean commit() {
            Bundle input = new Bundle();
            input.putParcelableArrayList(PreferenceUtil.KEY_VALUES, convertBundleList());
            input.putInt(OpEntry.KEY_OP_TYPE, OpEntry.OP_TYPE_COMMIT);
            Bundle res = null;
            try {
                res = ctx.getContentResolver().call(PreferenceUtil.URI, PreferenceUtil.METHOD_EIDIT_VALUE, preferName, input);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (res == null) {
                return false;
            }
            return res.getBoolean(PreferenceUtil.KEY_VALUES, false);
        }

        @Override
        public void apply() {
            Bundle intput = new Bundle();
            intput.putParcelableArrayList(PreferenceUtil.KEY_VALUES, convertBundleList());
            intput.putInt(OpEntry.KEY_OP_TYPE, OpEntry.OP_TYPE_APPLY);
            try {
                ctx.getContentResolver().call(PreferenceUtil.URI, PreferenceUtil.METHOD_EIDIT_VALUE, preferName, intput);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        private Editor addOps(OpEntry op) {
            synchronized (this) {
                mModified.add(op);
                return this;
            }
        }

        private ArrayList<Bundle> convertBundleList() {
            synchronized (this) {
                ArrayList<Bundle> bundleList = new ArrayList<>(mModified.size());
                for (OpEntry entry : mModified) {
                    bundleList.add(entry.getBundle());
                }
                return bundleList;
            }
        }
    }





    public static SharedPreferences getSharedPreferences(@NonNull Context ctx, String preferName) {
        //First check if the same process
        if (processFlag.get() == 0) {
            Bundle bundle = ctx.getContentResolver().call(PreferenceUtil.URI, PreferenceUtil.METHOD_QUERY_PID, "", null);
            int pid = 0;
            if (bundle != null) {
                pid = bundle.getInt(PreferenceUtil.KEY_VALUES);
//                pid =  android.os.Process.myPid();
            }
            //Can not get the pid, something wrong!
            if (pid == 0) {
                return getFromLocalProcess(ctx, preferName);
            }
            processFlag.set(Process.myPid() == pid ? 1 : -1);
            return getSharedPreferences(ctx, preferName);
        } else if (processFlag.get() > 0) {
            return getFromLocalProcess(ctx, preferName);
        } else {
            return getFromRemoteProcess(ctx, preferName);
        }
    }


    private static SharedPreferences getFromRemoteProcess(@NonNull Context ctx, String preferName) {
        synchronized (SharedPreferenceProxy.class) {
            if (sharedPreferenceProxyMap == null) {
                sharedPreferenceProxyMap = new ArrayMap<>();
            }
            SharedPreferenceProxy preferenceProxy = sharedPreferenceProxyMap.get(preferName);
            if (preferenceProxy == null) {
                preferenceProxy = new SharedPreferenceProxy(ctx.getApplicationContext(), preferName);
                sharedPreferenceProxyMap.put(preferName, preferenceProxy);
            }
            return preferenceProxy;
        }
    }

    private static SharedPreferences getFromLocalProcess(@NonNull Context ctx, String preferName) {
        return ctx.getSharedPreferences(preferName, Context.MODE_PRIVATE);
    }
}

 

package com.lain.prefercene;

import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.Process;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.util.ArrayMap;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;


public class SharedPreferenceProvider extends ContentProvider{

    private Map<String, MethodProcess> processerMap = new ArrayMap<>();
    @Override
    public boolean onCreate() {
        processerMap.put(PreferenceUtil.METHOD_QUERY_VALUE, methodQueryValues);
        processerMap.put(PreferenceUtil.METHOD_CONTAIN_KEY, methodContainKey);
        processerMap.put(PreferenceUtil.METHOD_EIDIT_VALUE, methodEditor);
        processerMap.put(PreferenceUtil.METHOD_QUERY_PID, methodQueryPid);
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public Bundle call(@NonNull String method, @Nullable String arg, @Nullable Bundle extras) {
        MethodProcess processer = processerMap.get(method);
        return processer == null?null:processer.process(arg, extras);
    }


    public interface MethodProcess {
        Bundle process(@Nullable String arg, @Nullable Bundle extras);
    }

    private MethodProcess methodQueryPid = new MethodProcess() {
        @Override
        public Bundle process(@Nullable String arg, @Nullable Bundle extras) {
            Bundle bundle = new Bundle();
            bundle.putInt(PreferenceUtil.KEY_VALUES, Process.myPid());
            return bundle;
        }
    };

    private MethodProcess methodQueryValues = new MethodProcess() {
        @Override
        public Bundle process(@Nullable String arg, @Nullable Bundle extras) {
            if (extras == null) {
                throw new IllegalArgumentException("methodQueryValues, extras is null!");
            }
            Context ctx = getContext();
            if (ctx == null) {
                throw new IllegalArgumentException("methodQueryValues, ctx is null!");
            }
            String key = extras.getString(OpEntry.KEY_KEY);
            SharedPreferences preferences = ctx.getSharedPreferences(arg, Context.MODE_PRIVATE);
            int valueType = extras.getInt(OpEntry.KEY_VALUE_TYPE);
            switch (valueType) {
                case OpEntry.VALUE_TYPE_BOOLEAN:{
                    boolean value = preferences.getBoolean(key, extras.getBoolean(OpEntry.KEY_VALUE));
                    extras.putBoolean(OpEntry.KEY_VALUE, value);
                    return extras;
                }
                case OpEntry.VALUE_TYPE_FLOAT:{
                    float value = preferences.getFloat(key, extras.getFloat(OpEntry.KEY_VALUE));
                    extras.putFloat(OpEntry.KEY_VALUE, value);
                    return extras;
                }
                case OpEntry.VALUE_TYPE_INT:{
                    int value = preferences.getInt(key, extras.getInt(OpEntry.KEY_VALUE));
                    extras.putInt(OpEntry.KEY_VALUE, value);
                    return extras;
                }
                case OpEntry.VALUE_TYPE_LONG:{
                    long value = preferences.getLong(key, extras.getLong(OpEntry.KEY_VALUE));
                    extras.putLong(OpEntry.KEY_VALUE, value);
                    return extras;
                }
                case OpEntry.VALUE_TYPE_STRING:{
                    String value = preferences.getString(key, extras.getString(OpEntry.KEY_VALUE));
                    extras.putString(OpEntry.KEY_VALUE, value);
                    return extras;
                }
                case OpEntry.VALUE_TYPE_STRING_SET:{
                    Set<String> value = preferences.getStringSet(key, null);
                    extras.putStringArrayList(OpEntry.KEY_VALUE, value == null?null:new ArrayList<>(value));
                    return extras;
                }
                default:{
                    throw new IllegalArgumentException("unknown valueType:" + valueType);
                }
            }
        }
    };

    private MethodProcess methodContainKey = new MethodProcess() {
        @Override
        public Bundle process(@Nullable String arg, @Nullable Bundle extras) {
            if (extras == null) {
                throw new IllegalArgumentException("methodQueryValues, extras is null!");
            }
            Context ctx = getContext();
            if (ctx == null) {
                throw new IllegalArgumentException("methodQueryValues, ctx is null!");
            }
            String key = extras.getString(OpEntry.KEY_KEY);
            SharedPreferences preferences = ctx.getSharedPreferences(arg, Context.MODE_PRIVATE);
            extras.putBoolean(PreferenceUtil.KEY_VALUES, preferences.contains(key));
            return extras;
        }
    };

    private MethodProcess methodEditor = new MethodProcess() {
        @Override
        public Bundle process(@Nullable String arg, @Nullable Bundle extras) {
            if (extras == null) {
                throw new IllegalArgumentException("methodQueryValues, extras is null!");
            }
            Context ctx = getContext();
            if (ctx == null) {
                throw new IllegalArgumentException("methodQueryValues, ctx is null!");
            }
            SharedPreferences preferences = ctx.getSharedPreferences(arg, Context.MODE_PRIVATE);
            ArrayList<Bundle> ops = extras.getParcelableArrayList(PreferenceUtil.KEY_VALUES);
            if (ops == null) {
                ops = new ArrayList<>();
            }
            SharedPreferences.Editor editor = preferences.edit();
            for (Bundle opBundler : ops) {
                int opType = opBundler.getInt(OpEntry.KEY_OP_TYPE);
                switch (opType) {
                    case OpEntry.OP_TYPE_PUT: {
                        editor = editValue(editor, opBundler);
                        break;
                    }
                    case OpEntry.OP_TYPE_REMOVE: {
                        editor = editor.remove(opBundler.getString(OpEntry.KEY_KEY));
                        break;
                    }
                    case OpEntry.OP_TYPE_CLEAR: {
                        editor = editor.clear();
                        break;
                    }
                    default: {
                        throw new IllegalArgumentException("unkonw op type:" + opType);
                    }
                }
            }

            int applyOrCommit = extras.getInt(OpEntry.KEY_OP_TYPE);
            if (applyOrCommit == OpEntry.OP_TYPE_APPLY) {
                editor.apply();
                return null;
            } else if (applyOrCommit == OpEntry.OP_TYPE_COMMIT) {
                boolean res = editor.commit();
                Bundle bundle = new Bundle();
                bundle.putBoolean(PreferenceUtil.KEY_VALUES, res);
                return bundle;
            } else {
                throw new IllegalArgumentException("unknown applyOrCommit:" + applyOrCommit);
            }
        }


        private SharedPreferences.Editor editValue(SharedPreferences.Editor editor, Bundle opBundle) {
            String key = opBundle.getString(OpEntry.KEY_KEY);
            int valueType = opBundle.getInt(OpEntry.KEY_VALUE_TYPE);
            switch (valueType) {
                case OpEntry.VALUE_TYPE_BOOLEAN: {
                    return editor.putBoolean(key, opBundle.getBoolean(OpEntry.KEY_VALUE));
                }
                case OpEntry.VALUE_TYPE_FLOAT: {
                    return editor.putFloat(key, opBundle.getFloat(OpEntry.KEY_VALUE));
                }
                case OpEntry.VALUE_TYPE_INT: {
                    return editor.putInt(key, opBundle.getInt(OpEntry.KEY_VALUE));
                }
                case OpEntry.VALUE_TYPE_LONG: {
                    return editor.putLong(key, opBundle.getLong(OpEntry.KEY_VALUE));
                }
                case OpEntry.VALUE_TYPE_STRING: {
                    return editor.putString(key, opBundle.getString(OpEntry.KEY_VALUE));
                }
                case OpEntry.VALUE_TYPE_STRING_SET: {
                    ArrayList<String> list = opBundle.getStringArrayList(OpEntry.KEY_VALUE);
                    if (list == null) {
                        return editor.putStringSet(key, null);
                    }
                    return editor.putStringSet(key, new HashSet<>(list));
                }
                default: {
                    throw new IllegalArgumentException("unknown valueType:" + valueType);
                }
            }
        }
    };
}

 

package com.lain.prefercene;
import android.content.Context;
import android.content.SharedPreferences;
import android.net.Uri;
import android.support.annotation.NonNull;
public class PreferenceUtil {
    public static final String METHOD_CONTAIN_KEY = "method_contain_key";
    public static final String AUTHORITY = "com.lain.preference";
    public static final Uri URI = Uri.parse("content://" + AUTHORITY);
    public static final String METHOD_QUERY_VALUE = "method_query_value";
    public static final String METHOD_EIDIT_VALUE = "method_edit";
    public static final String METHOD_QUERY_PID = "method_query_pid";
    public static final String KEY_VALUES = "key_result";


    public static final Uri sContentCreate = Uri.withAppendedPath(URI, "create");

    public static final Uri sContentChanged = Uri.withAppendedPath(URI, "changed");

    public static SharedPreferences getSharedPreference(@NonNull Context ctx, String preferName) {
        return SharedPreferenceProxy.getSharedPreferences(ctx, preferName);
    }
}

 

package com.lain.prefercene;

import android.os.Bundle;
import android.support.annotation.NonNull;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;


class OpEntry {

    static final int OP_TYPE_GET = 1;

    static final int OP_TYPE_PUT = 2;

    static final int OP_TYPE_CLEAR = 3;

    static final int OP_TYPE_REMOVE = 4;

    static final int OP_TYPE_COMMIT = 5;

    static final int OP_TYPE_APPLY = 6;


    static final int VALUE_TYPE_STRING = 1;

    static final int VALUE_TYPE_INT = 2;

    static final int VALUE_TYPE_LONG = 3;

    static final int VALUE_TYPE_FLOAT = 4;

    static final int VALUE_TYPE_BOOLEAN = 5;

    static final int VALUE_TYPE_STRING_SET = 6;


    static final String KEY_KEY = "key_key";

    static final String KEY_VALUE = "key_value";


    static final String KEY_VALUE_TYPE = "key_value_type";

    static final String KEY_OP_TYPE = "key_op_type";

    @NonNull
    private Bundle bundle;

    private OpEntry() {
        this.bundle = new Bundle();
    }

    public OpEntry(@NonNull Bundle bundle) {
        this.bundle = bundle;
    }

    public String getKey() {
        return bundle.getString(KEY_KEY, null);
    }

    public OpEntry setKey(String key) {
        bundle.putString(KEY_KEY, key);
        return this;
    }

    public int getValueType() {
        return bundle.getInt(KEY_VALUE_TYPE, 0);
    }

    public OpEntry setValueType(int valueType) {
        bundle.putInt(KEY_VALUE_TYPE, valueType);
        return this;
    }

    public int getOpType() {
        return bundle.getInt(KEY_OP_TYPE, 0);
    }

    public OpEntry setOpType(int opType) {
        bundle.putInt(KEY_OP_TYPE, opType);
        return this;
    }

    public String getStringValue(String defValue) {
        return bundle.getString(KEY_VALUE, defValue);
    }

    public OpEntry setStringValue(String value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_STRING);
        bundle.putString(KEY_VALUE, value);
        return this;
    }

    public int getIntValue(int defValue) {
        return bundle.getInt(KEY_VALUE, defValue);
    }

    public OpEntry setIntValue(int value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_INT);
        bundle.putInt(KEY_VALUE, value);
        return this;
    }

    public long getLongValue(long defValue) {
        return bundle.getLong(KEY_VALUE, defValue);
    }

    public OpEntry setLongValue(long value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_LONG);
        bundle.putLong(KEY_VALUE, value);
        return this;
    }

    public float getFloatValue(float defValue) {
        return bundle.getFloat(KEY_VALUE);
    }

    public OpEntry setFloatValue(float value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_FLOAT);
        bundle.putFloat(KEY_VALUE, value);
        return this;
    }


    public boolean getBooleanValue(boolean defValue) {
        return bundle.getBoolean(KEY_VALUE, defValue);
    }

    public OpEntry setBooleanValue(boolean value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_BOOLEAN);
        bundle.putBoolean(KEY_VALUE, value);
        return this;
    }

    public Set<String> getStringSet() {
        ArrayList<String> list = bundle.getStringArrayList(KEY_VALUE);
        return list == null ? null : new HashSet<>(list);
    }


    public Bundle getBundle() {
        return bundle;
    }

    public OpEntry setStringSettingsValue(Set<String> value) {
        bundle.putInt(KEY_VALUE_TYPE, VALUE_TYPE_STRING_SET);
        bundle.putStringArrayList(KEY_VALUE, value == null ? null : new ArrayList<>(value));
        return this;
    }


    static OpEntry obtainGetOperation(String key) {
        return new OpEntry()
                .setKey(key)
                .setOpType(OP_TYPE_GET);
    }

    static OpEntry obtainPutOperation(String key) {
        return new OpEntry()
                .setKey(key)
                .setOpType(OP_TYPE_PUT);
    }

    static OpEntry obtainRemoveOperation(String key) {
        return new OpEntry()
                .setKey(key)
                .setOpType(OP_TYPE_REMOVE);
    }

    static OpEntry obtainClear() {
        return new OpEntry()
                .setOpType(OP_TYPE_CLEAR);
    }
}
yangfanxiao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android跨进程之SharedPreference
itheimach的专栏
11-01 2852
Problem在主进程存了一个数据，要在remote进程去取出这个数据，开始没有考虑太多，直接用Sp去存取，然后获取到为null,然后将Sp的文件模式设为MODE_MULTI_PROCESS，MODE_WORLD_WRITEABLE 都没有什么卵用！看了下api: 1.在之前的SDK版本是支持MODE_MULTI_PROCESS的，而且不需要手动设置，后来需要手动设置 2.由于跨进程访
android多进程深入分析
tihi的博客
02-21 1623
android一个应用程序，可以存在多个进程， 在某些场景，比如希望获得更多的内存、希望功能模块间不相互影响，或者彻底解决webview内存泄漏等， 可以开多个进程； 看似好用且强大的多进程，也是一把双刃剑，今天就深入分析分析多进程；
Android SharedPreferences 源码分析以及跨进程读写问题
诺诺诺诺诺诺诺诺的博客
05-10 9688
概述 Android SharedPreferences 提供了下面的模式来支持跨进程读写数据问题。 @Deprecated public static final int MODE_MULTI_PROCESS = 0x0004; 这种模式已经被官方标记为Deprecated，关于废弃的原因，官方有解释： * @deprecated MODE_MULTI_PROCESS does ...
Android进程间通讯——多进程共用SharedPreferences
02-22
在使用SharedPreferences进行进程数据共享时，我们发现，有些虽然过时了，但是实际上还是可以用的。 只是Google不建议大家这么干了。所以这篇文章只是一个介绍实现，科普。 http://blog.csdn.net/yangzhaomuma/article/details/50718081
SharedPreferences多进程解决方案
热门推荐
维斯特洛（Westeros）大陆
04-27 1万+
由于进程间是不能内存共享的，每个进程操作的SharedPreferences都是一个单独的实例，这导致了多进程间通过SharedPreferences来共享数据是不安全的，这个问题只能通过多进程间其它的通信方式或者是在确保不会同时操作SharedPreferences数据的前提下使用SharedPreferences来解决。 SharedPreferences支持多进程吗其实原则上是不支持的，下面这
多进程中使用SharedPreferences
dengwoo的博客
06-08 448
一、问题描述         应用中起了两个进程，一个日志进程，一个应用的进程，使用SharedPreferences读取刚刚保存的数据时，获取到的不是最新的数据； 二、问题原因 在多进程中，每个进程都会持有SharedPreferences的一份缓存，其中一个进程操作了SharedPreferences，而其他进程不能及时更新最新的数据，导致了获取数据时拿到了旧数据； 三、解决办法 将
Android SharedPreference 支持多进程
bolang789的博客
05-03 474
Android SharedPreference 支持多进程  Lainn 关注2017.03.28 00:35* 字数 1345 阅读 1999评论 1喜欢 10在使用SharedPreference 时，有如下一些模式：MODE_PRIVATE 私有模式，这是最常见的模式，一般情况下都使用该模式。 MODE_WORLD_READABLE,MODE_WORLD_WRITEABLE ，文件开放读写...
面试：SharedPreference原理及多进程
王温暖的博客
12-08 2837
1、SharedPreference跨进程的使用方式： 在API Level>=11即Android 3.0可以通过Context.MODE_MULTI_PROCESS属性来实现SharedPreferences多进程共享，具体使用方式如下： public class PreferencesUtils { public static String PREFERENCE_NAME = "SharedPreferencesDemo"; private PreferencesUtils(){
harmonyos2-Harmony:没有ContentProvider的多进程SharedPreference实现
07-01
处理多进程 Android 应用程序是一项复杂的工作。 最大的挑战之一是管理多个进程之间的共享数据。 大多数解决方案依赖于一个进程可供另一个进程读取数据，这可能非常缓慢，并可能导致 ANR。 Harmony 是一个线程安全、...
SharedPreference的一些知识
黑夜
08-16 709
**先说结论： 1、SharedPreference是否是线程安全的，是否是进程安全的？ SharedPreference是线程安全的，不是进程安全的** 2、为什么SharedPreference不适合存储大量数据？ 因为SharedPreference是一次性将所有数据都加载到内存中的 3. SharedPreference中apply与commit的区别？ apply是异步的，其会将操作封装成一个事务，然后将事务提交到线程池，具体执行时间要看线程池的调度 commit是同步的，其会在当前线程执行。
Android 跨进程SharedPreferences异常详解
01-04
Android 跨进程SharedPreferences异常详解 Context c = null; try { c = context.createPackageContext(PREFERENCE_PACKAGE, Context.CONTEXT_IGNORE_SECURITY); } catch (NameNotFoundException e) { e.printStackTrace(); } if (c != null) { SharedPreferences infoSp = c.getSha
SharedPreferences跨应用跨进程获取数据（附件）
08-08
NULL 博文链接：https://flycatdeng.iteye.com/blog/2166036
Android-通过注解生成SharedPreferences包装类解决跨进程数据访问不同步的问题
08-13
通过注解生成SharedPreferences包装类，解决跨进程数据访问不同步的问题
android多用户共进程,Android-多进程初识
weixin_42143092的博客
05-28 684
Android-多进程初识学习自进程与线程IPC(Inter-Process Communication)指的是进程间通信，指的是两个进程之间交换数据的过程。在学习IPC之前我们得先了解一下什么是进程，什么是线程。进程是应用程序的实例，是操作系统进行资源分配和调度的最小单元，每个进程都代表着应用的一个实例线程是程序执行的最小单元，线程本身是不占有资源的(除了维持本身的资源除外)，线程与进程贡献资源...
多进程中的SharedPreferences
Small_Lee的博客
05-22 1466
概述如何让SharedPreferences支持多进程共享数据，我们可以在获取SharedPreferences对象的时候传入MODE_MULTI_PROCESS这个模式 SharedPreferences preferences = getSharedPreferences("default",MODE_MULTI_PROCESS);但是这种做法是不推荐的，已经过时了，我们去看看源码的解释 *
源码分析多进程下的SharedPreferences
XuJiaoJie的博客
05-20 604
多进程下的SharedPreferences情况 先启动主进程并获取SharedPreferences对象，然后对值进行修改，然后启动其他进程并获取SharedPreferences对象，能取得修改后的值，但此时如果再对此值进行修改，均不能对其他进程产生作用。 总结下来就是，其他进程在启动时获取到的SharedPreferences的值只能是这个进程启动前这个值的最后值，即在进程启
Android TV壁纸库之SharedPreferences 实现跨进程通信
hacker_crazy的专栏
03-22 404
一、SharedPreferences介绍：1.这里是官方文档地址。（这里是中文引导文档）2.它的实现例如官方文档给出如图：3.它的内容描述如图：【主要包括初始化、支持的键值对类型、存放和读取的方法】二、跨进程使用的方式：1.原理：SharedPreferences在使用的时候，会在当前应用的apk的路径为：/data/data/包名/shared_prefs/设置的文件名.xml如图为笔者所做项...
Android SharedPreference实例：登录密码记忆功能
总结，`SharedPreference` 是Android开发中处理本地数据存储的有效工具，通过合理的使用，可以在登录界面实现记住密码的功能，同时保证了数据的安全性和用户体验。但在实际应用中，还需结合项目需求和安全规范，选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值