Content Provider: vad det är, komponentens arkitektur och funktionsprincip

Vad är Content Provider?

Content Provider — är en Android-komponent som hanterar åtkomst till en centraliserad datalagring och tillhandahåller den till andra applikationer via ett enhetligt kontraktsgränssnitt. Den döljer implementeringsdetaljerna för lagring: data kan lagras i SQLite, på filsystemet, i molnet eller vara resultatet av en nätverksbegäran.

Android innehåller inbyggda Content Providers för systemdata — ContactsContract, MediaStore, CalendarContract, CallLog. Tredjepartsapplikationer kan också skapa egna leverantörer för säkert datautbyte. Varje leverantör registreras i AndroidManifest.xml med angivande av authority — en unik sträng som utgör den första delen av URI:n.

Hur Content Provider fungerar

Content Provider fungerar enligt klient-server-modellen. Leverantören agerar som en server som implementerar sex obligatoriska metoder: query, insert, update, delete, getType och onCreate. Klienten (en annan applikation) kommer åt leverantören via ContentResolver som vidarebefordrar anropen till leverantörens motsvarande metoder genom Android IPC-mekanism.

URI och authority

Varje Content Provider identifieras av en URI av schemat content://. Till exempel content://com.example.app.provider/items. Den första delen authority (com.example.app.provider) är bunden till leverantörens klass i manifestet. Sökvägen /items pekar på en tabell och /items/5 — på en specifik post med ID=5.

Anropsprocess

När en applikation anropar ContentResolver.query(URI), kontrollerar Android den anropande paketets behörigheter, hittar leverantören via authority och startar dess process om den inte redan är igång. Leverantören utför frågan och returnerar en Cursor — ett objekt som innehåller resultatet och låter klienten iterera genom poster.

Huvudmetoder för Content Provider

Klassen ContentProvider kräver implementering av sex abstrakta metoder. Varje metod tar emot en URI och returnerar ett resultat som motsvarar operationstypen. Systemet anropar dessa metoder från vilken process som helst, så de måste vara trådsäkra och inte blockera exekveringen under lång tid.

Metoden query

Metoden query tar emot en URI, en array av kolumner (projection), en selection-sträng med argument och sorteringsordning. Den returnerar en Cursor med data. I implementeringen måste URI:n tolkas med UriMatcher och motsvarande SQL-fråga utföras mot databasen.

Metoderna insert, update, delete

Dessa metoder ändrar data i lagringen. insert tar emot ContentValues — nyckel-värdepar — och returnerar URI:n för den nya posten. update och delete tar emot selection för att filtrera poster och returnerar antalet påverkade rader. Efter att ha ändrat data måste leverantören meddela detta via ContentResolver.notifyChange.

ContentResolver och URI i Android

ContentResolver — är en enhetlig åtkomstpunkt för att arbeta med alla Content Providers i systemet. Klientapplikationen anropar aldrig leverantörens metoder direkt — bara via ContentResolver, som Android får från kontexten. CRUD-operationer i ContentResolver har samma namn som hos leverantören men tar emot URI istället för direkta referenser.

UriMatcher

För tolkning av inkommande URI:er inuti leverantören används UriMatcher. Det gör det möjligt att matcha en URI till en numerisk kod — till exempel ger URI content://authority/items kod 1 och content://authority/items/# — kod 2. Detta eliminerar behovet av manuell tolkning av URI-strängen i varje metod.

// Använda ContentResolver för att komma åt kontakter
val uri = ContactsContract.Contacts.CONTENT_URI
val cursor = contentResolver.query(
    uri,
    arrayOf(ContactsContract.Contacts.DISPLAY_NAME),
    null, null, null
)
cursor?.use {
    while (it.moveToNext()) {
        val name = it.getString(it.getColumnIndexOrThrow(
            ContactsContract.Contacts.DISPLAY_NAME
        ))
        Log.d("Kontakter", "Namn: $name")
    }
}

Cursor måste stängas efter användning — i exemplet ovan gör use (Kotlin-tilläggsfunktionen) detta. Om Cursor inte stängs uppstår en minnesläcka eftersom den håller en referens till data i Binder-poolen. För UI-scenarier, använd CursorLoader eller Room med LiveData/Flow.

Exempel på Content Provider i Kotlin

Att skapa en egen Content Provider börjar med att ärva från klassen ContentProvider. Leverantören arbetar med SQLite-databasen via SQLiteOpenHelper och använder UriMatcher för att bestämma frågetypen. Låt oss titta på en minimal implementering för att hantera en anteckningslista.

Registrering i manifestet

Leverantören registreras i AndroidManifest.xml inuti application-taggen. Attributet authorities anger en unik identifierare och exported avgör om andra applikationer kan komma åt leverantören. Utan exported=true är leverantören endast tillgänglig inom din egen applikation.

// Exempel på Content Provider för anteckningar
class NotesProvider : ContentProvider() {

    companion object {
        const val AUTHORITY = "com.example.app.notes"
        const val NOTES_PATH = "notes"
        const val NOTES_URI = "content://$AUTHORITY/$NOTES_PATH"
        const val NOTES_ID = "content://$AUTHORITY/$NOTES_PATH/#"

        private val uriMatcher = UriMatcher(UriMatcher.NO_MATCH).apply {
            addURI(AUTHORITY, NOTES_PATH, 1)
            addURI(AUTHORITY, "$NOTES_PATH/#", 2)
        }
    }

    override fun query(uri: Uri, projection: Array<String>?,
        selection: String?, args: Array<String>?, sort: String?): Cursor? {
        return when (uriMatcher.match(uri)) {
            1 -> dbHelper.readableDatabase.query(TABLE_NOTES,
                projection, selection, args, null, null, sort)
            2 -> dbHelper.readableDatabase.query(TABLE_NOTES,
                projection, "_id=?", arrayOf(uri.lastPathSegment), null, null, null)
            else -> throw IllegalArgumentException("Unknown URI: $uri")
        }
    }

    override fun insert(uri: Uri, values: ContentValues?): Uri? {
        val id = dbHelper.writableDatabase.insert(TABLE_NOTES, null, values)
        context?.contentResolver?.notifyChange(uri, null)
        return ContentUris.withAppendedId(uri, id)
    }

    override fun delete(uri: Uri, selection: String?, args: Array<String>?): Int {
        val count = dbHelper.writableDatabase.delete(TABLE_NOTES, selection, args)
        context?.contentResolver?.notifyChange(uri, null)
        return count
    }

    // getType, update, onCreate utelämnade för korthetens skull
}

Efter att klassen skapats måste leverantören registreras i manifestet med attributen android:authorities och android:exported (true om leverantören är offentlig). Systemet skapar en instans av leverantören vid första åtkomst — detta sker i UI-tråden, så onCreate måste köras snabbt.

Skydda data genom behörigheter

Content Provider gör det möjligt att hantera åtkomst till data på två nivåer: läsbehörigheter och skrivbehörigheter. De anges i manifestet med attributen android:readPermission och android:writePermission. Om klientapplikationen inte har motsvarande behörighet kommer systemet att avvisa anropet med SecurityException.

Behörighet på URI-nivå

Android stöder tillfälliga behörigheter via flaggorna FLAG_GRANT_READ_URI_PERMISSION och FLAG_GRANT_WRITE_URI_PERMISSION. Detta är användbart när en applikation skickar URI:n för en fil till en annan applikation via Intent — mottagaren får endast åtkomst till den specifika URI:n under begränsad tid. Systemet återkallar den tillfälliga behörigheten efter att den mottagande applikationen slutförts.

För systemleverantörer kräver Android att specifika behörigheter anges i applikationsmanifestet. Till exempel för åtkomst till kontakter krävs READ_CONTACTS, för kalendern — READ_CALENDAR. Från och med Android 6 begärs dessa behörigheter under körning, inte vid installation.