How can you reference path to resources in Android Studio?

Hi I am trying to load series of pictures to create animation in Android Studio. I managed to spot similar thread and i got to this stage:

fun loadPics(context: Context, path: String, iconList: MutableList<Bitmap>): MutableList<Bitmap>{
    val assetManager = context.assets
    try
    {
        var `is`: InputStream
        var files = assetManager.list(path)
        for(i in files!!.indices) {
            `is` = assetManager.open(path + files[i])
            val bitmap = BitmapFactory.decodeStream(`is`)
            iconList.add(i, bitmap)
        }
    }
    catch (e: IOException)
    {
        e.printStackTrace()
    }
    finally {
        return iconList
    }
}

My really basic question is how do I reference path? i tried right - clicking on resource and copying path / reference but assetManager always returns nothing..

Tried copying paths by righ clicking resource files
res/drawable/
res/
absolute path C:\Users..\AndroidStudioProjects\ImageViewer\app\src\main\res\drawable\

The only resources you can open as an InputStream are raw resources and assets. It won't work for resources in other directories like res/drawable.

You can put files in res/raw and then access them as an InputStream via context.resources.openRawResource() using their R.raw ID. The advantage with raw resources is that they can be organized by device and locale characteristics just like layout and string resources, so the system takes care of selecting the appropariate flavor of the file. e.g. you could have a res/raw/myFile.txt and res/raw-large/myFile.txt and it will give you the specialized file on large screen devices. Also, if you bundle your app for Google Play, the store can tailor the download for the device so raw files that will never be used on a specific device won't be included.

You can put files in src/main/assets (you might have to create this directory) and access them as an InputStream via context.resources.assets.open(). The advantage with assets is that you can organize them with subdirectories inside src/main/assets. You can list asset files using context.resources.assets.list().

Assets Example:

You have an image here: src/main/assets/picture.png.

@Throws(IOException::class)
fun Context.loadBitmapAsset(fileNameInAssets: String): Bitmap {
    val stream = assets.open(fileNameInAssets)
    return BitmapFactory.decodeStream(stream)
}

If you call loadBitmapAsset("picture.png") it will load your picture.png.

Or if you want to open all files in res/main/assets as images:

@Throws(IOException::class)
fun Context.loadAllAssetsAsBitmaps(): List<Bitmap> {
    return assets.list("") // we use empty string for the root directory in assets
        .map { BitmapFactory.decodeStream(assets.open(it)) }
}

Raw resource example:

You have an image here: src/main/res/raw/picture.png

@Throws(IOException::class)
fun Context.loadRawBitmap(@RawRes resId: Int): Bitmap {
    val stream = resources.openRawResource(resId)
    return BitmapFactory.decodeStream(stream)
}

If you call loadBitmapAsset(R.raw.picture) it will load your picture.png.

Or if you want to open all files in res/main/res/raw as images:

@Throws(IOException::class)
fun Context.loadAllRawResourcesAsBitmaps(): List<Bitmap> {
    val rawIds = R.raw::class.java.fields.map { it.int }
    return rawIds.map { BitmapFactory.decodeStream(resources.openRawResource(it)) }
}