Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/ironsource/sdk/utils/IronSourceStorageUtils.java

@@ -0,0 +1,343 @@
+package com.ironsource.sdk.utils;
+
+import android.content.Context;
+import android.os.Build;
+import com.ironsource.ce;
+import com.ironsource.el;
+import com.ironsource.hs;
+import com.ironsource.i9;
+import com.ironsource.mediationsdk.logger.IronLog;
+import com.ironsource.v8;
+import com.ironsource.zf;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class IronSourceStorageUtils {
+    private static final String a = "supersonicads";
+    private static hs b;
+    private static boolean c;
+
+    private static void a(Context context) {
+        hs hsVar = b;
+        if (hsVar != null && hsVar.b()) {
+            deleteCacheDirectories(context);
+        }
+        hs hsVar2 = b;
+        if (hsVar2 == null || !hsVar2.c()) {
+            return;
+        }
+        deleteFilesDirectories(context);
+    }
+
+    private static void a(File file) {
+        if (file != null) {
+            deleteFolder(b(file).getPath());
+        }
+    }
+
+    private static boolean a() {
+        hs hsVar;
+        return Build.VERSION.SDK_INT > 29 && (hsVar = b) != null && hsVar.a();
+    }
+
+    private static File b(Context context) {
+        ce f = el.N().f();
+        hs hsVar = b;
+        return (hsVar == null || !hsVar.d()) ? f.t(context) : f.e(context);
+    }
+
+    private static File b(File file) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(file.getAbsolutePath());
+        String str = File.separator;
+        sb.append(str);
+        sb.append(a);
+        sb.append(str);
+        return new File(sb.toString());
+    }
+
+    public static String buildAbsolutePathToDirInCache(String str, String str2) {
+        if (str2 == null) {
+            return str;
+        }
+        return str + File.separator + str2;
+    }
+
+    public static JSONObject buildFilesMap(String str, String str2) {
+        Object c2;
+        String name;
+        File file = new File(str, str2);
+        JSONObject jSONObject = new JSONObject();
+        File[] listFiles = file.listFiles();
+        if (listFiles != null) {
+            for (File file2 : listFiles) {
+                try {
+                    c2 = c(file2);
+                } catch (JSONException e) {
+                    i9.d().a(e);
+                    IronLog.INTERNAL.error(e.toString());
+                }
+                if (c2 instanceof JSONArray) {
+                    name = "files";
+                } else if (c2 instanceof JSONObject) {
+                    name = file2.getName();
+                }
+                jSONObject.put(name, c(file2));
+            }
+        }
+        return jSONObject;
+    }
+
+    public static JSONObject buildFilesMapOfDirectory(zf zfVar, JSONObject jSONObject) throws Exception {
+        String name;
+        JSONObject buildFilesMapOfDirectory;
+        if (zfVar == null || !zfVar.isDirectory()) {
+            return new JSONObject();
+        }
+        File[] listFiles = zfVar.listFiles();
+        if (listFiles == null) {
+            return new JSONObject();
+        }
+        JSONObject jSONObject2 = new JSONObject();
+        for (File file : listFiles) {
+            zf zfVar2 = new zf(file.getPath());
+            if (zfVar2.isFile()) {
+                name = zfVar2.getName();
+                buildFilesMapOfDirectory = zfVar2.a();
+                if (jSONObject.has(name)) {
+                    buildFilesMapOfDirectory = SDKUtils.mergeJSONObjects(buildFilesMapOfDirectory, jSONObject.getJSONObject(name));
+                }
+            } else if (zfVar2.isDirectory()) {
+                name = zfVar2.getName();
+                buildFilesMapOfDirectory = buildFilesMapOfDirectory(zfVar2, jSONObject);
+            }
+            jSONObject2.put(name, buildFilesMapOfDirectory);
+        }
+        return jSONObject2;
+    }
+
+    private static File c(Context context) {
+        ce f = el.N().f();
+        hs hsVar = b;
+        return (hsVar == null || !hsVar.d()) ? f.v(context) : f.k(context);
+    }
+
+    private static Object c(File file) {
+        JSONObject jSONObject = new JSONObject();
+        JSONArray jSONArray = new JSONArray();
+        try {
+        } catch (JSONException e) {
+            i9.d().a(e);
+            IronLog.INTERNAL.error(e.toString());
+        }
+        if (file.isFile()) {
+            jSONArray.put(file.getName());
+            return jSONArray;
+        }
+        for (File file2 : file.listFiles()) {
+            if (file2.isDirectory()) {
+                jSONObject.put(file2.getName(), c(file2));
+            } else {
+                jSONArray.put(file2.getName());
+                jSONObject.put("files", jSONArray);
+            }
+        }
+        return jSONObject;
+    }
+
+    public static void deleteCacheDirectories(Context context) {
+        ce f = el.N().f();
+        a(f.e(context));
+        a(f.k(context));
+    }
+
+    public static synchronized boolean deleteFile(zf zfVar) {
+        synchronized (IronSourceStorageUtils.class) {
+            if (!zfVar.exists()) {
+                return false;
+            }
+            return zfVar.delete();
+        }
+    }
+
+    public static void deleteFilesDirectories(Context context) {
+        ce f = el.N().f();
+        a(f.t(context));
+        a(f.v(context));
+    }
+
+    public static synchronized boolean deleteFolder(String str) {
+        boolean z;
+        synchronized (IronSourceStorageUtils.class) {
+            File file = new File(str);
+            if (deleteFolderContentRecursive(file)) {
+                z = file.delete();
+            }
+        }
+        return z;
+    }
+
+    public static boolean deleteFolderContentRecursive(File file) {
+        File[] listFiles = file.listFiles();
+        boolean z = true;
+        if (listFiles != null) {
+            for (File file2 : listFiles) {
+                if (file2.isDirectory()) {
+                    z &= deleteFolderContentRecursive(file2);
+                }
+                if (!file2.delete()) {
+                    z = false;
+                }
+            }
+        }
+        return z;
+    }
+
+    public static void ensurePathSafety(File file, String str) throws Exception {
+        hs hsVar = b;
+        if (hsVar == null || !hsVar.e()) {
+            String canonicalPath = new File(str).getCanonicalPath();
+            String canonicalPath2 = file.getCanonicalPath();
+            if (canonicalPath2.startsWith(canonicalPath)) {
+                return;
+            }
+            throw new Exception(v8.c.u + canonicalPath2);
+        }
+    }
+
+    public static String getCachedFilesMap(String str, String str2) {
+        JSONObject buildFilesMap = buildFilesMap(str, str2);
+        try {
+            buildFilesMap.put("path", str2);
+        } catch (JSONException e) {
+            i9.d().a(e);
+            IronLog.INTERNAL.error(e.toString());
+        }
+        return buildFilesMap.toString();
+    }
+
+    public static String getDiskCacheDirPath(Context context) {
+        File b2;
+        if (!a() || !SDKUtils.isExternalStorageAvailable() || (b2 = b(context)) == null || !b2.canWrite()) {
+            return c(context).getPath();
+        }
+        c = true;
+        return b2.getPath();
+    }
+
+    public static ArrayList<zf> getFilesInFolderRecursive(zf zfVar) {
+        if (zfVar == null || !zfVar.isDirectory()) {
+            return new ArrayList<>();
+        }
+        ArrayList<zf> arrayList = new ArrayList<>();
+        File[] listFiles = zfVar.listFiles();
+        if (listFiles != null) {
+            for (File file : listFiles) {
+                zf zfVar2 = new zf(file.getPath());
+                if (zfVar2.isDirectory()) {
+                    arrayList.addAll(getFilesInFolderRecursive(zfVar2));
+                }
+                if (zfVar2.isFile()) {
+                    arrayList.add(zfVar2);
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    public static String getNetworkStorageDir(Context context) {
+        File b2 = b(new File(getDiskCacheDirPath(context)));
+        if (!b2.exists()) {
+            b2.mkdir();
+        }
+        return b2.getPath();
+    }
+
+    public static long getTotalSizeOfDir(zf zfVar) {
+        long totalSizeOfDir;
+        long j = 0;
+        if (zfVar != null && zfVar.isDirectory()) {
+            File[] listFiles = zfVar.listFiles();
+            if (listFiles == null) {
+                return 0L;
+            }
+            for (File file : listFiles) {
+                zf zfVar2 = new zf(file.getPath());
+                if (zfVar2.isFile()) {
+                    totalSizeOfDir = zfVar2.length();
+                } else if (zfVar2.isDirectory()) {
+                    totalSizeOfDir = getTotalSizeOfDir(zfVar2);
+                }
+                j += totalSizeOfDir;
+            }
+        }
+        return j;
+    }
+
+    public static void initializeCacheDirectory(Context context, hs hsVar) {
+        b = hsVar;
+        a(context);
+    }
+
+    public static boolean isPathExist(String str, String str2) {
+        return new File(str, str2).exists();
+    }
+
+    public static boolean isUxt() {
+        return c;
+    }
+
+    public static String makeDir(String str) {
+        File file = new File(str);
+        if (file.exists() || file.mkdirs()) {
+            return file.getPath();
+        }
+        return null;
+    }
+
+    public static String readFile(zf zfVar) throws Exception {
+        StringBuilder sb = new StringBuilder();
+        BufferedReader bufferedReader = new BufferedReader(new FileReader(zfVar));
+        while (true) {
+            String readLine = bufferedReader.readLine();
+            if (readLine == null) {
+                bufferedReader.close();
+                return sb.toString();
+            }
+            sb.append(readLine);
+            sb.append('\n');
+        }
+    }
+
+    public static boolean renameFile(String str, String str2) throws Exception {
+        return new File(str).renameTo(new File(str2));
+    }
+
+    public static int saveFile(byte[] bArr, String str) throws Exception {
+        FileOutputStream fileOutputStream = new FileOutputStream(new File(str));
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
+        try {
+            byte[] bArr2 = new byte[102400];
+            int i = 0;
+            while (true) {
+                int read = byteArrayInputStream.read(bArr2);
+                if (read == -1) {
+                    return i;
+                }
+                fileOutputStream.write(bArr2, 0, read);
+                i += read;
+            }
+        } finally {
+            fileOutputStream.close();
+            byteArrayInputStream.close();
+        }
+    }
+}