How to pass the android dependent data from data-layer to presentation-layer

Hi all, I am currently learning about android-clean architecture.
Related to #64 , I am thinking about how to pass the Android-specific data (like bitmap) from data-layer to presentation-layer through domain-layer.

IMO, I have to answer for that.

1. Data-layer should only handle ID for the ImageView (like url or column for DB), and never hold android-specific data (like android.graphics.Bitmap). In that case, presentation-layer should have the role to fetch data from Web (like AutoLoadImageView in this project) or access data-layer directly.
2. Add another layer as a helper for domain-layer (domain-service) and handling flow of framework dependent data. Now it's ok to pass Bitmap from data-layer to presentation-layer through domain-service .

How do you think ?
And thank you for the great project !

[Trikke]

I was wondering why something like "android.graphics.Bitmap" would be considered as data? Is your app something like a photoshop-app where you manipulate pixels?

Number 2 is not something you should do. That "layer" makes no sense from an architectural standpoint. It's just something you made up to help you solve a problem you're having. You are having troubles with the restrictions put up by the architecture, this should mean that you should re-think what you are doing and how you are going to do it.
If you are creating a "Helper" class, you should always wonder if you are actually solving a problem, or if you are just circumventing symptoms.

Either way, usually stuff like a Bitmap isn't really the "data" of an app. Probably the actual data of an app is a Photo Entity, that has a property "localFileUri" or something. That property is used by the Presentation Layer to show the Bitmap.

@Trikke Thank you for your great answer !
My app isn't something like photoshop-app, so I shouldn't do that.
I misunderstood that data-layer should handle all data within my app, but now I understand it became too complicated and it's not the role for data-layer.

So, is it collect data which is not the entity and related to only UI (presentation-layer) should handle (including logic like fetch/IO) in presentation-layer ?

[Trikke]

Well, the Data Layer is about what data is important to the workings of your app. I doubt that you depend on "android.graphics.Bitmap" very heavily.

It is a though nut, because it all depends on your usage on how you implement this kind of problem. I'll go over a few situations. Remember that these are just silly examples to explain the reasoning behind everything.

Image you have an app with a list of Users that all have a small profile picture. You'll probably end up with a User Entity that has a "profilePicUrl" property. We store this Entity in the Data Layer. The image is of no importance of the app, so all we really need to access it, is the URL. That's the only "Data" we care about. If you show a User in your Presentation Layer, you want to show this picture! Because it is solely a UI feature, it is fine to have the IO logic here. You probably will use something like Picasso to fetch and render.

Now let's go deeper. Imagine your app lets your Users set the background image of the app, to make them feel special. Because this is just a dumb local feature, there's no network involved. The background image suddenly because important "Data" to your app. If a user selects a photo to use as background image, you must save it in the Data Layer, to disk for example. We don't care about "android.graphics.Bitmap", we can save the bytearray to a file! Now the User Entity has a property "BackgroundImageFileUri". In the Presentation Layer, you'll have to draw the background of your app. You'll check if that property of the current User is set, and do a fetch from disk, load a "android.graphics.Bitmap" from the bytearray and render it.

Even more, if you want your app to be pretty, you'll apply blue and fade filters to the background image. Because people select the ugliest things to be a background... You can either do matrix operations in the Domain Layer, or even better apply those filters in the Presentation Layer. Because it's just silly UI, and your Product Manager might come and ask you next week to make all the images red.

If there's questions, just ask.

@Trikke
Thanks for the great answer and interesting examples !!!
I see that Android-Clean architecture is based on DDD, and it's very important to think about what is entity and what is the role of my app.

In my case, the picture is only about user profile, and if I allow for user don't have to save their picture, it will become just an extra profile (not important data).

I learned that "android.graphics.Bitmap" is a data format special to Android-UI, so data-layer handle bytearray or url, and graphic data should be render to "Bitmap" in presentation-layer.

Thanks for your helpful answer!

[mohamad-amin]

@Trikke i've got a question.

"Because it's just silly UI, and your Product Manager might come and ask you next week to make all the images red"

Why this implies that this should be handled in presentation layer ?
My idea was that there should be some use case like GetFilteredImage that receives a color as input and applies the proper filter on the image and when the Product Manager asks for a change the you just change the implementation of the use case or maybe only the use case input and get the right result without presentation layer knowing anything about how filter is implemented.

What do you think about this?

Also i've got another question about onActivtyResult and other similar methods in Android.
Suppose that we want to pick an image from gallery or take picture from camera and then apply some cropping to it (both using intent with actions ACTION_PICK and ACTION_CROP) and then use the final bitmap.
How do you achieve this in a clean architecture approach?

I thought it would be nice if we had a PickImageFromGallery or ... use case that would completely do the work and the implementation would be isolated from the presentation layer because we could treat gallery and camera as two more data sources and use them along with some other things in our use cases and achieve the PickImageFromGallery use case but the onActivityResult breaks this chain, unless we use some event bus to publish onActivityResult events to data layer but this also breaks the dependency rule.
What's your (or any one else's) opinion?

Thanks.

[Albul]

Here how I have resolved this issue in my app:
I have category entity to which the user can set an icon. This icon could be from app's resources like R.drwable.some_image, or it could be loaded from sd, processed and stored to database as blob.
So every time I load categories from database I need to parse it to CatEntry and it should be passed to the Model and Presenter that are not Android aware.

So I've created IconEntry class that has not such dependencies:

/**
 * @param bytes of bitmap
 * @param resource an identifier of project assets
 * @param tintColor color of the icon, it is applied if only asset resource is used
 */
open class IconEntry protected constructor(
    val bytes: ByteArray?,
    val resource: String?,
    val tintColor: Int
) {
    constructor(bytes: ByteArray, tintColor: Int) : this(bytes, null, tintColor)

    constructor(resource: String, tintColor: Int) : this(null, resource, tintColor)

    open fun copy(bytes: ByteArray): IconEntry =
        IconEntry(bytes, this.tintColor)

    open fun copy(resource: String): IconEntry =
        IconEntry(resource, this.tintColor)

    open fun copy(tintColor: Int): IconEntry =
        IconEntry(this.bytes, this.resource, tintColor)

    val isFormBytes: Boolean = bytes != null

    val isFormResource: Boolean = resource != null
}

Then I have subclassed from it:

class CatIcon : IconEntry,
    Parcelable {

    private var drawable: BitmapDrawable? = null

    protected constructor(
        bytes: ByteArray?,
        resource: String?,
        tintColor: Int
    ) : super(bytes, resource, tintColor)

    override fun copy(bytes: ByteArray): CatIcon =
        CatIcon(bytes, this.tintColor)

    override fun copy(resource: String): CatIcon =
        CatIcon(null, resource, this.tintColor)

    override fun copy(tintColor: Int): CatIcon =
        CatIcon(this.bytes, this.resource, tintColor)

    constructor(bytes: ByteArray, tintColor: Int) : super(bytes, null, tintColor)

    constructor(resource: String, tintColor: Int) : super(null, resource, tintColor)

    private fun createBitmapDrawable(context: Context): BitmapDrawable? =
        when {
            !resource.isNullOrEmpty() -> {
                context.getDrw(context.resources.getIdentifier(resource, DRAWABLE_RES, this.packageName)), tintColor)
            }

            bytes != null -> {
                bytes.toBitmap().let { bmp ->
                    BitmapDrawable(context.resources, bmp).also {
                        if (shouldTintBitmap(bmp)) {
                            it.setTintCompat(tintColor)
                        }
                    }
                }
            }

            else -> null
        }.also {
            drawable = it
        }

    /**
     * Tint custom bitmap as well, if it has transparent pixels on corners
     */
    private fun shouldTintBitmap(bitmap: Bitmap): Boolean =
        bitmap.width > 0 &&
            bitmap.height > 0 &&
            bitmap.getPixel(0, 0).alpha == 0 &&
            bitmap.getPixel(bitmap.width - 1, 0).alpha == 0

    fun getDrawable(context: Context): BitmapDrawable? =
        drawable ?: createBitmapDrawable(context)

//--------------------------------------------------------------------------------------------------
//  Parcelable
//--------------------------------------------------------------------------------------------------

    constructor(parcel: Parcel) : super(
        parcel.createByteArray(),
        parcel.readString(),
        parcel.readInt()
    )

    override fun describeContents(): Int = 0

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        with(parcel) {
            writeByteArray(bytes)
            writeString(resource)
            writeInt(tintColor)
        }
    }

    companion object CREATOR : Parcelable.Creator<CatIcon> {

        override fun createFromParcel(parcel: Parcel): CatIcon =
            CatIcon(parcel)

        override fun newArray(size: Int): Array<CatIcon?> = arrayOfNulls(size)
    }
}

Now I could parse CatEntry inside repository:

fun CatEntry(cursor: Cursor): CatEntry = CatEntry()
    .apply {
        id = cursor.getInt(Category.ID_)
        name = cursor.getString(Category.NAME_)

        val color = cursor.getInt(Category.COLOR_)
        val iconRes: String? = cursor.getString(Category.ICON_RES_)
        icon = if (iconRes.isNullOrEmpty()) {
            val bytes: ByteArray? = cursor.getBlob(Category.ICON_BMP_)
            if (bytes != null && bytes.isNotEmpty()) {
                CatIcon(bytes, color)
            } else {
                CatIcon(CatEntry.ICON_RES_DEF, color)
            }
        } else {
            CatIcon(iconRes, color)
        }
....
}

Now CatEntry could be processed inside model and presenter, as it has no android dependencies.
When CatEntry is passed to some view for some output, we could use next extensions to retrieve Drawable based on android resources or bitmap data:

val CatEntry.catIcon: CatIcon?
    get() = this.icon as? CatIcon

fun CatEntry.getIconDrawable(context: Context): BitmapDrawable? =
    this.catIcon?.getDrawable(context)

// Somewhere in the view
fun displayCategory(cat: CatEntry): {
    textField.setText(cat.name)
    imageFiled.setImageDrawable(cat.getIconDrawable(context))
}

@takuaki