expo-media-library 18.0.5 → 18.1.0

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 18.1.0 — 2025-09-08
+
+### 🎉 New features
+
+- Add MediaLibrary@Next. ([#38835](https://github.com/expo/expo/pull/38835) by [@Wenszel](https://github.com/wenszel))
+
+## 18.0.6 — 2025-09-02
+
+### 💡 Others
+
+- Change Constants to Constant/Property. ([#38926](https://github.com/expo/expo/pull/38926) by [@jakex7](https://github.com/jakex7))
+
 ## 18.0.5 — 2025-08-31
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '18.0.5'
+version = '18.1.0'
 
 android {
   namespace "expo.modules.medialibrary"
   defaultConfig {
     versionCode 37
-    versionName "18.0.5"
+    versionName "18.1.0"
   }
 }
 

package/android/src/main/java/expo/modules/medialibrary/MediaLibraryModule.kt

@@ -69,12 +69,16 @@ class MediaLibraryModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoMediaLibrary")
 
-    Constants {
-      return@Constants mapOf(
-        "MediaType" to MediaType.getConstants(),
-        "SortBy" to SortBy.getConstants(),
-        "CHANGE_LISTENER_NAME" to LIBRARY_DID_CHANGE_EVENT
-      )
+    Constant("MediaType") {
+      MediaType.getConstants()
+    }
+
+    Constant("SortBy") {
+      SortBy.getConstants()
+    }
+
+    Constant("CHANGE_LISTENER_NAME") {
+      LIBRARY_DID_CHANGE_EVENT
     }
 
     Events(LIBRARY_DID_CHANGE_EVENT)

package/android/src/main/java/expo/modules/medialibrary/next/MediaLibraryNextModule.kt

@@ -0,0 +1,187 @@
+package expo.modules.medialibrary.next
+
+import android.net.Uri
+import android.os.Build
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.apifeatures.EitherType
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.types.Either
+import expo.modules.kotlin.types.toKClass
+import expo.modules.medialibrary.next.objects.album.Album
+import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.album.factories.AlbumModernFactory
+import expo.modules.medialibrary.next.objects.album.factories.AlbumLegacyFactory
+import expo.modules.medialibrary.next.objects.asset.factories.AssetModernFactory
+import expo.modules.medialibrary.next.objects.asset.factories.AssetLegacyFactory
+import expo.modules.medialibrary.next.permissions.MediaStorePermissionsDelegate
+import expo.modules.medialibrary.next.permissions.SystemPermissionsDelegate
+import expo.modules.medialibrary.next.permissions.enums.GranularPermission
+
+class MediaLibraryNextModule : Module() {
+  private val context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  private val systemPermissionsDelegate by lazy {
+    SystemPermissionsDelegate(appContext)
+  }
+
+  private val mediaStorePermissionsDelegate by lazy {
+    MediaStorePermissionsDelegate(appContext)
+  }
+
+  private val albumFactory by lazy {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      AlbumModernFactory(assetFactory, context)
+    } else {
+      AlbumLegacyFactory(assetFactory, context)
+    }
+  }
+
+  private val assetFactory by lazy {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      AssetModernFactory(context)
+    } else {
+      AssetLegacyFactory(context)
+    }
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoMediaLibraryNext")
+
+    Class(Asset::class) {
+      Constructor { contentUri: Uri ->
+        Asset(contentUri, context)
+      }
+
+      Property("id") { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.contentUri
+      }
+
+      AsyncFunction("getCreationTime") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getCreationTime()
+      }
+
+      AsyncFunction("getDuration") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getDuration()
+      }
+
+      AsyncFunction("getFilename") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getFilename()
+      }
+
+      AsyncFunction("getHeight") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getHeight()
+      }
+
+      AsyncFunction("getMediaType") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getMediaType()
+      }
+
+      AsyncFunction("getModificationTime") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getModificationTime()
+      }
+
+      AsyncFunction("getUri") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getUri()
+      }
+
+      AsyncFunction("getWidth") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getWidth()
+      }
+
+      AsyncFunction("delete") Coroutine { self: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(true)
+        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(listOf(self.contentUri), needsDeletePermission = true)
+        self.delete()
+      }
+    }
+
+    Class(Album::class) {
+      Constructor { id: String ->
+        Album(id, context)
+      }
+
+      Property("id") { self: Album ->
+        self.id
+      }
+
+      AsyncFunction("getTitle") Coroutine { self: Album ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getTitle()
+      }
+
+      AsyncFunction("getAssets") Coroutine { self: Album ->
+        systemPermissionsDelegate.requireSystemPermissions(false)
+        self.getAssets()
+      }
+
+      AsyncFunction("add") Coroutine { self: Album, asset: Asset ->
+        systemPermissionsDelegate.requireSystemPermissions(true)
+        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(listOf(asset.contentUri))
+        self.add(asset)
+      }
+
+      AsyncFunction("delete") Coroutine { self: Album ->
+        systemPermissionsDelegate.requireSystemPermissions(true)
+        val assetIdsToDelete = self.getAssets().map { it.contentUri }
+        mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(assetIdsToDelete, needsDeletePermission = true)
+        self.delete()
+      }
+    }
+
+    AsyncFunction("createAsset") Coroutine { filePath: Uri, album: Album? ->
+      systemPermissionsDelegate.requireSystemPermissions(true)
+      return@Coroutine assetFactory.create(filePath, album?.getRelativePath())
+    }
+
+    @OptIn(EitherType::class)
+    AsyncFunction("createAlbum") Coroutine { name: String, assetRefs: Either<List<Asset>, List<Uri>>, move: Boolean ->
+      systemPermissionsDelegate.requireSystemPermissions(true)
+      val assetListKClass = toKClass<List<Asset>>()
+      if (assetRefs.`is`(assetListKClass)) {
+        val assetList = assetRefs.get(assetListKClass)
+        return@Coroutine albumFactory.createFromAssets(name, assetList, move)
+      }
+      val assetPaths = assetRefs.get(toKClass<List<Uri>>())
+      return@Coroutine albumFactory.createFromFilePaths(name, assetPaths)
+    }
+
+    AsyncFunction("deleteAlbums") Coroutine { albums: List<Album> ->
+      systemPermissionsDelegate.requireSystemPermissions(true)
+      albums.forEach { album -> album.delete() }
+    }
+
+    AsyncFunction("deleteAssets") Coroutine { assets: List<Asset> ->
+      systemPermissionsDelegate.requireSystemPermissions(true)
+      val assetIdsToDelete = assets.map { it.contentUri }
+      mediaStorePermissionsDelegate.requestMediaLibraryActionPermission(assetIdsToDelete, needsDeletePermission = true)
+      assets.forEach { asset -> asset.delete() }
+    }
+
+    AsyncFunction("requestPermissionsAsync") { writeOnly: Boolean, permissions: List<GranularPermission>?, promise: Promise ->
+      systemPermissionsDelegate.requestPermissions(writeOnly, permissions, promise)
+    }
+
+    AsyncFunction("getPermissionsAsync") { writeOnly: Boolean, permissions: List<GranularPermission>?, promise: Promise ->
+      systemPermissionsDelegate.getPermissions(writeOnly, permissions, promise)
+    }
+
+    RegisterActivityContracts {
+      with(mediaStorePermissionsDelegate) {
+        registerMediaStoreContracts(this@MediaLibraryNextModule)
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/medialibrary/next/exceptions/AlbumExceptions.kt

@@ -0,0 +1,15 @@
+package expo.modules.medialibrary.next.exceptions
+
+import expo.modules.kotlin.exception.CodedException
+
+class AlbumNotFoundException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class AlbumAlreadyExistsException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class AlbumPropertyNotFoundException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class AlbumCouldNotBeCreated(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)

package/android/src/main/java/expo/modules/medialibrary/next/exceptions/AssetExceptions.kt

@@ -0,0 +1,21 @@
+package expo.modules.medialibrary.next.exceptions
+
+import expo.modules.kotlin.exception.CodedException
+
+class PermissionsException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class UnableToSaveException(message: String) :
+  CodedException(message)
+
+class AssetNotFoundException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class AssetPropertyNotFoundException(propertyName: String, cause: Throwable? = null) :
+  CodedException("$propertyName not found. The asset may have been deleted or is no longer accessible.", cause)
+
+class AssetCouldNotBeCreated(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)
+
+class AssetInitializationException(message: String, cause: Throwable? = null) :
+  CodedException(message, cause)

package/android/src/main/java/expo/modules/medialibrary/next/exceptions/ContentResolverExceptions.kt

@@ -0,0 +1,6 @@
+package expo.modules.medialibrary.next.exceptions
+
+import expo.modules.kotlin.exception.CodedException
+
+class ContentResolverNotObtainedException(cause: Throwable? = null) :
+  CodedException("Could not obtain the content resolver", cause)

package/android/src/main/java/expo/modules/medialibrary/next/exceptions/PermissionExceptions.kt

@@ -0,0 +1,6 @@
+package expo.modules.medialibrary.next.exceptions
+
+import expo.modules.kotlin.exception.CodedException
+
+class PermissionException(message: String) :
+  CodedException(message)

package/android/src/main/java/expo/modules/medialibrary/next/extensions/CursorExtensions.kt

@@ -0,0 +1,28 @@
+package expo.modules.medialibrary.next.extensions
+
+import android.database.Cursor
+
+fun Cursor.asIterable(): Iterable<Cursor> {
+  return object : Iterable<Cursor> {
+    override fun iterator(): Iterator<Cursor> = object : Iterator<Cursor> {
+      private var hasNextCalled = false
+      private var hasNextCache = false
+
+      override fun hasNext(): Boolean {
+        if (!hasNextCalled) {
+          hasNextCache = moveToNext()
+          hasNextCalled = true
+        }
+        return hasNextCache
+      }
+
+      override fun next(): Cursor {
+        if (!hasNextCalled) {
+          if (!moveToNext()) throw NoSuchElementException()
+        }
+        hasNextCalled = false
+        return this@asIterable
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/FileExtensions.kt

@@ -0,0 +1,41 @@
+package expo.modules.medialibrary.next.extensions
+
+import expo.modules.medialibrary.MediaLibraryUtils.getFileNameAndExtension
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+
+fun File.safeMove(destinationDirectory: File): File =
+  safeCopy(destinationDirectory).also {
+    delete()
+  }
+
+fun File.safeCopy(destinationDirectory: File): File {
+  val newFile = createUniqueFileIn(destinationDirectory, name)
+  FileInputStream(this).channel.use { input ->
+    FileOutputStream(newFile).channel.use { output ->
+      val transferred = input.transferTo(0, input.size(), output)
+      if (transferred != input.size()) {
+        newFile.delete()
+        throw IOException("Could not save file to $destinationDirectory Not enough space.")
+      }
+      return newFile
+    }
+  }
+}
+
+private fun createUniqueFileIn(directory: File, newFileName: String): File {
+  var newFile = File(directory, newFileName)
+  var suffix = 2
+  val (filename, extension) = getFileNameAndExtension(newFileName)
+  val suffixLimit = Short.MAX_VALUE.toInt()
+  while (newFile.exists()) {
+    newFile = File(directory, filename + "_" + suffix + extension)
+    suffix++
+    if (suffix > suffixLimit) {
+      throw IOException("File name suffix limit reached ($suffixLimit)")
+    }
+  }
+  return newFile
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/WeakReferenceExtensions.kt

@@ -0,0 +1,9 @@
+package expo.modules.medialibrary.next.extensions
+
+import android.content.Context
+import expo.modules.kotlin.exception.Exceptions
+import java.lang.ref.WeakReference
+
+fun WeakReference<Context>.getOrThrow(): Context {
+  return get() ?: throw Exceptions.ReactContextLost()
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/AlbumExtensions.kt

@@ -0,0 +1,68 @@
+package expo.modules.medialibrary.next.extensions.resolver
+
+import android.content.ContentResolver
+import android.database.Cursor
+import android.net.Uri
+import android.provider.MediaStore
+import expo.modules.medialibrary.next.extensions.asIterable
+import expo.modules.medialibrary.next.objects.wrappers.RelativePath
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+
+val EXTERNAL_CONTENT_URI: Uri = MediaStore.Files.getContentUri("external")
+
+suspend fun ContentResolver.queryAlbumTitle(bucketId: String): String? =
+  queryOne(
+    EXTERNAL_CONTENT_URI,
+    MediaStore.MediaColumns.BUCKET_DISPLAY_NAME,
+    Cursor::getString,
+    "${MediaStore.MediaColumns.BUCKET_ID} = ?",
+    arrayOf(bucketId)
+  )
+
+suspend fun ContentResolver.queryAlbumRelativePath(bucketId: String): RelativePath? =
+  queryOne(
+    EXTERNAL_CONTENT_URI,
+    MediaStore.MediaColumns.RELATIVE_PATH,
+    { index -> RelativePath(getString(index)) },
+    "${MediaStore.MediaColumns.BUCKET_ID} = ?",
+    arrayOf(bucketId)
+  )
+
+suspend fun ContentResolver.queryAlbumFilepath(bucketId: String): String? =
+  queryOne(
+    EXTERNAL_CONTENT_URI,
+    MediaStore.MediaColumns.DATA,
+    Cursor::getString,
+    "${MediaStore.Files.FileColumns.BUCKET_ID} = ?",
+    arrayOf(bucketId)
+  )
+
+suspend fun ContentResolver.queryAlbumId(relativePath: RelativePath): String? =
+  queryOne(
+    EXTERNAL_CONTENT_URI,
+    MediaStore.Files.FileColumns.BUCKET_ID,
+    Cursor::getString,
+    "${MediaStore.Files.FileColumns.RELATIVE_PATH} = ?",
+    arrayOf(relativePath.value)
+  )
+
+suspend fun ContentResolver.queryAlbumAssetsContentUris(bucketId: String): List<Uri> =
+  withContext(Dispatchers.IO) {
+    val projection = arrayOf(
+      MediaStore.Files.FileColumns._ID,
+      MediaStore.Files.FileColumns.MEDIA_TYPE
+    )
+    val selection = "${MediaStore.Files.FileColumns.BUCKET_ID} = ?"
+
+    query(EXTERNAL_CONTENT_URI, projection, selection, arrayOf(bucketId), null)?.use { cursor ->
+      ensureActive()
+      val idColumn = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID)
+      val typeColumn = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MEDIA_TYPE)
+      cursor
+        .asIterable()
+        .map { it.extractAssetContentUri(idColumn, typeColumn) }
+        .toList()
+    } ?: emptyList()
+  }

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/AssetExtensions.kt

@@ -0,0 +1,89 @@
+package expo.modules.medialibrary.next.extensions.resolver
+
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.provider.MediaStore
+import androidx.annotation.RequiresApi
+import expo.modules.medialibrary.EXTERNAL_CONTENT_URI
+import expo.modules.medialibrary.next.exceptions.AssetCouldNotBeCreated
+import expo.modules.medialibrary.next.objects.wrappers.RelativePath
+import expo.modules.medialibrary.next.objects.wrappers.MimeType
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend fun ContentResolver.queryAssetDisplayName(contentUri: Uri): String? =
+  queryOne(contentUri, MediaStore.MediaColumns.DISPLAY_NAME, Cursor::getString)
+
+suspend fun ContentResolver.queryGetCreationTime(contentUri: Uri): Long? =
+  queryOne(contentUri, MediaStore.Images.Media.DATE_TAKEN, Cursor::getLong)
+
+suspend fun ContentResolver.queryAssetModificationTime(contentUri: Uri): Long? =
+  queryOne(contentUri, MediaStore.Images.Media.DATE_MODIFIED, Cursor::getLong)
+
+suspend fun ContentResolver.queryAssetDuration(contentUri: Uri): Long? =
+  queryOne(contentUri, MediaStore.Video.VideoColumns.DURATION, Cursor::getLong)
+
+suspend fun ContentResolver.queryAssetWidth(contentUri: Uri): Int? =
+  queryOne(contentUri, MediaStore.Images.Media.WIDTH, Cursor::getInt)
+
+suspend fun ContentResolver.queryAssetHeight(contentUri: Uri): Int? =
+  queryOne(contentUri, MediaStore.Images.Media.HEIGHT, Cursor::getInt)
+
+suspend fun ContentResolver.queryAssetPath(contentUri: Uri): String? =
+  queryOne(contentUri, MediaStore.Files.FileColumns.DATA, Cursor::getString)
+
+suspend fun ContentResolver.queryAssetBucketId(contentUri: Uri): Int? =
+  queryOne(contentUri, MediaStore.Images.Media.BUCKET_ID, Cursor::getInt)
+
+suspend fun ContentResolver.insertPendingAsset(
+  displayName: String,
+  mimeType: MimeType,
+  relativePath: RelativePath
+): Uri = withContext(Dispatchers.IO) {
+  val contentValues = ContentValues().apply {
+    put(MediaStore.MediaColumns.DISPLAY_NAME, displayName)
+    put(MediaStore.MediaColumns.MIME_TYPE, mimeType.value)
+    put(MediaStore.MediaColumns.RELATIVE_PATH, relativePath.value)
+    put(MediaStore.MediaColumns.IS_PENDING, 1)
+  }
+  val collectionUri = mimeType.mediaCollectionUri()
+  return@withContext insert(collectionUri, contentValues)
+    ?: throw AssetCouldNotBeCreated("Failed to create asset: contentResolver.insert() returned null.")
+}
+
+@RequiresApi(Build.VERSION_CODES.Q)
+fun ContentResolver.publishPendingAsset(uri: Uri) {
+  val contentValues = ContentValues().apply {
+    put(MediaStore.MediaColumns.IS_PENDING, 0)
+  }
+  safeUpdate(uri, contentValues)
+}
+
+fun ContentResolver.safeUpdate(
+  uri: Uri,
+  values: ContentValues
+): Int {
+  return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+    update(uri, values, null)
+  } else {
+    update(uri, values, null, null)
+  }
+}
+
+fun ContentResolver.updateRelativePath(contentUri: Uri, newRelativePath: RelativePath) {
+  val contentValues = ContentValues().apply {
+    put(MediaStore.MediaColumns.RELATIVE_PATH, newRelativePath.value)
+  }
+  update(contentUri, contentValues, null, null)
+}
+
+fun ContentResolver.deleteBy(assetPath: String) {
+  delete(
+    EXTERNAL_CONTENT_URI,
+    "${MediaStore.MediaColumns.DATA}=?",
+    arrayOf(assetPath)
+  )
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/CursorExtensions.kt

@@ -0,0 +1,18 @@
+package expo.modules.medialibrary.next.extensions.resolver
+
+import android.content.ContentUris
+import android.database.Cursor
+import android.net.Uri
+import android.provider.MediaStore
+
+fun Cursor.extractAssetContentUri(idColumn: Int, typeColumn: Int): Uri {
+  val id = getLong(idColumn)
+  val mediaType = getInt(typeColumn)
+  val baseUri = when (mediaType) {
+    MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+    MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+    MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+    else -> EXTERNAL_CONTENT_URI
+  }
+  return ContentUris.withAppendedId(baseUri, id)
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/QueryOne.kt

@@ -0,0 +1,29 @@
+package expo.modules.medialibrary.next.extensions.resolver
+
+import android.content.ContentResolver
+import android.database.Cursor
+import android.net.Uri
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+
+suspend fun <T> ContentResolver.queryOne(
+  contentUri: Uri,
+  column: String,
+  extractor: Cursor.(index: Int) -> T,
+  selection: String? = null,
+  selectionArgs: Array<String>? = null,
+  sortOrder: String? = null
+): T? = withContext(Dispatchers.IO) {
+  val projection = arrayOf(column)
+  query(contentUri, projection, selection, selectionArgs, sortOrder)?.use { cursor ->
+    ensureActive()
+    val index = cursor.getColumnIndexOrThrow(column)
+    return@withContext if (cursor.moveToFirst()) {
+      extractor(cursor, index)
+    } else {
+      null
+    }
+  }
+  return@withContext null
+}

package/android/src/main/java/expo/modules/medialibrary/next/extensions/resolver/TransferExtensions.kt

@@ -0,0 +1,15 @@
+package expo.modules.medialibrary.next.extensions.resolver
+
+import android.content.ContentResolver
+import android.net.Uri
+import kotlin.io.copyTo
+
+fun ContentResolver.copyUriContent(from: Uri, to: Uri) {
+  openInputStream(from).use { input ->
+    openOutputStream(to).use { output ->
+      if (input != null && output != null) {
+        input.copyTo(output)
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/medialibrary/next/objects/album/Album.kt

@@ -0,0 +1,71 @@
+package expo.modules.medialibrary.next.objects.album
+
+import android.content.Context
+import android.os.Build
+import android.os.Environment
+import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.medialibrary.next.exceptions.AlbumPropertyNotFoundException
+import expo.modules.medialibrary.next.exceptions.ContentResolverNotObtainedException
+import expo.modules.medialibrary.next.extensions.getOrThrow
+import expo.modules.medialibrary.next.extensions.resolver.queryAlbumAssetsContentUris
+import expo.modules.medialibrary.next.extensions.resolver.queryAlbumFilepath
+import expo.modules.medialibrary.next.extensions.resolver.queryAlbumRelativePath
+import expo.modules.medialibrary.next.extensions.resolver.queryAlbumTitle
+import expo.modules.medialibrary.next.objects.asset.Asset
+import expo.modules.medialibrary.next.objects.wrappers.RelativePath
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import java.io.File
+import java.lang.ref.WeakReference
+
+class Album(val id: String, context: Context) : SharedObject() {
+  private val contextRef = WeakReference(context)
+
+  private val contentResolver
+    get() = contextRef
+      .getOrThrow()
+      .contentResolver ?: throw ContentResolverNotObtainedException()
+
+  suspend fun getTitle(): String {
+    return contentResolver.queryAlbumTitle(id)
+      ?: throw AlbumPropertyNotFoundException("Album with ID=$id does not exist in MediaStore")
+  }
+
+  suspend fun getRelativePath(): RelativePath {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      contentResolver.queryAlbumRelativePath(id)
+        ?: throw AlbumPropertyNotFoundException("Album with ID=$id does not exist in MediaStore")
+    } else {
+      val filePath = contentResolver.queryAlbumFilepath(id)
+        ?: throw AlbumPropertyNotFoundException("Album with ID=$id does not exist in MediaStore")
+      createRelativePathFrom(filePath)
+    }
+  }
+
+  private fun createRelativePathFrom(filePath: String): RelativePath {
+    val albumDir = File(filePath).parent
+      ?: throw AlbumPropertyNotFoundException("Could get a relative path for the album")
+    val externalRoot = Environment.getExternalStorageDirectory().absolutePath
+    val relative = albumDir.removePrefix(externalRoot).trimStart('/').plus('/')
+    return RelativePath(relative)
+  }
+
+  suspend fun getAssets(): List<Asset> {
+    return contentResolver
+      .queryAlbumAssetsContentUris(id)
+      .map { contentUri -> Asset(contentUri, contextRef.getOrThrow()) }
+  }
+
+  suspend fun delete() = coroutineScope {
+    getAssets().map { asset ->
+      async {
+        asset.delete()
+      }
+    }.awaitAll()
+  }
+
+  suspend fun add(asset: Asset) {
+    asset.move(getRelativePath())
+  }
+}