Info Call to External Storage API

Description

List of all external storage API calls. Insecure storage of sensitive information by setting insecure permissions or storing data without encryption might expose this information to an attacker.

Recommendation

This entry is informative, no recommendations applicable.

Technical details

Method com.crashlytics.android.core.NativeFileUtils.readFile() calling method java.io.FileInputStream.<init>()


    static byte[] readFile(java.io.File p3)
    {
        try {
            java.io.FileInputStream v1 = new java.io.FileInputStream(p3);
            java.io.IOException v2_2 = com.crashlytics.android.core.NativeFileUtils.readBytes(v1);
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            return v2_2;
        } catch (Throwable v0_1) {
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            throw v0_1;
        } catch (java.io.IOException v2) {
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            return 0;
        } catch (java.io.IOException v2) {
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            return 0;
        }
    }

Method com.crashlytics.android.core.MetaDataStore.readUserData() calling method java.io.FileInputStream.<init>()


    public com.crashlytics.android.core.UserMetaData readUserData(String p7)
    {
        java.io.File v0 = this.getUserDataFileForSession(p7);
        if (v0.exists()) {
            try {
                java.io.FileInputStream v1_2 = new java.io.FileInputStream(v0);
                com.crashlytics.android.core.UserMetaData v2_1 = com.crashlytics.android.core.MetaDataStore.jsonToUserData(io.fabric.sdk.android.services.common.CommonUtils.streamToString(v1_2));
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                return v2_1;
            } catch (com.crashlytics.android.core.UserMetaData v2_5) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                throw v2_5;
            } catch (com.crashlytics.android.core.UserMetaData v2_2) {
                io.fabric.sdk.android.Fabric.getLogger().e("CrashlyticsCore", "Error deserializing user metadata.", v2_2);
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                return com.crashlytics.android.core.UserMetaData.EMPTY;
            }
        } else {
            return com.crashlytics.android.core.UserMetaData.EMPTY;
        }
    }

Method com.crashlytics.android.core.MetaDataStore.readKeyData() calling method java.io.FileInputStream.<init>()


    public java.util.Map readKeyData(String p7)
    {
        java.io.File v0 = this.getKeysFileForSession(p7);
        if (v0.exists()) {
            try {
                java.io.FileInputStream v1_2 = new java.io.FileInputStream(v0);
                java.util.Map v2_1 = com.crashlytics.android.core.MetaDataStore.jsonToKeysData(io.fabric.sdk.android.services.common.CommonUtils.streamToString(v1_2));
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                return v2_1;
            } catch (java.util.Map v2_5) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                throw v2_5;
            } catch (java.util.Map v2_2) {
                io.fabric.sdk.android.Fabric.getLogger().e("CrashlyticsCore", "Error deserializing user metadata.", v2_2);
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_2, "Failed to close user metadata file.");
                return java.util.Collections.emptyMap();
            }
        } else {
            return java.util.Collections.emptyMap();
        }
    }

Method com.crashlytics.android.core.CrashlyticsController.writeToCosFromFile() calling method java.io.FileInputStream.<init>()


    private static void writeToCosFromFile(com.crashlytics.android.core.CodedOutputStream p5, java.io.File p6)
    {
        if (p6.exists()) {
            try {
                java.io.FileInputStream v0_2 = new java.io.FileInputStream(p6);
                com.crashlytics.android.core.CrashlyticsController.copyToCodedOutputStream(v0_2, p5, ((int) p6.length()));
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_2, "Failed to close file input stream.");
                return;
            } catch (Throwable v1_2) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_2, "Failed to close file input stream.");
                throw v1_2;
            }
        } else {
            java.io.FileInputStream v0_1 = io.fabric.sdk.android.Fabric.getLogger();
            String v3_1 = new StringBuilder();
            v3_1.append("Tried to include a file that doesn\'t exist: ");
            v3_1.append(p6.getName());
            v0_1.e("CrashlyticsCore", v3_1.toString(), 0);
            return;
        }
    }

Method com.bumptech.glide.load.resource.file.FileToStreamDecoder$FileOpener.open() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream open(java.io.File p2)
    {
        return new java.io.FileInputStream(p2);
    }

Method com.bumptech.glide.disklrucache.DiskLruCache.readJournal() calling method java.io.FileInputStream.<init>()


    private void readJournal()
    {
        com.bumptech.glide.disklrucache.StrictLineReader v0_1 = new com.bumptech.glide.disklrucache.StrictLineReader(new java.io.FileInputStream(this.journalFile), com.bumptech.glide.disklrucache.Util.US_ASCII);
        try {
            Throwable v1_2 = v0_1.readLine();
            String v2_2 = v0_1.readLine();
            String v3 = v0_1.readLine();
            String v4 = v0_1.readLine();
            String v5 = v0_1.readLine();
        } catch (Throwable v1_3) {
            com.bumptech.glide.disklrucache.Util.closeQuietly(v0_1);
            throw v1_3;
        }
        if ((!"libcore.io.DiskLruCache".equals(v1_2)) || ((!"1".equals(v2_2)) || ((!Integer.toString(this.appVersion).equals(v3)) || ((!Integer.toString(this.valueCount).equals(v4)) || (!"".equals(v5)))))) {
            java.io.BufferedWriter v7_1 = new StringBuilder();
            v7_1.append("unexpected journal header: [");
            v7_1.append(v1_2);
            v7_1.append(", ");
            v7_1.append(v2_2);
            v7_1.append(", ");
            v7_1.append(v4);
            v7_1.append(", ");
            v7_1.append(v5);
            v7_1.append("]");
            throw new java.io.IOException(v7_1.toString());
        } else {
            int v6_14 = 0;
            try {
                while(true) {
                    this.readJournalLine(v0_1.readLine());
                    v6_14++;
                }
            } catch (java.io.BufferedWriter v7) {
                this.redundantOpCount = (v6_14 - this.lruEntries.size());
                if (!v0_1.hasUnterminatedLine()) {
                    this.journalWriter = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.journalFile, 1), com.bumptech.glide.disklrucache.Util.US_ASCII));
                } else {
                    this.rebuildJournal();
                }
                com.bumptech.glide.disklrucache.Util.closeQuietly(v0_1);
                return;
            }
        }
    }

Method com.bumptech.glide.disklrucache.DiskLruCache$Value.getString() calling method java.io.FileInputStream.<init>()


    public String getString(int p3)
    {
        return com.bumptech.glide.disklrucache.DiskLruCache.access$1700(new java.io.FileInputStream(this.files[p3]));
    }

Method com.bumptech.glide.disklrucache.DiskLruCache$Editor.newInputStream() calling method java.io.FileInputStream.<init>()


    private java.io.InputStream newInputStream(int p5)
    {
        try {
            if (com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$700(this.entry) != this) {
                throw new IllegalStateException();
            } else {
                if (com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$600(this.entry)) {
                    return new java.io.FileInputStream(this.entry.getCleanFile(p5));
                } else {
                    return 0;
                }
            }
        } catch (java.io.FileNotFoundException v1_4) {
            throw v1_4;
        }
    }

Method android.support.v4.util.AtomicFile.openRead() calling method java.io.FileInputStream.<init>()


    public java.io.FileInputStream openRead()
    {
        if (this.mBackupName.exists()) {
            this.mBaseName.delete();
            this.mBackupName.renameTo(this.mBaseName);
        }
        return new java.io.FileInputStream(this.mBaseName);
    }

Method android.support.v4.graphics.TypefaceCompatUtil.mmap() calling method java.io.FileInputStream.<init>()


    private static java.nio.ByteBuffer mmap(java.io.File p9)
    {
        try {
            java.io.IOException v1_1 = new java.io.FileInputStream(p9);
            try {
                Throwable v2_2 = v1_1.getChannel();
                Throwable v3_0 = v2_2.map(java.nio.channels.FileChannel$MapMode.READ_ONLY, 0, v2_2.size());
            } catch (Throwable v2_1) {
                Throwable v3_2 = 0;
                if (v3_2 == null) {
                    v1_1.close();
                } else {
                    try {
                        v1_1.close();
                    } catch (Throwable v4_0) {
                        v3_2.addSuppressed(v4_0);
                    }
                }
                throw v2_1;
            } catch (Throwable v2_0) {
                try {
                    throw v2_0;
                } catch (Throwable v3_1) {
                    v3_2 = v2_0;
                    v2_1 = v3_1;
                }
            }
            v1_1.close();
            return v3_0;
        } catch (java.io.IOException v1) {
            return 0;
        }
    }

Method android.support.v4.graphics.TypefaceCompatUtil.mmap() calling method java.io.FileInputStream.<init>()


    public static java.nio.ByteBuffer mmap(android.content.Context p11, android.os.CancellationSignal p12, android.net.Uri p13)
    {
        try {
            java.io.IOException v2_1 = p11.getContentResolver().openFileDescriptor(p13, "r", p12);
        } catch (java.io.IOException v2) {
            return 0;
        }
        if (v2_1 != null) {
            try {
                Throwable v3_0 = new java.io.FileInputStream(v2_1.getFileDescriptor());
                try {
                    Throwable v4_0 = v3_0.getChannel();
                    Throwable v5_1 = v4_0.map(java.nio.channels.FileChannel$MapMode.READ_ONLY, 0, v4_0.size());
                } catch (Throwable v4_2) {
                    Throwable v5_3 = 0;
                    if (v5_3 == null) {
                        v3_0.close();
                    } else {
                        try {
                            v3_0.close();
                        } catch (Throwable v6_1) {
                            v5_3.addSuppressed(v6_1);
                        }
                    }
                    throw v4_2;
                } catch (Throwable v4_1) {
                    try {
                        throw v4_1;
                    } catch (Throwable v5_2) {
                        v5_3 = v4_1;
                        v4_2 = v5_2;
                    }
                }
                v3_0.close();
                if (v2_1 != null) {
                    v2_1.close();
                }
                return v5_1;
            } catch (Throwable v3_2) {
                Throwable v4_4 = 0;
                if (v2_1 != null) {
                    if (v4_4 == null) {
                        v2_1.close();
                    } else {
                        try {
                            v2_1.close();
                        } catch (Throwable v5_4) {
                            v4_4.addSuppressed(v5_4);
                        }
                    }
                }
                throw v3_2;
            } catch (Throwable v3_1) {
                try {
                    throw v3_1;
                } catch (Throwable v4_3) {
                    v4_4 = v3_1;
                    v3_2 = v4_3;
                }
            }
        } else {
            if (v2_1 != null) {
                v2_1.close();
            }
            return 0;
        }
    }

Method io.fabric.sdk.android.services.common.CommonUtils.extractFieldFromSystemFile() calling method java.io.FileReader.<init>()


    public static String extractFieldFromSystemFile(java.io.File p7, String p8)
    {
        String v0 = 0;
        if (p7.exists()) {
            try {
                java.io.BufferedReader v1_0 = new java.io.BufferedReader(new java.io.FileReader(p7), 1024);
            } catch (String v2_4) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_0, "Failed to close system file reader.");
                throw v2_4;
            } catch (String v2_3) {
                io.fabric.sdk.android.Logger v3_1 = io.fabric.sdk.android.Fabric.getLogger();
                String v5_5 = new StringBuilder();
                v5_5.append("Error parsing ");
                v5_5.append(p7);
                v3_1.e("Fabric", v5_5.toString(), v2_3);
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1_0, "Failed to close system file reader.");
            }
            do {
                String v2_0 = v1_0.readLine();
                if (v2_0 == null) {
                } else {
                    String[] v4_1 = java.util.regex.Pattern.compile("\\s*:\\s*").split(v2_0, 2);
                }
            } while((v4_1.length <= 1) || (!v4_1[0].equals(p8)));
            v0 = v4_1[1];
        }
        return v0;
    }

Method com.google.android.gms.common.util.ProcessUtils.zzm() calling method java.io.FileReader.<init>()


    private static java.io.BufferedReader zzm(String p3)
    {
        android.os.StrictMode$ThreadPolicy v0 = android.os.StrictMode.allowThreadDiskReads();
        try {
            java.io.BufferedReader v1_1 = new java.io.BufferedReader(new java.io.FileReader(p3));
            android.os.StrictMode.setThreadPolicy(v0);
            return v1_1;
        } catch (Throwable v3_1) {
            android.os.StrictMode.setThreadPolicy(v0);
            throw v3_1;
        }
    }

Method com.crashlytics.android.core.NativeFileUtils.binaryImagesJsonFromMapsFile() calling method java.io.FileReader.<init>()


    private static byte[] binaryImagesJsonFromMapsFile(java.io.File p3, android.content.Context p4)
    {
        if (p3.exists()) {
            try {
                java.io.BufferedReader v0_1 = new java.io.BufferedReader(new java.io.FileReader(p3));
                Throwable v1_2 = new com.crashlytics.android.core.BinaryImagesConverter(p4, new com.crashlytics.android.core.Sha1FileIdStrategy()).convert(v0_1);
                io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v0_1);
                return v1_2;
            } catch (Throwable v1_3) {
                io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v0_1);
                throw v1_3;
            }
        } else {
            return 0;
        }
    }

Method kotlin.io.FilesKt__UtilsKt.startsWith() calling method java.io.File.<init>()


    public static final boolean startsWith(java.io.File p1, String p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p1, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "other");
        return kotlin.io.FilesKt.startsWith(p1, new java.io.File(p2));
    }

Method kotlin.io.FilesKt__UtilsKt.resolveSibling() calling method java.io.File.<init>()


    public static final java.io.File resolveSibling(java.io.File p1, String p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p1, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "relative");
        return kotlin.io.FilesKt.resolveSibling(p1, new java.io.File(p2));
    }

Method kotlin.io.FilesKt__UtilsKt.resolveSibling() calling method java.io.File.<init>()


    public static final java.io.File resolveSibling(java.io.File p3, java.io.File p4)
    {
        java.io.File v1_0;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p3, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "relative");
        kotlin.io.FilePathComponents v0_2 = kotlin.io.FilesKt.toComponents(p3);
        if (v0_2.getSize() != 0) {
            v1_0 = v0_2.subPath(0, (v0_2.getSize() - 1));
        } else {
            v1_0 = new java.io.File("..");
        }
        return kotlin.io.FilesKt.resolve(kotlin.io.FilesKt.resolve(v0_2.getRoot(), v1_0), p4);
    }

Method kotlin.io.FilesKt__UtilsKt.resolve() calling method java.io.File.<init>()


    public static final java.io.File resolve(java.io.File p1, String p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p1, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "relative");
        return kotlin.io.FilesKt.resolve(p1, new java.io.File(p2));
    }

Method kotlin.io.FilesKt__UtilsKt.resolve() calling method java.io.File.<init>()


    public static final java.io.File resolve(java.io.File p6, java.io.File p7)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p6, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p7, "relative");
        if (!kotlin.io.FilesKt.isRooted(p7)) {
            java.io.File v1_3;
            String v0_3 = p6.toString();
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_3, "this.toString()");
            if (((CharSequence) v0_3).length() != 0) {
                v1_3 = 0;
            } else {
                v1_3 = 1;
            }
            if ((v1_3 == null) && (!kotlin.text.StringsKt.endsWith$default(((CharSequence) v0_3), java.io.File.separatorChar, 0, 2, 0))) {
                String v2_2 = new StringBuilder();
                v2_2.append(v0_3);
                v2_2.append(java.io.File.separatorChar);
                v2_2.append(p7);
                java.io.File v1_8 = new java.io.File(v2_2.toString());
            } else {
                String v2_5 = new StringBuilder();
                v2_5.append(v0_3);
                v2_5.append(p7);
                v1_8 = new java.io.File(v2_5.toString());
            }
            return v1_8;
        } else {
            return p7;
        }
    }

Method kotlin.io.FilesKt__UtilsKt.relativeToOrSelf() calling method java.io.File.<init>()


    public static final java.io.File relativeToOrSelf(java.io.File p3, java.io.File p4)
    {
        java.io.File v2_0;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p3, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "base");
        String v0_2 = kotlin.io.FilesKt__UtilsKt.toRelativeStringOrNull$FilesKt__UtilsKt(p3, p4);
        if (v0_2 == null) {
            v2_0 = p3;
        } else {
            v2_0 = new java.io.File(v0_2);
        }
        return v2_0;
    }

Method kotlin.io.FilesKt__UtilsKt.relativeToOrNull() calling method java.io.File.<init>()


    public static final java.io.File relativeToOrNull(java.io.File p3, java.io.File p4)
    {
        int v2_0;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p3, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "base");
        String v0_2 = kotlin.io.FilesKt__UtilsKt.toRelativeStringOrNull$FilesKt__UtilsKt(p3, p4);
        if (v0_2 == null) {
            v2_0 = 0;
        } else {
            v2_0 = new java.io.File(v0_2);
        }
        return v2_0;
    }

Method kotlin.io.FilesKt__UtilsKt.relativeTo() calling method java.io.File.<init>()


    public static final java.io.File relativeTo(java.io.File p2, java.io.File p3)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p3, "base");
        return new java.io.File(kotlin.io.FilesKt.toRelativeString(p2, p3));
    }

Method kotlin.io.FilesKt__UtilsKt.endsWith() calling method java.io.File.<init>()


    public static final boolean endsWith(java.io.File p1, String p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p1, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "other");
        return kotlin.io.FilesKt.endsWith(p1, new java.io.File(p2));
    }

Method kotlin.io.FilesKt__UtilsKt.copyRecursively() calling method java.io.File.<init>()


    public static final boolean copyRecursively(java.io.File p12, java.io.File p13, boolean p14, kotlin.jvm.functions.Function2 p15)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p12, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p13, "target");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p15, "onError");
        int v1 = 1;
        if (p12.exists()) {
            try {
                kotlin.io.TerminateException v0_7 = kotlin.io.FilesKt.walkTopDown(p12).onFail(((kotlin.jvm.functions.Function2) new kotlin.io.FilesKt__UtilsKt$copyRecursively$2(p15))).iterator();
            } catch (kotlin.io.TerminateException v0) {
                return 0;
            }
            while (v0_7.hasNext()) {
                java.io.File v3_7 = ((java.io.File) v0_7.next());
                if (v3_7.exists()) {
                    java.io.File v11 = new java.io.File(p13, kotlin.io.FilesKt.toRelativeString(v3_7, p12));
                    if ((v11.exists()) && ((!v3_7.isDirectory()) || (!v11.isDirectory()))) {
                        int v4_14;
                        if (p14) {
                            if (!v11.isDirectory()) {
                                if (v11.delete()) {
                                } else {
                                    v4_14 = 1;
                                    if (v4_14 != 0) {
                                        if (((kotlin.io.OnErrorAction) p15.invoke(v11, new kotlin.io.FileAlreadyExistsException(v3_7, v11, "The destination file already exists."))) != kotlin.io.OnErrorAction.TERMINATE) {
                                        } else {
                                            return 0;
                                        }
                                    }
                                    if (!v3_7.isDirectory()) {
                                        if ((kotlin.io.FilesKt.copyTo$default(v3_7, v11, p14, 0, 4, 0).length() != v3_7.length()) && (((kotlin.io.OnErrorAction) p15.invoke(v3_7, new java.io.IOException("Source file wasn\'t copied completely, length of destination file differs."))) == kotlin.io.OnErrorAction.TERMINATE)) {
                                            return 0;
                                        }
                                    } else {
                                        v11.mkdirs();
                                    }
                                }
                            } else {
                                if (!kotlin.io.FilesKt.deleteRecursively(v11)) {
                                }
                            }
                            v4_14 = 0;
                        }
                    }
                } else {
                    String v10_0 = new kotlin.io.NoSuchFileException;
                    v10_0(v3_7, 0, "The source file doesn\'t exist.", 2, 0);
                    if (((kotlin.io.OnErrorAction) p15.invoke(v3_7, v10_0)) == kotlin.io.OnErrorAction.TERMINATE) {
                        return 0;
                    }
                }
            }
            return 1;
        } else {
            kotlin.io.TerminateException v0_1 = new kotlin.io.NoSuchFileException;
            v0_1(p12, 0, "The source file doesn\'t exist.", 2, 0);
            if (((kotlin.io.OnErrorAction) p15.invoke(p12, v0_1)) == kotlin.io.OnErrorAction.TERMINATE) {
                v1 = 0;
            }
            return v1;
        }
    }

Method okhttp3.internal.cache.DiskLruCache.<init>() calling method java.io.File.<init>()


    DiskLruCache(okhttp3.internal.io.FileSystem p7, java.io.File p8, int p9, int p10, long p11, java.util.concurrent.Executor p13)
    {
        this.size = 0;
        this.lruEntries = new java.util.LinkedHashMap(0, 1061158912, 1);
        this.nextSequenceNumber = 0;
        this.cleanupRunnable = new okhttp3.internal.cache.DiskLruCache$1(this);
        this.fileSystem = p7;
        this.directory = p8;
        this.appVersion = p9;
        this.journalFile = new java.io.File(p8, "journal");
        this.journalFileTmp = new java.io.File(p8, "journal.tmp");
        this.journalFileBackup = new java.io.File(p8, "journal.bkp");
        this.valueCount = p10;
        this.maxSize = p11;
        this.executor = p13;
        return;
    }

Method okhttp3.internal.cache.DiskLruCache$Entry.<init>() calling method java.io.File.<init>()


    DiskLruCache$Entry(okhttp3.internal.cache.DiskLruCache p8, String p9)
    {
        this.this$0 = p8;
        this.key = p9;
        StringBuilder v0_5 = new long[p8.valueCount];
        this.lengths = v0_5;
        StringBuilder v0_7 = new java.io.File[p8.valueCount];
        this.cleanFiles = v0_7;
        StringBuilder v0_0 = new java.io.File[p8.valueCount];
        this.dirtyFiles = v0_0;
        StringBuilder v0_3 = new StringBuilder(p9).append(46);
        int v1_1 = v0_3.length();
        int v2 = 0;
        while (v2 < p8.valueCount) {
            v0_3.append(v2);
            this.cleanFiles[v2] = new java.io.File(p8.directory, v0_3.toString());
            v0_3.append(".tmp");
            this.dirtyFiles[v2] = new java.io.File(p8.directory, v0_3.toString());
            v0_3.setLength(v1_1);
            v2++;
        }
        return;
    }

Method kotlin.io.FilesKt__FilePathComponentsKt.toComponents() calling method java.io.File.<init>()


    public static final kotlin.io.FilePathComponents toComponents(java.io.File p14)
    {
        kotlin.io.FilePathComponents v5_4;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p14, "receiver$0");
        String v0_1 = p14.getPath();
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "path");
        int v1_1 = kotlin.io.FilesKt__FilePathComponentsKt.getRootLength$FilesKt__FilePathComponentsKt(v0_1);
        String v3 = v0_1.substring(0, v1_1);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v3, "(this as java.lang.Strin\u2026ing(startIndex, endIndex)");
        String v4_1 = v0_1.substring(v1_1);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v4_1, "(this as java.lang.String).substring(startIndex)");
        if (((CharSequence) v4_1).length() != 0) {
            v5_4 = 0;
        } else {
            v5_4 = 1;
        }
        java.util.List v2_1;
        if (v5_4 == null) {
            kotlin.io.FilePathComponents v5_6 = ((CharSequence) v4_1);
            java.io.File v6_1 = new char[1];
            v6_1[0] = java.io.File.separatorChar;
            kotlin.io.FilePathComponents v5_8 = ((Iterable) kotlin.text.StringsKt.split$default(v5_6, v6_1, 0, 0, 6, 0));
            java.util.Collection v7_4 = ((java.util.Collection) new java.util.ArrayList(kotlin.collections.CollectionsKt.collectionSizeOrDefault(v5_8, 10)));
            java.util.Iterator v10_1 = v5_8.iterator();
            while (v10_1.hasNext()) {
                v7_4.add(new java.io.File(((String) v10_1.next())));
            }
            v2_1 = ((java.util.List) v7_4);
        } else {
            v2_1 = kotlin.collections.CollectionsKt.emptyList();
        }
        return new kotlin.io.FilePathComponents(new java.io.File(v3), v2_1);
    }

Method kotlin.io.FilesKt__FilePathComponentsKt.getRoot() calling method java.io.File.<init>()


    public static final java.io.File getRoot(java.io.File p2)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p2, "receiver$0");
        return new java.io.File(kotlin.io.FilesKt.getRootName(p2));
    }

Method kotlin.io.FilePathComponents.subPath() calling method java.io.File.<init>()


    public final java.io.File subPath(int p12, int p13)
    {
        if ((p12 < 0) || ((p12 > p13) || (p13 > this.getSize()))) {
            throw ((Throwable) new IllegalArgumentException());
        } else {
            Iterable v2_1 = ((Iterable) this.segments.subList(p12, p13));
            String v1_2 = java.io.File.separator;
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v1_2, "File.separator");
            return new java.io.File(kotlin.collections.CollectionsKt.joinToString$default(v2_1, ((CharSequence) v1_2), 0, 0, 0, 0, 0, 62, 0));
        }
    }

Method dev.jci.mwp.activities.MyProfileActivity.deleteCompressedProfPic() calling method java.io.File.<init>()


    public final void deleteCompressedProfPic()
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("User_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        java.io.File v3_6 = new java.io.File(v1_0, v2_2.toString());
        if (v3_6.exists()) {
            v3_6.delete();
        }
        return;
    }

Method dev.jci.mwp.activities.MyProfileActivity.saveUserProfPic() calling method java.io.File.<init>()


    private final void saveUserProfPic(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("User_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        v2_2.append(".png");
        java.io.File v3_7 = new java.io.File(v1_0, v2_2.toString());
        if (v3_7.exists()) {
            v3_7.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_7);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 100, ((java.io.OutputStream) v4_2));
            this.updateCompressedPic(v3_7);
            v4_2.flush();
            v4_2.close();
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.activities.MyProfileActivity.getFileFromURI() calling method java.io.File.<init>()


    private final java.io.File getFileFromURI(android.net.Uri p3)
    {
        return new java.io.File(new dev.jci.mwp.managers.MyProfileManager().getPath(p3));
    }

Method dev.jci.mwp.activities.FloorMapActivity.saveFloorImageInExtStorage() calling method java.io.File.<init>()


    private final void saveFloorImageInExtStorage(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("Floor_");
        v2_2.append(this.floorID);
        java.io.File v3_4 = new java.io.File(v1_0, v2_2.toString());
        if (v3_4.exists()) {
            v3_4.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_4);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 90, ((java.io.OutputStream) v4_2));
            v4_2.flush();
            v4_2.close();
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.activities.FloorMapActivity.chkIfFloorImgPresent() calling method java.io.File.<init>()


    private final void chkIfFloorImgPresent()
    {
        String v0_1 = new StringBuilder();
        v0_1.append("Floor_");
        v0_1.append(this.floorID);
        String v0_2 = v0_1.toString();
        String v1_0 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v1_0, "getExternalFilesDir(null)");
        String v1_1 = v1_0.getAbsolutePath();
        android.util.Log.v("FILE_PATH:: ", v1_1);
        java.io.File v3_1 = new StringBuilder();
        v3_1.append(v1_1);
        v3_1.append("/mwp");
        java.io.File v2_3 = new java.io.File(v3_1.toString());
        v2_3.mkdirs();
        java.io.File v3_4 = new java.io.File(v2_3, v0_2);
        if (!v3_4.exists()) {
            this.downloadFloorImg();
        } else {
            android.util.Log.v("DOWNLOAD:: ", "FILE EXISTS");
            ((com.jsibbold.zoomage.ZoomageView) this._$_findCachedViewById(dev.jci.mwp.R$id.ic_floor_imageview)).setImageURI(android.net.Uri.fromFile(v3_4));
            com.jsibbold.zoomage.ZoomageView v4_8 = ((com.jsibbold.zoomage.ZoomageView) this._$_findCachedViewById(dev.jci.mwp.R$id.ic_floor_imageview));
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v4_8, "ic_floor_imageview");
            v4_8.setVisibility(0);
            this.setListeners();
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.deleteCompressedAttachment() calling method java.io.File.<init>()


    public final void deleteCompressedAttachment()
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("Feedback_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        java.io.File v3_6 = new java.io.File(v1_0, v2_2.toString());
        if (v3_6.exists()) {
            v3_6.delete();
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.compressFilenCheck() calling method java.io.File.<init>()


    public final void compressFilenCheck(android.net.Uri p12)
    {
        android.graphics.Bitmap v1 = 0;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p12, "uri");
        java.io.ByteArrayOutputStream v2_4 = android.provider.MediaStore$Images$Media.getBitmap(this.getContentResolver(), p12);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v2_4, "MediaStore.Images.Media.\u2026etContentResolver(), uri)");
        android.graphics.Bitmap v0 = v2_4;
        java.io.ByteArrayOutputStream v2_1 = new java.io.ByteArrayOutputStream();
        v0.compress(android.graphics.Bitmap$CompressFormat.JPEG, 100, ((java.io.OutputStream) v2_1));
        byte[] v3_2 = v2_1.toByteArray();
        if (v3_2.length <= 1000000) {
            String v4_6 = android.graphics.BitmapFactory.decodeStream(((java.io.InputStream) new java.io.ByteArrayInputStream(v3_2)));
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v4_6, "BitmapFactory.decodeStre\u2026ayInputStream(byteArray))");
            v1 = v4_6;
            java.io.File v5_4 = new StringBuilder();
            v5_4.append("");
            v5_4.append(v1);
            android.util.Log.d("DECODED BITMAP : ", v5_4.toString());
            java.io.File v5_7 = new java.io.File(this.getCacheDir(), "FEEDBACK_IMAGE");
            java.io.FileOutputStream v6_3 = new java.io.FileOutputStream(v5_7);
            v6_3.write(v3_2);
            v6_3.flush();
            v6_3.close();
            java.net.URI v7 = v5_7.toURI();
            String v9_1 = new StringBuilder();
            v9_1.append("");
            v9_1.append(v7);
            android.util.Log.d("URI CACHE: ", v9_1.toString());
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.saveAttachment() calling method java.io.File.<init>()


    private final void saveAttachment(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("Feedback_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        v2_2.append(".png");
        java.io.File v3_7 = new java.io.File(v1_0, v2_2.toString());
        if (v3_7.exists()) {
            v3_7.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_7);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 100, ((java.io.OutputStream) v4_2));
            v4_2.flush();
            v4_2.close();
            this.updateCompressedPic(v3_7);
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.getFileFromURI() calling method java.io.File.<init>()


    private final java.io.File getFileFromURI()
    {
        java.io.File v0_2;
        java.io.File v0_0 = this.selectedImgURI;
        if (v0_0 == null) {
            v0_2 = 0;
        } else {
            dev.jci.mwp.managers.FeedbackManager v2 = this.feedbackManager;
            if (v2 == null) {
                kotlin.jvm.internal.Intrinsics.throwUninitializedPropertyAccessException("feedbackManager");
            }
            v0_2 = v2.getPath(v0_0);
        }
        return new java.io.File(v0_2);
    }

Method dev.jci.mwp.utils.AppInitializer.clearImage() calling method java.io.File.<init>()


    public final void clearImage(android.content.Context p6)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p6, "context");
        String v0_2 = new StringBuilder();
        v0_2.append("Floor_");
        v0_2.append(dev.jci.mwp.utils.AppInitializer.floorId);
        String v0_3 = v0_2.toString();
        String v1_1 = p6.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v1_1, "context.getExternalFilesDir(null)");
        String v1_2 = v1_1.getAbsolutePath();
        java.io.File v3_1 = new StringBuilder();
        v3_1.append(v1_2);
        v3_1.append("/mwp");
        java.io.File v2_2 = new java.io.File(v3_1.toString());
        v2_2.mkdirs();
        java.io.File v3_4 = new java.io.File(v2_2, v0_3);
        if (v3_4.exists()) {
            v3_4.delete();
        }
        return;
    }

Method android.support.v4.graphics.drawable.IconCompat.loadDrawableInner() calling method java.io.File.<init>()


    private android.graphics.drawable.Drawable loadDrawableInner(android.content.Context p9)
    {
        switch (this.mType) {
            case 1:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), ((android.graphics.Bitmap) this.mObj1));
            case 2:
                String v0_11 = this.getResPackage();
                if (android.text.TextUtils.isEmpty(v0_11)) {
                    v0_11 = p9.getPackageName();
                }
                try {
                    return android.support.v4.content.res.ResourcesCompat.getDrawable(android.support.v4.graphics.drawable.IconCompat.getResources(p9, v0_11), this.mInt1, p9.getTheme());
                } catch (android.graphics.drawable.BitmapDrawable v3_17) {
                    String v6_3 = new Object[2];
                    v6_3[0] = Integer.valueOf(this.mInt1);
                    v6_3[1] = this.mObj1;
                    android.util.Log.e("IconCompat", String.format("Unable to load resource 0x%08x from pkg=%s", v6_3), v3_17);
                }
            case 3:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.graphics.BitmapFactory.decodeByteArray(((byte[]) this.mObj1), this.mInt1, this.mInt2));
            case 4:
                java.io.FileInputStream v2_2;
                String v0_7 = android.net.Uri.parse(((String) this.mObj1));
                String v1_4 = v0_7.getScheme();
                if ((!"content".equals(v1_4)) && (!"file".equals(v1_4))) {
                    try {
                        v2_2 = new java.io.FileInputStream(new java.io.File(((String) this.mObj1)));
                    } catch (android.graphics.drawable.BitmapDrawable v3_6) {
                        android.graphics.Bitmap v5_3 = new StringBuilder();
                        v5_3.append("Unable to load image from path: ");
                        v5_3.append(v0_7);
                        android.util.Log.w("IconCompat", v5_3.toString(), v3_6);
                    }
                } else {
                    try {
                        v2_2 = p9.getContentResolver().openInputStream(v0_7);
                    } catch (android.graphics.drawable.BitmapDrawable v3_9) {
                        android.graphics.Bitmap v5_6 = new StringBuilder();
                        v5_6.append("Unable to load image from URI: ");
                        v5_6.append(v0_7);
                        android.util.Log.w("IconCompat", v5_6.toString(), v3_9);
                    }
                }
                if (v2_2 == null) {
                } else {
                    return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.graphics.BitmapFactory.decodeStream(v2_2));
                }
            case 5:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.support.v4.graphics.drawable.IconCompat.createLegacyIconFromAdaptiveIcon(((android.graphics.Bitmap) this.mObj1), 0));
            default:
        }
        return 0;
    }

Method io.fabric.sdk.android.services.settings.DefaultCachedSettingsIo.writeCachedSettings() calling method java.io.File.<init>()


    public void writeCachedSettings(long p6, org.json.JSONObject p8)
    {
        io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Writing settings to cache file...");
        if (p8 != null) {
            try {
                p8.put("expires_at", p6);
                java.io.FileWriter v0_1 = new java.io.FileWriter(new java.io.File(new io.fabric.sdk.android.services.persistence.FileStoreImpl(this.kit).getFilesDir(), "com.crashlytics.settings.json"));
                v0_1.write(p8.toString());
                v0_1.flush();
            } catch (String v1_4) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Failed to close settings writer.");
                throw v1_4;
            } catch (String v1_3) {
                io.fabric.sdk.android.Fabric.getLogger().e("Fabric", "Failed to cache settings", v1_3);
            }
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Failed to close settings writer.");
        }
        return;
    }

Method io.fabric.sdk.android.services.settings.DefaultCachedSettingsIo.readCachedSettings() calling method java.io.File.<init>()


    public org.json.JSONObject readCachedSettings()
    {
        io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Reading cached settings...");
        java.io.FileInputStream v0_1 = 0;
        org.json.JSONObject v1_1 = 0;
        try {
            String v2_0 = new java.io.File(new io.fabric.sdk.android.services.persistence.FileStoreImpl(this.kit).getFilesDir(), "com.crashlytics.settings.json");
        } catch (String v2_3) {
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            throw v2_3;
        } catch (String v2_2) {
            io.fabric.sdk.android.Fabric.getLogger().e("Fabric", "Failed to fetch cached settings", v2_2);
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        }
        if (!v2_0.exists()) {
            io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "No cached settings found.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        } else {
            v0_1 = new java.io.FileInputStream(v2_0);
            v1_1 = new org.json.JSONObject(io.fabric.sdk.android.services.common.CommonUtils.streamToString(v0_1));
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        }
    }

Method io.fabric.sdk.android.services.persistence.FileStoreImpl.getExternalFilesDir() calling method java.io.File.<init>()


    public java.io.File getExternalFilesDir()
    {
        java.io.File v0 = 0;
        if (this.isExternalStorageAvailable()) {
            if (android.os.Build$VERSION.SDK_INT < 8) {
                java.io.File v2_2 = android.os.Environment.getExternalStorageDirectory();
                String v3_1 = new StringBuilder();
                v3_1.append(this.legacySupport);
                v3_1.append("/files/");
                v3_1.append(this.contentPath);
                v0 = new java.io.File(v2_2, v3_1.toString());
            } else {
                v0 = this.context.getExternalFilesDir(0);
            }
        }
        return this.prepare(v0);
    }

Method io.fabric.sdk.android.services.persistence.FileStoreImpl.getExternalCacheDir() calling method java.io.File.<init>()


    public java.io.File getExternalCacheDir()
    {
        java.io.File v0 = 0;
        if (this.isExternalStorageAvailable()) {
            if (android.os.Build$VERSION.SDK_INT < 8) {
                java.io.File v2_1 = android.os.Environment.getExternalStorageDirectory();
                String v3_1 = new StringBuilder();
                v3_1.append(this.legacySupport);
                v3_1.append("/cache/");
                v3_1.append(this.contentPath);
                v0 = new java.io.File(v2_1, v3_1.toString());
            } else {
                v0 = this.context.getExternalCacheDir();
            }
        }
        return this.prepare(v0);
    }

Method io.fabric.sdk.android.services.events.QueueFileEventStorage.rollOver() calling method java.io.File.<init>()


    public void rollOver(String p4)
    {
        this.queueFile.close();
        this.move(this.workingFile, new java.io.File(this.targetDirectory, p4));
        this.queueFile = new io.fabric.sdk.android.services.common.QueueFile(this.workingFile);
        return;
    }

Method io.fabric.sdk.android.services.events.QueueFileEventStorage.createTargetDirectory() calling method java.io.File.<init>()


    private void createTargetDirectory()
    {
        this.targetDirectory = new java.io.File(this.workingDirectory, this.targetDirectoryName);
        if (!this.targetDirectory.exists()) {
            this.targetDirectory.mkdirs();
        }
        return;
    }

Method io.fabric.sdk.android.services.events.QueueFileEventStorage.<init>() calling method java.io.File.<init>()


    public QueueFileEventStorage(android.content.Context p3, java.io.File p4, String p5, String p6)
    {
        this.context = p3;
        this.workingDirectory = p4;
        this.targetDirectoryName = p6;
        this.workingFile = new java.io.File(this.workingDirectory, p5);
        this.queueFile = new io.fabric.sdk.android.services.common.QueueFile(this.workingFile);
        this.createTargetDirectory();
        return;
    }

Method com.microsoft.identity.common.adal.internal.cache.StorageHelper.writeKeyData() calling method java.io.File.<init>()


    private void writeKeyData(byte[] p5)
    {
        android.util.Log.v("StorageHelper", "Writing key data to a file");
        java.io.FileOutputStream v1_3 = new java.io.FileOutputStream(new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks"));
        try {
            v1_3.write(p5);
            v1_3.close();
            return;
        } catch (Throwable v2_1) {
            v1_3.close();
            throw v2_1;
        }
    }

Method com.microsoft.identity.common.adal.internal.cache.StorageHelper.readKeyData() calling method java.io.File.<init>()


    private byte[] readKeyData()
    {
        java.io.File v0_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (!v0_1.exists()) {
            throw new java.io.IOException("Key file to read does not exist");
        } else {
            android.util.Log.v("StorageHelper", "Reading key data from a file");
            java.io.IOException v1_6 = new java.io.FileInputStream(v0_1);
            try {
                Throwable v2_4 = new java.io.ByteArrayOutputStream();
                byte[] v4_1 = new byte[1024];
            } catch (Throwable v2_5) {
                v1_6.close();
                throw v2_5;
            }
            while(true) {
                int v5 = v1_6.read(v4_1);
                if (v5 == -1) {
                    break;
                }
                v2_4.write(v4_1, 0, v5);
            }
            byte[] v3_0 = v2_4.toByteArray();
            v1_6.close();
            return v3_0;
        }
    }

Method com.microsoft.identity.common.adal.internal.cache.StorageHelper.deleteKeyFile() calling method java.io.File.<init>()


    private void deleteKeyFile()
    {
        java.io.File v0_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (v0_1.exists()) {
            android.util.Log.v("StorageHelper", "Delete KeyFile");
            if (!v0_1.delete()) {
                android.util.Log.v("StorageHelper", "Delete KeyFile failed");
            }
        }
        return;
    }

Method com.microsoft.aad.adal.FileTokenCacheStore.<init>() calling method java.io.File.<init>()


    public FileTokenCacheStore(android.content.Context p10, String p11)
    {
        this.mCacheLock = new Object();
        if (p10 == null) {
            throw new IllegalArgumentException("context");
        } else {
            if (com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p11)) {
                throw new IllegalArgumentException("fileName");
            } else {
                IllegalArgumentException v1_4 = p10.getDir(p10.getPackageName(), 0);
                if (v1_4 == null) {
                    throw new IllegalStateException("It could not access the Authorization cache directory");
                } else {
                    try {
                        this.mFile = new java.io.File(v1_4, p11);
                    } catch (com.microsoft.aad.adal.MemoryTokenCacheStore v2_19) {
                        String v3_13 = new StringBuilder();
                        v3_13.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v3_13.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.e(v3_13.toString(), "Exception during cache load. ", com.microsoft.aad.adal.ExceptionExtensions.getExceptionMessage(v2_19), com.microsoft.aad.adal.ADALError.DEVICE_FILE_CACHE_IS_NOT_LOADED_FROM_FILE);
                        throw new IllegalStateException(v2_19);
                    }
                    if (!this.mFile.exists()) {
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_9 = new StringBuilder();
                        v2_9.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v2_9.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.v(v2_9.toString(), "There is not any previous cache file to load cache. ");
                        this.mInMemoryCache = new com.microsoft.aad.adal.MemoryTokenCacheStore();
                    } else {
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_14 = new StringBuilder();
                        v2_14.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v2_14.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.v(v2_14.toString(), "There is previous cache file to load cache. ");
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_17 = new java.io.FileInputStream(this.mFile);
                        String v3_11 = new java.io.ObjectInputStream(v2_17);
                        Object v4_0 = v3_11.readObject();
                        v2_17.close();
                        v3_11.close();
                        if (!(v4_0 instanceof com.microsoft.aad.adal.MemoryTokenCacheStore)) {
                            com.microsoft.aad.adal.MemoryTokenCacheStore v5_2 = new StringBuilder();
                            v5_2.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                            v5_2.append(":FileTokenCacheStore");
                            com.microsoft.aad.adal.Logger.w(v5_2.toString(), "Existing cache format is wrong. ", "", com.microsoft.aad.adal.ADALError.DEVICE_FILE_CACHE_FORMAT_IS_WRONG);
                            this.mInMemoryCache = new com.microsoft.aad.adal.MemoryTokenCacheStore();
                        } else {
                            this.mInMemoryCache = ((com.microsoft.aad.adal.MemoryTokenCacheStore) v4_0);
                        }
                    }
                    return;
                }
            }
        }
    }

Method com.google.android.exoplayer2.upstream.cache.SimpleCacheSpan.getCacheFile() calling method java.io.File.<init>()


    public static java.io.File getCacheFile(java.io.File p3, int p4, long p5, long p7)
    {
        String v1_2 = new StringBuilder();
        v1_2.append(p4);
        v1_2.append(".");
        v1_2.append(p5);
        v1_2.append(".");
        v1_2.append(p7);
        v1_2.append(".v3.exo");
        return new java.io.File(p3, v1_2.toString());
    }

Method com.crashlytics.android.core.CrashlyticsController$LogFileDirectoryProvider.getLogFileDir() calling method java.io.File.<init>()


    public java.io.File getLogFileDir()
    {
        java.io.File v0_1 = new java.io.File(this.rootFileStore.getFilesDir(), "log-files");
        if (!v0_1.exists()) {
            v0_1.mkdirs();
        }
        return v0_1;
    }

Method com.crashlytics.android.answers.Answers.onPreExecute() calling method java.io.File.<init>()


    protected boolean onPreExecute()
    {
        try {
            boolean v3_3;
            Exception v2_0 = this.getContext();
            android.content.pm.PackageManager v10 = v2_0.getPackageManager();
            String v11 = v2_0.getPackageName();
            android.content.pm.PackageInfo v12 = v10.getPackageInfo(v11, 0);
            String v6 = Integer.toString(v12.versionCode);
        } catch (Exception v2_1) {
            io.fabric.sdk.android.Fabric.getLogger().e("Answers", "Error retrieving app properties", v2_1);
            return 0;
        }
        if (v12.versionName != null) {
            v3_3 = v12.versionName;
        } else {
            v3_3 = "0.0";
        }
        long v8;
        if (android.os.Build$VERSION.SDK_INT < 9) {
            v8 = new java.io.File(v10.getApplicationInfo(v11, 0).sourceDir).lastModified();
        } else {
            v8 = v12.firstInstallTime;
        }
        this.analyticsManager = com.crashlytics.android.answers.SessionAnalyticsManager.build(this, v2_0, this.getIdManager(), v6, v3_3, v8);
        this.analyticsManager.enable();
        this.firebaseEnabled = new io.fabric.sdk.android.services.common.FirebaseInfo().isFirebaseCrashlyticsEnabled(v2_0);
        return 1;
    }

Method com.bumptech.glide.load.model.StringLoader.toFileUri() calling method java.io.File.<init>()


    private static android.net.Uri toFileUri(String p1)
    {
        return android.net.Uri.fromFile(new java.io.File(p1));
    }

Method com.bumptech.glide.load.engine.cache.InternalCacheDiskCacheFactory$1.getCacheDirectory() calling method java.io.File.<init>()


    public java.io.File getCacheDirectory()
    {
        java.io.File v0_1 = this.val$context.getCacheDir();
        if (v0_1 != null) {
            if (this.val$diskCacheName == null) {
                return v0_1;
            } else {
                return new java.io.File(v0_1, this.val$diskCacheName);
            }
        } else {
            return 0;
        }
    }

Method com.bumptech.glide.load.engine.cache.ExternalCacheDiskCacheFactory$1.getCacheDirectory() calling method java.io.File.<init>()


    public java.io.File getCacheDirectory()
    {
        java.io.File v0_1 = this.val$context.getExternalCacheDir();
        if (v0_1 != null) {
            if (this.val$diskCacheName == null) {
                return v0_1;
            } else {
                return new java.io.File(v0_1, this.val$diskCacheName);
            }
        } else {
            return 0;
        }
    }

Method com.bumptech.glide.load.engine.cache.DiskLruCacheFactory$2.getCacheDirectory() calling method java.io.File.<init>()


    public java.io.File getCacheDirectory()
    {
        return new java.io.File(this.val$diskCacheFolder, this.val$diskCacheName);
    }

Method com.bumptech.glide.load.engine.cache.DiskLruCacheFactory$1.getCacheDirectory() calling method java.io.File.<init>()


    public java.io.File getCacheDirectory()
    {
        return new java.io.File(this.val$diskCacheFolder);
    }

Method android.support.v4.provider.RawDocumentFile.renameTo() calling method java.io.File.<init>()


    public boolean renameTo(String p3)
    {
        java.io.File v0_1 = new java.io.File(this.mFile.getParentFile(), p3);
        if (!this.mFile.renameTo(v0_1)) {
            return 0;
        } else {
            this.mFile = v0_1;
            return 1;
        }
    }

Method android.support.v4.provider.RawDocumentFile.createFile() calling method java.io.File.<init>()


    public android.support.v4.provider.DocumentFile createFile(String p7, String p8)
    {
        String v0_1 = android.webkit.MimeTypeMap.getSingleton().getExtensionFromMimeType(p7);
        if (v0_1 != null) {
            java.io.File v1_3 = new StringBuilder();
            v1_3.append(p8);
            v1_3.append(".");
            v1_3.append(v0_1);
            p8 = v1_3.toString();
        }
        java.io.File v1_1 = new java.io.File(this.mFile, p8);
        try {
            v1_1.createNewFile();
            return new android.support.v4.provider.RawDocumentFile(this, v1_1);
        } catch (java.io.IOException v2_3) {
            String v4_1 = new StringBuilder();
            v4_1.append("Failed to createFile: ");
            v4_1.append(v2_3);
            android.util.Log.w("DocumentFile", v4_1.toString());
            return 0;
        }
    }

Method android.support.v4.provider.RawDocumentFile.createDirectory() calling method java.io.File.<init>()


    public android.support.v4.provider.DocumentFile createDirectory(String p3)
    {
        java.io.File v0_1 = new java.io.File(this.mFile, p3);
        if ((!v0_1.isDirectory()) && (!v0_1.mkdir())) {
            return 0;
        } else {
            return new android.support.v4.provider.RawDocumentFile(this, v0_1);
        }
    }

Method android.support.v4.graphics.TypefaceCompatApi21Impl.getFile() calling method java.io.File.<init>()


    private java.io.File getFile(android.os.ParcelFileDescriptor p4)
    {
        try {
            android.system.ErrnoException v1_2 = new StringBuilder();
            v1_2.append("/proc/self/fd/");
            v1_2.append(p4.getFd());
            android.system.ErrnoException v1_1 = android.system.Os.readlink(v1_2.toString());
        } catch (android.system.ErrnoException v1) {
            return 0;
        }
        if (!android.system.OsConstants.S_ISREG(android.system.Os.stat(v1_1).st_mode)) {
            return 0;
        } else {
            return new java.io.File(v1_1);
        }
    }

Method android.support.v4.content.FileProvider$SimplePathStrategy.getFileForUri() calling method java.io.File.<init>()


    public java.io.File getFileForUri(android.net.Uri p10)
    {
        String v0_0 = p10.getEncodedPath();
        int v2_1 = v0_0.indexOf(47, 1);
        String v1_2 = android.net.Uri.decode(v0_0.substring(1, v2_1));
        String vtmp6 = android.net.Uri.decode(v0_0.substring((v2_1 + 1)));
        java.io.File v3_4 = ((java.io.File) this.mRoots.get(v1_2));
        if (v3_4 == null) {
            SecurityException v5_1 = new StringBuilder();
            v5_1.append("Unable to find configured root for ");
            v5_1.append(p10);
            throw new IllegalArgumentException(v5_1.toString());
        } else {
            try {
                java.io.File v4_4 = new java.io.File(v3_4, vtmp6).getCanonicalFile();
            } catch (SecurityException v5) {
                String v7_1 = new StringBuilder();
                v7_1.append("Failed to resolve canonical path for ");
                v7_1.append(v4_4);
                throw new IllegalArgumentException(v7_1.toString());
            }
            if (!v4_4.getPath().startsWith(v3_4.getPath())) {
                throw new SecurityException("Resolved path jumped beyond configured root");
            } else {
                return v4_4;
            }
        }
    }

Method io.fabric.sdk.android.services.common.QueueFile.initialize() calling method java.io.File.<init>()


    private static void initialize(java.io.File p4)
    {
        java.io.RandomAccessFile v1_2 = new StringBuilder();
        v1_2.append(p4.getPath());
        v1_2.append(".tmp");
        java.io.File v0_1 = new java.io.File(v1_2.toString());
        java.io.RandomAccessFile v1_1 = io.fabric.sdk.android.services.common.QueueFile.open(v0_1);
        try {
            v1_1.setLength(4096);
            v1_1.seek(0);
            java.io.IOException v2_3 = new byte[16];
            String v3_1 = new int[4];
            v3_1 = {4096, 0, 0, 0};
            io.fabric.sdk.android.services.common.QueueFile.writeInts(v2_3, v3_1);
            v1_1.write(v2_3);
            v1_1.close();
        } catch (java.io.IOException v2_5) {
            v1_1.close();
            throw v2_5;
        }
        if (!v0_1.renameTo(p4)) {
            throw new java.io.IOException("Rename failed!");
        } else {
            return;
        }
    }

Method io.fabric.sdk.android.services.common.CommonUtils.isRooted() calling method java.io.File.<init>()


    public static boolean isRooted(android.content.Context p6)
    {
        boolean v0 = io.fabric.sdk.android.services.common.CommonUtils.isEmulator(p6);
        String v1 = android.os.Build.TAGS;
        if ((v0) || ((v1 == null) || (!v1.contains("test-keys")))) {
            if (!new java.io.File("/system/app/Superuser.apk").exists()) {
                boolean v4_3 = new java.io.File("/system/xbin/su");
                if ((v0) || (!v4_3.exists())) {
                    return 0;
                } else {
                    return 1;
                }
            } else {
                return 1;
            }
        } else {
            return 1;
        }
    }

Method io.fabric.sdk.android.services.common.CommonUtils.getTotalRamInBytes() calling method java.io.File.<init>()


    public static declared_synchronized long getTotalRamInBytes()
    {
        try {
            if (io.fabric.sdk.android.services.common.CommonUtils.totalRamInBytes == -1) {
                long v1_2 = 0;
                String v3_0 = io.fabric.sdk.android.services.common.CommonUtils.extractFieldFromSystemFile(new java.io.File("/proc/meminfo"), "MemTotal");
                if (!android.text.TextUtils.isEmpty(v3_0)) {
                    String v3_1 = v3_0.toUpperCase(java.util.Locale.US);
                    try {
                        if (!v3_1.endsWith("KB")) {
                            if (!v3_1.endsWith("MB")) {
                                if (!v3_1.endsWith("GB")) {
                                    io.fabric.sdk.android.Logger v4_9 = io.fabric.sdk.android.Fabric.getLogger();
                                    String v6_1 = new StringBuilder();
                                    v6_1.append("Unexpected meminfo format while computing RAM: ");
                                    v6_1.append(v3_1);
                                    v4_9.d("Fabric", v6_1.toString());
                                } else {
                                    v1_2 = io.fabric.sdk.android.services.common.CommonUtils.convertMemInfoToBytes(v3_1, "GB", 1073741824);
                                }
                            } else {
                                v1_2 = io.fabric.sdk.android.services.common.CommonUtils.convertMemInfoToBytes(v3_1, "MB", 1048576);
                            }
                        } else {
                            v1_2 = io.fabric.sdk.android.services.common.CommonUtils.convertMemInfoToBytes(v3_1, "KB", 1024);
                        }
                    } catch (io.fabric.sdk.android.Logger v4_16) {
                        String v5_4 = io.fabric.sdk.android.Fabric.getLogger();
                        String v7_2 = new StringBuilder();
                        v7_2.append("Unexpected meminfo format while computing RAM: ");
                        v7_2.append(v3_1);
                        v5_4.e("Fabric", v7_2.toString(), v4_16);
                    }
                }
                io.fabric.sdk.android.services.common.CommonUtils.totalRamInBytes = v1_2;
            }
        } catch (long v1_3) {
            throw v1_3;
        }
        return io.fabric.sdk.android.services.common.CommonUtils.totalRamInBytes;
    }

Method io.fabric.sdk.android.FabricContext.getFilesDir() calling method java.io.File.<init>()


    public java.io.File getFilesDir()
    {
        return new java.io.File(super.getFilesDir(), this.componentPath);
    }

Method io.fabric.sdk.android.FabricContext.getExternalFilesDir() calling method java.io.File.<init>()


    public java.io.File getExternalFilesDir(String p4)
    {
        return new java.io.File(super.getExternalFilesDir(p4), this.componentPath);
    }

Method io.fabric.sdk.android.FabricContext.getExternalCacheDir() calling method java.io.File.<init>()


    public java.io.File getExternalCacheDir()
    {
        return new java.io.File(super.getExternalCacheDir(), this.componentPath);
    }

Method io.fabric.sdk.android.FabricContext.getDatabasePath() calling method java.io.File.<init>()


    public java.io.File getDatabasePath(String p4)
    {
        java.io.File v0_1 = new java.io.File(super.getDatabasePath(p4).getParentFile(), this.componentPath);
        v0_1.mkdirs();
        return new java.io.File(v0_1, p4);
    }

Method io.fabric.sdk.android.FabricContext.getCacheDir() calling method java.io.File.<init>()


    public java.io.File getCacheDir()
    {
        return new java.io.File(super.getCacheDir(), this.componentPath);
    }

Method com.squareup.okhttp.internal.DiskLruCache.<init>() calling method java.io.File.<init>()


    DiskLruCache(com.squareup.okhttp.internal.io.FileSystem p7, java.io.File p8, int p9, int p10, long p11, java.util.concurrent.Executor p13)
    {
        this.size = 0;
        this.lruEntries = new java.util.LinkedHashMap(0, 1061158912, 1);
        this.nextSequenceNumber = 0;
        this.cleanupRunnable = new com.squareup.okhttp.internal.DiskLruCache$1(this);
        this.fileSystem = p7;
        this.directory = p8;
        this.appVersion = p9;
        this.journalFile = new java.io.File(p8, "journal");
        this.journalFileTmp = new java.io.File(p8, "journal.tmp");
        this.journalFileBackup = new java.io.File(p8, "journal.bkp");
        this.valueCount = p10;
        this.maxSize = p11;
        this.executor = p13;
        return;
    }

Method com.squareup.okhttp.internal.DiskLruCache$Entry.<init>() calling method java.io.File.<init>()


    private DiskLruCache$Entry(com.squareup.okhttp.internal.DiskLruCache p8, String p9)
    {
        this.this$0 = p8;
        this.key = p9;
        StringBuilder v0_6 = new long[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.lengths = v0_6;
        StringBuilder v0_8 = new java.io.File[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.cleanFiles = v0_8;
        StringBuilder v0_1 = new java.io.File[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.dirtyFiles = v0_1;
        StringBuilder v0_4 = new StringBuilder(p9).append(46);
        int v1_1 = v0_4.length();
        int v2 = 0;
        while (v2 < com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)) {
            v0_4.append(v2);
            this.cleanFiles[v2] = new java.io.File(com.squareup.okhttp.internal.DiskLruCache.access$2800(p8), v0_4.toString());
            v0_4.append(".tmp");
            this.dirtyFiles[v2] = new java.io.File(com.squareup.okhttp.internal.DiskLruCache.access$2800(p8), v0_4.toString());
            v0_4.setLength(v1_1);
            v2++;
        }
        return;
    }

Method com.microsoft.aad.adal.StorageHelper.writeKeyData() calling method java.io.File.<init>()


    private void writeKeyData(byte[] p5)
    {
        com.microsoft.aad.adal.Logger.v("StorageHelper", "Writing key data to a file");
        java.io.FileOutputStream v1_3 = new java.io.FileOutputStream(new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks"));
        try {
            v1_3.write(p5);
            v1_3.close();
            return;
        } catch (Throwable v2_1) {
            v1_3.close();
            throw v2_1;
        }
    }

Method com.microsoft.aad.adal.StorageHelper.readKeyData() calling method java.io.File.<init>()


    private byte[] readKeyData()
    {
        java.io.File v0_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (!v0_1.exists()) {
            throw new java.io.IOException("Key file to read does not exist");
        } else {
            com.microsoft.aad.adal.Logger.v("StorageHelper", "Reading key data from a file");
            java.io.IOException v1_6 = new java.io.FileInputStream(v0_1);
            try {
                Throwable v2_4 = new java.io.ByteArrayOutputStream();
                byte[] v4_1 = new byte[1024];
            } catch (Throwable v2_5) {
                v1_6.close();
                throw v2_5;
            }
            while(true) {
                int v5 = v1_6.read(v4_1);
                if (v5 == -1) {
                    break;
                }
                v2_4.write(v4_1, 0, v5);
            }
            byte[] v3_0 = v2_4.toByteArray();
            v1_6.close();
            return v3_0;
        }
    }

Method com.microsoft.aad.adal.StorageHelper.deleteKeyFile() calling method java.io.File.<init>()


    private void deleteKeyFile()
    {
        java.io.File v1_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (v1_1.exists()) {
            com.microsoft.aad.adal.Logger.v("StorageHelper:deleteKeyFile", "Delete KeyFile");
            if (!v1_1.delete()) {
                com.microsoft.aad.adal.Logger.v("StorageHelper:deleteKeyFile", "Delete KeyFile failed");
            }
        }
        return;
    }

Method com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.<clinit>() calling method java.io.File.<init>()


    static PRNGFixes$LinuxPRNGSecureRandom()
    {
        com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.URANDOM_FILE = new java.io.File("/dev/urandom");
        com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.SLOCK = new Object();
        return;
    }

Method com.google.android.gms.common.util.SharedPreferencesUtils.publishWorldReadableSharedPreferences() calling method java.io.File.<init>()


    public static void publishWorldReadableSharedPreferences(android.content.Context p3, android.content.SharedPreferences$Editor p4, String p5)
    {
        java.io.File v0_1 = new java.io.File(p3.getApplicationInfo().dataDir, "shared_prefs");
        java.io.File v3_5 = v0_1.getParentFile();
        if (v3_5 != null) {
            v3_5.setExecutable(1, 0);
        }
        v0_1.setExecutable(1, 0);
        p4.commit();
        new java.io.File(v0_1, String.valueOf(p5).concat(".xml")).setReadable(1, 0);
        return;
    }

Method com.google.android.exoplayer2.util.AtomicFile.<init>() calling method java.io.File.<init>()


    public AtomicFile(java.io.File p4)
    {
        this.baseName = p4;
        String v1_2 = new StringBuilder();
        v1_2.append(p4.getPath());
        v1_2.append(".bak");
        this.backupName = new java.io.File(v1_2.toString());
        return;
    }

Method com.google.android.exoplayer2.upstream.cache.CachedContentIndex.<init>() calling method java.io.File.<init>()


    public CachedContentIndex(java.io.File p4, byte[] p5, boolean p6)
    {
        this.encrypt = p6;
        if (p5 == null) {
            com.google.android.exoplayer2.util.Assertions.checkState((p6 ^ 1));
            this.cipher = 0;
            this.secretKeySpec = 0;
        } else {
            java.security.NoSuchAlgorithmException v0_0;
            if (p5.length != 16) {
                v0_0 = 0;
            } else {
                v0_0 = 1;
            }
            com.google.android.exoplayer2.util.Assertions.checkArgument(v0_0);
            try {
                this.cipher = com.google.android.exoplayer2.upstream.cache.CachedContentIndex.getCipher();
                this.secretKeySpec = new javax.crypto.spec.SecretKeySpec(p5, "AES");
            } catch (java.security.NoSuchAlgorithmException v0_4) {
                throw new IllegalStateException(v0_4);
            }
        }
        this.keyToContent = new java.util.HashMap();
        this.idToKey = new android.util.SparseArray();
        this.atomicFile = new com.google.android.exoplayer2.util.AtomicFile(new java.io.File(p4, "cached_content_index.exi"));
        return;
    }

Method com.crashlytics.android.core.MetaDataStore.getUserDataFileForSession() calling method java.io.File.<init>()


    public java.io.File getUserDataFileForSession(String p5)
    {
        java.io.File v1 = this.filesDir;
        String v2_2 = new StringBuilder();
        v2_2.append(p5);
        v2_2.append("user");
        v2_2.append(".meta");
        return new java.io.File(v1, v2_2.toString());
    }

Method com.crashlytics.android.core.MetaDataStore.getKeysFileForSession() calling method java.io.File.<init>()


    public java.io.File getKeysFileForSession(String p5)
    {
        java.io.File v1 = this.filesDir;
        String v2_2 = new StringBuilder();
        v2_2.append(p5);
        v2_2.append("keys");
        v2_2.append(".meta");
        return new java.io.File(v1, v2_2.toString());
    }

Method com.crashlytics.android.core.LogFileManager.getWorkingFileForSession() calling method java.io.File.<init>()


    private java.io.File getWorkingFileForSession(String p4)
    {
        String v0_1 = new StringBuilder();
        v0_1.append("crashlytics-userlog-");
        v0_1.append(p4);
        v0_1.append(".temp");
        return new java.io.File(this.directoryProvider.getLogFileDir(), v0_1.toString());
    }

Method com.crashlytics.android.core.CrashlyticsFileMarker.getMarkerFile() calling method java.io.File.<init>()


    private java.io.File getMarkerFile()
    {
        return new java.io.File(this.fileStore.getFilesDir(), this.markerName);
    }

Method com.crashlytics.android.core.CrashlyticsController.getNonFatalSessionFilesDir() calling method java.io.File.<init>()


    java.io.File getNonFatalSessionFilesDir()
    {
        return new java.io.File(this.getFilesDir(), "nonfatal-sessions");
    }

Method com.crashlytics.android.core.CrashlyticsController.getInvalidFilesDir() calling method java.io.File.<init>()


    java.io.File getInvalidFilesDir()
    {
        return new java.io.File(this.getFilesDir(), "invalidClsFiles");
    }

Method com.crashlytics.android.core.CrashlyticsController.getFatalSessionFilesDir() calling method java.io.File.<init>()


    java.io.File getFatalSessionFilesDir()
    {
        return new java.io.File(this.getFilesDir(), "fatal-sessions");
    }

Method com.crashlytics.android.core.CrashlyticsController.doCleanInvalidTempFiles() calling method java.io.File.<init>()


    void doCleanInvalidTempFiles(java.io.File[] p12)
    {
        java.util.HashSet v0_1 = new java.util.HashSet();
        java.io.File v1_1 = p12.length;
        int v2 = 0;
        com.crashlytics.android.core.CrashlyticsController$15 v3_3 = 0;
        while (v3_3 < v1_1) {
            java.io.File[] v4_1 = p12[v3_3];
            int v5_1 = io.fabric.sdk.android.Fabric.getLogger();
            io.fabric.sdk.android.Logger v7_6 = new StringBuilder();
            v7_6.append("Found invalid session part file: ");
            v7_6.append(v4_1);
            v5_1.d("CrashlyticsCore", v7_6.toString());
            v0_1.add(com.crashlytics.android.core.CrashlyticsController.getSessionIdFromSessionFile(v4_1));
            v3_3++;
        }
        if (!v0_1.isEmpty()) {
            java.io.File v1_0 = this.getInvalidFilesDir();
            if (!v1_0.exists()) {
                v1_0.mkdir();
            }
            java.io.File[] v4_0 = this.listFilesMatching(new com.crashlytics.android.core.CrashlyticsController$15(this, v0_1));
            int v5_0 = v4_0.length;
            while (v2 < v5_0) {
                java.io.File v6_0 = v4_0[v2];
                io.fabric.sdk.android.Logger v7_0 = io.fabric.sdk.android.Fabric.getLogger();
                String v9_1 = new StringBuilder();
                v9_1.append("Moving session file: ");
                v9_1.append(v6_0);
                v7_0.d("CrashlyticsCore", v9_1.toString());
                if (!v6_0.renameTo(new java.io.File(v1_0, v6_0.getName()))) {
                    io.fabric.sdk.android.Logger v7_4 = io.fabric.sdk.android.Fabric.getLogger();
                    String v9_4 = new StringBuilder();
                    v9_4.append("Could not move session file. Deleting ");
                    v9_4.append(v6_0);
                    v7_4.d("CrashlyticsCore", v9_4.toString());
                    v6_0.delete();
                }
                v2++;
            }
            this.trimInvalidSessionFiles();
            return;
        } else {
            return;
        }
    }

Method com.crashlytics.android.core.CrashlyticsController.writeFile() calling method java.io.File.<init>()


    private void writeFile(String p6, String p7, com.crashlytics.android.core.CrashlyticsController$FileOutputStreamWriteAction p8)
    {
        try {
            String v3_2 = this.getFilesDir();
            String v4_2 = new StringBuilder();
            v4_2.append(p6);
            v4_2.append(p7);
            java.io.FileOutputStream v0 = new java.io.FileOutputStream(new java.io.File(v3_2, v4_2.toString()));
            p8.writeTo(v0);
            Throwable v1_3 = new StringBuilder();
            v1_3.append("Failed to close ");
            v1_3.append(p7);
            v1_3.append(" file.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, v1_3.toString());
            return;
        } catch (Throwable v1_5) {
            String v2_5 = new StringBuilder();
            v2_5.append("Failed to close ");
            v2_5.append(p7);
            v2_5.append(" file.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, v2_5.toString());
            throw v1_5;
        }
    }

Method com.crashlytics.android.core.CrashlyticsController.readFile() calling method java.io.File.<init>()


    private byte[] readFile(String p4, String p5)
    {
        java.io.File v1 = this.getFilesDir();
        String v2_1 = new StringBuilder();
        v2_1.append(p4);
        v2_1.append(p5);
        return com.crashlytics.android.core.NativeFileUtils.readFile(new java.io.File(v1, v2_1.toString()));
    }

Method com.crashlytics.android.core.CrashlyticsController.finalizeMostRecentNativeCrash() calling method java.io.File.<init>()


    private void finalizeMostRecentNativeCrash(android.content.Context p18, java.io.File p19, String p20)
    {
        byte[] v3 = com.crashlytics.android.core.NativeFileUtils.minidumpFromDirectory(p19);
        byte[] v4 = com.crashlytics.android.core.NativeFileUtils.metadataJsonFromDirectory(p19);
        byte[] v6 = com.crashlytics.android.core.NativeFileUtils.binaryImagesJsonFromDirectory(p19, p18);
        if ((v3 != null) && (v3.length != 0)) {
            com.crashlytics.android.core.CrashlyticsController.recordFatalExceptionAnswersEvent(p20, "<native-crash: minidump>");
            byte[] v7_6 = this.readFile(p20, "BeginSession.json");
            byte[] v8_2 = this.readFile(p20, "SessionApp.json");
            byte[] v9_1 = this.readFile(p20, "SessionDevice.json");
            byte[] v10_1 = this.readFile(p20, "SessionOS.json");
            byte[] v11_3 = com.crashlytics.android.core.NativeFileUtils.readFile(new com.crashlytics.android.core.MetaDataStore(this.getFilesDir()).getUserDataFileForSession(p20));
            String v12_4 = new com.crashlytics.android.core.LogFileManager(this.crashlyticsCore.getContext(), this.logFileDirectoryProvider, p20);
            byte[] v13_2 = v12_4.getBytesForLog();
            v12_4.clearLog();
            byte[] v14_4 = com.crashlytics.android.core.NativeFileUtils.readFile(new com.crashlytics.android.core.MetaDataStore(this.getFilesDir()).getKeysFileForSession(p20));
            java.io.File v5_3 = new java.io.File(this.fileStore.getFilesDir(), p20);
            if (v5_3.mkdir()) {
                this.gzipIfNotEmpty(v3, new java.io.File(v5_3, "minidump")).gzipIfNotEmpty(v4, new java.io.File(v5_3, "metadata")).gzipIfNotEmpty(v6, new java.io.File(v5_3, "binaryImages")).gzipIfNotEmpty(v7_6, new java.io.File(v5_3, "session")).gzipIfNotEmpty(v8_2, new java.io.File(v5_3, "app")).gzipIfNotEmpty(v9_1, new java.io.File(v5_3, "device")).gzipIfNotEmpty(v10_1, new java.io.File(v5_3, "os")).gzipIfNotEmpty(v11_3, new java.io.File(v5_3, "user")).gzipIfNotEmpty(v13_2, new java.io.File(v5_3, "logs")).gzipIfNotEmpty(v14_4, new java.io.File(v5_3, "keys"));
                return;
            } else {
                io.fabric.sdk.android.Fabric.getLogger().d("CrashlyticsCore", "Couldn\'t create native sessions directory");
                return;
            }
        } else {
            java.io.File v2_3 = io.fabric.sdk.android.Fabric.getLogger();
            byte[] v7_1 = new StringBuilder();
            v7_1.append("No minidump data found in directory ");
            v7_1.append(p19);
            v2_3.w("CrashlyticsCore", v7_1.toString());
            return;
        }
    }

Method com.crashlytics.android.core.ClsFileOutputStream.close() calling method java.io.File.<init>()


    public declared_synchronized void close()
    {
        try {
            if (!this.closed) {
                this.closed = 1;
                super.flush();
                super.close();
                String v1_6 = new StringBuilder();
                v1_6.append(this.root);
                v1_6.append(".cls");
                java.io.File v0_1 = new java.io.File(v1_6.toString());
                if (!this.inProgress.renameTo(v0_1)) {
                    String v1_3 = "";
                    if (v0_1.exists()) {
                        v1_3 = " (target already exists)";
                    } else {
                        if (!this.inProgress.exists()) {
                            v1_3 = " (source does not exist)";
                        }
                    }
                    String v3_1 = new StringBuilder();
                    v3_1.append("Could not rename temp file: ");
                    v3_1.append(this.inProgress);
                    v3_1.append(" -> ");
                    v3_1.append(v0_1);
                    v3_1.append(v1_3);
                    throw new java.io.IOException(v3_1.toString());
                } else {
                    this.inProgress = 0;
                    this.complete = v0_1;
                    return;
                }
            } else {
                return;
            }
        } catch (java.io.File v0_3) {
            throw v0_3;
        }
    }

Method com.crashlytics.android.core.ClsFileOutputStream.<init>() calling method java.io.File.<init>()


    public ClsFileOutputStream(String p2, String p3)
    {
        this(new java.io.File(p2), p3);
        return;
    }

Method com.crashlytics.android.core.ClsFileOutputStream.<init>() calling method java.io.File.<init>()


    public ClsFileOutputStream(java.io.File p4, String p5)
    {
        String v1_2 = new StringBuilder();
        v1_2.append(p5);
        v1_2.append(".cls_temp");
        super(new java.io.File(p4, v1_2.toString()));
        super.closed = 0;
        java.io.File v0_3 = new StringBuilder();
        v0_3.append(p4);
        v0_3.append(java.io.File.separator);
        v0_3.append(p5);
        super.root = v0_3.toString();
        String v1_4 = new StringBuilder();
        v1_4.append(super.root);
        v1_4.append(".cls_temp");
        super.inProgress = new java.io.File(v1_4.toString());
        return;
    }

Method kotlin.io.FilesKt__UtilsKt.copyTo() calling method java.io.FileOutputStream.<init>()


    public static final java.io.File copyTo(java.io.File p10, java.io.File p11, boolean p12, int p13)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p10, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p11, "target");
        if (!p10.exists()) {
            java.io.Closeable v0_11 = new kotlin.io.NoSuchFileException;
            v0_11(p10, 0, "The source file doesn\'t exist.", 2, 0);
            throw ((Throwable) v0_11);
        } else {
            if (p11.exists()) {
                java.io.Closeable v0_4 = 1;
                if ((p12) && (p11.delete())) {
                    v0_4 = 0;
                }
                if (v0_4 != null) {
                    throw ((Throwable) new kotlin.io.FileAlreadyExistsException(p10, p11, "The destination file already exists."));
                }
            }
            if (!p10.isDirectory()) {
                java.io.Closeable v0_6 = p11.getParentFile();
                if (v0_6 != null) {
                    v0_6.mkdirs();
                }
                java.io.Closeable v0_9 = ((java.io.Closeable) new java.io.FileInputStream(p10));
                Throwable v3_1 = ((Throwable) 0);
                try {
                    java.io.Closeable v6_2 = ((java.io.Closeable) new java.io.FileOutputStream(p11));
                    Throwable v2_3 = ((Throwable) 0);
                    try {
                        kotlin.io.ByteStreamsKt.copyTo(((java.io.InputStream) ((java.io.FileInputStream) v0_9)), ((java.io.OutputStream) ((java.io.FileOutputStream) v6_2)), p13);
                    } catch (Throwable v1_5) {
                        kotlin.io.CloseableKt.closeFinally(v6_2, v2_3);
                        throw v1_5;
                    } catch (Throwable v1_4) {
                        v2_3 = v1_4;
                        throw v2_3;
                    }
                    kotlin.io.CloseableKt.closeFinally(v6_2, ((Throwable) 0));
                    kotlin.io.CloseableKt.closeFinally(v0_9, ((Throwable) 0));
                } catch (Throwable v1_7) {
                    kotlin.io.CloseableKt.closeFinally(v0_9, v3_1);
                    throw v1_7;
                } catch (Throwable v1_6) {
                    v3_1 = v1_6;
                    throw v3_1;
                }
            } else {
                if (!p11.mkdirs()) {
                    throw ((Throwable) new kotlin.io.FileSystemException(p10, p11, "Failed to create target directory."));
                }
            }
            return p11;
        }
    }

Method kotlin.io.FilesKt__FileReadWriteKt.writer$default() calling method java.io.FileOutputStream.<init>()


    static synthetic java.io.OutputStreamWriter writer$default(java.io.File p1, java.nio.charset.Charset p2, int p3, Object p4)
    {
        if ((p3 & 1) != 0) {
            p2 = kotlin.text.Charsets.UTF_8;
        }
        return new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p1)), p2);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.writer() calling method java.io.FileOutputStream.<init>()


    private static final java.io.OutputStreamWriter writer(java.io.File p3, java.nio.charset.Charset p4)
    {
        return new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p3)), p4);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.writeBytes() calling method java.io.FileOutputStream.<init>()


    public static final void writeBytes(java.io.File p4, byte[] p5)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p5, "array");
        java.io.Closeable v0_4 = ((java.io.Closeable) new java.io.FileOutputStream(p4));
        Throwable v1_0 = ((Throwable) 0);
        try {
            ((java.io.FileOutputStream) v0_4).write(p5);
            kotlin.io.CloseableKt.closeFinally(v0_4, ((Throwable) 0));
            return;
        } catch (Throwable v2_1) {
            kotlin.io.CloseableKt.closeFinally(v0_4, v1_0);
            throw v2_1;
        } catch (Throwable v1_0) {
            throw v1_0;
        }
    }

Method kotlin.io.FilesKt__FileReadWriteKt.printWriter$default() calling method java.io.FileOutputStream.<init>()


    static synthetic java.io.PrintWriter printWriter$default(java.io.File p2, java.nio.charset.Charset p3, int p4, Object p5)
    {
        if ((p4 & 1) != 0) {
            p3 = kotlin.text.Charsets.UTF_8;
        }
        java.io.Writer v0_2;
        java.io.BufferedWriter v1_3 = ((java.io.Writer) new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p2)), p3));
        if (!(v1_3 instanceof java.io.BufferedWriter)) {
            v0_2 = new java.io.BufferedWriter(v1_3, 8192);
        } else {
            v0_2 = ((java.io.BufferedWriter) v1_3);
        }
        return new java.io.PrintWriter(((java.io.Writer) v0_2));
    }

Method kotlin.io.FilesKt__FileReadWriteKt.printWriter() calling method java.io.FileOutputStream.<init>()


    private static final java.io.PrintWriter printWriter(java.io.File p4, java.nio.charset.Charset p5)
    {
        java.io.Writer v1_1;
        java.io.PrintWriter v2_5 = ((java.io.Writer) new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p4)), p5));
        if (!(v2_5 instanceof java.io.BufferedWriter)) {
            v1_1 = new java.io.BufferedWriter(v2_5, 8192);
        } else {
            v1_1 = ((java.io.BufferedWriter) v2_5);
        }
        return new java.io.PrintWriter(((java.io.Writer) v1_1));
    }

Method kotlin.io.FilesKt__FileReadWriteKt.outputStream() calling method java.io.FileOutputStream.<init>()


    private static final java.io.FileOutputStream outputStream(java.io.File p2)
    {
        return new java.io.FileOutputStream(p2);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.bufferedWriter$default() calling method java.io.FileOutputStream.<init>()


    static synthetic java.io.BufferedWriter bufferedWriter$default(java.io.File p1, java.nio.charset.Charset p2, int p3, int p4, Object p5)
    {
        if ((p4 & 1) != 0) {
            p2 = kotlin.text.Charsets.UTF_8;
        }
        if ((p4 & 2) != 0) {
            p3 = 8192;
        }
        java.io.BufferedWriter v5_3;
        java.io.BufferedWriter v0_1 = ((java.io.Writer) new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p1)), p2));
        if (!(v0_1 instanceof java.io.BufferedWriter)) {
            v5_3 = new java.io.BufferedWriter(v0_1, p3);
        } else {
            v5_3 = ((java.io.BufferedWriter) v0_1);
        }
        return v5_3;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.bufferedWriter() calling method java.io.FileOutputStream.<init>()


    private static final java.io.BufferedWriter bufferedWriter(java.io.File p3, java.nio.charset.Charset p4, int p5)
    {
        java.io.BufferedWriter v1_1;
        java.io.BufferedWriter v2_3 = ((java.io.Writer) new java.io.OutputStreamWriter(((java.io.OutputStream) new java.io.FileOutputStream(p3)), p4));
        if (!(v2_3 instanceof java.io.BufferedWriter)) {
            v1_1 = new java.io.BufferedWriter(v2_3, p5);
        } else {
            v1_1 = ((java.io.BufferedWriter) v2_3);
        }
        return v1_1;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.appendBytes() calling method java.io.FileOutputStream.<init>()


    public static final void appendBytes(java.io.File p4, byte[] p5)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p5, "array");
        java.io.Closeable v0_4 = ((java.io.Closeable) new java.io.FileOutputStream(p4, 1));
        Throwable v1_0 = ((Throwable) 0);
        try {
            ((java.io.FileOutputStream) v0_4).write(p5);
            kotlin.io.CloseableKt.closeFinally(v0_4, ((Throwable) 0));
            return;
        } catch (Throwable v2_2) {
            kotlin.io.CloseableKt.closeFinally(v0_4, v1_0);
            throw v2_2;
        } catch (Throwable v1_0) {
            throw v1_0;
        }
    }

Method okio.Okio.sink() calling method java.io.FileOutputStream.<init>()


    public static okio.Sink sink(java.io.File p2)
    {
        if (p2 == null) {
            throw new IllegalArgumentException("file == null");
        } else {
            return okio.Okio.sink(new java.io.FileOutputStream(p2));
        }
    }

Method okio.Okio.appendingSink() calling method java.io.FileOutputStream.<init>()


    public static okio.Sink appendingSink(java.io.File p2)
    {
        if (p2 == null) {
            throw new IllegalArgumentException("file == null");
        } else {
            return okio.Okio.sink(new java.io.FileOutputStream(p2, 1));
        }
    }

Method dev.jci.mwp.activities.MyProfileActivity.saveUserProfPic() calling method java.io.FileOutputStream.<init>()


    private final void saveUserProfPic(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("User_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        v2_2.append(".png");
        java.io.File v3_7 = new java.io.File(v1_0, v2_2.toString());
        if (v3_7.exists()) {
            v3_7.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_7);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 100, ((java.io.OutputStream) v4_2));
            this.updateCompressedPic(v3_7);
            v4_2.flush();
            v4_2.close();
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.activities.FloorMapActivity.saveFloorImageInExtStorage() calling method java.io.FileOutputStream.<init>()


    private final void saveFloorImageInExtStorage(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("Floor_");
        v2_2.append(this.floorID);
        java.io.File v3_4 = new java.io.File(v1_0, v2_2.toString());
        if (v3_4.exists()) {
            v3_4.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_4);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 90, ((java.io.OutputStream) v4_2));
            v4_2.flush();
            v4_2.close();
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.compressFilenCheck() calling method java.io.FileOutputStream.<init>()


    public final void compressFilenCheck(android.net.Uri p12)
    {
        android.graphics.Bitmap v1 = 0;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p12, "uri");
        java.io.ByteArrayOutputStream v2_4 = android.provider.MediaStore$Images$Media.getBitmap(this.getContentResolver(), p12);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v2_4, "MediaStore.Images.Media.\u2026etContentResolver(), uri)");
        android.graphics.Bitmap v0 = v2_4;
        java.io.ByteArrayOutputStream v2_1 = new java.io.ByteArrayOutputStream();
        v0.compress(android.graphics.Bitmap$CompressFormat.JPEG, 100, ((java.io.OutputStream) v2_1));
        byte[] v3_2 = v2_1.toByteArray();
        if (v3_2.length <= 1000000) {
            String v4_6 = android.graphics.BitmapFactory.decodeStream(((java.io.InputStream) new java.io.ByteArrayInputStream(v3_2)));
            kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v4_6, "BitmapFactory.decodeStre\u2026ayInputStream(byteArray))");
            v1 = v4_6;
            java.io.File v5_4 = new StringBuilder();
            v5_4.append("");
            v5_4.append(v1);
            android.util.Log.d("DECODED BITMAP : ", v5_4.toString());
            java.io.File v5_7 = new java.io.File(this.getCacheDir(), "FEEDBACK_IMAGE");
            java.io.FileOutputStream v6_3 = new java.io.FileOutputStream(v5_7);
            v6_3.write(v3_2);
            v6_3.flush();
            v6_3.close();
            java.net.URI v7 = v5_7.toURI();
            String v9_1 = new StringBuilder();
            v9_1.append("");
            v9_1.append(v7);
            android.util.Log.d("URI CACHE: ", v9_1.toString());
        }
        return;
    }

Method dev.jci.mwp.activities.FeedbackActivity.saveAttachment() calling method java.io.FileOutputStream.<init>()


    private final void saveAttachment(android.graphics.Bitmap p9)
    {
        String v0_1 = this.getExternalFilesDir(0);
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_1, "getExternalFilesDir(null)");
        String v0_2 = v0_1.getAbsolutePath();
        String v2_5 = new StringBuilder();
        v2_5.append(v0_2);
        v2_5.append("/mwp");
        java.io.File v1_0 = new java.io.File(v2_5.toString());
        v1_0.mkdirs();
        String v2_2 = new StringBuilder();
        v2_2.append("Feedback_");
        v2_2.append(dev.jci.mwp.utils.AppInitializer.Companion.getInstance().getUserId());
        v2_2.append(".png");
        java.io.File v3_7 = new java.io.File(v1_0, v2_2.toString());
        if (v3_7.exists()) {
            v3_7.delete();
        }
        try {
            Exception v4_2 = new java.io.FileOutputStream(v3_7);
            p9.compress(android.graphics.Bitmap$CompressFormat.PNG, 100, ((java.io.OutputStream) v4_2));
            v4_2.flush();
            v4_2.close();
            this.updateCompressedPic(v3_7);
        } catch (Exception v4_3) {
            v4_3.printStackTrace();
        }
        return;
    }

Method dev.jci.mwp.utils.CameraUtils$Companion.bitmapToFile() calling method java.io.FileOutputStream.<init>()


    public final android.net.Uri bitmapToFile(android.graphics.Bitmap p4, java.io.File p5)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "bitmap");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p5, "file");
        try {
            android.net.Uri v0_9 = ((java.io.OutputStream) new java.io.FileOutputStream(p5));
            p4.compress(android.graphics.Bitmap$CompressFormat.JPEG, 100, v0_9);
            v0_9.flush();
            v0_9.close();
        } catch (android.net.Uri v0_1) {
            v0_1.printStackTrace();
        }
        android.net.Uri v0_3 = new StringBuilder();
        v0_3.append("file://");
        v0_3.append(p5.getAbsolutePath());
        android.net.Uri v0_6 = android.net.Uri.parse(v0_3.toString());
        kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v0_6, "Uri.parse(\"file://\"+file.absolutePath)");
        return v0_6;
    }

Method io.fabric.sdk.android.services.events.GZIPQueueFileEventStorage.getMoveOutputStream() calling method java.io.FileOutputStream.<init>()


    public java.io.OutputStream getMoveOutputStream(java.io.File p3)
    {
        return new java.util.zip.GZIPOutputStream(new java.io.FileOutputStream(p3));
    }

Method com.google.android.gms.common.data.BitmapTeleporter.zzcj() calling method java.io.FileOutputStream.<init>()


    private final java.io.FileOutputStream zzcj()
    {
        if (this.zzne == null) {
            throw new IllegalStateException("setTempDir() must be called before writing this object to a parcel");
        } else {
            try {
                IllegalStateException v0_1 = java.io.File.createTempFile("teleporter", ".tmp", this.zzne);
                try {
                    String v1_3 = new java.io.FileOutputStream(v0_1);
                    this.zznb = android.os.ParcelFileDescriptor.open(v0_1, 268435456);
                    v0_1.delete();
                    return v1_3;
                } catch (IllegalStateException v0) {
                    throw new IllegalStateException("Temporary file is somehow already deleted");
                }
            } catch (IllegalStateException v0_2) {
                throw new IllegalStateException("Could not create temporary file", v0_2);
            }
            v1_3 = new java.io.FileOutputStream(v0_1);
            this.zznb = android.os.ParcelFileDescriptor.open(v0_1, 268435456);
            v0_1.delete();
            return v1_3;
        }
    }

Method io.fabric.sdk.android.services.events.QueueFileEventStorage.getMoveOutputStream() calling method java.io.FileOutputStream.<init>()


    public java.io.OutputStream getMoveOutputStream(java.io.File p2)
    {
        return new java.io.FileOutputStream(p2);
    }

Method com.microsoft.identity.common.adal.internal.cache.StorageHelper.writeKeyData() calling method java.io.FileOutputStream.<init>()


    private void writeKeyData(byte[] p5)
    {
        android.util.Log.v("StorageHelper", "Writing key data to a file");
        java.io.FileOutputStream v1_3 = new java.io.FileOutputStream(new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks"));
        try {
            v1_3.write(p5);
            v1_3.close();
            return;
        } catch (Throwable v2_1) {
            v1_3.close();
            throw v2_1;
        }
    }

Method com.microsoft.aad.adal.FileTokenCacheStore.writeToFile() calling method java.io.FileOutputStream.<init>()


    private void writeToFile()
    {
        try {
            if ((this.mFile != null) && (this.mInMemoryCache != null)) {
                try {
                    java.io.IOException v1_5 = new java.io.FileOutputStream(this.mFile);
                    String v2_3 = new java.io.ObjectOutputStream(v1_5);
                    v2_3.writeObject(this.mInMemoryCache);
                    v2_3.flush();
                    v2_3.close();
                    v1_5.close();
                } catch (java.io.IOException v1_1) {
                    com.microsoft.aad.adal.Logger.e(com.microsoft.aad.adal.FileTokenCacheStore.TAG, "Exception during cache flush", com.microsoft.aad.adal.ExceptionExtensions.getExceptionMessage(v1_1), com.microsoft.aad.adal.ADALError.DEVICE_FILE_CACHE_IS_NOT_WRITING_TO_FILE);
                }
            }
        } catch (java.io.IOException v1_2) {
            throw v1_2;
        }
        return;
    }

Method com.google.android.exoplayer2.upstream.cache.CacheDataSink.openNextOutputStream() calling method java.io.FileOutputStream.<init>()


    private void openNextOutputStream()
    {
        com.google.android.exoplayer2.util.ReusableBufferedOutputStream v0_2;
        if (this.dataSpec.length != -1) {
            v0_2 = Math.min((this.dataSpec.length - this.dataSpecBytesWritten), this.maxCacheFileSize);
        } else {
            v0_2 = this.maxCacheFileSize;
        }
        this.file = this.cache.startFile(this.dataSpec.key, (this.dataSpecBytesWritten + this.dataSpec.absoluteStreamPosition), v0_2);
        this.underlyingFileOutputStream = new java.io.FileOutputStream(this.file);
        if (this.bufferSize <= 0) {
            this.outputStream = this.underlyingFileOutputStream;
        } else {
            if (this.bufferedOutputStream != null) {
                this.bufferedOutputStream.reset(this.underlyingFileOutputStream);
            } else {
                this.bufferedOutputStream = new com.google.android.exoplayer2.util.ReusableBufferedOutputStream(this.underlyingFileOutputStream, this.bufferSize);
            }
            this.outputStream = this.bufferedOutputStream;
        }
        this.outputStreamBytesWritten = 0;
        return;
    }

Method io.fabric.sdk.android.services.network.HttpRequest.receive() calling method java.io.FileOutputStream.<init>()


    public io.fabric.sdk.android.services.network.HttpRequest receive(java.io.File p4)
    {
        try {
            java.io.FileNotFoundException v0_2 = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p4), this.bufferSize);
            return ((io.fabric.sdk.android.services.network.HttpRequest) new io.fabric.sdk.android.services.network.HttpRequest$3(this, v0_2, this.ignoreCloseExceptions, v0_2).call());
        } catch (java.io.FileNotFoundException v0_1) {
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v0_1);
        }
    }

Method com.microsoft.aad.adal.StorageHelper.writeKeyData() calling method java.io.FileOutputStream.<init>()


    private void writeKeyData(byte[] p5)
    {
        com.microsoft.aad.adal.Logger.v("StorageHelper", "Writing key data to a file");
        java.io.FileOutputStream v1_3 = new java.io.FileOutputStream(new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks"));
        try {
            v1_3.write(p5);
            v1_3.close();
            return;
        } catch (Throwable v2_1) {
            v1_3.close();
            throw v2_1;
        }
    }

Method com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.getUrandomOutputStream() calling method java.io.FileOutputStream.<init>()


    private java.io.OutputStream getUrandomOutputStream()
    {
        try {
            if (com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomOut == null) {
                com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomOut = new java.io.FileOutputStream(com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.URANDOM_FILE);
            }
        } catch (java.io.OutputStream v1_4) {
            throw v1_4;
        }
        return com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomOut;
    }

Method com.journeyapps.barcodescanner.CaptureManager.getBarcodeImagePath() calling method java.io.FileOutputStream.<init>()


    private String getBarcodeImagePath(com.journeyapps.barcodescanner.BarcodeResult p7)
    {
        String v0 = 0;
        if (this.returnBarcodeImagePath) {
            android.graphics.Bitmap v1_1 = p7.getBitmap();
            try {
                java.io.IOException v2_0 = java.io.File.createTempFile("barcodeimage", ".jpg", this.activity.getCacheDir());
                String v3_1 = new java.io.FileOutputStream(v2_0);
                v1_1.compress(android.graphics.Bitmap$CompressFormat.JPEG, 100, v3_1);
                v3_1.close();
                v0 = v2_0.getAbsolutePath();
            } catch (java.io.IOException v2_1) {
                String v4_3 = new StringBuilder();
                v4_3.append("Unable to create temporary file and store bitmap! ");
                v4_3.append(v2_1);
                android.util.Log.w(com.journeyapps.barcodescanner.CaptureManager.TAG, v4_3.toString());
            }
        }
        return v0;
    }

Method com.google.android.exoplayer2.util.AtomicFile$AtomicFileOutputStream.<init>() calling method java.io.FileOutputStream.<init>()


    public AtomicFile$AtomicFileOutputStream(java.io.File p2)
    {
        this.closed = 0;
        this.fileOutputStream = new java.io.FileOutputStream(p2);
        return;
    }

Method com.crashlytics.android.core.MetaDataStore.writeUserData() calling method java.io.FileOutputStream.<init>()


    public void writeUserData(String p8, com.crashlytics.android.core.UserMetaData p9)
    {
        try {
            java.io.BufferedWriter v1 = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.getUserDataFileForSession(p8)), com.crashlytics.android.core.MetaDataStore.UTF_8));
            v1.write(com.crashlytics.android.core.MetaDataStore.userDataToJson(p9));
            v1.flush();
        } catch (String v2_1) {
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close user metadata file.");
            throw v2_1;
        } catch (String v2_0) {
            io.fabric.sdk.android.Fabric.getLogger().e("CrashlyticsCore", "Error serializing user metadata.", v2_0);
        }
        io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close user metadata file.");
        return;
    }

Method com.crashlytics.android.core.MetaDataStore.writeKeyData() calling method java.io.FileOutputStream.<init>()


    public void writeKeyData(String p8, java.util.Map p9)
    {
        try {
            java.io.BufferedWriter v1 = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.getKeysFileForSession(p8)), com.crashlytics.android.core.MetaDataStore.UTF_8));
            v1.write(com.crashlytics.android.core.MetaDataStore.keysDataToJson(p9));
            v1.flush();
        } catch (String v2_1) {
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close key/value metadata file.");
            throw v2_1;
        } catch (String v2_0) {
            io.fabric.sdk.android.Fabric.getLogger().e("CrashlyticsCore", "Error serializing key/value metadata.", v2_0);
        }
        io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close key/value metadata file.");
        return;
    }

Method com.crashlytics.android.core.CrashlyticsController.writeFile() calling method java.io.FileOutputStream.<init>()


    private void writeFile(String p6, String p7, com.crashlytics.android.core.CrashlyticsController$FileOutputStreamWriteAction p8)
    {
        try {
            String v3_2 = this.getFilesDir();
            String v4_2 = new StringBuilder();
            v4_2.append(p6);
            v4_2.append(p7);
            java.io.FileOutputStream v0 = new java.io.FileOutputStream(new java.io.File(v3_2, v4_2.toString()));
            p8.writeTo(v0);
            Throwable v1_3 = new StringBuilder();
            v1_3.append("Failed to close ");
            v1_3.append(p7);
            v1_3.append(" file.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, v1_3.toString());
            return;
        } catch (Throwable v1_5) {
            String v2_5 = new StringBuilder();
            v2_5.append("Failed to close ");
            v2_5.append(p7);
            v2_5.append(" file.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, v2_5.toString());
            throw v1_5;
        }
    }

Method com.crashlytics.android.core.CrashlyticsController.gzip() calling method java.io.FileOutputStream.<init>()


    private void gzip(byte[] p4, java.io.File p5)
    {
        try {
            java.util.zip.GZIPOutputStream v0 = new java.util.zip.GZIPOutputStream(new java.io.FileOutputStream(p5));
            v0.write(p4);
            v0.finish();
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v0);
            return;
        } catch (Throwable v1_1) {
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v0);
            throw v1_1;
        }
    }

Method com.crashlytics.android.core.ClsFileOutputStream.<init>() calling method java.io.FileOutputStream.<init>()


    public ClsFileOutputStream(java.io.File p4, String p5)
    {
        String v1_2 = new StringBuilder();
        v1_2.append(p5);
        v1_2.append(".cls_temp");
        super(new java.io.File(p4, v1_2.toString()));
        super.closed = 0;
        java.io.File v0_3 = new StringBuilder();
        v0_3.append(p4);
        v0_3.append(java.io.File.separator);
        v0_3.append(p5);
        super.root = v0_3.toString();
        String v1_4 = new StringBuilder();
        v1_4.append(super.root);
        v1_4.append(".cls_temp");
        super.inProgress = new java.io.File(v1_4.toString());
        return;
    }

Method com.bumptech.glide.load.engine.DecodeJob$FileOpener.open() calling method java.io.FileOutputStream.<init>()


    public java.io.OutputStream open(java.io.File p3)
    {
        return new java.io.BufferedOutputStream(new java.io.FileOutputStream(p3));
    }

Method com.bumptech.glide.gifencoder.AnimatedGifEncoder.start() calling method java.io.FileOutputStream.<init>()


    public boolean start(String p5)
    {
        try {
            this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p5));
            int v1 = this.start(this.out);
            this.closeStream = 1;
        } catch (java.io.IOException v0) {
            v1 = 0;
        }
        this.started = v1;
        return v1;
    }

Method com.bumptech.glide.disklrucache.DiskLruCache.rebuildJournal() calling method java.io.FileOutputStream.<init>()


    private declared_synchronized void rebuildJournal()
    {
        try {
            if (this.journalWriter != null) {
                this.journalWriter.close();
            }
        } catch (java.io.BufferedWriter v0_1) {
            throw v0_1;
        }
        java.io.BufferedWriter v0_2 = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.journalFileTmp), com.bumptech.glide.disklrucache.Util.US_ASCII));
        try {
            v0_2.write("libcore.io.DiskLruCache");
            v0_2.write("\n");
            v0_2.write("1");
            v0_2.write("\n");
            v0_2.write(Integer.toString(this.appVersion));
            v0_2.write("\n");
            v0_2.write(Integer.toString(this.valueCount));
            v0_2.write("\n");
            v0_2.write("\n");
            java.io.BufferedWriter v1_15 = this.lruEntries.values().iterator();
        } catch (java.io.BufferedWriter v1_1) {
            v0_2.close();
            throw v1_1;
        }
        while (v1_15.hasNext()) {
            java.nio.charset.Charset v2_5 = ((com.bumptech.glide.disklrucache.DiskLruCache$Entry) v1_15.next());
            if (com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$700(v2_5) == null) {
                java.io.OutputStreamWriter v3_7 = new StringBuilder();
                v3_7.append("CLEAN ");
                v3_7.append(com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$1100(v2_5));
                v3_7.append(v2_5.getLengths());
                v3_7.append(10);
                v0_2.write(v3_7.toString());
            } else {
                java.io.OutputStreamWriter v3_11 = new StringBuilder();
                v3_11.append("DIRTY ");
                v3_11.append(com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$1100(v2_5));
                v3_11.append(10);
                v0_2.write(v3_11.toString());
            }
        }
        v0_2.close();
        if (this.journalFile.exists()) {
            com.bumptech.glide.disklrucache.DiskLruCache.renameTo(this.journalFile, this.journalFileBackup, 1);
        }
        com.bumptech.glide.disklrucache.DiskLruCache.renameTo(this.journalFileTmp, this.journalFile, 0);
        this.journalFileBackup.delete();
        this.journalWriter = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.journalFile, 1), com.bumptech.glide.disklrucache.Util.US_ASCII));
        return;
    }

Method com.bumptech.glide.disklrucache.DiskLruCache.readJournal() calling method java.io.FileOutputStream.<init>()


    private void readJournal()
    {
        com.bumptech.glide.disklrucache.StrictLineReader v0_1 = new com.bumptech.glide.disklrucache.StrictLineReader(new java.io.FileInputStream(this.journalFile), com.bumptech.glide.disklrucache.Util.US_ASCII);
        try {
            Throwable v1_2 = v0_1.readLine();
            String v2_2 = v0_1.readLine();
            String v3 = v0_1.readLine();
            String v4 = v0_1.readLine();
            String v5 = v0_1.readLine();
        } catch (Throwable v1_3) {
            com.bumptech.glide.disklrucache.Util.closeQuietly(v0_1);
            throw v1_3;
        }
        if ((!"libcore.io.DiskLruCache".equals(v1_2)) || ((!"1".equals(v2_2)) || ((!Integer.toString(this.appVersion).equals(v3)) || ((!Integer.toString(this.valueCount).equals(v4)) || (!"".equals(v5)))))) {
            java.io.BufferedWriter v7_1 = new StringBuilder();
            v7_1.append("unexpected journal header: [");
            v7_1.append(v1_2);
            v7_1.append(", ");
            v7_1.append(v2_2);
            v7_1.append(", ");
            v7_1.append(v4);
            v7_1.append(", ");
            v7_1.append(v5);
            v7_1.append("]");
            throw new java.io.IOException(v7_1.toString());
        } else {
            int v6_14 = 0;
            try {
                while(true) {
                    this.readJournalLine(v0_1.readLine());
                    v6_14++;
                }
            } catch (java.io.BufferedWriter v7) {
                this.redundantOpCount = (v6_14 - this.lruEntries.size());
                if (!v0_1.hasUnterminatedLine()) {
                    this.journalWriter = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.journalFile, 1), com.bumptech.glide.disklrucache.Util.US_ASCII));
                } else {
                    this.rebuildJournal();
                }
                com.bumptech.glide.disklrucache.Util.closeQuietly(v0_1);
                return;
            }
        }
    }

Method com.bumptech.glide.disklrucache.DiskLruCache$Editor.set() calling method java.io.FileOutputStream.<init>()


    public void set(int p5, String p6)
    {
        try {
            java.io.OutputStreamWriter v0 = new java.io.OutputStreamWriter(new java.io.FileOutputStream(this.getFile(p5)), com.bumptech.glide.disklrucache.Util.UTF_8);
            v0.write(p6);
            com.bumptech.glide.disklrucache.Util.closeQuietly(v0);
            return;
        } catch (Throwable v1_1) {
            com.bumptech.glide.disklrucache.Util.closeQuietly(v0);
            throw v1_1;
        }
    }

Method android.support.v4.util.AtomicFile.startWrite() calling method java.io.FileOutputStream.<init>()


    public java.io.FileOutputStream startWrite()
    {
        if (this.mBaseName.exists()) {
            if (this.mBackupName.exists()) {
                this.mBaseName.delete();
            } else {
                if (!this.mBaseName.renameTo(this.mBackupName)) {
                    String v1_2 = new StringBuilder();
                    v1_2.append("Couldn\'t rename file ");
                    v1_2.append(this.mBaseName);
                    v1_2.append(" to backup file ");
                    v1_2.append(this.mBackupName);
                    android.util.Log.w("AtomicFile", v1_2.toString());
                }
            }
        }
        try {
            java.io.FileOutputStream v0_6 = new java.io.FileOutputStream(this.mBaseName);
        } catch (java.io.FileOutputStream v0) {
            if (!this.mBaseName.getParentFile().mkdirs()) {
                java.io.IOException v3_1 = new StringBuilder();
                v3_1.append("Couldn\'t create directory ");
                v3_1.append(this.mBaseName);
                throw new java.io.IOException(v3_1.toString());
            } else {
                try {
                    java.io.FileNotFoundException v2_8 = new java.io.FileOutputStream(this.mBaseName);
                    v0_6 = v2_8;
                } catch (java.io.FileNotFoundException v2) {
                    String v4_3 = new StringBuilder();
                    v4_3.append("Couldn\'t create ");
                    v4_3.append(this.mBaseName);
                    throw new java.io.IOException(v4_3.toString());
                }
            }
        }
        return v0_6;
    }

Method android.support.v4.print.PrintHelper$1.doInBackground() calling method java.io.FileOutputStream.<init>()


    protected varargs Throwable doInBackground(Void[] p9)
    {
        try {
            if (!this.val$cancellationSignal.isCanceled()) {
                android.print.pdf.PrintedPdfDocument v0_4 = new android.print.pdf.PrintedPdfDocument(this.this$0.mContext, this.val$pdfAttributes);
                android.graphics.Bitmap v2_1 = android.support.v4.print.PrintHelper.convertBitmapForColorMode(this.val$bitmap, this.val$pdfAttributes.getColorMode());
                if (!this.val$cancellationSignal.isCanceled()) {
                    try {
                        java.io.IOException v3_6;
                        android.graphics.pdf.PdfDocument$Page v4 = v0_4.startPage(1);
                    } catch (Throwable v1_1) {
                        v0_4.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.IOException v3) {
                            }
                        }
                        if (v2_1 != this.val$bitmap) {
                            v2_1.recycle();
                        }
                        throw v1_1;
                    }
                    if (!android.support.v4.print.PrintHelper.IS_MIN_MARGINS_HANDLING_CORRECT) {
                        android.graphics.Matrix v5_2 = new android.print.pdf.PrintedPdfDocument(this.this$0.mContext, this.val$attributes);
                        java.io.IOException v3_5 = v5_2.startPage(1);
                        java.io.IOException v6_6 = new android.graphics.RectF(v3_5.getInfo().getContentRect());
                        v5_2.finishPage(v3_5);
                        v5_2.close();
                        v3_6 = v6_6;
                    } else {
                        v3_6 = new android.graphics.RectF(v4.getInfo().getContentRect());
                    }
                    android.graphics.Matrix v5_6 = android.support.v4.print.PrintHelper.getMatrix(v2_1.getWidth(), v2_1.getHeight(), v3_6, this.val$fittingMode);
                    if (!android.support.v4.print.PrintHelper.IS_MIN_MARGINS_HANDLING_CORRECT) {
                        v5_6.postTranslate(v3_6.left, v3_6.top);
                        v4.getCanvas().clipRect(v3_6);
                    } else {
                    }
                    v4.getCanvas().drawBitmap(v2_1, v5_6, 0);
                    v0_4.finishPage(v4);
                    if (!this.val$cancellationSignal.isCanceled()) {
                        v0_4.writeTo(new java.io.FileOutputStream(this.val$fileDescriptor.getFileDescriptor()));
                        v0_4.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.IOException v6) {
                            }
                        }
                        if (v2_1 != this.val$bitmap) {
                            v2_1.recycle();
                        }
                        return 0;
                    } else {
                        v0_4.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.IOException v6) {
                            }
                        }
                        if (v2_1 != this.val$bitmap) {
                            v2_1.recycle();
                        }
                        return 0;
                    }
                } else {
                    return 0;
                }
            } else {
                return 0;
            }
        } catch (android.print.pdf.PrintedPdfDocument v0_1) {
            return v0_1;
        }
    }

Method android.support.v4.graphics.TypefaceCompatUtil.copyToFile() calling method java.io.FileOutputStream.<init>()


    public static boolean copyToFile(java.io.File p7, java.io.InputStream p8)
    {
        android.os.StrictMode$ThreadPolicy v1 = android.os.StrictMode.allowThreadDiskWrites();
        int v2_1 = 0;
        try {
            java.io.FileOutputStream v0 = new java.io.FileOutputStream(p7, 0);
            java.io.IOException v3_4 = new byte[1024];
        } catch (int v2_0) {
            android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v0);
            android.os.StrictMode.setThreadPolicy(v1);
            throw v2_0;
        } catch (java.io.IOException v3_0) {
            String v5_2 = new StringBuilder();
            v5_2.append("Error copying resource contents to temp file: ");
            v5_2.append(v3_0.getMessage());
            android.util.Log.e("TypefaceCompatUtil", v5_2.toString());
            android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v0);
            android.os.StrictMode.setThreadPolicy(v1);
            return v2_1;
        }
        while(true) {
            String v4_0 = p8.read(v3_4);
            if (v4_0 == -1) {
                break;
            }
            v0.write(v3_4, 0, v4_0);
        }
        v2_1 = 1;
        android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v0);
        android.os.StrictMode.setThreadPolicy(v1);
        return v2_1;
    }

Method io.fabric.sdk.android.services.settings.DefaultCachedSettingsIo.writeCachedSettings() calling method java.io.FileWriter.<init>()


    public void writeCachedSettings(long p6, org.json.JSONObject p8)
    {
        io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Writing settings to cache file...");
        if (p8 != null) {
            try {
                p8.put("expires_at", p6);
                java.io.FileWriter v0_1 = new java.io.FileWriter(new java.io.File(new io.fabric.sdk.android.services.persistence.FileStoreImpl(this.kit).getFilesDir(), "com.crashlytics.settings.json"));
                v0_1.write(p8.toString());
                v0_1.flush();
            } catch (String v1_4) {
                io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Failed to close settings writer.");
                throw v1_4;
            } catch (String v1_3) {
                io.fabric.sdk.android.Fabric.getLogger().e("Fabric", "Failed to cache settings", v1_3);
            }
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Failed to close settings writer.");
        }
        return;
    }

Method kotlin.io.FilesKt__UtilsKt.copyTo() calling method java.io.FileInputStream.<init>()


    public static final java.io.File copyTo(java.io.File p10, java.io.File p11, boolean p12, int p13)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p10, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p11, "target");
        if (!p10.exists()) {
            java.io.Closeable v0_11 = new kotlin.io.NoSuchFileException;
            v0_11(p10, 0, "The source file doesn\'t exist.", 2, 0);
            throw ((Throwable) v0_11);
        } else {
            if (p11.exists()) {
                java.io.Closeable v0_4 = 1;
                if ((p12) && (p11.delete())) {
                    v0_4 = 0;
                }
                if (v0_4 != null) {
                    throw ((Throwable) new kotlin.io.FileAlreadyExistsException(p10, p11, "The destination file already exists."));
                }
            }
            if (!p10.isDirectory()) {
                java.io.Closeable v0_6 = p11.getParentFile();
                if (v0_6 != null) {
                    v0_6.mkdirs();
                }
                java.io.Closeable v0_9 = ((java.io.Closeable) new java.io.FileInputStream(p10));
                Throwable v3_1 = ((Throwable) 0);
                try {
                    java.io.Closeable v6_2 = ((java.io.Closeable) new java.io.FileOutputStream(p11));
                    Throwable v2_3 = ((Throwable) 0);
                    try {
                        kotlin.io.ByteStreamsKt.copyTo(((java.io.InputStream) ((java.io.FileInputStream) v0_9)), ((java.io.OutputStream) ((java.io.FileOutputStream) v6_2)), p13);
                    } catch (Throwable v1_5) {
                        kotlin.io.CloseableKt.closeFinally(v6_2, v2_3);
                        throw v1_5;
                    } catch (Throwable v1_4) {
                        v2_3 = v1_4;
                        throw v2_3;
                    }
                    kotlin.io.CloseableKt.closeFinally(v6_2, ((Throwable) 0));
                    kotlin.io.CloseableKt.closeFinally(v0_9, ((Throwable) 0));
                } catch (Throwable v1_7) {
                    kotlin.io.CloseableKt.closeFinally(v0_9, v3_1);
                    throw v1_7;
                } catch (Throwable v1_6) {
                    v3_1 = v1_6;
                    throw v3_1;
                }
            } else {
                if (!p11.mkdirs()) {
                    throw ((Throwable) new kotlin.io.FileSystemException(p10, p11, "Failed to create target directory."));
                }
            }
            return p11;
        }
    }

Method org.apache.commons.math3.random.EmpiricalDistribution.load() calling method java.io.FileInputStream.<init>()


    public void load(java.io.File p7)
    {
        org.apache.commons.math3.util.MathUtils.checkNotNull(p7);
        java.nio.charset.Charset v0_1 = java.nio.charset.Charset.forName("US-ASCII");
        try {
            new org.apache.commons.math3.random.EmpiricalDistribution$StreamDataAdapter(this, new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(p7), v0_1))).computeStats();
            java.io.BufferedReader v2_0 = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(p7), v0_1));
            this.fillBinStats(new org.apache.commons.math3.random.EmpiricalDistribution$StreamDataAdapter(this, v2_0));
            this.loaded = 1;
            try {
                v2_0.close();
            } catch (java.io.IOException v3) {
            }
            return;
        } catch (java.io.IOException v3_2) {
            try {
                v2_0.close();
            } catch (java.io.IOException v4) {
            }
            throw v3_2;
        }
    }

Method kotlin.io.FilesKt__FileReadWriteKt.useLines$default() calling method java.io.FileInputStream.<init>()


    public static synthetic Object useLines$default(java.io.File p6, java.nio.charset.Charset p7, kotlin.jvm.functions.Function1 p8, int p9, Object p10)
    {
        if ((p9 & 1) != 0) {
            p7 = kotlin.text.Charsets.UTF_8;
        }
        java.io.Closeable v0_5;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p6, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p7, "charset");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p8, "block");
        boolean v1_2 = ((java.io.Reader) new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p6)), p7));
        if (!(v1_2 instanceof java.io.BufferedReader)) {
            v0_5 = new java.io.BufferedReader(v1_2, 8192);
        } else {
            v0_5 = ((java.io.BufferedReader) v1_2);
        }
        java.io.Closeable v0_6 = ((java.io.Closeable) v0_5);
        Throwable v10_2 = ((Throwable) 0);
        try {
            Throwable v3_2 = p8.invoke(kotlin.io.TextStreamsKt.lineSequence(((java.io.BufferedReader) v0_6)));
            kotlin.jvm.internal.InlineMarker.finallyStart(1);
            boolean v1_5 = kotlin.internal.PlatformImplementationsKt.apiVersionIsAtLeast(1, 1, 0);
        } catch (Throwable v3_3) {
            kotlin.jvm.internal.InlineMarker.finallyStart(1);
            if (kotlin.internal.PlatformImplementationsKt.apiVersionIsAtLeast(1, 1, v1_5)) {
                kotlin.io.CloseableKt.closeFinally(v0_6, v10_2);
            } else {
                if (v10_2 != null) {
                    try {
                        v0_6.close();
                    } catch (Throwable v10) {
                    }
                } else {
                    v0_6.close();
                }
            }
            kotlin.jvm.internal.InlineMarker.finallyEnd(1);
            throw v3_3;
        } catch (Throwable v10_2) {
            throw v10_2;
        }
        if (!v1_5) {
            v0_6.close();
        } else {
            kotlin.io.CloseableKt.closeFinally(v0_6, ((Throwable) 0));
        }
        kotlin.jvm.internal.InlineMarker.finallyEnd(1);
        return v3_2;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.useLines() calling method java.io.FileInputStream.<init>()


    public static final Object useLines(java.io.File p8, java.nio.charset.Charset p9, kotlin.jvm.functions.Function1 p10)
    {
        Throwable v1_3;
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p8, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p9, "charset");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p10, "block");
        Throwable v2_2 = ((java.io.Reader) new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p8)), p9));
        if (!(v2_2 instanceof java.io.BufferedReader)) {
            v1_3 = new java.io.BufferedReader(v2_2, 8192);
        } else {
            v1_3 = ((java.io.BufferedReader) v2_2);
        }
        Throwable v1_4 = ((java.io.Closeable) v1_3);
        Throwable v2_5 = ((Throwable) 0);
        try {
            Throwable v5_2 = p10.invoke(kotlin.io.TextStreamsKt.lineSequence(((java.io.BufferedReader) v1_4)));
            kotlin.jvm.internal.InlineMarker.finallyStart(1);
            boolean v3_2 = kotlin.internal.PlatformImplementationsKt.apiVersionIsAtLeast(1, 1, 0);
        } catch (Throwable v5_3) {
            kotlin.jvm.internal.InlineMarker.finallyStart(1);
            if (kotlin.internal.PlatformImplementationsKt.apiVersionIsAtLeast(1, 1, v3_2)) {
                kotlin.io.CloseableKt.closeFinally(v1_4, v2_5);
            } else {
                if (v2_5 != null) {
                    try {
                        v1_4.close();
                    } catch (Throwable v1) {
                    }
                } else {
                    v1_4.close();
                }
            }
            kotlin.jvm.internal.InlineMarker.finallyEnd(1);
            throw v5_3;
        } catch (Throwable v2_5) {
            throw v2_5;
        }
        if (!v3_2) {
            v1_4.close();
        } else {
            kotlin.io.CloseableKt.closeFinally(v1_4, ((Throwable) 0));
        }
        kotlin.jvm.internal.InlineMarker.finallyEnd(1);
        return v5_2;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.reader$default() calling method java.io.FileInputStream.<init>()


    static synthetic java.io.InputStreamReader reader$default(java.io.File p1, java.nio.charset.Charset p2, int p3, Object p4)
    {
        if ((p3 & 1) != 0) {
            p2 = kotlin.text.Charsets.UTF_8;
        }
        return new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p1)), p2);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.reader() calling method java.io.FileInputStream.<init>()


    private static final java.io.InputStreamReader reader(java.io.File p3, java.nio.charset.Charset p4)
    {
        return new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p3)), p4);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.readBytes() calling method java.io.FileInputStream.<init>()


    public static final byte[] readBytes(java.io.File p12)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p12, "receiver$0");
        java.io.Closeable v0_3 = ((java.io.Closeable) new java.io.FileInputStream(p12));
        Throwable v1_1 = ((Throwable) 0);
        try {
            Throwable v2_2 = ((java.io.FileInputStream) v0_3);
            int v5 = 0;
            byte[] v6_0 = p12.length();
            String v8_0 = v6_0;
        } catch (Throwable v2_0) {
            kotlin.io.CloseableKt.closeFinally(v0_3, v1_1);
            throw v2_0;
        } catch (Throwable v1_1) {
            throw v1_1;
        }
        if (v8_0 > ((long) 2147483647)) {
            byte[] v7_1 = new StringBuilder();
            v7_1.append("File ");
            v7_1.append(p12);
            v7_1.append(" is too big (");
            v7_1.append(v8_0);
            v7_1.append(" bytes) to fit in memory.");
            throw ((Throwable) new OutOfMemoryError(v7_1.toString()));
        } else {
            int v3_0 = ((int) v6_0);
            byte[] v6_4 = new byte[v3_0];
            while (v3_0 > 0) {
                byte[] v7_3 = v2_2.read(v6_4, v5, v3_0);
                if (v7_3 >= null) {
                    v3_0 -= v7_3;
                    v5 += v7_3;
                } else {
                    break;
                }
            }
            if (v3_0 != 0) {
                byte[] v7_4 = java.util.Arrays.copyOf(v6_4, v5);
                kotlin.jvm.internal.Intrinsics.checkExpressionValueIsNotNull(v7_4, "java.util.Arrays.copyOf(this, newSize)");
                v6_4 = v7_4;
            } else {
            }
            kotlin.io.CloseableKt.closeFinally(v0_3, ((Throwable) 0));
            return v6_4;
        }
    }

Method kotlin.io.FilesKt__FileReadWriteKt.inputStream() calling method java.io.FileInputStream.<init>()


    private static final java.io.FileInputStream inputStream(java.io.File p2)
    {
        return new java.io.FileInputStream(p2);
    }

Method kotlin.io.FilesKt__FileReadWriteKt.forEachLine() calling method java.io.FileInputStream.<init>()


    public static final void forEachLine(java.io.File p3, java.nio.charset.Charset p4, kotlin.jvm.functions.Function1 p5)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p3, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p4, "charset");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p5, "action");
        kotlin.io.TextStreamsKt.forEachLine(((java.io.Reader) new java.io.BufferedReader(((java.io.Reader) new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p3)), p4)))), p5);
        return;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.forEachBlock() calling method java.io.FileInputStream.<init>()


    public static final void forEachBlock(java.io.File p7, int p8, kotlin.jvm.functions.Function2 p9)
    {
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p7, "receiver$0");
        kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(p9, "action");
        byte[] v0_4 = new byte[kotlin.ranges.RangesKt.coerceAtLeast(p8, 512)];
        java.io.Closeable v1_0 = ((java.io.Closeable) new java.io.FileInputStream(p7));
        Throwable v2_1 = ((Throwable) 0);
        try {
            kotlin.Unit v3_1 = ((java.io.FileInputStream) v1_0);
        } catch (kotlin.Unit v3_2) {
            kotlin.io.CloseableKt.closeFinally(v1_0, v2_1);
            throw v3_2;
        } catch (Throwable v2_1) {
            throw v2_1;
        }
        while(true) {
            int v5 = v3_1.read(v0_4);
            if (v5 <= 0) {
                break;
            }
            p9.invoke(v0_4, Integer.valueOf(v5));
        }
        kotlin.io.CloseableKt.closeFinally(v1_0, ((Throwable) 0));
        return;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.bufferedReader$default() calling method java.io.FileInputStream.<init>()


    static synthetic java.io.BufferedReader bufferedReader$default(java.io.File p1, java.nio.charset.Charset p2, int p3, int p4, Object p5)
    {
        if ((p4 & 1) != 0) {
            p2 = kotlin.text.Charsets.UTF_8;
        }
        if ((p4 & 2) != 0) {
            p3 = 8192;
        }
        java.io.BufferedReader v5_3;
        java.io.BufferedReader v0_1 = ((java.io.Reader) new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p1)), p2));
        if (!(v0_1 instanceof java.io.BufferedReader)) {
            v5_3 = new java.io.BufferedReader(v0_1, p3);
        } else {
            v5_3 = ((java.io.BufferedReader) v0_1);
        }
        return v5_3;
    }

Method kotlin.io.FilesKt__FileReadWriteKt.bufferedReader() calling method java.io.FileInputStream.<init>()


    private static final java.io.BufferedReader bufferedReader(java.io.File p3, java.nio.charset.Charset p4, int p5)
    {
        java.io.BufferedReader v1_1;
        java.io.BufferedReader v2_3 = ((java.io.Reader) new java.io.InputStreamReader(((java.io.InputStream) new java.io.FileInputStream(p3)), p4));
        if (!(v2_3 instanceof java.io.BufferedReader)) {
            v1_1 = new java.io.BufferedReader(v2_3, p5);
        } else {
            v1_1 = ((java.io.BufferedReader) v2_3);
        }
        return v1_1;
    }

Method okio.Okio.source() calling method java.io.FileInputStream.<init>()


    public static okio.Source source(java.io.File p2)
    {
        if (p2 == null) {
            throw new IllegalArgumentException("file == null");
        } else {
            return okio.Okio.source(new java.io.FileInputStream(p2));
        }
    }

Method android.support.v4.graphics.drawable.IconCompat.loadDrawableInner() calling method java.io.FileInputStream.<init>()


    private android.graphics.drawable.Drawable loadDrawableInner(android.content.Context p9)
    {
        switch (this.mType) {
            case 1:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), ((android.graphics.Bitmap) this.mObj1));
            case 2:
                String v0_11 = this.getResPackage();
                if (android.text.TextUtils.isEmpty(v0_11)) {
                    v0_11 = p9.getPackageName();
                }
                try {
                    return android.support.v4.content.res.ResourcesCompat.getDrawable(android.support.v4.graphics.drawable.IconCompat.getResources(p9, v0_11), this.mInt1, p9.getTheme());
                } catch (android.graphics.drawable.BitmapDrawable v3_17) {
                    String v6_3 = new Object[2];
                    v6_3[0] = Integer.valueOf(this.mInt1);
                    v6_3[1] = this.mObj1;
                    android.util.Log.e("IconCompat", String.format("Unable to load resource 0x%08x from pkg=%s", v6_3), v3_17);
                }
            case 3:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.graphics.BitmapFactory.decodeByteArray(((byte[]) this.mObj1), this.mInt1, this.mInt2));
            case 4:
                java.io.FileInputStream v2_2;
                String v0_7 = android.net.Uri.parse(((String) this.mObj1));
                String v1_4 = v0_7.getScheme();
                if ((!"content".equals(v1_4)) && (!"file".equals(v1_4))) {
                    try {
                        v2_2 = new java.io.FileInputStream(new java.io.File(((String) this.mObj1)));
                    } catch (android.graphics.drawable.BitmapDrawable v3_6) {
                        android.graphics.Bitmap v5_3 = new StringBuilder();
                        v5_3.append("Unable to load image from path: ");
                        v5_3.append(v0_7);
                        android.util.Log.w("IconCompat", v5_3.toString(), v3_6);
                    }
                } else {
                    try {
                        v2_2 = p9.getContentResolver().openInputStream(v0_7);
                    } catch (android.graphics.drawable.BitmapDrawable v3_9) {
                        android.graphics.Bitmap v5_6 = new StringBuilder();
                        v5_6.append("Unable to load image from URI: ");
                        v5_6.append(v0_7);
                        android.util.Log.w("IconCompat", v5_6.toString(), v3_9);
                    }
                }
                if (v2_2 == null) {
                } else {
                    return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.graphics.BitmapFactory.decodeStream(v2_2));
                }
            case 5:
                return new android.graphics.drawable.BitmapDrawable(p9.getResources(), android.support.v4.graphics.drawable.IconCompat.createLegacyIconFromAdaptiveIcon(((android.graphics.Bitmap) this.mObj1), 0));
            default:
        }
        return 0;
    }

Method io.fabric.sdk.android.services.settings.DefaultCachedSettingsIo.readCachedSettings() calling method java.io.FileInputStream.<init>()


    public org.json.JSONObject readCachedSettings()
    {
        io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "Reading cached settings...");
        java.io.FileInputStream v0_1 = 0;
        org.json.JSONObject v1_1 = 0;
        try {
            String v2_0 = new java.io.File(new io.fabric.sdk.android.services.persistence.FileStoreImpl(this.kit).getFilesDir(), "com.crashlytics.settings.json");
        } catch (String v2_3) {
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            throw v2_3;
        } catch (String v2_2) {
            io.fabric.sdk.android.Fabric.getLogger().e("Fabric", "Failed to fetch cached settings", v2_2);
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        }
        if (!v2_0.exists()) {
            io.fabric.sdk.android.Fabric.getLogger().d("Fabric", "No cached settings found.");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        } else {
            v0_1 = new java.io.FileInputStream(v2_0);
            v1_1 = new org.json.JSONObject(io.fabric.sdk.android.services.common.CommonUtils.streamToString(v0_1));
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0_1, "Error while closing settings cache file.");
            return v1_1;
        }
    }

Method io.fabric.sdk.android.services.events.QueueFileEventStorage.move() calling method java.io.FileInputStream.<init>()


    private void move(java.io.File p5, java.io.File p6)
    {
        java.io.FileInputStream v1 = 0;
        try {
            v1 = new java.io.FileInputStream(p5);
            java.io.OutputStream v0 = this.getMoveOutputStream(p6);
            Throwable v2_7 = new byte[1024];
            io.fabric.sdk.android.services.common.CommonUtils.copyStream(v1, v0, v2_7);
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close file input stream");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, "Failed to close output stream");
            p5.delete();
            return;
        } catch (Throwable v2_2) {
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v1, "Failed to close file input stream");
            io.fabric.sdk.android.services.common.CommonUtils.closeOrLog(v0, "Failed to close output stream");
            p5.delete();
            throw v2_2;
        }
    }

Method com.microsoft.identity.common.adal.internal.cache.StorageHelper.readKeyData() calling method java.io.FileInputStream.<init>()


    private byte[] readKeyData()
    {
        java.io.File v0_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (!v0_1.exists()) {
            throw new java.io.IOException("Key file to read does not exist");
        } else {
            android.util.Log.v("StorageHelper", "Reading key data from a file");
            java.io.IOException v1_6 = new java.io.FileInputStream(v0_1);
            try {
                Throwable v2_4 = new java.io.ByteArrayOutputStream();
                byte[] v4_1 = new byte[1024];
            } catch (Throwable v2_5) {
                v1_6.close();
                throw v2_5;
            }
            while(true) {
                int v5 = v1_6.read(v4_1);
                if (v5 == -1) {
                    break;
                }
                v2_4.write(v4_1, 0, v5);
            }
            byte[] v3_0 = v2_4.toByteArray();
            v1_6.close();
            return v3_0;
        }
    }

Method com.microsoft.aad.adal.FileTokenCacheStore.<init>() calling method java.io.FileInputStream.<init>()


    public FileTokenCacheStore(android.content.Context p10, String p11)
    {
        this.mCacheLock = new Object();
        if (p10 == null) {
            throw new IllegalArgumentException("context");
        } else {
            if (com.microsoft.identity.common.adal.internal.util.StringExtensions.isNullOrBlank(p11)) {
                throw new IllegalArgumentException("fileName");
            } else {
                IllegalArgumentException v1_4 = p10.getDir(p10.getPackageName(), 0);
                if (v1_4 == null) {
                    throw new IllegalStateException("It could not access the Authorization cache directory");
                } else {
                    try {
                        this.mFile = new java.io.File(v1_4, p11);
                    } catch (com.microsoft.aad.adal.MemoryTokenCacheStore v2_19) {
                        String v3_13 = new StringBuilder();
                        v3_13.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v3_13.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.e(v3_13.toString(), "Exception during cache load. ", com.microsoft.aad.adal.ExceptionExtensions.getExceptionMessage(v2_19), com.microsoft.aad.adal.ADALError.DEVICE_FILE_CACHE_IS_NOT_LOADED_FROM_FILE);
                        throw new IllegalStateException(v2_19);
                    }
                    if (!this.mFile.exists()) {
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_9 = new StringBuilder();
                        v2_9.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v2_9.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.v(v2_9.toString(), "There is not any previous cache file to load cache. ");
                        this.mInMemoryCache = new com.microsoft.aad.adal.MemoryTokenCacheStore();
                    } else {
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_14 = new StringBuilder();
                        v2_14.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                        v2_14.append(":FileTokenCacheStore");
                        com.microsoft.aad.adal.Logger.v(v2_14.toString(), "There is previous cache file to load cache. ");
                        com.microsoft.aad.adal.MemoryTokenCacheStore v2_17 = new java.io.FileInputStream(this.mFile);
                        String v3_11 = new java.io.ObjectInputStream(v2_17);
                        Object v4_0 = v3_11.readObject();
                        v2_17.close();
                        v3_11.close();
                        if (!(v4_0 instanceof com.microsoft.aad.adal.MemoryTokenCacheStore)) {
                            com.microsoft.aad.adal.MemoryTokenCacheStore v5_2 = new StringBuilder();
                            v5_2.append(com.microsoft.aad.adal.FileTokenCacheStore.TAG);
                            v5_2.append(":FileTokenCacheStore");
                            com.microsoft.aad.adal.Logger.w(v5_2.toString(), "Existing cache format is wrong. ", "", com.microsoft.aad.adal.ADALError.DEVICE_FILE_CACHE_FORMAT_IS_WRONG);
                            this.mInMemoryCache = new com.microsoft.aad.adal.MemoryTokenCacheStore();
                        } else {
                            this.mInMemoryCache = ((com.microsoft.aad.adal.MemoryTokenCacheStore) v4_0);
                        }
                    }
                    return;
                }
            }
        }
    }

Method com.google.android.exoplayer2.upstream.RawResourceDataSource.open() calling method java.io.FileInputStream.<init>()


    public long open(com.google.android.exoplayer2.upstream.DataSpec p9)
    {
        try {
            this.uri = p9.uri;
        } catch (long v0_6) {
            throw new com.google.android.exoplayer2.upstream.RawResourceDataSource$RawResourceDataSourceException(v0_6);
        }
        if (!android.text.TextUtils.equals("rawresource", this.uri.getScheme())) {
            throw new com.google.android.exoplayer2.upstream.RawResourceDataSource$RawResourceDataSourceException("URI must use scheme rawresource");
        } else {
            int vtmp4 = Integer.parseInt(this.uri.getLastPathSegment());
            this.assetFileDescriptor = this.resources.openRawResourceFd(vtmp4);
            this.inputStream = new java.io.FileInputStream(this.assetFileDescriptor.getFileDescriptor());
            this.inputStream.skip(this.assetFileDescriptor.getStartOffset());
            if (this.inputStream.skip(p9.position) < p9.position) {
                throw new java.io.EOFException();
            } else {
                long v5_0 = -1;
                if (p9.length == -1) {
                    long v3_7 = this.assetFileDescriptor.getLength();
                    if (v3_7 != -1) {
                        v5_0 = (v3_7 - p9.position);
                    } else {
                    }
                    this.bytesRemaining = v5_0;
                } else {
                    this.bytesRemaining = p9.length;
                }
                this.opened = 1;
                if (this.listener != null) {
                    this.listener.onTransferStart(this, p9);
                }
                return this.bytesRemaining;
            }
        }
    }

Method com.google.android.exoplayer2.upstream.ContentDataSource.open() calling method java.io.FileInputStream.<init>()


    public long open(com.google.android.exoplayer2.upstream.DataSpec p14)
    {
        try {
            this.uri = p14.uri;
            this.assetFileDescriptor = this.resolver.openAssetFileDescriptor(this.uri, "r");
        } catch (long v0_9) {
            throw new com.google.android.exoplayer2.upstream.ContentDataSource$ContentDataSourceException(v0_9);
        }
        if (this.assetFileDescriptor == null) {
            String v1_1 = new StringBuilder();
            v1_1.append("Could not open file descriptor for: ");
            v1_1.append(this.uri);
            throw new java.io.FileNotFoundException(v1_1.toString());
        } else {
            this.inputStream = new java.io.FileInputStream(this.assetFileDescriptor.getFileDescriptor());
            long v0_7 = this.assetFileDescriptor.getStartOffset();
            android.net.Uri v2_4 = (this.inputStream.skip((p14.position + v0_7)) - v0_7);
            if (v2_4 != p14.position) {
                throw new java.io.EOFException();
            } else {
                long v6_0 = -1;
                if (p14.length == -1) {
                    long v4_7 = this.assetFileDescriptor.getLength();
                    if (v4_7 != -1) {
                        this.bytesRemaining = (v4_7 - v2_4);
                    } else {
                        java.nio.channels.FileChannel v8_2 = this.inputStream.getChannel();
                        long v9 = v8_2.size();
                        if (v9 != 0) {
                            v6_0 = (v9 - v8_2.position());
                        } else {
                        }
                        this.bytesRemaining = v6_0;
                    }
                } else {
                    this.bytesRemaining = p14.length;
                }
                this.opened = 1;
                if (this.listener != null) {
                    this.listener.onTransferStart(this, p14);
                }
                return this.bytesRemaining;
            }
        }
    }

Method com.crashlytics.android.core.Sha1FileIdStrategy.getFileSHA() calling method java.io.FileInputStream.<init>()


    private static String getFileSHA(String p4)
    {
        java.io.BufferedInputStream v1 = 0;
        try {
            v1 = new java.io.BufferedInputStream(new java.io.FileInputStream(p4));
            String v0 = io.fabric.sdk.android.services.common.CommonUtils.sha1(v1);
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            return v0;
        } catch (Throwable v2_0) {
            io.fabric.sdk.android.services.common.CommonUtils.closeQuietly(v1);
            throw v2_0;
        }
    }

Method com.crashlytics.android.beta.DeviceTokenLoader.getZipInputStreamOfApkFrom() calling method java.io.FileInputStream.<init>()


    java.util.zip.ZipInputStream getZipInputStreamOfApkFrom(android.content.Context p6, String p7)
    {
        return new java.util.zip.ZipInputStream(new java.io.FileInputStream(p6.getPackageManager().getApplicationInfo(p7, 0).sourceDir));
    }

Method android.support.v4.graphics.TypefaceCompatApi21Impl.createFromFontInfo() calling method java.io.FileInputStream.<init>()


    public android.graphics.Typeface createFromFontInfo(android.content.Context p11, android.os.CancellationSignal p12, android.support.v4.provider.FontsContractCompat$FontInfo[] p13, int p14)
    {
        if (p13.length >= 1) {
            android.support.v4.provider.FontsContractCompat$FontInfo v0_1 = this.findBestInfo(p13, p14);
            android.content.ContentResolver v2_1 = p11.getContentResolver();
            try {
                java.io.IOException v3_1 = v2_1.openFileDescriptor(v0_1.getUri(), "r", p12);
                try {
                    Throwable v4_1 = this.getFile(v3_1);
                } catch (Throwable v4_3) {
                    Throwable v5_5 = 0;
                    if (v3_1 != null) {
                        if (v5_5 == null) {
                            v3_1.close();
                        } else {
                            try {
                                v3_1.close();
                            } catch (Throwable v6_4) {
                                v5_5.addSuppressed(v6_4);
                            }
                        }
                    }
                    throw v4_3;
                } catch (Throwable v4_2) {
                    try {
                        throw v4_2;
                    } catch (Throwable v5_4) {
                        v5_5 = v4_2;
                        v4_3 = v5_4;
                    }
                }
                if (v4_1 != null) {
                    if (v4_1.canRead()) {
                        Throwable v5_1 = android.graphics.Typeface.createFromFile(v4_1);
                        if (v3_1 != null) {
                            v3_1.close();
                        }
                        return v5_1;
                    } else {
                    }
                }
                Throwable v5_3 = new java.io.FileInputStream(v3_1.getFileDescriptor());
                try {
                    Throwable v6_1 = super.createFromInputStream(p11, v5_3);
                } catch (Throwable v6_3) {
                    Throwable v7_1 = 0;
                    if (v7_1 == null) {
                        v5_3.close();
                    } else {
                        try {
                            v5_3.close();
                        } catch (Throwable v8) {
                            v7_1.addSuppressed(v8);
                        }
                    }
                    throw v6_3;
                } catch (Throwable v6_2) {
                    try {
                        throw v6_2;
                    } catch (Throwable v7_0) {
                        v7_1 = v6_2;
                        v6_3 = v7_0;
                    }
                }
                v5_3.close();
                if (v3_1 != null) {
                    v3_1.close();
                }
                return v6_1;
            } catch (java.io.IOException v3) {
                return 0;
            }
        } else {
            return 0;
        }
    }

Method io.fabric.sdk.android.services.network.HttpRequest.send() calling method java.io.FileInputStream.<init>()


    public io.fabric.sdk.android.services.network.HttpRequest send(java.io.File p3)
    {
        try {
            java.io.FileNotFoundException v0_1 = new java.io.BufferedInputStream(new java.io.FileInputStream(p3));
            return this.send(v0_1);
        } catch (java.io.FileNotFoundException v0_2) {
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v0_2);
        }
    }

Method io.fabric.sdk.android.services.network.HttpRequest.part() calling method java.io.FileInputStream.<init>()


    public io.fabric.sdk.android.services.network.HttpRequest part(String p4, String p5, String p6, java.io.File p7)
    {
        try {
            java.io.BufferedInputStream v0 = new java.io.BufferedInputStream(new java.io.FileInputStream(p7));
            java.io.IOException v1_3 = this.part(p4, p5, p6, v0);
            try {
                v0.close();
            } catch (java.io.IOException v2) {
            }
            return v1_3;
        } catch (java.io.IOException v1_1) {
            if (v0 != null) {
                try {
                    v0.close();
                } catch (java.io.IOException v2) {
                }
            }
            throw v1_1;
        } catch (java.io.IOException v1_4) {
            throw new io.fabric.sdk.android.services.network.HttpRequest$HttpRequestException(v1_4);
        }
    }

Method com.nimbusds.jose.util.IOUtils.readFileToString() calling method java.io.FileInputStream.<init>()


    public static String readFileToString(java.io.File p1, java.nio.charset.Charset p2)
    {
        return com.nimbusds.jose.util.IOUtils.readInputStreamToString(new java.io.FileInputStream(p1), p2);
    }

Method com.microsoft.aad.adal.StorageHelper.readKeyData() calling method java.io.FileInputStream.<init>()


    private byte[] readKeyData()
    {
        java.io.File v0_1 = new java.io.File(this.mContext.getDir(this.mContext.getPackageName(), 0), "adalks");
        if (!v0_1.exists()) {
            throw new java.io.IOException("Key file to read does not exist");
        } else {
            com.microsoft.aad.adal.Logger.v("StorageHelper", "Reading key data from a file");
            java.io.IOException v1_6 = new java.io.FileInputStream(v0_1);
            try {
                Throwable v2_4 = new java.io.ByteArrayOutputStream();
                byte[] v4_1 = new byte[1024];
            } catch (Throwable v2_5) {
                v1_6.close();
                throw v2_5;
            }
            while(true) {
                int v5 = v1_6.read(v4_1);
                if (v5 == -1) {
                    break;
                }
                v2_4.write(v4_1, 0, v5);
            }
            byte[] v3_0 = v2_4.toByteArray();
            v1_6.close();
            return v3_0;
        }
    }

Method com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.getUrandomInputStream() calling method java.io.FileInputStream.<init>()


    private java.io.DataInputStream getUrandomInputStream()
    {
        try {
            if (com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomIn == null) {
                try {
                    com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomIn = new java.io.DataInputStream(new java.io.FileInputStream(com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.URANDOM_FILE));
                } catch (java.io.IOException v1_5) {
                    String v3_1 = new StringBuilder();
                    v3_1.append("Failed to open ");
                    v3_1.append(com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.URANDOM_FILE);
                    v3_1.append(" for reading");
                    throw new SecurityException(v3_1.toString(), v1_5);
                }
            }
        } catch (java.io.IOException v1_2) {
            throw v1_2;
        }
        return com.microsoft.aad.adal.PRNGFixes$LinuxPRNGSecureRandom.sUrandomIn;
    }

Method com.google.android.gms.common.util.IOUtils$zzb.zzdd() calling method java.io.FileInputStream.<init>()


    public final byte[] zzdd()
    {
        try {
            int v1_1 = new java.io.FileInputStream(this.file);
            try {
                Throwable v0_1 = com.google.android.gms.common.util.IOUtils.zzb(v1_1, v1_1.getChannel().size());
                com.google.android.gms.common.util.IOUtils.closeQuietly(v1_1);
                return v0_1;
            } catch (Throwable v0_2) {
                com.google.android.gms.common.util.IOUtils.closeQuietly(v1_1);
                throw v0_2;
            }
        } catch (int v1_2) {
            v1_1 = 0;
            v0_2 = v1_2;
        }
        v0_1 = com.google.android.gms.common.util.IOUtils.zzb(v1_1, v1_1.getChannel().size());
        com.google.android.gms.common.util.IOUtils.closeQuietly(v1_1);
        return v0_1;
    }

Method com.google.android.exoplayer2.util.AtomicFile.openRead() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream openRead()
    {
        this.restoreBackup();
        return new java.io.FileInputStream(this.baseName);
    }

Method com.crashlytics.android.core.BinaryImagesConverter.getLibraryFile() calling method java.io.File.<init>()


    private java.io.File getLibraryFile(String p3)
    {
        java.io.File v0_1 = new java.io.File(p3);
        if (!v0_1.exists()) {
            v0_1 = this.correctDataPath(v0_1);
        }
        return v0_1;
    }

Method com.crashlytics.android.core.BinaryImagesConverter.correctDataPath() calling method java.io.File.<init>()


    private java.io.File correctDataPath(java.io.File p5)
    {
        if (android.os.Build$VERSION.SDK_INT >= 9) {
            if (p5.getAbsolutePath().startsWith("/data")) {
                try {
                    p5 = new java.io.File(this.context.getPackageManager().getApplicationInfo(this.context.getPackageName(), 0).nativeLibraryDir, p5.getName());
                } catch (android.content.pm.PackageManager$NameNotFoundException v0_3) {
                    io.fabric.sdk.android.Fabric.getLogger().e("CrashlyticsCore", "Error getting ApplicationInfo", v0_3);
                }
            }
            return p5;
        } else {
            return p5;
        }
    }

Method com.bumptech.glide.load.data.MediaStoreThumbFetcher$FileService.get() calling method java.io.File.<init>()


    public java.io.File get(String p2)
    {
        return new java.io.File(p2);
    }

Method com.bumptech.glide.disklrucache.DiskLruCache.open() calling method java.io.File.<init>()


    public static com.bumptech.glide.disklrucache.DiskLruCache open(java.io.File p11, int p12, int p13, long p14)
    {
        if (p14 <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        } else {
            if (p13 <= 0) {
                throw new IllegalArgumentException("valueCount <= 0");
            } else {
                IllegalArgumentException v0_4 = new java.io.File(p11, "journal.bkp");
                if (v0_4.exists()) {
                    void v1_3 = new java.io.File(p11, "journal");
                    if (!v1_3.exists()) {
                        com.bumptech.glide.disklrucache.DiskLruCache.renameTo(v0_4, v1_3, 0);
                    } else {
                        v0_4.delete();
                    }
                }
                void v1_4 = new com.bumptech.glide.disklrucache.DiskLruCache;
                v1_4(p11, p12, p13, p14);
                if (v1_4.journalFile.exists()) {
                    try {
                        void v1_6 = v1_4.readJournal().processJournal();
                        return v1_6;
                    } catch (java.io.IOException v2_5) {
                        String v4_2 = new StringBuilder();
                        v4_2.append("DiskLruCache ");
                        v4_2.append(p11);
                        v4_2.append(" is corrupt: ");
                        v4_2.append(v2_5.getMessage());
                        v4_2.append(", removing");
                        System.out.println(v4_2.toString());
                        v1_6.delete();
                    }
                }
                p11.mkdirs();
                java.io.IOException v2_6 = new com.bumptech.glide.disklrucache.DiskLruCache;
                v2_6(p11, p12, p13, p14);
                return v2_6.rebuildJournal();
            }
        }
    }

Method com.bumptech.glide.disklrucache.DiskLruCache.<init>() calling method java.io.File.<init>()


    private DiskLruCache(java.io.File p16, int p17, int p18, long p19)
    {
        this.size = 0;
        this.lruEntries = new java.util.LinkedHashMap(0, 1061158912, 1);
        this.nextSequenceNumber = 0;
        int v2_0 = new java.util.concurrent.ThreadPoolExecutor;
        v2_0(0, 1, 60, java.util.concurrent.TimeUnit.SECONDS, new java.util.concurrent.LinkedBlockingQueue());
        this.executorService = v2_0;
        this.cleanupCallable = new com.bumptech.glide.disklrucache.DiskLruCache$1(this);
        this.directory = p16;
        this.appVersion = p17;
        this.journalFile = new java.io.File(p16, "journal");
        this.journalFileTmp = new java.io.File(p16, "journal.tmp");
        this.journalFileBackup = new java.io.File(p16, "journal.bkp");
        this.valueCount = p18;
        this.maxSize = p19;
        return;
    }

Method com.bumptech.glide.disklrucache.DiskLruCache$Entry.<init>() calling method java.io.File.<init>()


    private DiskLruCache$Entry(com.bumptech.glide.disklrucache.DiskLruCache p8, String p9)
    {
        this.this$0 = p8;
        this.key = p9;
        StringBuilder v0_6 = new long[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p8)];
        this.lengths = v0_6;
        StringBuilder v0_8 = new java.io.File[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p8)];
        this.cleanFiles = v0_8;
        StringBuilder v0_1 = new java.io.File[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p8)];
        this.dirtyFiles = v0_1;
        StringBuilder v0_4 = new StringBuilder(p9).append(46);
        int v1_1 = v0_4.length();
        int v2 = 0;
        while (v2 < com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p8)) {
            v0_4.append(v2);
            this.cleanFiles[v2] = new java.io.File(com.bumptech.glide.disklrucache.DiskLruCache.access$1900(p8), v0_4.toString());
            v0_4.append(".tmp");
            this.dirtyFiles[v2] = new java.io.File(com.bumptech.glide.disklrucache.DiskLruCache.access$1900(p8), v0_4.toString());
            v0_4.setLength(v1_1);
            v2++;
        }
        return;
    }

Method com.bumptech.glide.Glide.getPhotoCacheDir() calling method java.io.File.<init>()


    public static java.io.File getPhotoCacheDir(android.content.Context p4, String p5)
    {
        java.io.File v0 = p4.getCacheDir();
        if (v0 == null) {
            if (android.util.Log.isLoggable("Glide", 6)) {
                android.util.Log.e("Glide", "default disk cache dir is null");
            }
            return 0;
        } else {
            String v2_1 = new java.io.File(v0, p5);
            if ((v2_1.mkdirs()) || ((v2_1.exists()) && (v2_1.isDirectory()))) {
                return v2_1;
            } else {
                return 0;
            }
        }
    }

Method android.support.v4.util.AtomicFile.<init>() calling method java.io.File.<init>()


    public AtomicFile(java.io.File p4)
    {
        this.mBaseName = p4;
        String v1_2 = new StringBuilder();
        v1_2.append(p4.getPath());
        v1_2.append(".bak");
        this.mBackupName = new java.io.File(v1_2.toString());
        return;
    }

Method android.support.v4.graphics.TypefaceCompatUtil.getTempFile() calling method java.io.File.<init>()


    public static java.io.File getTempFile(android.content.Context p5)
    {
        String v0_1 = new StringBuilder();
        v0_1.append(".font");
        v0_1.append(android.os.Process.myPid());
        v0_1.append("-");
        v0_1.append(android.os.Process.myTid());
        v0_1.append("-");
        String v0_2 = v0_1.toString();
        int v1_2 = 0;
        while (v1_2 < 100) {
            java.io.IOException v3_0 = p5.getCacheDir();
            String v4_1 = new StringBuilder();
            v4_1.append(v0_2);
            v4_1.append(v1_2);
            java.io.File v2_2 = new java.io.File(v3_0, v4_1.toString());
            try {
                if (v2_2.createNewFile()) {
                    return v2_2;
                }
                v1_2++;
            } catch (java.io.IOException v3) {
            }
        }
        return 0;
    }

Method android.support.v4.content.FileProvider.buildPath() calling method java.io.File.<init>()


    private static varargs java.io.File buildPath(java.io.File p5, String[] p6)
    {
        java.io.File v0 = p5;
        int v2 = 0;
        while (v2 < p6.length) {
            String v3 = p6[v2];
            if (v3 != null) {
                v0 = new java.io.File(v0, v3);
            }
            v2++;
        }
        return v0;
    }

Method android.support.v4.content.FileProvider.<clinit>() calling method java.io.File.<init>()


    static FileProvider()
    {
        android.support.v4.content.FileProvider.COLUMNS = new String[] {"_display_name", "_size"});
        android.support.v4.content.FileProvider.DEVICE_ROOT = new java.io.File("/");
        android.support.v4.content.FileProvider.sCache = new java.util.HashMap();
        return;
    }

Method android.support.v4.content.ContextCompat.getNoBackupFilesDir() calling method java.io.File.<init>()


    public static java.io.File getNoBackupFilesDir(android.content.Context p4)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            return android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p4.getApplicationInfo().dataDir, "no_backup"));
        } else {
            return p4.getNoBackupFilesDir();
        }
    }

Method android.support.v4.content.ContextCompat.getDataDir() calling method java.io.File.<init>()


    public static java.io.File getDataDir(android.content.Context p2)
    {
        if (android.os.Build$VERSION.SDK_INT < 24) {
            int v1_1;
            String v0_3 = p2.getApplicationInfo().dataDir;
            if (v0_3 == null) {
                v1_1 = 0;
            } else {
                v1_1 = new java.io.File(v0_3);
            }
            return v1_1;
        } else {
            return p2.getDataDir();
        }
    }

Method android.support.v4.content.ContextCompat.getCodeCacheDir() calling method java.io.File.<init>()


    public static java.io.File getCodeCacheDir(android.content.Context p4)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            return android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p4.getApplicationInfo().dataDir, "code_cache"));
        } else {
            return p4.getCodeCacheDir();
        }
    }

Method android.support.v4.content.ContextCompat.buildPath() calling method java.io.File.<init>()


    private static varargs java.io.File buildPath(java.io.File p5, String[] p6)
    {
        java.io.File v0 = p5;
        int v2 = 0;
        while (v2 < p6.length) {
            String v3 = p6[v2];
            if (v0 != null) {
                if (v3 != null) {
                    v0 = new java.io.File(v0, v3);
                }
            } else {
                v0 = new java.io.File(v3);
            }
            v2++;
        }
        return v0;
    }

Method android.arch.persistence.db.SupportSQLiteOpenHelper$Callback.deleteDatabaseFile() calling method java.io.File.<init>()


    private void deleteDatabaseFile(String p5)
    {
        if ((!p5.equalsIgnoreCase(":memory:")) && (p5.trim().length() != 0)) {
            String v1_1 = new StringBuilder();
            v1_1.append("deleting the database file: ");
            v1_1.append(p5);
            android.util.Log.w("SupportSQLite", v1_1.toString());
            try {
                if (android.os.Build$VERSION.SDK_INT < 16) {
                    try {
                        if (!new java.io.File(p5).delete()) {
                            String v2_2 = new StringBuilder();
                            v2_2.append("Could not delete the database file ");
                            v2_2.append(p5);
                            android.util.Log.e("SupportSQLite", v2_2.toString());
                        }
                    } catch (Exception v0_6) {
                        android.util.Log.e("SupportSQLite", "error while deleting corrupted database file", v0_6);
                    }
                } else {
                    android.database.sqlite.SQLiteDatabase.deleteDatabase(new java.io.File(p5));
                }
            } catch (Exception v0_7) {
                android.util.Log.w("SupportSQLite", "delete failed: ", v0_7);
            }
            return;
        } else {
            return;
        }
    }

Method okhttp3.internal.cache2.Relay.read() calling method java.io.RandomAccessFile.<init>()


    public static okhttp3.internal.cache2.Relay read(java.io.File p22)
    {
        java.io.RandomAccessFile v1_1 = new java.io.RandomAccessFile(p22, "rw");
        okhttp3.internal.cache2.FileOperator v9_1 = new okhttp3.internal.cache2.FileOperator(v1_1.getChannel());
        okio.Buffer v15 = new okio.Buffer();
        v9_1.read(0, v15, 32);
        if (!v15.readByteString(((long) okhttp3.internal.cache2.Relay.PREFIX_CLEAN.size())).equals(okhttp3.internal.cache2.Relay.PREFIX_CLEAN)) {
            throw new java.io.IOException("unreadable cache file");
        } else {
            long v11 = v15.readLong();
            long v13_1 = v15.readLong();
            okio.Buffer v19_1 = new okio.Buffer();
            v9_1.read((v11 + 32), v19_1, v13_1);
            okhttp3.internal.cache2.Relay v17_1 = new okhttp3.internal.cache2.Relay;
            v17_1(v1_1, 0, v11, v19_1.readByteString(), 0);
            return v17_1;
        }
    }

Method okhttp3.internal.cache2.Relay.edit() calling method java.io.RandomAccessFile.<init>()


    public static okhttp3.internal.cache2.Relay edit(java.io.File p14, okio.Source p15, okio.ByteString p16, long p17)
    {
        java.io.RandomAccessFile v0_1 = new java.io.RandomAccessFile(p14, "rw");
        okhttp3.internal.cache2.Relay v1_1 = new okhttp3.internal.cache2.Relay;
        v1_1(v0_1, p15, 0, p16, p17);
        v0_1.setLength(0);
        v1_1.writeHeader(okhttp3.internal.cache2.Relay.PREFIX_DIRTY, -1, -1);
        return v1_1;
    }

Method com.google.android.exoplayer2.upstream.FileDataSource.open() calling method java.io.RandomAccessFile.<init>()


    public long open(com.google.android.exoplayer2.upstream.DataSpec p6)
    {
        try {
            long v0_3;
            this.uri = p6.uri;
            this.file = new java.io.RandomAccessFile(p6.uri.getPath(), "r");
            this.file.seek(p6.position);
        } catch (long v0_11) {
            throw new com.google.android.exoplayer2.upstream.FileDataSource$FileDataSourceException(v0_11);
        }
        if (p6.length != -1) {
            v0_3 = p6.length;
        } else {
            v0_3 = (this.file.length() - p6.position);
        }
        this.bytesRemaining = v0_3;
        if (this.bytesRemaining < 0) {
            throw new java.io.EOFException();
        } else {
            this.opened = 1;
            if (this.listener != null) {
                this.listener.onTransferStart(this, p6);
            }
            return this.bytesRemaining;
        }
    }

Method io.fabric.sdk.android.services.common.QueueFile.open() calling method java.io.RandomAccessFile.<init>()


    private static java.io.RandomAccessFile open(java.io.File p2)
    {
        return new java.io.RandomAccessFile(p2, "rwd");
    }

Method com.google.android.gms.common.util.IOUtils.lockAndTruncateFile() calling method java.io.RandomAccessFile.<init>()


    public static void lockAndTruncateFile(java.io.File p5)
    {
        if (!p5.exists()) {
            throw new java.io.FileNotFoundException();
        } else {
            java.io.IOException v0_1 = 0;
            try {
                int v1_0 = new java.io.RandomAccessFile(p5, "rw");
                try {
                    java.io.IOException v5_2 = v1_0.getChannel();
                    boolean v2_0 = v5_2.lock();
                    try {
                        v5_2.truncate(0);
                    } catch (java.io.IOException v5_1) {
                        v0_1 = v2_0;
                        if (v0_1 != null) {
                            if (v0_1.isValid()) {
                                try {
                                    v0_1.release();
                                } catch (java.io.IOException v0) {
                                }
                            }
                        }
                        if (v1_0 != 0) {
                            com.google.android.gms.common.util.IOUtils.closeQuietly(v1_0);
                        }
                        throw v5_1;
                    }
                    if ((v2_0) && (v2_0.isValid())) {
                        try {
                            v2_0.release();
                        } catch (java.io.IOException v5) {
                        }
                    }
                    com.google.android.gms.common.util.IOUtils.closeQuietly(v1_0);
                    return;
                } catch (java.io.IOException v5_1) {
                }
            } catch (java.io.IOException v5_1) {
                v1_0 = 0;
            }
        }
    }

Method android.support.v7.widget.ActivityChooserModel$PersistHistoryAsyncTask.doInBackground() calling method android.content.Context.openFileOutput()


    public varargs Void doInBackground(Object[] p14)
    {
        java.util.List v1_1 = ((java.util.List) p14[0]);
        String v3_1 = ((String) p14[1]);
        try {
            java.io.FileOutputStream v5 = this.this$0.mContext.openFileOutput(v3_1, 0);
            String v6_1 = android.util.Xml.newSerializer();
            try {
                v6_1.setOutput(v5, 0);
                v6_1.startDocument("UTF-8", Boolean.valueOf(1));
                v6_1.startTag(0, "historical-records");
                String v7_4 = v1_1.size();
                int v8_4 = 0;
            } catch (java.io.IOException v0_3) {
                this.this$0.mCanReadHistoricalData = 1;
                if (v5 != null) {
                    try {
                        v5.close();
                    } catch (java.io.IOException v2) {
                    }
                }
                throw v0_3;
            } catch (java.io.IOException v0_1) {
                int v8_1 = new StringBuilder();
                v8_1.append("Error writing historical record file: ");
                v8_1.append(this.this$0.mHistoryFileName);
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, v8_1.toString(), v0_1);
                this.this$0.mCanReadHistoricalData = 1;
                if (v5 == null) {
                    return 0;
                } else {
                    v5.close();
                    return 0;
                }
            } catch (java.io.IOException v0_9) {
                int v8_9 = new StringBuilder();
                v8_9.append("Error writing historical record file: ");
                v8_9.append(this.this$0.mHistoryFileName);
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, v8_9.toString(), v0_9);
                this.this$0.mCanReadHistoricalData = 1;
                if (v5 == null) {
                    return 0;
                } else {
                    v5.close();
                    return 0;
                }
            } catch (java.io.IOException v0_7) {
                int v8_6 = new StringBuilder();
                v8_6.append("Error writing historical record file: ");
                v8_6.append(this.this$0.mHistoryFileName);
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, v8_6.toString(), v0_7);
                this.this$0.mCanReadHistoricalData = 1;
                if (v5 == null) {
                    return 0;
                } else {
                    v5.close();
                    return 0;
                }
            } catch (java.io.IOException v0) {
                return 0;
            }
            while (v8_4 < v7_4) {
                android.support.v7.widget.ActivityChooserModel$HistoricalRecord v9_4 = ((android.support.v7.widget.ActivityChooserModel$HistoricalRecord) v1_1.remove(0));
                v6_1.startTag(0, "historical-record");
                v6_1.attribute(0, "activity", v9_4.activity.flattenToString());
                v6_1.attribute(0, "time", String.valueOf(v9_4.time));
                v6_1.attribute(0, "weight", String.valueOf(v9_4.weight));
                v6_1.endTag(0, "historical-record");
                v8_4++;
            }
            v6_1.endTag(0, "historical-records");
            v6_1.endDocument();
            this.this$0.mCanReadHistoricalData = 1;
            if (v5 == null) {
                return 0;
            } else {
                v5.close();
                return 0;
            }
        } catch (java.io.IOException v0_4) {
            String v6_3 = new StringBuilder();
            v6_3.append("Error writing historical record file: ");
            v6_3.append(v3_1);
            android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, v6_3.toString(), v0_4);
            return 0;
        }
    }