Android 具有内容提供者的领域

所以，我已经用了一段时间了。目前，我的任务是与其他应用程序共享登录数据

因为登录数据是使用领域存储的。我选择使用内容提供商

我发现了一个例子：

不幸的是，我无法让它工作。这是应用程序A中的我的内容提供商

static final String[] sColumns = new String[]{
        "LoginResultData"
};

public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection,
                    @Nullable String[] selectionArgs, @Nullable String sortOrder) {

    Realm mRealm = Realm.getDefaultInstance();

    RealmQuery<LoginResultData> query = mRealm.where(LoginResultData.class);
    LoginResultData result = query.findFirst();

    String json = new Gson().toJson(result);

    MatrixCursor matrixCursor = new MatrixCursor(sColumns);
    Object[] rowData = new Object[]{json};
    matrixCursor.addRow(rowData);

    return matrixCursor;
}

我不知道为什么，但当我使用SQlite时，它工作得很好。所以我假设Realm与内容提供商smh不能很好地协同工作。这是真的吗

如果没有，请向我展示一个将内容提供商与领域结合使用的示例

---

谢谢

内容提供程序与RealmDB配合良好

您所需要做的就是重写ContentProvider中的CRUD方法。请查看下面的内容提供商类。需要注意的三件事：

RealmDB在的onCreate（）方法中初始化 ContentProvider（不是应用程序活动）

您可以以适合RealmDB的方式重写CRUD方法（查询、插入、删除、更新）。检查以下样本

这就是你需要做的一切。在代码的其余部分中，您将使用本机组件，如recyclerview、adapter、Loader和services。在任何需要查询的地方，都可以使用getContentResolver.query（uri，null，null，null，null）调用它 TaskProvider.java

package com.example.rgher.realmtodo.data；
导入android.app.job.JobInfo；
导入android.app.job.JobScheduler；
导入android.content.ComponentName；
导入android.content.ContentProvider；
导入android.content.ContentUris；
导入android.content.ContentValues；
导入android.content.Context；
导入android.content.UriMatcher；
导入android.database.Cursor；
导入android.database.MatrixCursor；
导入android.net.Uri；
导入android.support.annotation.Nullable；
导入android.text.format.DateUtils；
导入android.util.Log；
导入io.realm.dynamicrelm；
导入io.realm.realm；
导入io.realm.RealmConfiguration；
导入io.realm.RealmMigration；
导入io.realm.RealmResults；
导入io.realm.RealmSchema；
导入com.example.rgher.realmtodo.data.DatabaseContract.TaskColumns；
公共类TaskProvider扩展了ContentProvider{
私有静态最终字符串标记=TaskProvider.class.getSimpleName（）；
私有静态最终整型清理作业ID=43；
私有静态最终整数任务=100；
私有静态final int TASKS_，_ID=101；
私有静态最终UriMatcher sUriMatcher=新UriMatcher（UriMatcher.NO_匹配）；
静止的{
// content://com.example.rgher.realmtodo/tasks
sUriMatcher.addURI（DatabaseContract.CONTENT\u权限，
DatabaseContract.TABLE_任务，
任务）；
// content://com.example.rgher.realmtodo/tasks/id
sUriMatcher.addURI（DatabaseContract.CONTENT\u权限，
DatabaseContract.TABLE_TASKS+“/#”，
任务（具有任务ID）；
}
@凌驾
公共布尔onCreate（）{
//重新初始化RealmDB
Realm.init（getContext（））；
RealmConfiguration config=newrealmconfiguration.Builder（）
.阴谋厌恶（1）
.migration（新的MyRealmMigration（））
.build（）；
Realm.setDefaultConfiguration（配置）；
manageCleanupJob（）；
返回true；
}
@可空
@凌驾
公共字符串getType（Uri）{
返回null；/*未使用*/
}
@可空
@凌驾
公共游标查询（Uri、字符串[]投影、字符串选择、字符串[]选择、字符串，
字符串排序器）{
int match=sUriMatcher.match（uri）；
//获取领域实例
Realm Realm=Realm.getDefaultInstance（）；
MatrixCursor myCursor=新MatrixCursor（新字符串[]{TaskColumns.\u ID，TaskColumns.DESCRIPTION
，TaskColumns.IS_完成，TaskColumns.IS_优先级
，TaskColumns.DUE\u日期
});
试一试{
开关（匹配）{
//预期的“查询所有”Uri：content://com.example.rgher.realmtodo/tasks
案例任务：
RealmResults tasksRealmResults=realm.where（RealmTask.class）.findAll（）；
对于（RealmTask myTask:tasksrelamresults）{
Object[]rowData=新对象[]{myTask.getTask_id（），myTask.getDescription（），myTask.getIs_complete（）
，myTask.getIs_priority（），myTask.getDue_date（）}；
myCursor.addRow（rowData）；
Log.v（“RealmDB”，myTask.toString（））；
}
打破
//预期的“查询一”Uri：content://com.example.rgher.realmtodo/tasks/{id}
具有\u ID的案例任务\u：
整数id=Integer.parseInt（uri.getPathSegments（）.get（1））；
RealmTask myTask=realm.where（RealmTask.class）.equalTo（“任务id”，id）.findFirst（）；
myCursor.addRow（新对象[]{myTask.getTask_id（），myTask.getDescription（），myTask.getIs_complete（），myTask.getIs_priority（），myTask.getDue_date（））；
Log.v（“RealmDB”，myTask.toString（））；
打破
违约：
抛出新的UnsupportedOperationException（“未知uri:+uri”）；
}
myCursor.setNotificationUri（getContext（）.getContentResolver（），uri）；
}最后{
realm.close（）；
}
返回myCursor；
}
@可空
@凌驾
公共Uri插入（Uri Uri，最终ContentValues ContentValues）{
//完成：预期Uri为：content://com.example.rgher.realmtodo/tasks
//最终SQLiteDatabase taskDb=mDbHelper.getReadableDatabase（）；
int match=sUriMatcher.match（uri）；
urireturnuri；
//获取领域实例
Realm Realm=Realm.getDefaultInstance（）；
试一试{
开关（匹配）{
案例任务：
realm.executeTransaction（新realm.Transaction（）{
@O
getContentResolver.query(uri, null, null, null, null);

package com.example.rgher.realmtodo.data;

import android.app.job.JobInfo;
import android.app.job.JobScheduler;
import android.content.ComponentName;
import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.support.annotation.Nullable;
import android.text.format.DateUtils;
import android.util.Log;

import io.realm.DynamicRealm;
import io.realm.Realm;
import io.realm.RealmConfiguration;
import io.realm.RealmMigration;
import io.realm.RealmResults;
import io.realm.RealmSchema;

import com.example.rgher.realmtodo.data.DatabaseContract.TaskColumns;

public class TaskProvider extends ContentProvider {
    private static final String TAG = TaskProvider.class.getSimpleName();

    private static final int CLEANUP_JOB_ID = 43;
    private static final int TASKS = 100;
    private static final int TASKS_WITH_ID = 101;

    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    static {
        // content://com.example.rgher.realmtodo/tasks
        sUriMatcher.addURI(DatabaseContract.CONTENT_AUTHORITY,
                DatabaseContract.TABLE_TASKS,
                TASKS);

        // content://com.example.rgher.realmtodo/tasks/id
        sUriMatcher.addURI(DatabaseContract.CONTENT_AUTHORITY,
                DatabaseContract.TABLE_TASKS + "/#",
                TASKS_WITH_ID);
    }

    @Override
    public boolean onCreate() {

        //Innitializing RealmDB
        Realm.init(getContext());
        RealmConfiguration config = new RealmConfiguration.Builder()
                .schemaVersion(1)
                .migration(new MyRealmMigration())
                .build();
        Realm.setDefaultConfiguration(config);

        manageCleanupJob();

        return true;
    }

    @Nullable
    @Override
    public String getType(Uri uri) {
        return null; /* Not used */
    }

    @Nullable
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
                        String sortOrder) {

        int match = sUriMatcher.match(uri);

        //Get Realm Instance
        Realm realm = Realm.getDefaultInstance();
        MatrixCursor myCursor = new MatrixCursor( new String[]{TaskColumns._ID, TaskColumns.DESCRIPTION
                , TaskColumns.IS_COMPLETE, TaskColumns.IS_PRIORITY
                , TaskColumns.DUE_DATE
        });

        try {
            switch (match) {
                //Expected "query all" Uri: content://com.example.rgher.realmtodo/tasks

                case TASKS:
                    RealmResults<RealmTask> tasksRealmResults = realm.where(RealmTask.class).findAll();
                    for (RealmTask myTask : tasksRealmResults) {
                        Object[] rowData = new Object[]{myTask.getTask_id(), myTask.getDescription(), myTask.getIs_complete()
                                , myTask.getIs_priority(), myTask.getDue_date()};
                        myCursor.addRow(rowData);
                        Log.v("RealmDB", myTask.toString());
                    }
                    break;

                //Expected "query one" Uri: content://com.example.rgher.realmtodo/tasks/{id}
                case TASKS_WITH_ID:
                    Integer id = Integer.parseInt(uri.getPathSegments().get(1));
                    RealmTask myTask = realm.where(RealmTask.class).equalTo("task_id", id).findFirst();
                    myCursor.addRow(new Object[]{myTask.getTask_id(), myTask.getDescription(), myTask.getIs_complete(), myTask.getIs_priority(), myTask.getDue_date()});
                    Log.v("RealmDB", myTask.toString());
                    break;
                default:
                    throw new UnsupportedOperationException("Unknown uri: " + uri);
            }


        myCursor.setNotificationUri(getContext().getContentResolver(), uri);
        } finally {
            realm.close();
        }
        return myCursor;

    }

    @Nullable
    @Override
    public Uri insert(Uri uri, final ContentValues contentValues) {
        //COMPLETE: Expected Uri: content://com.example.rgher.realmtodo/tasks

        //final SQLiteDatabase taskDb = mDbHelper.getReadableDatabase();
        int match = sUriMatcher.match(uri);
        Uri returnUri;

        //Get Realm Instance
        Realm realm = Realm.getDefaultInstance();
        try {
            switch (match) {
                case TASKS:
                    realm.executeTransaction(new Realm.Transaction() {
                        @Override
                        public void execute(Realm realm) {

                            Number currId = realm.where(RealmTask.class).max(TaskColumns._ID);
                            Integer nextId = (currId == null) ? 1 : currId.intValue() + 1;

                            RealmTask myNewTask = realm.createObject(RealmTask.class, nextId);
                            myNewTask.setDescription(contentValues.get(TaskColumns.DESCRIPTION).toString());
                            myNewTask.setIs_complete((Integer) contentValues.get(TaskColumns.IS_COMPLETE));
                            myNewTask.setIs_priority((Integer) contentValues.get(TaskColumns.IS_PRIORITY));
                            myNewTask.setDue_date((Long) contentValues.get(TaskColumns.DUE_DATE));
                        }
                    });
                    returnUri = ContentUris.withAppendedId(DatabaseContract.CONTENT_URI, '1');
                    break;

                default:
                    throw new UnsupportedOperationException("Unknown uri: " + uri);
            }

            getContext().getContentResolver().notifyChange(uri, null);
        }finally {
            realm.close();
        }
        return returnUri;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {

        //Expected Uri: content://com.example.rgher.realmtodo/tasks/{id}
        Realm realm = Realm.getDefaultInstance();

            int match = sUriMatcher.match(uri);
            int nrUpdated = 0;
        try {
            switch (match) {
                case TASKS_WITH_ID:
                    Integer id = Integer.parseInt(uri.getPathSegments().get(1));
                    RealmTask myTask = realm.where(RealmTask.class).equalTo("task_id", id).findFirst();
                    realm.beginTransaction();
                    myTask.setIs_complete(Integer.parseInt(values.get(TaskColumns.IS_COMPLETE).toString()));
                    if (values.get(TaskColumns.DUE_DATE) != null) {
                        myTask.setDue_date(Long.valueOf(values.get(TaskColumns.DUE_DATE).toString()));
                    }
                    nrUpdated++;
                    realm.commitTransaction();
                    break;
                default:
                    throw new UnsupportedOperationException("Unknown uri: " + uri);
            }


        } finally {
            realm.close();
        }

        if (nrUpdated != 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return nrUpdated;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int count = 0;
        Realm realm = Realm.getDefaultInstance();
        try {
            switch (sUriMatcher.match(uri)) {
                case TASKS:
                    selection = (selection == null) ? "1" : selection;
                    RealmResults<RealmTask> tasksRealmResults = realm.where(RealmTask.class).equalTo(selection, Integer.parseInt(selectionArgs[0])).findAll();
                    realm.beginTransaction();
                    tasksRealmResults.deleteAllFromRealm();
                    count++;
                    realm.commitTransaction();
                    break;
                case TASKS_WITH_ID:
                    Integer id = Integer.parseInt(String.valueOf(ContentUris.parseId(uri)));
                    RealmTask myTask = realm.where(RealmTask.class).equalTo("task_id", id).findFirst();
                    realm.beginTransaction();
                    myTask.deleteFromRealm();
                    count++;
                    realm.commitTransaction();
                    break;
                default:
                    throw new IllegalArgumentException("Illegal delete URI");
            }
        } finally {
            realm.close();
        }
        if (count > 0) {
            //Notify observers of the change
            getContext().getContentResolver().notifyChange(uri, null);
        }

        return count;
    }

}

// Example of REALM migration
class MyRealmMigration implements RealmMigration {
    @Override
    public void migrate(DynamicRealm realm, long oldVersion, long newVersion) {

        RealmSchema schema = realm.getSchema();

        if (oldVersion != 0) {
            schema.create(DatabaseContract.TABLE_TASKS)
                    .addField(DatabaseContract.TaskColumns._ID, Integer.class)
                    .addField(DatabaseContract.TaskColumns.DESCRIPTION, String.class)
                    .addField(DatabaseContract.TaskColumns.IS_COMPLETE, Integer.class)
                    .addField(DatabaseContract.TaskColumns.IS_PRIORITY, Integer.class);
            oldVersion++;
        }

    }
}