fix(scplus): update mappings

app/src/main/kotlin/me/rhunk/snapenhance/features/impl/extras/SnapchatPlus.kt

@@ -7,28 +7,23 @@ import me.rhunk.snapenhance.hook.HookStage
 import me.rhunk.snapenhance.hook.Hooker
 
 class SnapchatPlus: Feature("SnapchatPlus", loadParams = FeatureLoadParams.ACTIVITY_CREATE_ASYNC) {
+    private val originalSubscriptionTime = (System.currentTimeMillis() - 7776000000L)
+    private val expirationTimeMillis = (System.currentTimeMillis() + 15552000000L)
+
     override fun asyncOnActivityCreate() {
         if (!context.config.bool(ConfigProperty.SNAPCHAT_PLUS)) return
 
-        val subscriptionInfoMembers = context.mappings.getMappedMap("SubscriptionInfoClassMembers")
+        val subscriptionInfoClass = context.mappings.getMappedClass("SubscriptionInfoClass")
 
-        Hooker.hookConstructor(context.mappings.getMappedClass("SubscriptionInfoClass"), HookStage.AFTER) { param ->
-            val getField = { key: String ->  param.thisObject<Any>().javaClass.declaredFields.first {it.name == (subscriptionInfoMembers[key] as String)}.also { it.isAccessible = true }}
+        Hooker.hookConstructor(subscriptionInfoClass, HookStage.BEFORE) { param ->
+            if (param.arg<Int>(0) == 2) return@hookConstructor
+            //subscription tier
+            param.setArg(0, 2)
+            //subscription status
+            param.setArg(1, 2)
 
-            val subscriptionStatusField = getField("status")
-            val isSubscribedField = getField("isSubscribed")
-            val startTimeMsField = getField("startTimeMs")
-            val expireTimeMsField = getField("expireTimeMs")
-
-            //check if the user is already premium
-            if ((subscriptionStatusField[param.thisObject()] as Double).toInt() == 2) {
-                return@hookConstructor
-            }
-
-            isSubscribedField.set(param.thisObject(), true)
-            startTimeMsField.set(param.thisObject(), (System.currentTimeMillis() - 7776000000L).toDouble())
-            expireTimeMsField.set(param.thisObject(), (System.currentTimeMillis() + 15552000000L).toDouble())
-            subscriptionStatusField.set(param.thisObject(), 2.toDouble())
+            param.setArg(2, originalSubscriptionTime)
+            param.setArg(3, expirationTimeMillis)
         }
     }
 }

app/src/main/kotlin/me/rhunk/snapenhance/mapping/impl/PlusSubscriptionMapper.kt

@@ -1,41 +1,27 @@
 package me.rhunk.snapenhance.mapping.impl
 
 import me.rhunk.snapenhance.mapping.Mapper
-import java.lang.reflect.Field
-import java.lang.reflect.Method
+import java.lang.reflect.Modifier
 
 
 class PlusSubscriptionMapper : Mapper() {
-    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
     override fun useClasses(
         classLoader: ClassLoader,
         classes: List<Class<*>>,
         mappings: MutableMap<String, Any>
     ) {
-        //find a method that contains annotations with isSubscribed
-        val loadSubscriptionMethod = context.classCache.composerLocalSubscriptionStore.declaredMethods.first { method: Method ->
-            val returnType = method.returnType
-            returnType.declaredFields.any { field: Field ->
-                field.declaredAnnotations.any { annotation: Annotation ->
-                    annotation.toString().contains("isSubscribed")
-                }
-            }
-        }
-        /*
-        //get the first param of the method which is the PlusSubscriptionState class
-        val plusSubscriptionStateClass = loadSubscriptionMethod.parameterTypes[0]
-        //get the first param of the constructor of PlusSubscriptionState which is the SubscriptionInfo class
-        val subscriptionInfoClass = plusSubscriptionStateClass.constructors[0].parameterTypes[0]
-        */
-        mappings["SubscriptionInfoClass"] = loadSubscriptionMethod.returnType.name
+        for (clazz in classes) {
+            clazz.fields.firstOrNull {
+                it.type == clazz &&
+                Modifier.isFinal(it.modifiers) &&
+                Modifier.isStatic(it.modifiers) &&
+                runCatching {
+                    it?.get(null).toString().startsWith("PlusSubscriptionState")
+                }.getOrDefault(false)
+            } ?: continue
 
-        val members = mutableMapOf<String, Any>()
-        loadSubscriptionMethod.returnType.declaredFields.forEach { field ->
-            val serializedNameAnnotation = (field.declaredAnnotations.first() as java.lang.annotation.Annotation)
-            val propertyName = serializedNameAnnotation.annotationType().getDeclaredMethod("name").also { it.isAccessible = true }.invoke(serializedNameAnnotation) as String
-            members[propertyName] = field.name
+            mappings["SubscriptionInfoClass"] = clazz.constructors[0]!!.parameterTypes[0]!!.name
+            return
         }
-
-        mappings["SubscriptionInfoClassMembers"] = members
     }
 }