Optimize code

Author: DylanCaiCoding

library/src/main/java/com/dylanc/tracker/TrackNode.kt

@@ -35,7 +35,7 @@ fun Activity.PageTrackNode(referrerKeyMap: Map<String, String>, vararg params: P
 
 fun Activity.PageTrackNode(referrerKeyMap: Map<String, String> = emptyMap(), trackNode: TrackNode = TrackNode { }): TrackNode {
   val referrerParams = intent.getSerializableExtra(KEY_TRACK_PARAMS) as? Map<String, Any>
-  threadNodeClasses = intent.getStringArrayExtra(KEY_TRACK_THREAD_NODES)?.run { MutableList(size) { Class.forName(get(it)) } }
+  window.decorView.setTag(R.id.tag_thread_node_names, intent.getStringArrayExtra(KEY_TRACK_THREAD_NODES)?.toMutableList())
   return TrackNode { params ->
     referrerParams?.forEach {
       params.put(referrerKeyMap.getOrElse(it.key) { it.key }, it.value)

library/src/main/java/com/dylanc/tracker/Tracker.kt

@@ -33,11 +33,11 @@ internal const val KEY_TRACK_PARAMS = "track_params"
 internal const val KEY_TRACK_THREAD_NODES = "track_thread_nodes"
 private lateinit var application: Application
 private var trackHandler: TrackHandler? = null
-private val threadNodeCache by lazy { mutableMapOf<Class<*>, TrackNode>() }
+private val threadNodes by lazy { mutableMapOf<String, TrackNode>() }
 
 @JvmName("init")
-fun initTracker(application: Application, handler: TrackHandler) {
-  com.dylanc.tracker.application = application
+fun initTracker(app: Application, handler: TrackHandler) {
+  application = app
   trackHandler = handler
 }
 
@@ -64,24 +64,24 @@ fun Intent.putReferrerTrackNode(activity: Activity): Intent = putReferrerTrackNo
 fun Intent.putReferrerTrackNode(fragment: Fragment): Intent = putReferrerTrackNode(fragment.view)
 
 fun Intent.putReferrerTrackNode(view: View?): Intent = putExtra(KEY_TRACK_PARAMS, view?.collectTrack() as? Serializable)
-  .putExtra(KEY_TRACK_THREAD_NODES, view?.threadNodeClasses?.let { list -> Array(list.size) { list[it].name } })
+  .putExtra(KEY_TRACK_THREAD_NODES, view?.findThreadNodeNames()?.toTypedArray())
 
-fun ComponentActivity.setPageTrackNode(trackNode: TrackNode) = setPageTrackNode(emptyMap(), trackNode)
+fun Activity.setPageTrackNode(trackNode: TrackNode) = setPageTrackNode(emptyMap(), trackNode)
 
 @JvmOverloads
-fun ComponentActivity.setPageTrackNode(referrerKeyMap: Map<String, String> = emptyMap(), trackNode: TrackNode = TrackNode { }) {
+fun Activity.setPageTrackNode(referrerKeyMap: Map<String, String> = emptyMap(), trackNode: TrackNode = TrackNode { }) {
   this.trackNode = PageTrackNode(referrerKeyMap, trackNode)
 }
 
 fun Activity.postTrack(eventName: String, vararg clazz: Class<*>) = window.decorView.postTrack(eventName, *clazz)
 
 fun Fragment.postTrack(eventName: String, vararg clazz: Class<*>) = view?.postTrack(eventName, *clazz)
 
-fun View.postTrack(eventId: String, vararg clazz: Class<*>) {
-  trackHandler?.onEvent(application, eventId, collectTrack(*clazz))
+fun View.postTrack(eventId: String, vararg threadNodeClasses: Class<*>) {
+  trackHandler?.onEvent(application, eventId, collectTrack(*threadNodeClasses))
 }
 
-fun View.collectTrack(vararg classes: Class<*>): Map<String, String> {
+fun View.collectTrack(vararg threadNodeClasses: Class<*>): Map<String, String> {
   var view: View? = this
   val params = TrackParams()
   val nodeList = mutableListOf<TrackNode>()
@@ -90,30 +90,28 @@ fun View.collectTrack(vararg classes: Class<*>): Map<String, String> {
     view = view.parent as? View
   }
   nodeList.reversed().forEach { node -> node.fillTackParams(params) }
-  classes.forEach { clazz ->
-    if (threadNodeClasses?.any { it == clazz } == true) {
-      threadNodeCache[clazz]?.fillTackParams(params)
+  threadNodeClasses.forEach { clazz ->
+    if (findThreadNodeNames()?.any { it == clazz.name } == true) {
+      threadNodes[clazz.name]?.fillTackParams(params)
     }
   }
   return params.toMap()
 }
 
 fun ComponentActivity.putThreadTrackNode(trackNode: TrackNode) {
-  if (threadNodeClasses == null) {
-    threadNodeClasses = mutableListOf(trackNode.javaClass)
-  } else {
-    threadNodeClasses!!.add(trackNode.javaClass)
-  }
-  threadNodeCache[trackNode.javaClass] = trackNode
+  val clazzName = trackNode.javaClass.name
+  threadNodes[clazzName] = trackNode
+  val list = window.decorView.getTag(R.id.tag_thread_node_names) as? MutableList<String> ?: mutableListOf()
+  list.add(clazzName)
+  window.decorView.setTag(R.id.tag_thread_node_names, list)
   lifecycle.addObserver(object : DefaultLifecycleObserver {
     override fun onResume(owner: LifecycleOwner) {
-      if (threadNodeCache[trackNode.javaClass] == null) {
-        threadNodeCache[trackNode.javaClass] = trackNode
-      }
+      if (threadNodes[clazzName] == null)
+        threadNodes[clazzName] = trackNode
     }
 
     override fun onDestroy(owner: LifecycleOwner) {
-      threadNodeCache.remove(trackNode.javaClass)
+      threadNodes.remove(clazzName)
     }
   })
 }
@@ -129,25 +127,19 @@ fun <T : TrackNode> Fragment.updateThreadTrackNode(clazz: Class<T>, callback: Ca
 inline fun <reified T : TrackNode> View.updateThreadTrackNode(callback: Callback<T>) = updateThreadTrackNode(T::class.java, callback)
 
 fun <T : TrackNode> View.updateThreadTrackNode(clazz: Class<T>, callback: Callback<T>) =
-  (if (threadNodeClasses?.contains(clazz) == true) threadNodeCache[clazz] as? T else null)?.let { callback.apply { it.onUpdate() } }
-
-internal var Activity.threadNodeClasses: MutableList<Class<*>>?
-  get() = window.decorView.getTag(R.id.tag_track_thread) as? MutableList<Class<*>>
-  set(value) {
-    window.decorView.setTag(R.id.tag_track_thread, value)
+  findThreadNodeNames()?.any { it == clazz.name }?.takeIf { it }?.let {
+    callback.apply { (threadNodes[clazz.name] as? T)?.onUpdate() }
   }
 
-private val View.threadNodeClasses: List<Class<*>>?
-  get() {
-    var view: View? = this
-    while (view != null) {
-      if (view.getTag(R.id.tag_track_thread) != null) {
-        return view.getTag(R.id.tag_track_thread) as List<Class<*>>
-      }
-      view = view.parent as? View
-    }
-    return null
+private fun View.findThreadNodeNames(): List<String>? {
+  var view: View? = this
+  while (view != null) {
+    if (view.getTag(R.id.tag_thread_node_names) != null)
+      return view.getTag(R.id.tag_thread_node_names) as List<String>
+    view = view.parent as? View
   }
+  return null
+}
 
 fun interface Callback<T : TrackNode> {
   fun T.onUpdate()

library/src/main/res/values/ids.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
   <item name="tag_track_node" type="id" />
-  <item name="tag_track_thread" type="id" />
+  <item name="tag_thread_node_names" type="id" />
 </resources>