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.google.android.gms.common.data.BitmapTeleporter.zabz() calling method java.io.FileOutputStream.<init>()


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

Method com.urbandroid.lux.TwilightService.filterWallpaper() calling method java.io.FileOutputStream.<init>()


    public declared_synchronized void filterWallpaper(android.content.Context p17, boolean p18)
    {
        try {
            int v2_21 = new java.io.File(p17.getCacheDir(), "wallpaper_temp");
            int v3_1 = new java.io.File(p17.getCacheDir(), "wallpaper_temp_lock");
            int v4_1 = new java.io.File(p17.getCacheDir(), "wallpaper_backup");
            java.io.File v5_3 = new java.io.File(p17.getCacheDir(), "wallpaper_backup_lock");
            int v6_4 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered");
            java.io.File v7_3 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered_lock");
            android.app.WallpaperManager v8_2 = android.app.WallpaperManager.getInstance(p17);
            int v9_8 = new StringBuilder();
            v9_8.append("Wallpaper filterWallpaper() should filter ");
            v9_8.append(p18);
            v9_8.append(" set ");
            v9_8.append(com.urbandroid.lux.context.AppContext.settings().isWallpaperSet());
            com.urbandroid.common.logging.Logger.logInfo(v9_8.toString());
        } catch (java.io.FileInputStream v0_31) {
            throw v0_31;
        }
        if ((!p18) || (com.urbandroid.lux.context.AppContext.settings().isWallpaperSet())) {
            if (!p18) {
                try {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper OFF");
                } catch (java.io.FileInputStream v0_5) {
                    com.urbandroid.common.logging.Logger.logSevere(v0_5);
                }
                if (android.os.Build$VERSION.SDK_INT < 24) {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        v8_2.setStream(new java.io.FileInputStream(v4_1));
                    }
                } else {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system");
                        if (v5_3.exists()) {
                            if (v5_3.canRead()) {
                                v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1, 1);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system after");
                                if ((v5_3.exists()) && (v5_3.canRead())) {
                                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring lock");
                                    v8_2.setStream(new java.io.FileInputStream(v5_3), 0, 1, 2);
                                }
                                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(0);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
                                return;
                            } else {
                            }
                        }
                        v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1);
                    }
                }
            }
        } else {
            try {
                java.io.FileInputStream v0_9 = (1065353216 - (((float) com.urbandroid.lux.context.AppContext.settings().getDim()) / 1120403456));
            } catch (java.io.FileInputStream v0_29) {
                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                throw v0_29;
            } catch (java.io.FileInputStream v0_27) {
                com.urbandroid.common.logging.Logger.logSevere(v0_27);
                java.io.FileInputStream v0_23 = com.urbandroid.lux.context.AppContext.settings();
                v0_23.setWallpaperSet(1);
            } catch (java.io.FileInputStream v0_26) {
                com.urbandroid.common.logging.Logger.logSevere(v0_26);
                v0_23 = com.urbandroid.lux.context.AppContext.settings();
            }
            if (android.os.Build$VERSION.SDK_INT >= 27) {
                v0_9 = Math.min(v0_9, 1050253722);
            }
            android.graphics.Bitmap$CompressFormat v14_6 = v8_2.getDrawable();
            if ((v14_6 instanceof android.graphics.drawable.BitmapDrawable)) {
                android.os.ParcelFileDescriptor v11_1 = ((android.graphics.drawable.BitmapDrawable) v14_6).getBitmap();
                android.graphics.Bitmap$CompressFormat v14_8 = this.getBlueAmount(v11_1);
                if (v14_8 != null) {
                    android.graphics.Bitmap v12_1 = new StringBuilder();
                    v12_1.append("Wallpaper: blue ");
                    v12_1.append(v14_8);
                    com.urbandroid.common.logging.Logger.logInfo(v12_1.toString());
                    android.graphics.Bitmap v12_3 = this.filterBitmap(v11_1, v0_9);
                    android.graphics.Bitmap$CompressFormat v14_10 = new StringBuilder();
                    v14_10.append("Wallpaper: blue after ");
                    v14_10.append(this.getBlueAmount(v12_3));
                    com.urbandroid.common.logging.Logger.logInfo(v14_10.toString());
                    if (android.os.Build$VERSION.SDK_INT < 24) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: filter using getBitmap");
                        v11_1.compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v4_1));
                        if ((v5_3.exists()) && (v5_3.canWrite())) {
                            v5_3.delete();
                        }
                        v8_2.setBitmap(v12_3);
                    } else {
                        if (((v8_2.getWallpaperId(1) != v8_2.getWallpaperId(2)) && (v8_2.getWallpaperId(2) != -1)) || ((!com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper()) || (android.os.Build$VERSION.SDK_INT >= 27))) {
                            int v9_5 = v8_2.getWallpaperFile(1);
                            android.os.ParcelFileDescriptor v11_2 = v8_2.getWallpaperFile(2);
                            if (v11_2 == null) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: lock is not set using system");
                                v11_2 = v8_2.getWallpaperFile(1);
                            }
                            if ((v9_5 != 0) && (com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper())) {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v9_5.getFileDescriptor()), new java.io.FileOutputStream(v2_21));
                                android.graphics.Bitmap v12_10 = android.graphics.BitmapFactory.decodeFile(v2_21.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v12_10) != 0) {
                                    this.filterBitmap(v12_10, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v6_4));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v2_21), new java.io.FileOutputStream(v4_1));
                                    v8_2.setStream(new java.io.FileInputStream(v6_4), 0, 0, 1);
                                }
                                v9_5.close();
                            }
                            if ((v11_2 == null) || (!com.urbandroid.lux.context.AppContext.settings().isFilterLockWallpaper())) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: not filtering");
                                if ((v5_3.exists()) && (v5_3.canWrite())) {
                                    v5_3.delete();
                                }
                            } else {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v11_2.getFileDescriptor()), new java.io.FileOutputStream(v3_1));
                                int v2_13 = android.graphics.BitmapFactory.decodeFile(v3_1.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v2_13) != 0) {
                                    this.filterBitmap(v2_13, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v7_3));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v3_1), new java.io.FileOutputStream(v5_3));
                                    v8_2.setStream(new java.io.FileInputStream(v7_3), 0, 0, 2);
                                }
                                v11_2.close();
                            }
                        } else {
                        }
                    }
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                } else {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper: already filtered, doing nothing");
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    return;
                }
            }
            v0_23 = com.urbandroid.lux.context.AppContext.settings();
        }
        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
        return;
    }

Method com.urbandroid.common.logging.Logger$LogFlusher.run() calling method java.io.FileOutputStream.<init>()


    public void run()
    {
        try {
            while (!Thread.interrupted()) {
                this.FLUSH_COND.wait(((long) (this.flushFrequencySeconds * 1000)));
                com.urbandroid.common.logging.Logger.access$302(com.urbandroid.common.logging.Logger.access$400());
                com.urbandroid.common.logging.Logger.access$500();
                if (com.urbandroid.common.logging.Logger.access$300() != null) {
                    java.util.Iterator v0_4 = com.urbandroid.common.logging.Logger.access$300().entrySet().iterator();
                    while (v0_4.hasNext()) {
                        java.util.Map v1_23 = ((java.util.Map$Entry) v0_4.next());
                        Throwable v2_3 = ((com.urbandroid.common.logging.Logger$LogConfig) v1_23.getKey());
                        java.util.Map v1_25 = ((java.util.LinkedList) v1_23.getValue());
                        java.io.BufferedWriter v3_2 = ((java.io.BufferedWriter) com.urbandroid.common.logging.Logger.access$600().get(v2_3));
                        if (!v1_25.isEmpty()) {
                            try {
                                if (v3_2 == null) {
                                    com.urbandroid.common.logging.Logger.access$700().put(v2_3, Long.valueOf(this.rotateLogFilesIfRequired(this.context, v2_3)));
                                    v3_2 = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(com.urbandroid.common.logging.Logger.access$800(this.context, v2_3), 1)));
                                    com.urbandroid.common.logging.Logger.access$600().put(v2_3, v3_2);
                                    if (v2_3.writeHeader) {
                                        Object v5_14 = new StringBuilder();
                                        v5_14.append("************ Log file started [");
                                        v5_14.append(new java.util.Date());
                                        v5_14.append("] Version: ");
                                        v5_14.append(new com.urbandroid.common.version.ApplicationVersionExtractor().getCurrentVersion(this.context));
                                        v5_14.append(" **************");
                                        v3_2.write(v5_14.toString());
                                    }
                                    v3_2.newLine();
                                }
                                Object v5_2 = 0;
                                if (com.urbandroid.common.logging.Logger.access$900().get(v2_3) != null) {
                                    v5_2 = ((Integer) com.urbandroid.common.logging.Logger.access$900().get(v2_3)).intValue();
                                }
                                long v9_0;
                                if (com.urbandroid.common.logging.Logger.access$700().get(v2_3) == null) {
                                    v9_0 = 0;
                                } else {
                                    v9_0 = ((Long) com.urbandroid.common.logging.Logger.access$700().get(v2_3)).longValue();
                                }
                                String v6_5 = v1_25.iterator();
                                while (v6_5.hasNext()) {
                                    long v11_3 = ((com.urbandroid.common.logging.Logger$LogRecord) v6_5.next()).getFormattedRecord();
                                    v3_2.write(v11_3);
                                    v3_2.newLine();
                                    v5_2++;
                                    v9_0 += ((long) (v11_3.length() + 1));
                                }
                                com.urbandroid.common.logging.Logger.access$900().put(v2_3, Integer.valueOf(v5_2));
                                com.urbandroid.common.logging.Logger.access$700().put(v2_3, Long.valueOf(v9_0));
                                v3_2.flush();
                                v1_25.clear();
                                Long v4_3 = this.waiters.iterator();
                                while (v4_3.hasNext()) {
                                    v4_3.next().notifyAll();
                                }
                                if (com.urbandroid.common.logging.Logger.access$900().get(v2_3) != null) {
                                    ((Integer) com.urbandroid.common.logging.Logger.access$900().get(v2_3)).intValue();
                                }
                                Long v4_4;
                                if (com.urbandroid.common.logging.Logger.access$700().get(v2_3) == null) {
                                    v4_4 = 0;
                                } else {
                                    v4_4 = ((Long) com.urbandroid.common.logging.Logger.access$700().get(v2_3)).longValue();
                                }
                                if (v4_4 > ((long) v2_3.minLengthToRotate)) {
                                    java.util.Map v1_16 = new StringBuilder();
                                    v1_16.append("Written bytes: ");
                                    v1_16.append(v4_4);
                                    v1_16.append(" -> rotating");
                                    v3_2.write(v1_16.toString());
                                    com.urbandroid.common.logging.Logger.access$700().put(v2_3, Long.valueOf(0));
                                    v3_2.close();
                                    com.urbandroid.common.logging.Logger.access$600().remove(v2_3);
                                }
                            } catch (java.util.Map v1_20) {
                                com.urbandroid.common.logging.Logger.logSevere(v1_20);
                            }
                        }
                    }
                } else {
                }
            }
        } catch (InterruptedException) {
        }
        return;
    }

Method com.urbandroid.common.file.FileCopyUtils.copyPrivateFileToSdCardFile() calling method java.io.FileOutputStream.<init>()


    public static void copyPrivateFileToSdCardFile(android.content.Context p1, String p2, String p3)
    {
        com.urbandroid.common.file.FileCopyUtils.copyFile(p2, p3, p1.openFileInput(p2), new java.io.FileOutputStream(p3));
        return;
    }

Method com.urbandroid.common.datastore.serialization.RecordSerializerExample.main() calling method java.io.FileOutputStream.<init>()


    public static void main(String[] p7)
    {
        java.util.HashMap v6_1 = new java.util.HashMap();
        java.io.File v7_5 = new java.util.HashMap();
        java.io.BufferedOutputStream v0_7 = Integer.valueOf(1);
        v7_5.put("testVal2", v0_7);
        java.io.FileOutputStream v1_0 = Integer.valueOf(2);
        v7_5.put("testVal22", v1_0);
        v6_1.put("test", v0_7);
        v6_1.put("test2", v1_0);
        v6_1.put("testMap", v7_5);
        v6_1.put("test3", Integer.valueOf(3));
        new com.urbandroid.common.datastore.serialization.RecordDTO(0, "user", Long.valueOf(new java.util.Date().getTime()), "scope", v6_1);
        new java.io.BufferedOutputStream(new java.io.FileOutputStream(new java.io.File("/tmp/ser")));
        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.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.nio.charset.Charset v1_14 = this.lruEntries.values().iterator();
        } catch (java.nio.charset.Charset v1_18) {
            v0_2.close();
            throw v1_18;
        }
        while (v1_14.hasNext()) {
            java.io.OutputStreamWriter v2_7 = ((com.bumptech.glide.disklrucache.DiskLruCache$Entry) v1_14.next());
            if (com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$700(v2_7) == null) {
                java.io.FileOutputStream v3_6 = new StringBuilder();
                v3_6.append("CLEAN ");
                v3_6.append(com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$1100(v2_7));
                v3_6.append(v2_7.getLengths());
                v3_6.append(10);
                v0_2.write(v3_6.toString());
            } else {
                java.io.FileOutputStream v3_8 = new StringBuilder();
                v3_8.append("DIRTY ");
                v3_8.append(com.bumptech.glide.disklrucache.DiskLruCache$Entry.access$1100(v2_7));
                v3_8.append(10);
                v0_2.write(v3_8.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 v1_1 = new com.bumptech.glide.disklrucache.StrictLineReader(new java.io.FileInputStream(this.journalFile), com.bumptech.glide.disklrucache.Util.US_ASCII);
        try {
            java.io.OutputStreamWriter v2_7 = v1_1.readLine();
            java.io.FileOutputStream v3_0 = v1_1.readLine();
            java.nio.charset.Charset v4_0 = v1_1.readLine();
            int v5_0 = v1_1.readLine();
            String v6 = v1_1.readLine();
        } catch (java.io.BufferedWriter v0_8) {
            com.bumptech.glide.disklrucache.Util.closeQuietly(v1_1);
            throw v0_8;
        }
        if ((!"libcore.io.DiskLruCache".equals(v2_7)) || ((!"1".equals(v3_0)) || ((!Integer.toString(this.appVersion).equals(v4_0)) || ((!Integer.toString(this.valueCount).equals(v5_0)) || (!"".equals(v6)))))) {
            String v7_7 = new StringBuilder();
            v7_7.append("unexpected journal header: [");
            v7_7.append(v2_7);
            v7_7.append(", ");
            v7_7.append(v3_0);
            v7_7.append(", ");
            v7_7.append(v5_0);
            v7_7.append(", ");
            v7_7.append(v6);
            v7_7.append("]");
            throw new java.io.IOException(v7_7.toString());
        } else {
            java.io.BufferedWriter v0_3 = 0;
            while(true) {
                this.readJournalLine(v1_1.readLine());
                v0_3++;
            }
        }
    }

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


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

Method com.urbandroid.lux.TwilightService.filterWallpaper() calling method java.io.FileInputStream.<init>()


    public declared_synchronized void filterWallpaper(android.content.Context p17, boolean p18)
    {
        try {
            int v2_21 = new java.io.File(p17.getCacheDir(), "wallpaper_temp");
            int v3_1 = new java.io.File(p17.getCacheDir(), "wallpaper_temp_lock");
            int v4_1 = new java.io.File(p17.getCacheDir(), "wallpaper_backup");
            java.io.File v5_3 = new java.io.File(p17.getCacheDir(), "wallpaper_backup_lock");
            int v6_4 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered");
            java.io.File v7_3 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered_lock");
            android.app.WallpaperManager v8_2 = android.app.WallpaperManager.getInstance(p17);
            int v9_8 = new StringBuilder();
            v9_8.append("Wallpaper filterWallpaper() should filter ");
            v9_8.append(p18);
            v9_8.append(" set ");
            v9_8.append(com.urbandroid.lux.context.AppContext.settings().isWallpaperSet());
            com.urbandroid.common.logging.Logger.logInfo(v9_8.toString());
        } catch (java.io.FileInputStream v0_31) {
            throw v0_31;
        }
        if ((!p18) || (com.urbandroid.lux.context.AppContext.settings().isWallpaperSet())) {
            if (!p18) {
                try {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper OFF");
                } catch (java.io.FileInputStream v0_5) {
                    com.urbandroid.common.logging.Logger.logSevere(v0_5);
                }
                if (android.os.Build$VERSION.SDK_INT < 24) {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        v8_2.setStream(new java.io.FileInputStream(v4_1));
                    }
                } else {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system");
                        if (v5_3.exists()) {
                            if (v5_3.canRead()) {
                                v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1, 1);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system after");
                                if ((v5_3.exists()) && (v5_3.canRead())) {
                                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring lock");
                                    v8_2.setStream(new java.io.FileInputStream(v5_3), 0, 1, 2);
                                }
                                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(0);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
                                return;
                            } else {
                            }
                        }
                        v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1);
                    }
                }
            }
        } else {
            try {
                java.io.FileInputStream v0_9 = (1065353216 - (((float) com.urbandroid.lux.context.AppContext.settings().getDim()) / 1120403456));
            } catch (java.io.FileInputStream v0_29) {
                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                throw v0_29;
            } catch (java.io.FileInputStream v0_27) {
                com.urbandroid.common.logging.Logger.logSevere(v0_27);
                java.io.FileInputStream v0_23 = com.urbandroid.lux.context.AppContext.settings();
                v0_23.setWallpaperSet(1);
            } catch (java.io.FileInputStream v0_26) {
                com.urbandroid.common.logging.Logger.logSevere(v0_26);
                v0_23 = com.urbandroid.lux.context.AppContext.settings();
            }
            if (android.os.Build$VERSION.SDK_INT >= 27) {
                v0_9 = Math.min(v0_9, 1050253722);
            }
            android.graphics.Bitmap$CompressFormat v14_6 = v8_2.getDrawable();
            if ((v14_6 instanceof android.graphics.drawable.BitmapDrawable)) {
                android.os.ParcelFileDescriptor v11_1 = ((android.graphics.drawable.BitmapDrawable) v14_6).getBitmap();
                android.graphics.Bitmap$CompressFormat v14_8 = this.getBlueAmount(v11_1);
                if (v14_8 != null) {
                    android.graphics.Bitmap v12_1 = new StringBuilder();
                    v12_1.append("Wallpaper: blue ");
                    v12_1.append(v14_8);
                    com.urbandroid.common.logging.Logger.logInfo(v12_1.toString());
                    android.graphics.Bitmap v12_3 = this.filterBitmap(v11_1, v0_9);
                    android.graphics.Bitmap$CompressFormat v14_10 = new StringBuilder();
                    v14_10.append("Wallpaper: blue after ");
                    v14_10.append(this.getBlueAmount(v12_3));
                    com.urbandroid.common.logging.Logger.logInfo(v14_10.toString());
                    if (android.os.Build$VERSION.SDK_INT < 24) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: filter using getBitmap");
                        v11_1.compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v4_1));
                        if ((v5_3.exists()) && (v5_3.canWrite())) {
                            v5_3.delete();
                        }
                        v8_2.setBitmap(v12_3);
                    } else {
                        if (((v8_2.getWallpaperId(1) != v8_2.getWallpaperId(2)) && (v8_2.getWallpaperId(2) != -1)) || ((!com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper()) || (android.os.Build$VERSION.SDK_INT >= 27))) {
                            int v9_5 = v8_2.getWallpaperFile(1);
                            android.os.ParcelFileDescriptor v11_2 = v8_2.getWallpaperFile(2);
                            if (v11_2 == null) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: lock is not set using system");
                                v11_2 = v8_2.getWallpaperFile(1);
                            }
                            if ((v9_5 != 0) && (com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper())) {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v9_5.getFileDescriptor()), new java.io.FileOutputStream(v2_21));
                                android.graphics.Bitmap v12_10 = android.graphics.BitmapFactory.decodeFile(v2_21.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v12_10) != 0) {
                                    this.filterBitmap(v12_10, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v6_4));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v2_21), new java.io.FileOutputStream(v4_1));
                                    v8_2.setStream(new java.io.FileInputStream(v6_4), 0, 0, 1);
                                }
                                v9_5.close();
                            }
                            if ((v11_2 == null) || (!com.urbandroid.lux.context.AppContext.settings().isFilterLockWallpaper())) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: not filtering");
                                if ((v5_3.exists()) && (v5_3.canWrite())) {
                                    v5_3.delete();
                                }
                            } else {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v11_2.getFileDescriptor()), new java.io.FileOutputStream(v3_1));
                                int v2_13 = android.graphics.BitmapFactory.decodeFile(v3_1.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v2_13) != 0) {
                                    this.filterBitmap(v2_13, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v7_3));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v3_1), new java.io.FileOutputStream(v5_3));
                                    v8_2.setStream(new java.io.FileInputStream(v7_3), 0, 0, 2);
                                }
                                v11_2.close();
                            }
                        } else {
                        }
                    }
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                } else {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper: already filtered, doing nothing");
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    return;
                }
            }
            v0_23 = com.urbandroid.lux.context.AppContext.settings();
        }
        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
        return;
    }

Method com.urbandroid.common.error.EmailIntentErrorDispatcher.loadErrorReport() calling method java.io.FileInputStream.<init>()

Couldn't retrieve source code

Method com.urbandroid.common.error.DefaultErrorReportSerializer.serializeLogFiles() calling method java.io.FileInputStream.<init>()


    public static void serializeLogFiles(java.io.OutputStream p8, java.io.File[] p9)
    {
        byte[] v0_1 = new byte[32768];
        int v1_0 = (p9.length - 1);
        int v2_4 = (p9.length - 1);
        java.io.FileInputStream v3_0 = 0;
        while(true) {
            int v2_9 = v1_0;
            v1_0 = v2_4;
            if (v1_0 < 0) {
                break;
            }
            if (p9[v1_0].exists()) {
                v3_0 += p9[v1_0].length();
                if (v3_0 > 2097152) {
                    while ((v1_0 >= 0) && (v1_0 < p9.length)) {
                        java.io.FileInputStream v3_2 = new java.io.FileInputStream(p9[v1_0]);
                        while(true) {
                            int v2_7 = v3_2.read(v0_1);
                            if (v2_7 < 0) {
                                break;
                            }
                            p8.write(v0_1, 0, v2_7);
                        }
                        v3_2.close();
                        v1_0++;
                    }
                    return;
                }
            }
            v2_4 = (v1_0 - 1);
        }
        v1_0 = v2_9;
    }

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


    public android.graphics.Typeface createFromFontInfo(android.content.Context p5, android.os.CancellationSignal p6, android.support.v4.provider.FontsContractCompat$FontInfo[] p7, int p8)
    {
        if (p7.length >= 1) {
            try {
                Throwable v6_1 = p5.getContentResolver().openFileDescriptor(this.findBestInfo(p7, p8).getUri(), "r", p6);
                try {
                    Throwable v7_1 = this.getFile(v6_1);
                } catch (Throwable v5_6) {
                    Throwable v7_7 = 0;
                    if (v6_1 != null) {
                        if (v7_7 == null) {
                            v6_1.close();
                        } else {
                            try {
                                v6_1.close();
                            } catch (Throwable v6_2) {
                                v7_7.addSuppressed(v6_2);
                            }
                        }
                    }
                    throw v5_6;
                } catch (Throwable v5_5) {
                    try {
                        throw v5_5;
                    } catch (Throwable v7_5) {
                        v7_7 = v5_5;
                        v5_6 = v7_5;
                    }
                }
                if (v7_1 != null) {
                    if (v7_1.canRead()) {
                        Throwable v5_1 = android.graphics.Typeface.createFromFile(v7_1);
                        if (v6_1 != null) {
                            v6_1.close();
                        }
                        return v5_1;
                    } else {
                    }
                }
                Throwable v7_3 = new java.io.FileInputStream(v6_1.getFileDescriptor());
                try {
                    Throwable v5_2 = super.createFromInputStream(p5, v7_3);
                } catch (Throwable v5_4) {
                    Throwable v8_4 = 0;
                    if (v8_4 == null) {
                        v7_3.close();
                    } else {
                        try {
                            v7_3.close();
                        } catch (Throwable v7_4) {
                            v8_4.addSuppressed(v7_4);
                        }
                    }
                    throw v5_4;
                } catch (Throwable v5_3) {
                    try {
                        throw v5_3;
                    } catch (Throwable v8_3) {
                        v8_4 = v5_3;
                        v5_4 = v8_3;
                    }
                }
                v7_3.close();
                if (v6_1 != null) {
                    v6_1.close();
                }
                return v5_2;
            } catch (java.io.IOException) {
                return 0;
            }
        } else {
            return 0;
        }
    }

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 v1_1 = new com.bumptech.glide.disklrucache.StrictLineReader(new java.io.FileInputStream(this.journalFile), com.bumptech.glide.disklrucache.Util.US_ASCII);
        try {
            java.io.OutputStreamWriter v2_7 = v1_1.readLine();
            java.io.FileOutputStream v3_0 = v1_1.readLine();
            java.nio.charset.Charset v4_0 = v1_1.readLine();
            int v5_0 = v1_1.readLine();
            String v6 = v1_1.readLine();
        } catch (java.io.BufferedWriter v0_8) {
            com.bumptech.glide.disklrucache.Util.closeQuietly(v1_1);
            throw v0_8;
        }
        if ((!"libcore.io.DiskLruCache".equals(v2_7)) || ((!"1".equals(v3_0)) || ((!Integer.toString(this.appVersion).equals(v4_0)) || ((!Integer.toString(this.valueCount).equals(v5_0)) || (!"".equals(v6)))))) {
            String v7_7 = new StringBuilder();
            v7_7.append("unexpected journal header: [");
            v7_7.append(v2_7);
            v7_7.append(", ");
            v7_7.append(v3_0);
            v7_7.append(", ");
            v7_7.append(v5_0);
            v7_7.append(", ");
            v7_7.append(v6);
            v7_7.append("]");
            throw new java.io.IOException(v7_7.toString());
        } else {
            java.io.BufferedWriter v0_3 = 0;
            while(true) {
                this.readJournalLine(v1_1.readLine());
                v0_3++;
            }
        }
    }

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


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

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


    public static java.nio.ByteBuffer mmap(android.content.Context p8, android.os.CancellationSignal p9, android.net.Uri p10)
    {
        try {
            Throwable v8_3 = p8.getContentResolver().openFileDescriptor(p10, "r", p9);
        } catch (java.io.IOException) {
            return 0;
        }
        if (v8_3 != null) {
            try {
                Throwable v9_1 = new java.io.FileInputStream(v8_3.getFileDescriptor());
                try {
                    Throwable v1_0 = v9_1.getChannel();
                    Throwable v10_1 = v1_0.map(java.nio.channels.FileChannel$MapMode.READ_ONLY, 0, v1_0.size());
                } catch (Throwable v10_3) {
                    Throwable v1_2 = 0;
                    if (v1_2 == null) {
                        v9_1.close();
                    } else {
                        try {
                            v9_1.close();
                        } catch (Throwable v9_2) {
                            v1_2.addSuppressed(v9_2);
                        }
                    }
                    throw v10_3;
                } catch (Throwable v10_2) {
                    try {
                        throw v10_2;
                    } catch (Throwable v1_1) {
                        v1_2 = v10_2;
                        v10_3 = v1_1;
                    }
                }
                v9_1.close();
                if (v8_3 != null) {
                    v8_3.close();
                }
                return v10_1;
            } catch (Throwable v9_4) {
                Throwable v10_5 = 0;
                if (v8_3 != null) {
                    if (v10_5 == null) {
                        v8_3.close();
                    } else {
                        try {
                            v8_3.close();
                        } catch (Throwable v8_2) {
                            v10_5.addSuppressed(v8_2);
                        }
                    }
                }
                throw v9_4;
            } catch (Throwable v9_3) {
                try {
                    throw v9_3;
                } catch (Throwable v10_4) {
                    v10_5 = v9_3;
                    v9_4 = v10_4;
                }
            }
        } else {
            if (v8_3 != null) {
                v8_3.close();
            }
            return 0;
        }
    }

Method com.urbandroid.common.util.Environment.isCyanogenMod() calling method java.io.FileReader.<init>()

Couldn't retrieve source code

Method com.urbandroid.lux.TwilightService.filterWallpaper() calling method java.io.File.<init>()


    public declared_synchronized void filterWallpaper(android.content.Context p17, boolean p18)
    {
        try {
            int v2_21 = new java.io.File(p17.getCacheDir(), "wallpaper_temp");
            int v3_1 = new java.io.File(p17.getCacheDir(), "wallpaper_temp_lock");
            int v4_1 = new java.io.File(p17.getCacheDir(), "wallpaper_backup");
            java.io.File v5_3 = new java.io.File(p17.getCacheDir(), "wallpaper_backup_lock");
            int v6_4 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered");
            java.io.File v7_3 = new java.io.File(p17.getCacheDir(), "wallpaper_filtered_lock");
            android.app.WallpaperManager v8_2 = android.app.WallpaperManager.getInstance(p17);
            int v9_8 = new StringBuilder();
            v9_8.append("Wallpaper filterWallpaper() should filter ");
            v9_8.append(p18);
            v9_8.append(" set ");
            v9_8.append(com.urbandroid.lux.context.AppContext.settings().isWallpaperSet());
            com.urbandroid.common.logging.Logger.logInfo(v9_8.toString());
        } catch (java.io.FileInputStream v0_31) {
            throw v0_31;
        }
        if ((!p18) || (com.urbandroid.lux.context.AppContext.settings().isWallpaperSet())) {
            if (!p18) {
                try {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper OFF");
                } catch (java.io.FileInputStream v0_5) {
                    com.urbandroid.common.logging.Logger.logSevere(v0_5);
                }
                if (android.os.Build$VERSION.SDK_INT < 24) {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        v8_2.setStream(new java.io.FileInputStream(v4_1));
                    }
                } else {
                    if ((v4_1.exists()) && (v4_1.canRead())) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system");
                        if (v5_3.exists()) {
                            if (v5_3.canRead()) {
                                v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1, 1);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring system after");
                                if ((v5_3.exists()) && (v5_3.canRead())) {
                                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper restoring lock");
                                    v8_2.setStream(new java.io.FileInputStream(v5_3), 0, 1, 2);
                                }
                                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(0);
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
                                return;
                            } else {
                            }
                        }
                        v8_2.setStream(new java.io.FileInputStream(v4_1), 0, 1);
                    }
                }
            }
        } else {
            try {
                java.io.FileInputStream v0_9 = (1065353216 - (((float) com.urbandroid.lux.context.AppContext.settings().getDim()) / 1120403456));
            } catch (java.io.FileInputStream v0_29) {
                com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                throw v0_29;
            } catch (java.io.FileInputStream v0_27) {
                com.urbandroid.common.logging.Logger.logSevere(v0_27);
                java.io.FileInputStream v0_23 = com.urbandroid.lux.context.AppContext.settings();
                v0_23.setWallpaperSet(1);
            } catch (java.io.FileInputStream v0_26) {
                com.urbandroid.common.logging.Logger.logSevere(v0_26);
                v0_23 = com.urbandroid.lux.context.AppContext.settings();
            }
            if (android.os.Build$VERSION.SDK_INT >= 27) {
                v0_9 = Math.min(v0_9, 1050253722);
            }
            android.graphics.Bitmap$CompressFormat v14_6 = v8_2.getDrawable();
            if ((v14_6 instanceof android.graphics.drawable.BitmapDrawable)) {
                android.os.ParcelFileDescriptor v11_1 = ((android.graphics.drawable.BitmapDrawable) v14_6).getBitmap();
                android.graphics.Bitmap$CompressFormat v14_8 = this.getBlueAmount(v11_1);
                if (v14_8 != null) {
                    android.graphics.Bitmap v12_1 = new StringBuilder();
                    v12_1.append("Wallpaper: blue ");
                    v12_1.append(v14_8);
                    com.urbandroid.common.logging.Logger.logInfo(v12_1.toString());
                    android.graphics.Bitmap v12_3 = this.filterBitmap(v11_1, v0_9);
                    android.graphics.Bitmap$CompressFormat v14_10 = new StringBuilder();
                    v14_10.append("Wallpaper: blue after ");
                    v14_10.append(this.getBlueAmount(v12_3));
                    com.urbandroid.common.logging.Logger.logInfo(v14_10.toString());
                    if (android.os.Build$VERSION.SDK_INT < 24) {
                        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: filter using getBitmap");
                        v11_1.compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v4_1));
                        if ((v5_3.exists()) && (v5_3.canWrite())) {
                            v5_3.delete();
                        }
                        v8_2.setBitmap(v12_3);
                    } else {
                        if (((v8_2.getWallpaperId(1) != v8_2.getWallpaperId(2)) && (v8_2.getWallpaperId(2) != -1)) || ((!com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper()) || (android.os.Build$VERSION.SDK_INT >= 27))) {
                            int v9_5 = v8_2.getWallpaperFile(1);
                            android.os.ParcelFileDescriptor v11_2 = v8_2.getWallpaperFile(2);
                            if (v11_2 == null) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: lock is not set using system");
                                v11_2 = v8_2.getWallpaperFile(1);
                            }
                            if ((v9_5 != 0) && (com.urbandroid.lux.context.AppContext.settings().isFilterSystemWallpaper())) {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v9_5.getFileDescriptor()), new java.io.FileOutputStream(v2_21));
                                android.graphics.Bitmap v12_10 = android.graphics.BitmapFactory.decodeFile(v2_21.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v12_10) != 0) {
                                    this.filterBitmap(v12_10, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v6_4));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v2_21), new java.io.FileOutputStream(v4_1));
                                    v8_2.setStream(new java.io.FileInputStream(v6_4), 0, 0, 1);
                                }
                                v9_5.close();
                            }
                            if ((v11_2 == null) || (!com.urbandroid.lux.context.AppContext.settings().isFilterLockWallpaper())) {
                                com.urbandroid.common.logging.Logger.logInfo("Wallpaper: not filtering");
                                if ((v5_3.exists()) && (v5_3.canWrite())) {
                                    v5_3.delete();
                                }
                            } else {
                                com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v11_2.getFileDescriptor()), new java.io.FileOutputStream(v3_1));
                                int v2_13 = android.graphics.BitmapFactory.decodeFile(v3_1.getAbsolutePath(), new android.graphics.BitmapFactory$Options());
                                if (this.getBlueAmount(v2_13) != 0) {
                                    this.filterBitmap(v2_13, v0_9).compress(android.graphics.Bitmap$CompressFormat.PNG, 0, new java.io.FileOutputStream(v7_3));
                                    com.urbandroid.common.util.InputStreamUtil.copy(new java.io.FileInputStream(v3_1), new java.io.FileOutputStream(v5_3));
                                    v8_2.setStream(new java.io.FileInputStream(v7_3), 0, 0, 2);
                                }
                                v11_2.close();
                            }
                        } else {
                        }
                    }
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                } else {
                    com.urbandroid.common.logging.Logger.logInfo("Wallpaper: already filtered, doing nothing");
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    com.urbandroid.lux.context.AppContext.settings().setWallpaperSet(1);
                    return;
                }
            }
            v0_23 = com.urbandroid.lux.context.AppContext.settings();
        }
        com.urbandroid.common.logging.Logger.logInfo("Wallpaper: innerFilterWallpaper() after ");
        return;
    }

Method com.urbandroid.common.error.EmailIntentErrorDispatcher.getSubmitDebugFile() calling method java.io.File.<init>()


    private java.io.File getSubmitDebugFile(com.urbandroid.common.error.ErrorReport$Type p5)
    {
        java.io.File v0_1 = new StringBuilder();
        v0_1.append(this.configuration.getReportFilename());
        v0_1.append("-");
        v0_1.append(p5);
        v0_1.append(".txt");
        String v5_1 = v0_1.toString();
        if (!com.urbandroid.common.util.Environment.isMOrGreater()) {
            return new java.io.File(com.urbandroid.common.util.Environment.getExternalPublicWriteableStorage(), v5_1);
        } else {
            java.io.File v0_5 = new java.io.File(this.contextActivity.getCacheDir(), "reports");
            try {
                if (!v0_5.exists()) {
                    v0_5.mkdir();
                }
            } catch (java.io.File v0_6) {
                com.urbandroid.common.logging.Logger.logWarning("Failed to create reports dir.", v0_6);
            }
            java.io.File v1_8 = this.contextActivity.getCacheDir();
            StringBuilder v2_2 = new StringBuilder();
            v2_2.append("reports/");
            v2_2.append(v5_1);
            return new java.io.File(v1_8, v2_2.toString());
        }
    }

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()
    {
        int v0_2 = this.val$context.getCacheDir();
        if (v0_2 != 0) {
            String v1 = this.val$diskCacheName;
            if (v1 == null) {
                return v0_2;
            } else {
                return new java.io.File(v0_2, v1);
            }
        } else {
            return 0;
        }
    }

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


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

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


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

Method com.urbandroid.common.util.RootUtil.checkRootMethod2() calling method java.io.File.<init>()


    public boolean checkRootMethod2()
    {
        try {
            return new java.io.File("/system/app/Superuser.apk").exists();
        } catch (Exception) {
            return 0;
        }
    }

Method com.urbandroid.common.util.Environment.canCreateFile() calling method java.io.File.<init>()


    private static boolean canCreateFile(java.io.File p3)
    {
        try {
            StringBuilder v1_1 = new java.io.File(p3, "directory-writable-test");
        } catch (Exception) {
            return 0;
        }
        v1_1.createNewFile();
        return v1_1.delete();
    }

Method com.urbandroid.common.logging.Logger.getPersistentBufferFiles() calling method java.io.File.<init>()


    public static java.io.File[] getPersistentBufferFiles(android.content.Context p5, com.urbandroid.common.logging.Logger$LogConfig p6)
    {
        java.util.LinkedList v0_1 = new java.util.LinkedList();
        if (!new java.io.File(com.urbandroid.common.logging.Logger.getCurrentLogFileName(p5, p6)).exists()) {
            java.io.File[] v5_1 = new java.io.File[0];
            return ((java.io.File[]) v0_1.toArray(v5_1));
        } else {
            int v1_0 = p6.maxLogFiles;
            while (v1_0 > 0) {
                java.io.File v3_1 = new java.io.File(com.urbandroid.common.logging.Logger.getOldLogFileName(p5, p6, v1_0));
                if (v3_1.exists()) {
                    v0_1.add(v3_1);
                }
                v1_0--;
            }
            java.io.File[] v5_4 = new java.io.File[0];
            return ((java.io.File[]) v0_1.toArray(v5_4));
        }
    }

Method com.urbandroid.common.logging.Logger$LogFlusher.rotateLogFilesIfRequired() calling method java.io.File.<init>()


    private long rotateLogFilesIfRequired(android.content.Context p8, com.urbandroid.common.logging.Logger$LogConfig p9)
    {
        java.io.File v4_0;
        int v0_8 = new java.io.File(com.urbandroid.common.logging.Logger.access$800(p8, p9));
        if (!v0_8.exists()) {
            v4_0 = 0;
        } else {
            v4_0 = v0_8.length();
        }
        if ((v0_8.exists()) && (v4_0 >= ((long) p9.minLengthToRotate))) {
            int v0_5 = new StringBuilder();
            v0_5.append("Rotating log files: ");
            v0_5.append(p9.logFileName);
            com.urbandroid.common.logging.Logger.logDebug(v0_5.toString());
            int v0_9 = new java.io.File(com.urbandroid.common.logging.Logger.access$1000(p8, p9, p9.maxLogFiles));
            if (v0_9.exists()) {
                v0_9.delete();
            }
            int v0_11 = (p9.maxLogFiles - 1);
            while (v0_11 > 0) {
                java.io.File v1_7 = new java.io.File(com.urbandroid.common.logging.Logger.access$1000(p8, p9, v0_11));
                if (v1_7.exists()) {
                    v1_7.renameTo(new java.io.File(com.urbandroid.common.logging.Logger.access$1000(p8, p9, (v0_11 + 1))));
                }
                v0_11--;
            }
            return 0;
        } else {
            String v8_2 = new StringBuilder();
            v8_2.append("No need to rotate log (");
            v8_2.append(p9.logFileName);
            v8_2.append("), too small: ");
            v8_2.append(v4_0);
            com.urbandroid.common.logging.Logger.logDebug(v8_2.toString());
            return v4_0;
        }
    }

Method com.urbandroid.common.error.LogCatExtractor.backupFileIfAny() calling method java.io.File.<init>()


    private static void backupFileIfAny(String p1, String p2)
    {
        try {
            java.io.File v0_1 = new java.io.File(p1);
        } catch (java.io.File v1_2) {
            com.urbandroid.common.logging.Logger.logWarning("Log ackup failed.", v1_2);
            return;
        }
        if (!v0_1.exists()) {
            return;
        } else {
            v0_1.renameTo(new java.io.File(p2));
            return;
        }
    }

Method com.urbandroid.common.datastore.serialization.RecordSerializerExample.main() calling method java.io.File.<init>()


    public static void main(String[] p7)
    {
        java.util.HashMap v6_1 = new java.util.HashMap();
        java.io.File v7_5 = new java.util.HashMap();
        java.io.BufferedOutputStream v0_7 = Integer.valueOf(1);
        v7_5.put("testVal2", v0_7);
        java.io.FileOutputStream v1_0 = Integer.valueOf(2);
        v7_5.put("testVal22", v1_0);
        v6_1.put("test", v0_7);
        v6_1.put("test2", v1_0);
        v6_1.put("testMap", v7_5);
        v6_1.put("test3", Integer.valueOf(3));
        new com.urbandroid.common.datastore.serialization.RecordDTO(0, "user", Long.valueOf(new java.util.Date().getTime()), "scope", v6_1);
        new java.io.BufferedOutputStream(new java.io.FileOutputStream(new java.io.File("/tmp/ser")));
        return;
    }

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


    public static com.bumptech.glide.disklrucache.DiskLruCache open(java.io.File p9, int p10, int p11, long p12)
    {
        if (p12 <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        } else {
            if (p11 <= 0) {
                throw new IllegalArgumentException("valueCount <= 0");
            } else {
                void v0_2 = new java.io.File(p9, "journal.bkp");
                if (v0_2.exists()) {
                    String v1_3 = new java.io.File(p9, "journal");
                    if (!v1_3.exists()) {
                        com.bumptech.glide.disklrucache.DiskLruCache.renameTo(v0_2, v1_3, 0);
                    } else {
                        v0_2.delete();
                    }
                }
                void v0_3 = new com.bumptech.glide.disklrucache.DiskLruCache;
                v0_3(p9, p10, p11, p12);
                if (v0_3.journalFile.exists()) {
                    try {
                        void v0_5 = v0_3.readJournal().processJournal();
                        return v0_5;
                    } catch (String v1_6) {
                        StringBuilder v3_2 = new StringBuilder();
                        v3_2.append("DiskLruCache ");
                        v3_2.append(p9);
                        v3_2.append(" is corrupt: ");
                        v3_2.append(v1_6.getMessage());
                        v3_2.append(", removing");
                        System.out.println(v3_2.toString());
                        v0_5.delete();
                    }
                }
                p9.mkdirs();
                void v0_6 = new com.bumptech.glide.disklrucache.DiskLruCache;
                v0_6(p9, p10, p11, p12);
                return v0_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;
        java.io.File 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 p7, String p8)
    {
        this.this$0 = p7;
        this.key = p8;
        StringBuilder v0_5 = new long[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p7)];
        this.lengths = v0_5;
        StringBuilder v0_7 = new java.io.File[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p7)];
        this.cleanFiles = v0_7;
        StringBuilder v0_1 = new java.io.File[com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p7)];
        this.dirtyFiles = v0_1;
        StringBuilder v0_3 = new StringBuilder(p8);
        v0_3.append(46);
        int v8_2 = v0_3.length();
        int v1 = 0;
        while (v1 < com.bumptech.glide.disklrucache.DiskLruCache.access$1800(p7)) {
            v0_3.append(v1);
            this.cleanFiles[v1] = new java.io.File(com.bumptech.glide.disklrucache.DiskLruCache.access$1900(p7), v0_3.toString());
            v0_3.append(".tmp");
            this.dirtyFiles[v1] = new java.io.File(com.bumptech.glide.disklrucache.DiskLruCache.access$1900(p7), v0_3.toString());
            v0_3.setLength(v8_2);
            v1++;
        }
        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_0 = 0;
        while (v1_0 < 100) {
            boolean v3_0 = p5.getCacheDir();
            String v4_1 = new StringBuilder();
            v4_1.append(v0_2);
            v4_1.append(v1_0);
            java.io.File v2_3 = new java.io.File(v3_0, v4_1.toString());
            try {
                if (!v2_3.createNewFile()) {
                    v1_0++;
                } else {
                    return v2_3;
                }
            } catch (java.io.IOException) {
            }
        }
        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 p4, String[] p5)
    {
        int v1 = 0;
        while (v1 < p5.length) {
            String v2 = p5[v1];
            if (v2 != null) {
                p4 = new java.io.File(p4, v2);
            }
            v1++;
        }
        return p4;
    }

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


    static FileProvider()
    {
        java.util.HashMap v0_1 = new String[2];
        v0_1[0] = "_display_name";
        v0_1[1] = "_size";
        android.support.v4.content.FileProvider.COLUMNS = v0_1;
        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 p2)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            return android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p2.getApplicationInfo().dataDir, "no_backup"));
        } else {
            return p2.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 v0_1;
            String v2_3 = p2.getApplicationInfo().dataDir;
            if (v2_3 == null) {
                v0_1 = 0;
            } else {
                v0_1 = new java.io.File(v2_3);
            }
            return v0_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 p2)
    {
        if (android.os.Build$VERSION.SDK_INT < 21) {
            return android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p2.getApplicationInfo().dataDir, "code_cache"));
        } else {
            return p2.getCodeCacheDir();
        }
    }

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


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

Method com.urbandroid.common.error.EmailIntentErrorDispatcher.saveDebugReport() calling method android.content.Context.openFileOutput()


    protected void saveDebugReport(com.urbandroid.common.error.ErrorReport p6, String p7, com.urbandroid.common.error.ErrorReport$Type p8)
    {
        long v1 = System.currentTimeMillis();
        try {
            android.content.Context v4_0;
            long v3_5 = this.contextActivity;
            java.io.FileOutputStream v8_4 = this.getTemporaryFileName(p8);
        } catch (String v6_4) {
            long v3_1 = System.currentTimeMillis();
            java.io.FileOutputStream v8_2 = new StringBuilder();
            v8_2.append("Error report save time ");
            v8_2.append((v3_1 - v1));
            v8_2.append(" ms.");
            com.urbandroid.common.logging.Logger.logInfo(v8_2.toString());
            throw v6_4;
        } catch (String v6_1) {
            com.urbandroid.common.logging.Logger.logSevere(v6_1);
            long v3_0 = System.currentTimeMillis();
            String v6_3 = new StringBuilder();
            v6_3.append("Error report save time ");
            v6_3.append((v3_0 - v1));
            v6_3.append(" ms.");
            com.urbandroid.common.logging.Logger.logInfo(v6_3.toString());
            return;
        }
        if (com.urbandroid.common.util.Environment.isNOrGreater()) {
            v4_0 = 32768;
        } else {
            v4_0 = 32769;
        }
        java.io.FileOutputStream v8_3 = v3_5.openFileOutput(v8_4, v4_0);
        this.configuration.getSerializer().serzializeErrorReport(this.contextActivity, p6, v8_3);
        v8_3.write("----------------- END OF REPORT ---------------------------\n\n".getBytes());
        v8_3.close();
        v3_0 = System.currentTimeMillis();
        v6_3 = new StringBuilder();
        v6_3.append("Error report save time ");
        v6_3.append((v3_0 - v1));
        v6_3.append(" ms.");
        com.urbandroid.common.logging.Logger.logInfo(v6_3.toString());
        return;
    }

Method com.urbandroid.common.file.FileCopyUtils.copyRawResourceToPrivateFile() calling method android.content.Context.openFileOutput()


    public static void copyRawResourceToPrivateFile(android.content.Context p1, int p2, String p3, boolean p4)
    {
        String v4_1;
        java.io.InputStream v2_1 = p1.getResources().openRawResource(p2);
        if (p4 == null) {
            v4_1 = 0;
        } else {
            v4_1 = 32768;
        }
        com.urbandroid.common.file.FileCopyUtils.copyFile("RESOURCE", p3, v2_1, p1.openFileOutput(p3, v4_1));
        return;
    }

Method com.urbandroid.common.file.FileCopyUtils.copyPrivateFileToPrivateFile() calling method android.content.Context.openFileOutput()


    public static void copyPrivateFileToPrivateFile(android.content.Context p2, String p3, String p4)
    {
        com.urbandroid.common.file.FileCopyUtils.copyFile(p3, p4, p2.openFileInput(p3), p2.openFileOutput(p4, 0));
        return;
    }

Method com.urbandroid.common.error.ErrorReporter.serializeException() calling method android.content.Context.openFileOutput()


    private void serializeException(Thread p6, Throwable p7)
    {
        String v0_1 = com.urbandroid.common.error.ErrorReporter.loadPastExceptions(this.contextActivity);
        if (v0_1.length() >= 50000) {
            v0_1 = v0_1.substring(25000);
        }
        try {
            java.io.FileOutputStream v1_1 = this.contextActivity.openFileOutput("EXCEPTIONS_ALL", 0);
            StringBuilder v2_2 = new StringBuilder();
            v2_2.append("************ PAST EXCEPTION [");
            v2_2.append(new java.util.Date());
            v2_2.append("] Version: ");
            v2_2.append(new com.urbandroid.common.version.ApplicationVersionExtractor().getCurrentVersion(this.contextActivity));
            v2_2.append(" Thread: ");
            v2_2.append(p6.getName());
            v2_2.append(" **************\n");
            v1_1.write(v2_2.toString().getBytes());
            v1_1.write(com.urbandroid.common.error.DefaultErrorReportSerializer.serializeException(p7).getBytes());
            v1_1.write(v0_1.getBytes());
            v1_1.close();
        } catch (java.io.IOException v6_8) {
            com.urbandroid.common.logging.Logger.logSevere(v6_8);
        }
        return;
    }