feat: implement pinned filter method and enhance PinnedKeySet functionality

Author: Dev4Mod

app/src/main/java/com/wmods/wppenhacer/utils/FeatureCatalog.java

@@ -82,14 +82,6 @@ private static List<SearchableFeature> buildFeatureCatalog(Context context) {
                 "general_home",
                 Arrays.asList("backup", "restore", "force")));
 
-        catalog.add(new SearchableFeature("disable_ads",
-                context.getString(R.string.disable_ads),
-                context.getString(R.string.disable_ads_sum),
-                SearchableFeature.Category.GENERAL_HOME,
-                SearchableFeature.FragmentType.GENERAL,
-                "general_home",
-                Arrays.asList("ads", "advertising", "block")));
-
         catalog.add(new SearchableFeature("lite_mode",
                 context.getString(R.string.lite_mode),
                 context.getString(R.string.lite_mode_sum),

app/src/main/java/com/wmods/wppenhacer/xposed/core/devkit/Unobfuscator.java

@@ -2665,4 +2665,21 @@ public static Class<?>[] loadSharedPreferencesClasses(ClassLoader classLoader) t
                     .toArray(Class[]::new);
         });
     }
+
+    public static Method loadPinnedFilterMethod(ClassLoader classLoader) throws Exception {
+        return UnobfuscatorCache.getInstance().getMethod(classLoader, () -> {
+            var method = findFirstMethodUsingStrings(classLoader, StringMatchType.Contains, "pinSelectedJids");
+            var methodData = dexkit.getMethodData(method);
+            var invokes = methodData.getInvokes();
+            for (var invoke : invokes) {
+                if (!invoke.isMethod()) continue;
+                var methodInstance = invoke.getMethodInstance(classLoader);
+                if (!Set.class.isAssignableFrom(methodInstance.getReturnType()))
+                    continue;
+                if (methodInstance.getParameterCount() == 2 && methodInstance.getParameterTypes()[0] == Iterable.class && methodInstance.getParameterTypes()[1] == Set.class)
+                    return methodInstance;
+            }
+            throw new NoSuchMethodException("PinnedLinkedHashMethod not found");
+        });
+    }
 }

app/src/main/java/com/wmods/wppenhacer/xposed/features/general/PinnedLimit.java

@@ -7,6 +7,7 @@
 
 import com.wmods.wppenhacer.xposed.core.Feature;
 import com.wmods.wppenhacer.xposed.core.devkit.Unobfuscator;
+import com.wmods.wppenhacer.xposed.utils.DebugUtils;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -33,11 +34,9 @@ public PinnedLimit(@NonNull ClassLoader loader, @NonNull XSharedPreferences pref
     @Override
     @SuppressLint("DiscouragedApi")
     public void doHook() throws Throwable {
-
-        var pinnedSetMethod = Unobfuscator.loadPinnedHashSetMethod(classLoader);
+        var pinnedHashSetMethod = Unobfuscator.loadPinnedHashSetMethod(classLoader);
         var pinnedInChatMethod = Unobfuscator.loadPinnedInChatMethod(classLoader);
 
-
         // increase pinned limit in chat to 60
         XposedBridge.hookMethod(pinnedInChatMethod, XC_MethodReplacement.returnConstant(60));
 
@@ -63,7 +62,7 @@ protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
 
 
         // This creates a modified linkedhashMap to return 0 if the fixed list is less than 60.
-        XposedBridge.hookMethod(pinnedSetMethod, new XC_MethodHook() {
+        XposedBridge.hookMethod(pinnedHashSetMethod, new XC_MethodHook() {
 
             @Override
             @SuppressWarnings("unchecked")
@@ -81,6 +80,26 @@ protected void afterHookedMethod(MethodHookParam param) throws Throwable {
             }
         });
 
+        var method = Unobfuscator.loadPinnedFilterMethod(classLoader);
+        XposedBridge.hookMethod(method, new XC_MethodHook() {
+            @Override
+            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
+                if (!(param.args[0] instanceof PinnedLinkedHashMap.PinnedKeySet<?>)) {
+                    return;
+                }
+                var set = (Set) param.getResult();
+                PinnedLinkedHashMap<Object> pinnedMod;
+                pinnedMod = new PinnedLinkedHashMap<>();
+                pinnedMod.setLimit(prefs.getBoolean("pinnedlimit", false) ? 60 : 3);
+                for (Object item : set) {
+                    pinnedMod.put(item, item);
+                }
+                PinnedLinkedHashMap.PinnedKeySet<Object> newKeySet = pinnedMod.keySet();
+                newKeySet.setDisableInterator(false);
+                param.setResult(pinnedMod.keySet());
+            }
+        });
+
     }
 
     @NonNull
@@ -105,19 +124,13 @@ public int size() {
 
         @NonNull
         @Override
-        public Set<T> keySet() {
+        public PinnedKeySet<T> keySet() {
             return new PinnedKeySet<>(this, super.keySet());
         }
 
-        static class PinnedKeySet<T> implements Set<T> {
-
-            private final Set<T> set;
-            private final PinnedLinkedHashMap<T> pinnedKeySet;
+        record PinnedKeySet<T>(PinnedLinkedHashMap<T> pinnedKeySet, Set<T> set) implements Set<T> {
 
-            public PinnedKeySet(PinnedLinkedHashMap<T> pinnedKeySet, Set<T> set) {
-                this.pinnedKeySet = pinnedKeySet;
-                this.set = set;
-            }
+            private static boolean disableInterator = true;
 
             @Override
             public int size() {
@@ -137,6 +150,21 @@ public boolean contains(@Nullable Object o) {
             @NonNull
             @Override
             public Iterator<T> iterator() {
+                if (disableInterator) {
+                    if (pinnedKeySet.size() < pinnedKeySet.limit) {
+                        return new Iterator<T>() {
+                            @Override
+                            public boolean hasNext() {
+                                return false;
+                            }
+
+                            @Override
+                            public T next() {
+                                return null;
+                            }
+                        };
+                    }
+                }
                 return set.iterator();
             }
 
@@ -154,22 +182,33 @@ public <T1> T1[] toArray(@NonNull T1[] a) {
 
             @Override
             public boolean add(@Nullable T t) {
-                return set.add(t);
+                var hadKey = pinnedKeySet.containsKey(t);
+                pinnedKeySet.put(t, t);
+                return !hadKey;
             }
 
             @Override
             public boolean remove(@Nullable Object o) {
-                return set.remove(o);
+                var hadKey = pinnedKeySet.containsKey(o);
+                if (hadKey) {
+                    pinnedKeySet.remove(o);
+                }
+                return hadKey;
             }
 
+
             @Override
             public boolean containsAll(@NonNull Collection<?> c) {
                 return set.containsAll(c);
             }
 
             @Override
             public boolean addAll(@NonNull Collection<? extends T> c) {
-                return false;
+                var changed = false;
+                for (T item : c) {
+                    changed |= add(item);
+                }
+                return changed;
             }
 
             @Override
@@ -193,7 +232,11 @@ public void clear() {
             public Spliterator<T> spliterator() {
                 return set.spliterator();
             }
+
+            public void setDisableInterator(boolean b) {
+                this.disableInterator = b;
+            }
         }
     }
 
-}
+}