src/com/android/quicksearchbox/CachingIconLoader.kt

/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.quicksearchbox

import android.graphics.drawable.Drawable
import android.net.Uri
import android.text.TextUtils
import android.util.Log
import com.android.quicksearchbox.util.*
import java.util.WeakHashMap

/** Icon loader that caches the results of another icon loader. */
class CachingIconLoader(private val mWrapped: IconLoader) : IconLoader {
  private val mIconCache: WeakHashMap<String, Entry>
  override fun getIcon(drawableId: String?): NowOrLater<Drawable?>? {
    if (DBG) Log.d(TAG, "getIcon($drawableId)")
    if (TextUtils.isEmpty(drawableId) || "0".equals(drawableId)) {
      return Now<Drawable>(null)
    }
    var newEntry: Entry? = null
    var drawableState: NowOrLater<Drawable.ConstantState?>?
    synchronized(this) {
      drawableState = queryCache(drawableId)
      if (drawableState == null) {
        newEntry = Entry()
        storeInIconCache(drawableId, newEntry)
      }
    }
    if (drawableState != null) {
      return object : NowOrLaterWrapper<Drawable.ConstantState?, Drawable?>(drawableState!!) {
        @Override
        override operator fun get(value: Drawable.ConstantState?): Drawable? {
          return if (value == null) null else value.newDrawable()
        }
      }
    }
    val drawable: NowOrLater<Drawable?>? = mWrapped.getIcon(drawableId)
    newEntry?.set(drawable)
    storeInIconCache(drawableId, newEntry)
    return drawable!!
  }

  override fun getIconUri(drawableId: String?): Uri? {
    return mWrapped.getIconUri(drawableId)
  }

  @Synchronized
  private fun queryCache(drawableId: String?): NowOrLater<Drawable.ConstantState?>? {
    val cached: Entry? = mIconCache.get(drawableId)
    if (DBG) {
      if (cached != null) Log.d(TAG, "Found icon in cache: $drawableId")
    }
    return cached
  }

  @Synchronized
  private fun storeInIconCache(resourceUri: String?, drawable: Entry?) {
    if (drawable != null) {
      mIconCache.put(resourceUri, drawable)
    }
  }

  private class Entry : CachedLater<Drawable.ConstantState?>(), Consumer<Drawable?> {
    private var mDrawable: NowOrLater<Drawable?>? = null
    private var mGotDrawable = false
    private var mCreateRequested = false

    @Synchronized
    fun set(drawable: NowOrLater<Drawable?>?) {
      if (mGotDrawable) throw IllegalStateException("set() may only be called once.")
      mGotDrawable = true
      mDrawable = drawable
      if (mCreateRequested) {
        later
      }
    }

    @Override
    @Synchronized
    override fun create() {
      if (!mCreateRequested) {
        mCreateRequested = true
        if (mGotDrawable) {
          later
        }
      }
    }

    private val later: Unit
      get() {
        val drawable: NowOrLater<Drawable?>? = mDrawable
        mDrawable = null
        drawable!!.getLater(this)
      }

    override fun consume(value: Drawable?): Boolean {
      store(if (value == null) null else value.getConstantState())
      return true
    }
  }

  companion object {
    private const val DBG = false
    private const val TAG = "QSB.CachingIconLoader"
  }

  /**
   * Creates a new caching icon loader.
   *
   * @param wrapped IconLoader whose results will be cached.
   */
  init {
    mIconCache = WeakHashMap<String, Entry>()
  }
}