创建数据库，封装ContentProvider供外界访问

最新推荐文章于 2022-12-29 14:21:05 发布
最新推荐文章于 2022-12-29 14:21:05 发布
阅读量268 收藏
点赞数
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tony_baopeng/article/details/82683241
版权

1、在AndroidManifast.xml添加

<provider android:name="com.hsae.userprofile.provide.UserProfileProvider"
            android:authorities="com.hsae.userprofile"
            android:exported="true"
            android:multiprocess="true"
            android:permission="com.hsae.userprofile.provide.UserProfileProvider"> <--  访问权限 -->
     </provider>

1、创建 UserProfileProvider 继承 ContentProvider

package com.userprofile.provide;
 
import android.content.ContentProvider;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteQueryBuilder;
import android.net.Uri;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
 
import java.util.HashMap;
 
public class UserProfileProvider extends ContentProvider {
 
    private final static String TAG = UserProfileProvider.class
            .getSimpleName();
 
    /**
     * 数据库名称
     */
    private final static String DB_NAME = "userprofile.db";
 
    /**
     * 存储默认账户信息的表
     */
    private final static String DB_TABLE_USER_DEFAULT = "userDefault";
 
    /**
     * 存储用户一信息的表
     */
    private final static String DB_TABLE_USER_ONE = "userDefaultOne";
    /**
     * 存储用户二信息的表
     */
    private final static String DB_TABLE_USER_TWO = "userDefaultTwo";
 
    /**
     * 数据库版本号
     */
    private final static int DB_VERSION = 1;
 

//数据库语法，创建默认账户
    private static final String DB_CREATE_DEFAULT = "create table if not exists " +
            DB_TABLE_USER_DEFAULT + " ("
            + UserProfileGlobal.ID + " integer primary key autoincrement, " + UserProfileGlobal.NAME
            + " text not null, " + UserProfileGlobal.VALUE + " text not null);";
 
    private static final String DB_CREATE_ONE = "create table if not exists " + DB_TABLE_USER_ONE
            + " ("
            + UserProfileGlobal.ID + " integer primary key autoincrement, " + UserProfileGlobal.NAME
            + " text not null, " + UserProfileGlobal.VALUE + " text not null);";
 
    private static final String DB_CREATE_TOW = "create table if not exists " + DB_TABLE_USER_TWO
            + " ("
            + UserProfileGlobal.ID + " integer primary key autoincrement, " + UserProfileGlobal.NAME
            + " text not null, " + UserProfileGlobal.VALUE + " text not null);";
 
    private DBHelper dbHelper = null;
    private ContentResolver resolver = null;
 
    /**
     * URI matcher used to recognize URIs sent by applications
     */

//初始化UriMatcher 用于匹配Uri
    private static final UriMatcher sURIMatcher = new UriMatcher(
            UriMatcher.NO_MATCH);
 

//注册需要的Uri:
    static {
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefault", UserProfileGlobal
                .ITEM_DEFAULT);
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefault/#", UserProfileGlobal
                .ITEM_DEFAULT_ID);
 
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefaultOne", UserProfileGlobal
                .ITEM_ONE);
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefaultOne/#", UserProfileGlobal
                .ITEM_ONE_ID);
 
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefaultTwo", UserProfileGlobal
                .ITEM_TWO);
        sURIMatcher.addURI(UserProfileGlobal.AUTHORITY, "userDefaultTwo/#", UserProfileGlobal
                .ITEM_TWO_ID);
    }
 
    private static final HashMap<String, String> HaseUserProfileProjectionMap;
 
    static {
        HaseUserProfileProjectionMap = new HashMap<String, String>();
        HaseUserProfileProjectionMap.put(UserProfileGlobal.ID, UserProfileGlobal.ID);
        HaseUserProfileProjectionMap.put(UserProfileGlobal.NAME, UserProfileGlobal.NAME);
        HaseUserProfileProjectionMap.put(UserProfileGlobal.VALUE, UserProfileGlobal.VALUE);
    }
 
    @Override
    public boolean onCreate() {
        Context context = getContext();
        resolver = context.getContentResolver();
        dbHelper = new DBHelper(context, DB_NAME, null, DB_VERSION);
 
        Log.i(TAG, "HaseSettings Provider Create");
 
        return true;
    }
 
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        if (!(sURIMatcher.match(uri) == UserProfileGlobal.ITEM_DEFAULT || sURIMatcher.match(uri)
                == UserProfileGlobal.ITEM_ONE || sURIMatcher.match(uri) == UserProfileGlobal
                .ITEM_TWO)) {
            throw new IllegalArgumentException("Error Uri: " + uri);
        }
 
        SQLiteDatabase db = dbHelper.getWritableDatabase();
      //与已经注册的Uri进行匹配:
        if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_DEFAULT) {
            long id = db.insert(DB_TABLE_USER_DEFAULT, UserProfileGlobal.ID, values);
            if (id < 0) {
                throw new SQLiteException("Unable to insert " + values + " for "
                        + uri);
            }
            String name = values.getAsString(UserProfileGlobal.NAME);
            Uri newUri = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_DEFAULT, name);
            resolver.notifyChange(newUri, null);
 
            return newUri;
        } else if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_ONE) {
            long id = db.insert(DB_TABLE_USER_ONE, UserProfileGlobal.ID, values);
            if (id < 0) {
                throw new SQLiteException("Unable to insert " + values + " for "
                        + uri);
            }
 
            String name = values.getAsString(UserProfileGlobal.NAME);
            Uri newUri = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_ONE, name);
            resolver.notifyChange(newUri, null);
 
            return newUri;
        } else if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_TWO) {
            long id = db.insert(DB_TABLE_USER_TWO, UserProfileGlobal.ID, values);
            if (id < 0) {
                throw new SQLiteException("Unable to insert " + values + " for "
                        + uri);
            }
 
            String name = values.getAsString(UserProfileGlobal.NAME);
            Uri newUri = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_TWO, name);
            resolver.notifyChange(newUri, null);
 
            return newUri;
        }
 
        return null;
 
 
    }
 
    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
                        String[] selectionArgs, String sortOrder) {
        Log.i(TAG, "HaseSettingsProvider.query: " + uri);
 
        SQLiteDatabase db = dbHelper.getReadableDatabase();
 
        SQLiteQueryBuilder sqlBuilder = new SQLiteQueryBuilder();
        String limit = null;
 
        switch (sURIMatcher.match(uri)) {
            case UserProfileGlobal.ITEM_DEFAULT: {
                sqlBuilder.setTables(DB_TABLE_USER_DEFAULT);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                break;
            }
            case UserProfileGlobal.ITEM_DEFAULT_ID: {
                String id = uri.getPathSegments().get(1);
                sqlBuilder.setTables(DB_TABLE_USER_DEFAULT);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                sqlBuilder.appendWhere(UserProfileGlobal.ID + "=" + id);
                break;
            }
            case UserProfileGlobal.ITEM_ONE: {
                sqlBuilder.setTables(DB_TABLE_USER_ONE);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                break;
            }
            case UserProfileGlobal.ITEM_ONE_ID: {
                String id = uri.getPathSegments().get(1);
                sqlBuilder.setTables(DB_TABLE_USER_ONE);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                sqlBuilder.appendWhere(UserProfileGlobal.ID + "=" + id);
                break;
            }
            case UserProfileGlobal.ITEM_TWO: {
                sqlBuilder.setTables(DB_TABLE_USER_TWO);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                break;
            }
            case UserProfileGlobal.ITEM_TWO_ID: {
                String id = uri.getPathSegments().get(1);
                sqlBuilder.setTables(DB_TABLE_USER_TWO);
                sqlBuilder.setProjectionMap(HaseUserProfileProjectionMap);
                sqlBuilder.appendWhere(UserProfileGlobal.ID + "=" + id);
                break;
            }
            default:
                throw new IllegalArgumentException("Error Uri: " + uri);
        }
 
        Cursor cursor = sqlBuilder.query(db, projection, selection,
                selectionArgs, null, null,
                TextUtils.isEmpty(sortOrder) ? UserProfileGlobal.DEFAULT_SORT_ORDER
                        : sortOrder, limit);
        cursor.setNotificationUri(resolver, uri);
 
        return cursor;
    }
 
    @Override
    public int update(Uri uri, ContentValues values, String selection,
                      String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int count = 0;
 
        switch (sURIMatcher.match(uri)) {
            case UserProfileGlobal.ITEM_DEFAULT: {
                count = db.update(DB_TABLE_USER_DEFAULT, values, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_DEFAULT_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.update(DB_TABLE_USER_DEFAULT, values, UserProfileGlobal.ID
                        + "="
                        + id
                        + (!TextUtils.isEmpty(selection) ? " and (" + selection
                        + ')' : ""), selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_ONE: {
                count = db.update(DB_TABLE_USER_ONE, values, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_ONE_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.update(DB_TABLE_USER_ONE, values, UserProfileGlobal.ID
                        + "="
                        + id
                        + (!TextUtils.isEmpty(selection) ? " and (" + selection
                        + ')' : ""), selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_TWO: {
                count = db.update(DB_TABLE_USER_TWO, values, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_TWO_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.update(DB_TABLE_USER_TWO, values, UserProfileGlobal.ID
                        + "="
                        + id
                        + (!TextUtils.isEmpty(selection) ? " and (" + selection
                        + ')' : ""), selectionArgs);
                break;
            }
            default:
                throw new IllegalArgumentException("Error Uri: " + uri);
        }
 
        String name = values.getAsString(UserProfileGlobal.NAME);
        if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_DEFAULT || sURIMatcher.match(uri) ==
                UserProfileGlobal.ITEM_DEFAULT_ID) {
            Uri uri_update = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_DEFAULT, name);
            resolver.notifyChange(uri_update, null);
        } else if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_ONE || sURIMatcher.match(uri)
                == UserProfileGlobal
                .ITEM_ONE_ID) {
            Uri uri_update = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_ONE, name);
            resolver.notifyChange(uri_update, null);
        } else if (sURIMatcher.match(uri) == UserProfileGlobal.ITEM_TWO || sURIMatcher.match(uri)
                == UserProfileGlobal
                .ITEM_TWO_ID) {
            Uri uri_update = Uri.withAppendedPath(UserProfileGlobal.CONTENT_URI_TWO, name);
            resolver.notifyChange(uri_update, null);
        }
        return count;
    }
 
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int count = 0;
 
        switch (sURIMatcher.match(uri)) {
            case UserProfileGlobal.ITEM_DEFAULT: {
                count = db.delete(DB_TABLE_USER_DEFAULT, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_DEFAULT_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.delete(DB_TABLE_USER_DEFAULT,
                        UserProfileGlobal.ID
                                + "="
                                + id
                                + (!TextUtils.isEmpty(selection) ? " and ("
                                + selection + ')' : ""), selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_ONE: {
                count = db.delete(DB_TABLE_USER_ONE, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_ONE_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.delete(DB_TABLE_USER_ONE,
                        UserProfileGlobal.ID
                                + "="
                                + id
                                + (!TextUtils.isEmpty(selection) ? " and ("
                                + selection + ')' : ""), selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_TWO: {
                count = db.delete(DB_TABLE_USER_TWO, selection, selectionArgs);
                break;
            }
            case UserProfileGlobal.ITEM_TWO_ID: {
                String id = uri.getPathSegments().get(1);
                count = db.delete(DB_TABLE_USER_TWO,
                        UserProfileGlobal.ID
                                + "="
                                + id
                                + (!TextUtils.isEmpty(selection) ? " and ("
                                + selection + ')' : ""), selectionArgs);
                break;
            }
            default:
                throw new IllegalArgumentException("Error Uri: " + uri);
        }
 
        resolver.notifyChange(uri, null);
 
        return count;
    }
 
    @Override
    public String getType(Uri uri) {
        switch (sURIMatcher.match(uri)) {
            case UserProfileGlobal.ITEM_DEFAULT:
                return UserProfileGlobal.CONTENT_TYPE;
            case UserProfileGlobal.ITEM_DEFAULT_ID:
                return UserProfileGlobal.CONTENT_ITEM_TYPE;
            case UserProfileGlobal.ITEM_ONE:
                return UserProfileGlobal.CONTENT_TYPE;
            case UserProfileGlobal.ITEM_ONE_ID:
                return UserProfileGlobal.CONTENT_ITEM_TYPE;
            case UserProfileGlobal.ITEM_TWO:
                return UserProfileGlobal.CONTENT_TYPE;
            case UserProfileGlobal.ITEM_TWO_ID:
                return UserProfileGlobal.CONTENT_ITEM_TYPE;
            default:
                throw new IllegalArgumentException("Error Uri: " + uri);
        }
    }
 
    @Override
    public Bundle call(String method, String name, Bundle extras) {
        Log.i(TAG, "HaseSettingsProvider.call: " + method);
 
        if (method.equals(UserProfileGlobal.METHOD_GET_VALUE)) {
            return getValue(name);
        } else if (method.equals(UserProfileGlobal.METHOD_PUT_VALUE)) {
            return putValue(name, extras);
        } else {
 
        }
 
        throw new IllegalArgumentException("Error method call: " + method);
    }
 
    /**
     * 获取设置值
     *
     * @param name
     * @return
     */
    private Bundle getValue(String name) {
        Cursor mCursor = query(UserProfileGlobal.getAccontUri(), new String[]{UserProfileGlobal.ID,
                        UserProfileGlobal.NAME, UserProfileGlobal.VALUE}, UserProfileGlobal.NAME
                        + " = ?",
                new String[]{name}, UserProfileGlobal.DEFAULT_SORT_ORDER);
        if (mCursor.getCount() > 0) {
            mCursor.moveToFirst();
            Bundle bundle = new Bundle();
            bundle.putCharSequence(UserProfileGlobal.VALUE,
                    mCursor.getString(mCursor.getColumnIndex(UserProfileGlobal.VALUE)));
            Log.i(TAG, "SettingProvide getValue name:" + name + ", value:" + bundle
                    .getCharSequence(UserProfileGlobal.VALUE));
            mCursor.close();
            return bundle;
        }
        mCursor.close();
        return null;
    }
 
    /**
     * 修改设置值
     *
     * @param name
     * @param extras
     * @return
     */
    private Bundle putValue(String name, Bundle extras) {
        Cursor mCursor = query(UserProfileGlobal.getAccontUri(), new String[]{UserProfileGlobal.ID,
                        UserProfileGlobal.NAME, UserProfileGlobal.VALUE}, UserProfileGlobal.NAME
                        + " = ?",
                new String[]{name}, UserProfileGlobal.DEFAULT_SORT_ORDER);
 
        ContentValues values = new ContentValues();
        values.put(UserProfileGlobal.NAME, name);
        values.put(UserProfileGlobal.VALUE, extras.getString(UserProfileGlobal.VALUE));
 
        Log.i(TAG, "SettingProvide putValue name:" + name + ", value:" + extras.getString
                (UserProfileGlobal.VALUE));
        if (mCursor.getCount() > 0) {
            mCursor.moveToFirst();
            String id = mCursor.getString(mCursor.getColumnIndex(UserProfileGlobal.ID));
            Uri uri = Uri.withAppendedPath(UserProfileGlobal.getAccontUri(), id);
            update(uri, values, null, null);
        } else {
            insert(UserProfileGlobal.getAccontUri(), values);
        }
        mCursor.close();
        return null;
    }
 
    private static class DBHelper extends SQLiteOpenHelper {
        public DBHelper(Context context, String name, CursorFactory factory,
                        int version) {
            super(context, name, factory, version);
        }
 
        @Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL(DB_CREATE_DEFAULT);
            db.execSQL(DB_CREATE_ONE);
            db.execSQL(DB_CREATE_TOW);
        }
 
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE_USER_DEFAULT);
            db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE_USER_ONE);
            db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE_USER_TWO);
            onCreate(db);
        }
    }
}

 

3、UserProfileGlobal 类

package com.userprofile.provide;

import android.net.Uri;

import com.hsae.autosdk.userprofile.UserProfileConst;

public class UserProfileGlobal {
    /* uri 主体 */
    public static final String AUTHORITY = "com.hsae.userprofile";
    /* 默认账户 */
    private static String accountDefault = "/userDefault";
    /* 账户1 */
    private static String accountOne = "/userDefaultOne";
    /* 账户2 */
    private static String accountTwo = "/userDefaultTwo";

    /**
     * 数据库列表，索引ID
     */
    public final static String ID = "_id";

    /**
     * 数据库列表，名称
     */
    public final static String NAME = "name";

    /**
     * 数据库列表，值
     */
    public final static String VALUE = UserProfileConst.VALUE;

    /* Match Code */
    public static final int ITEM_DEFAULT = 1;
    public static final int ITEM_DEFAULT_ID = 2;
    public static final int ITEM_ONE = 3;
    public static final int ITEM_ONE_ID = 4;
    public static final int ITEM_TWO = 5;
    public static final int ITEM_TWO_ID = 6;

    /* 默认账户Uri */
    public static final Uri CONTENT_URI_DEFAULT = UserProfileConst.CONTENT_URI_DEFAULT;
    /* 账户一Uri */
    public static final Uri CONTENT_URI_ONE = UserProfileConst.CONTENT_URI_ONE;
    /* 账户二Uri */
    public static final Uri CONTENT_URI_TWO = UserProfileConst.CONTENT_URI_TWO;

    /* Default sort order */
    public static final String DEFAULT_SORT_ORDER = "_id asc";

    /* Call Method */
    public static final String METHOD_GET_VALUE = UserProfileConst.METHOD_GET_VALUE;
    public static final String METHOD_PUT_VALUE = UserProfileConst.METHOD_PUT_VALUE;


    /* MIME */
    public static final String CONTENT_TYPE = "vnd.android.cursor.dir/com.hsae" +
            ".userprofile";
    public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/com.hsae" +
            ".userprofile";


    public static Uri getAccontUri() {
        return UserProfileConst.getAccontUri();
    }
}

4、创建 公共类 UserProfileConst ，可供其他app访问

package com.autosdk.userprofile;

import android.net.Uri;

public class UserProfileConst {
    /* userprofile 数据库 start */
    /* uri 主体 */
    private static final String AUTHORITY = "com.hsae.userprofile";
    /* 默认账户 */
    private static String accountDefault = "/userDefault";
    /* 账户1 */
    private static String accountOne = "/userDefaultOne";
    /* 账户2 */
    private static String accountTwo = "/userDefaultTwo";

    /* 默认账户Uri */
    public static final Uri CONTENT_URI_DEFAULT = Uri.parse("content://" + AUTHORITY
            + "/" + accountDefault);
    /* 账户一Uri */
    public static final Uri CONTENT_URI_ONE = Uri.parse("content://" + AUTHORITY
            + "/" + accountOne);
    /* 账户二Uri */
    public static final Uri CONTENT_URI_TWO = Uri.parse("content://" + AUTHORITY
            + "/" + accountTwo);

    /**
     * 数据库列表，值
     */
    public final static String VALUE = "value";
    /* Call Method */
    public static final String METHOD_GET_VALUE = "getValue";
    public static final String METHOD_PUT_VALUE = "putValue";

    public static Uri getAccontUri() {
        return CONTENT_URI_DEFAULT;
    }
    /* userprofile 数据库 end */

}

5、封装统一的调用接口UserProfile

package com.autosdk.userprofile;

import android.content.Context;
import android.os.Bundle;

public class UserProfile {
    private static String TAG = UserProfile.class.getSimpleName();

    private Context mContext;
    private static UserProfile mInstance;


    public static UserProfile getInstance(Context context) {
        if (mInstance == null) {
            synchronized (UserProfile.class) {
                if (mInstance == null) {
                    mInstance = new UserProfile(context);
                }
            }
        }
        return mInstance;
    }

    public UserProfile(Context context) {
        this.mContext = context;
    }

    /**
     * 存储数据
     *
     * @param key   参数key, 每一个key唯一value
     * @param value 参数value 需要存储的参数
     */
    public void saveValue(String key, Object value) {
        Bundle bundle = new Bundle();
        bundle.putCharSequence(UserProfileConst.VALUE, value + "");
        mContext.getContentResolver().call(UserProfileConst.getAccontUri(), UserProfileConst.METHOD_PUT_VALUE, key, bundle);
    }

    /**
     * 读取数据
     *
     * @param key 参数key, 每一个key唯一value
     * @param def 参数def 默认值
     */
    public String getStringValue(String key, String def) {
        Bundle bundle = mContext.getContentResolver().call(UserProfileConst.getAccontUri(), UserProfileConst.METHOD_GET_VALUE, key,
                null);
        if (bundle != null) {
            return bundle.getString(UserProfileConst.VALUE);
        }
        return def;
    }

    /**
     * 读取数据
     *
     * @param key 参数key, 每一个key唯一value
     * @param def 参数def 默认值
     */
    public boolean getBooleanValue(String key, boolean def) {
        Bundle bundle = mContext.getContentResolver().call(UserProfileConst.getAccontUri(), UserProfileConst.METHOD_GET_VALUE, key,
                null);
        if (bundle != null) {
            return bundle.getString(UserProfileConst.VALUE).equalsIgnoreCase("true") ? true : false;
        }
        return def;
    }

    /**
     * 读取数据
     *
     * @param key 参数key, 每一个key唯一value
     * @param def 参数def 默认值
     */
    public int getIntegerValue(String key, int def) {
        Bundle bd = mContext.getContentResolver().call(UserProfileConst.getAccontUri(),
                UserProfileConst.METHOD_GET_VALUE, key, null);
        if (bd != null) {
            return Integer.parseInt(bd.getString(UserProfileConst.VALUE));
        }
        return def;
    }

    /**
     * 读取数据
     *
     * @param key 参数key, 每一个key唯一value
     * @param def 参数def 默认值
     */
    public float getFloatValue(String key, float def) {
        Bundle bd = mContext.getContentResolver().call(UserProfileConst.getAccontUri(),
                UserProfileConst.METHOD_GET_VALUE, key, null);
        if (bd != null) {
            return Float.parseFloat(bd.getString(UserProfileConst.VALUE));
        }
        return def;
    }

    /**
     * 读取数据
     *
     * @param key 参数key, 每一个key唯一value
     * @param def 参数def 默认值
     */
    public double getDoubleValue(String key, double def) {
        Bundle bd = mContext.getContentResolver().call(UserProfileConst.getAccontUri(),
                UserProfileConst.METHOD_GET_VALUE, key, null);
        if (bd != null) {
            return Double.parseDouble(bd.getString(UserProfileConst.VALUE));
        }
        return def;
    }
}

6、调用方法：

UserProfile userProfile = UserProfile.getInstance(context);

userProfile.saveValue(keyValue, value );

userProfile.getBooleanValue(keyValue, defValue);

Tony_阿呆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ContentProvider封装SharedPreferences功能，解决跨进程存取值的问题
10-09
ContentProvider封装SharedPreferences功能，解决跨进程存取值的问题, 我之前一直用自己封装的SharePreferences,后来出现跨进程问题；就用这个 ContentProvider，真好用，值得拥有！
Android数据库ContentProvider封装原理
www.v5qq.com的技术博客
07-12 127
大家都知道Android数据库使用的是SQLite，但是Google为了给我们简化操作，可以不用经常编写容易出错的SQL语句，直接通过ContentProvider来封装数据的query查询、添加insert、删除delete和更新update，我们就以Android系统的SDK中的例子来给大家简单的说明下吧。 public class NotePadProvider extends C...
ContentProvider
时代我西的博客
10-13 258
ContentProvider 管理对结构化数据集的访问。它们封装数据，并提供用于定义数据安全性的机制。 内容提供程序是连接一个进程中的数据与另一个进程中运行的代码的标准界面。 ContentProvider 无法被用户感知，对于一个 ContentProvider 组件来说，它的内部需要实现增删该查这四种操作，它的内部维持着一份数据集合，这个数据集合既可以是数据库实现，也可以是其他任何类型，如 List 和 Map，内部的 insert、delete、update、query 方法需要处理好线程同步，因
Android ContentProvider一个标准的内容提供器的创建封装代码和使用例子
最新发布
yzwfeng的专栏
12-29 767
所以，对于content://com.example.app.provider/table1 这个内容URI,它所对应的MIME。而现在，我们需要对传入的Uri 参数进行。这就表示调用方期望访问的是com.example.app 这个应用的table1 表中的数据。UriMatcher 的match()方法判断出调用方期望访问的是哪张表，再对该表中的数据进行相应。现在，我们可以继续完善MyProvider 类中的内容，这次实现getType()方法的逻辑，代。那么前面所提到的，如何才能保证隐私数据不。
Android数据库ContentProvider封装原理.pdf
10-11
"Android数据库ContentProvider封装原理" Android操作系统中的数据库管理是通过ContentProvider来实现的，而ContentProvider是一个抽象类，提供了标准化的接口来访问和管理应用程序的数据。ContentProvider可以提供...
android 创建数据库contentprovider
11-10
总结，创建`android 创建数据库contentprovider`的关键在于理解ContentProvider的作用，正确配置并实现ContentProvider类，以及在需要的地方使用ContentResolver来访问数据。通过这种方式，可以安全、高效地实现...
contentprovider实现数据库访问
12-16
下面我们将深入探讨如何通过ContentProvider实现数据库的访问以及如何自定义组件来展示这些数据。 一、ContentProvider基础 1.1 创建ContentProvider 首先，我们需要创建一个继承自`android.content....
实验8 SQLite数据库与ContentProvider.doc
10-07
SQLite数据库与ContentProvider实验报告 随着移动设备的普及，移动应用程序的开发也变得越来越重要。在移动应用程序开发中，数据存储是非常重要的一部分，SQLite数据库是Android操作系统中常用的数据库管理系统。本...
ContentProvider的创建与访问 android
06-26
本篇文章将深入探讨ContentProvider的创建与访问过程，帮助你更好地理解和应用这一核心功能。 一、ContentProvider基础 1. **作用**：ContentProvider允许应用程序将自己的数据结构化，然后通过URI（统一资源...
ContentProvider实现数据库操作
11-01
本示例结合ContentProvider实现了数据库的增删改查操作 并且扩展性比较好
android uri db,Android ContentProvider封装数据库和文件读写总结
weixin_30413765的博客
05-28 258
本文是我各处东拼西凑加上自己实现一个ContentProvider的使用总结，留做后用，主要介绍ContentProvider的集成方法。一、综述ContentProvider是Android四大组件之一，其核心功能是提供应用间的统一的数据访问方式，当然也可以用于应用内的数据封装。ContentProvider类似C/S结构，应用A实现ContentProvider向外提供应用内的数据访问，应用B...
基础复习——内容共享——通过ContentProvider封装数据——通过ContentResolver访问数据...
小白龙白龙马的博客
08-21 936
利用ContentProvider只实现服务端App的数据封装，如果客户端App想访问对方的内部数据，就要通过内容解析器ContentResolver访问。 内容解析器是客户端App操作服务端数据的工具，相对应的内容提供器是服务端的数据接口。 ContentResolver提供的方法与ContentProvider是一一对应的，比如query、insert、update、delete、g...
【Android】19.3 ContentProvider及安卓进一步封装后的相关类
weixin_33909059的博客
03-08 109
分类：C#、Android、VS2015； 创建日期：2016-03-08 一、简介 ContentProvider：内容提供程序。 Android的ContentProvider与.NET框架的EF（Entity Framework）非常类似。在EF中，每个类表示数据库中的一个表，类中的每个属性对应表的字段，类的每个实例表示数据库表的一行记录。同样，在Android中，每个ContentProv...
如何创建一个ContentProvider，提供给其他App访问
weixin_30830327的博客
12-27 283
一、概述 内容提供者是封装一套给其他APP访问此APP数据的接口，并提供安全的权限机制，如何数据不用提供给其他应用访问的话，使用数据库就可以了，内容提供者更加强调的是需要跨应用。 二、编码思路 1、使用SQliteOpenHelper类，创建一个数据库。 2、写一个类继承ContentPrivoder实现抽象方法 3、定义一套访问的此ContentPrivo...
Android ContentProvider封装数据库和文件读写总结
u013478336的专栏
02-23 4403
本文是我各处东拼西凑加上自己实践的一个ContentProvider使用总结，留做后用，主要介绍ContentProvider的集成方法。 一、综述 ContentProvider是Android四大组件之一，其核心功能是提供应用间的统一的数据访问方式，当然也可以用于应用内的数据封装。ContentProvider类似C/S结构，应用A实现ContentProvider向外提供应用内的数据访问，应
[Android Pro] 内容提供者ContentProvider的基本使用
weixin_33859844的博客
07-23 297
一、ContentProvider简介当应用继承ContentProvider类，并重写该类用于提供数据和存储数据的方法，就可以向其他应用共享其数据。ContentProvider为存储和获取数据提供了统一的接口。虽然使用其他方法也可以对外共享数据，但数据访问方式会因数据存储的方式而不同，如采用文件方式对外共享数据，需要进行文件操作读写数据；采用sharedpreferenc...
数据存储之ContentProvide
FLY_THINK2012的博客
03-09 246
3、ContentProvider 数据在Android当中是私有的，当然这些数据包括文件数据和数据库数据以及一些其他类型的数据。ContentProvider实现多应用程序间的数据共享类 一般利用ContentProvider为需要共享的数据定义一个URI(统一资源定位符) 然后其他程序通过Context获得ContentResolver并将数据的URI传入即可 Android已...
Android SQLite数据库操作：ContentProvider与ContentResolver详解
"这篇文档主要介绍了SQLite数据库在Android中的使用，包括如何创建和操作数据库，以及如何通过ContentProvider和ContentResolver实现数据共享。" 在Android开发中，SQLite数据库是一个轻量级的数据库系统，用于存储...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值