Java AbstractCursor类代码示例

import android.database.AbstractCursor; //导入依赖的package包/类
@SuppressLint("NewApi")
@Nullable
@Override
public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
    String path = uri.getEncodedPath();
    if (!path.startsWith("/font/")
            || selectionArgs == null ||  selectionArgs[0] == null) {
        return null;
    }

    String name = path.substring("/font/".length());
    String[] w = selectionArgs[0].split(",");
    int[] weight = new int[w.length];
    for (int i = 0; i < w.length; i++) {
        weight[i] = Integer.parseInt(w[i]);
    }

    FontFamily[] families = FontManager.getFontFamily(getContext(), name, weight);

    Bundle bundle = new Bundle();
    bundle.putParcelableArray("data", families);

    AbstractCursor cursor = new SimpleCursor();
    cursor.setExtras(bundle);
    return cursor;
}
 

import android.database.AbstractCursor; //导入依赖的package包/类
public static SubjectFactory<AbstractCursor_Subject, AbstractCursor> type() {
  return new SubjectFactory<AbstractCursor_Subject, AbstractCursor>() {
    @Override
    public AbstractCursor_Subject getSubject(FailureStrategy fs, AbstractCursor that) {
      return new AbstractCursor_Subject(fs, that);
    }
  };
}
 

import android.database.AbstractCursor; //导入依赖的package包/类
private Loader getInstanceUncheckedLocked(String documentId)
        throws FileNotFoundException {
    try {
        final ParsedDocumentId id = ParsedDocumentId.fromDocumentId(documentId, mIdDelimiter);
        if (mArchives.get(id.mArchiveId) != null) {
            return mArchives.get(id.mArchiveId);
        }

        final Cursor cursor = mProvider.queryDocument(id.mArchiveId, new String[]
                { Document.COLUMN_MIME_TYPE, COLUMN_LOCAL_FILE_PATH });
        cursor.moveToFirst();
        final String mimeType = cursor.getString(cursor.getColumnIndex(
                Document.COLUMN_MIME_TYPE));
        Preconditions.checkArgument(isSupportedArchiveType(mimeType),
                "Unsupported archive type.");
        final int columnIndex = cursor.getColumnIndex(COLUMN_LOCAL_FILE_PATH);
        final String localFilePath = columnIndex != -1 ? cursor.getString(columnIndex) : null;
        final File localFile = localFilePath != null ? new File(localFilePath) : null;

        final Uri notificationUri = ((AbstractCursor)cursor).getNotificationUri();
        final Loader loader = new Loader(mProvider, localFile, id, mIdDelimiter,
                notificationUri);

        // Remove the instance from mArchives collection once the archive file changes.
        if (notificationUri != null) {
            final LruCache<String, Loader> finalArchives = mArchives;
            mProvider.getContext().getContentResolver().registerContentObserver(notificationUri,
                    false,
                    new ContentObserver(null) {
                        @Override
                        public void onChange(boolean selfChange, Uri uri) {
                            synchronized (mArchives) {
                                final Loader currentLoader = mArchives.get(id.mArchiveId);
                                if (currentLoader == loader) {
                                    mArchives.remove(id.mArchiveId);
                                }
                            }
                        }
                    });
        }

        mArchives.put(id.mArchiveId, loader);
        return loader;
    } catch (IOException e) {
        // DocumentsProvider doesn't use IOException. For consistency convert it to
        // IllegalStateException.
        throw new IllegalStateException(e);
    }
}
 

import android.database.AbstractCursor; //导入依赖的package包/类
protected AbstractCursor_Subject(FailureStrategy failureStrategy, AbstractCursor subject) {
  super(failureStrategy, subject);
}
 

import android.database.AbstractCursor; //导入依赖的package包/类
public AbstractCursor_Assert(AbstractCursor actual) {
  super(actual, AbstractCursor_Assert.class);
}