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 okio.Okio.sink() calling method java.io.FileOutputStream.<init>()


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

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


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

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.writeObject() calling method java.io.FileOutputStream.<init>()


    public static void writeObject(java.io.File p2, java.io.Serializable p3)
    {
        java.io.ObjectOutputStream v0_1 = new java.io.ObjectOutputStream(new java.io.FileOutputStream(p2));
        try {
            v0_1.writeObject(p3);
            v0_1.close();
            return;
        } catch (Throwable v1_2) {
            v0_1.close();
            throw v1_2;
        }
    }

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)) {
                    android.util.Log.w("AtomicFile", new StringBuilder().append("Couldn\'t rename file ").append(this.mBaseName).append(" to backup file ").append(this.mBackupName).toString());
                }
            }
        }
        try {
            java.io.FileOutputStream v3_1 = new java.io.FileOutputStream(this.mBaseName);
        } catch (java.io.FileNotFoundException v0) {
            if (this.mBaseName.getParentFile().mkdirs()) {
                try {
                    v3_1 = new java.io.FileOutputStream(this.mBaseName);
                } catch (java.io.FileNotFoundException v1) {
                    throw new java.io.IOException(new StringBuilder().append("Couldn\'t create ").append(this.mBaseName).toString());
                }
            } else {
                throw new java.io.IOException(new StringBuilder().append("Couldn\'t create directory ").append(this.mBaseName).toString());
            }
        }
        return v3_1;
    }

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


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

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


    public static boolean copyToFile(java.io.File p10, java.io.InputStream p11)
    {
        int v6_0 = 0;
        java.io.FileOutputStream v3 = 0;
        android.os.StrictMode$ThreadPolicy v2 = android.os.StrictMode.allowThreadDiskWrites();
        try {
            java.io.FileOutputStream v4_1 = new java.io.FileOutputStream(p10, 0);
            try {
                byte[] v0 = new byte[1024];
            } catch (int v6_1) {
                v3 = v4_1;
                android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v3);
                android.os.StrictMode.setThreadPolicy(v2);
                throw v6_1;
            } catch (java.io.IOException v1) {
                v3 = v4_1;
                android.util.Log.e("TypefaceCompatUtil", new StringBuilder().append("Error copying resource contents to temp file: ").append(v1.getMessage()).toString());
                android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v3);
                android.os.StrictMode.setThreadPolicy(v2);
                return v6_0;
            }
            while(true) {
                int v5 = p11.read(v0);
                if (v5 == -1) {
                    break;
                }
                v4_1.write(v0, 0, v5);
            }
            v6_0 = 1;
            android.support.v4.graphics.TypefaceCompatUtil.closeQuietly(v4_1);
            android.os.StrictMode.setThreadPolicy(v2);
            return v6_0;
        } catch (int v6_1) {
        } catch (java.io.IOException v1) {
        }
    }

Method android.support.multidex.MultiDexExtractor.extract() calling method java.io.FileOutputStream.<init>()


    private static void extract(java.util.zip.ZipFile p10, java.util.zip.ZipEntry p11, java.io.File p12, String p13)
    {
        java.io.InputStream v2 = p10.getInputStream(p11);
        java.io.File v6 = java.io.File.createTempFile(p13, ".zip", p12.getParentFile());
        android.util.Log.i("MultiDex", new StringBuilder().append("Extracting ").append(v6.getPath()).toString());
        try {
            java.util.zip.ZipOutputStream v5_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(new java.io.FileOutputStream(v6)));
            try {
                java.util.zip.ZipEntry v1_1 = new java.util.zip.ZipEntry("classes.dex");
                v1_1.setTime(p11.getTime());
                v5_1.putNextEntry(v1_1);
                byte[] v0 = new byte[16384];
                int v3 = v2.read(v0);
            } catch (java.io.IOException v7_13) {
                v5_1.close();
                throw v7_13;
            } catch (java.io.IOException v7_2) {
                android.support.multidex.MultiDexExtractor.closeQuietly(v2);
                v6.delete();
                throw v7_2;
            }
            while (v3 != -1) {
                v5_1.write(v0, 0, v3);
                v3 = v2.read(v0);
            }
            v5_1.closeEntry();
            v5_1.close();
            android.util.Log.i("MultiDex", new StringBuilder().append("Renaming to ").append(p12.getPath()).toString());
            if (v6.renameTo(p12)) {
                android.support.multidex.MultiDexExtractor.closeQuietly(v2);
                v6.delete();
                return;
            } else {
                throw new java.io.IOException(new StringBuilder().append("Failed to rename \"").append(v6.getAbsolutePath()).append("\" to \"").append(p12.getAbsolutePath()).append("\"").toString());
            }
        } catch (java.io.IOException v7_2) {
        }
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.write() calling method java.io.FileWriter.<init>()


    public static void write(java.io.File p2, String p3)
    {
        if ((!android.text.TextUtils.isEmpty(p3)) && (android.text.TextUtils.getTrimmedLength(p3) > 0)) {
            java.io.BufferedWriter v0_1 = new java.io.BufferedWriter(new java.io.FileWriter(p2));
            try {
                v0_1.write(p3);
                v0_1.close();
            } catch (Throwable v1_1) {
                v0_1.close();
                throw v1_1;
            }
        }
        return;
    }

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


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

Method no.nordicsemi.android.dfu.DfuBaseService.onHandleIntent() calling method java.io.FileInputStream.<init>()


    protected void onHandleIntent(android.content.Intent p38)
    {
        String v10 = p38.getStringExtra("no.nordicsemi.android.dfu.extra.EXTRA_DEVICE_ADDRESS");
        String v11 = p38.getStringExtra("no.nordicsemi.android.dfu.extra.EXTRA_DEVICE_NAME");
        boolean v12 = p38.getBooleanExtra("no.nordicsemi.android.dfu.extra.EXTRA_DISABLE_NOTIFICATION", 0);
        boolean v19 = p38.getBooleanExtra("no.nordicsemi.android.dfu.extra.EXTRA_FOREGROUND_SERVICE", 1);
        String v15 = p38.getStringExtra("no.nordicsemi.android.dfu.extra.EXTRA_FILE_PATH");
        android.net.Uri v17_1 = ((android.net.Uri) p38.getParcelableExtra("no.nordicsemi.android.dfu.extra.EXTRA_FILE_URI"));
        int v16 = p38.getIntExtra("no.nordicsemi.android.dfu.extra.EXTRA_FILE_RES_ID", 0);
        String v21 = p38.getStringExtra("no.nordicsemi.android.dfu.extra.EXTRA_INIT_FILE_PATH");
        android.net.Uri v23_1 = ((android.net.Uri) p38.getParcelableExtra("no.nordicsemi.android.dfu.extra.EXTRA_INIT_FILE_URI"));
        int v22 = p38.getIntExtra("no.nordicsemi.android.dfu.extra.EXTRA_INIT_FILE_RES_ID", 0);
        int v7 = p38.getIntExtra("no.nordicsemi.android.dfu.extra.EXTRA_FILE_TYPE", 0);
        if ((v15 != null) && (v7 == 0)) {
            if (!v15.toLowerCase(java.util.Locale.US).endsWith("zip")) {
                v7 = 4;
            } else {
                v7 = 0;
            }
        }
        String v26 = p38.getStringExtra("no.nordicsemi.android.dfu.extra.EXTRA_MIME_TYPE");
        if (v26 == null) {
            if (v7 != 0) {
                v26 = "application/octet-stream";
            } else {
                v26 = "application/zip";
            }
        }
        if (((v7 & -8) <= 0) && (("application/zip".equals(v26)) || ("application/octet-stream".equals(v26)))) {
            if ((!"application/octet-stream".equals(v26)) || ((v7 == 1) || ((v7 == 2) || (v7 == 4)))) {
                if ((v12) || (this.getNotificationTarget() != null)) {
                    if ((!v19) && (android.os.Build$VERSION.SDK_INT >= 26)) {
                        this.logw("Foreground service disabled. Android Oreo or newer may kill a background service few moments after user closes the application.\nConsider enabling foreground service using DfuServiceInitiator#setForeground(boolean)");
                    }
                    no.nordicsemi.android.dfu.UuidHelper.assignCustomUuids(p38);
                    this.mDeviceAddress = v10;
                    this.mDeviceName = v11;
                    this.mDisableNotification = v12;
                    this.mConnectionState = 0;
                    this.mError = 0;
                    try {
                        int v25 = Integer.parseInt(android.preference.PreferenceManager.getDefaultSharedPreferences(this).getString("settings_mbr_size", String.valueOf(4096)));
                    } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13) {
                        v25 = 4096;
                        if (v19) {
                            this = this.startForeground();
                        }
                        this.sendLogBroadcast(1, "DFU service started");
                        java.io.InputStream v8 = this.mFirmwareInputStream;
                        java.io.ByteArrayInputStream v9_0 = this.mInitFileInputStream;
                        try {
                            int v18;
                            if (this.mFirmwareInputStream != null) {
                                v18 = 0;
                                try {
                                    if (v18 == 0) {
                                        java.io.FileInputStream v24_1 = v9_0;
                                        try {
                                            java.io.ByteArrayInputStream v9_2;
                                            if (!"application/zip".equals(v26)) {
                                                v9_2 = v24_1;
                                            } else {
                                                no.nordicsemi.android.dfu.internal.ArchiveInputStream v31 = ((no.nordicsemi.android.dfu.internal.ArchiveInputStream) v8);
                                                if (v7 != 0) {
                                                    v7 = v31.setContentType(v7);
                                                } else {
                                                    v7 = v31.getContentType();
                                                }
                                                if (((v7 & 4) <= 0) || ((v31.applicationImageSize() % 4) == 0)) {
                                                    if (((v7 & 2) <= 0) || ((v31.bootloaderImageSize() % 4) == 0)) {
                                                        if (((v7 & 1) <= 0) || ((v31.softDeviceImageSize() % 4) == 0)) {
                                                            if (v7 != 4) {
                                                                if (v31.getSystemInit() == null) {
                                                                } else {
                                                                    v9_2 = new java.io.ByteArrayInputStream(v31.getSystemInit());
                                                                }
                                                            } else {
                                                                if (v31.getApplicationInit() == null) {
                                                                } else {
                                                                    v9_2 = new java.io.ByteArrayInputStream(v31.getApplicationInit());
                                                                }
                                                            }
                                                        } else {
                                                            throw new no.nordicsemi.android.dfu.internal.exception.SizeValidationException("Soft Device firmware is not word-aligned.");
                                                        }
                                                    } else {
                                                        throw new no.nordicsemi.android.dfu.internal.exception.SizeValidationException("Bootloader firmware is not word-aligned.");
                                                    }
                                                } else {
                                                    throw new no.nordicsemi.android.dfu.internal.exception.SizeValidationException("Application firmware is not word-aligned.");
                                                }
                                            }
                                        } catch (int v5_129) {
                                            if (v19) {
                                                this.stopForeground(v12);
                                            }
                                            throw v5_129;
                                        } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_6) {
                                            this.loge("An exception occurred while opening file", v13_6);
                                            this.sendLogBroadcast(20, "Opening file failed: File not found");
                                            this.report(4097);
                                            if (!v19) {
                                                return;
                                            } else {
                                                this.stopForeground(v12);
                                                return;
                                            }
                                            this.mFirmwareInputStream = v8;
                                            this.mInitFileInputStream = v9_2;
                                            this.sendLogBroadcast(5, "Firmware file opened successfully");
                                            if (v18 == 0) {
                                                this.waitFor(1000);
                                                this.waitFor(1000);
                                            }
                                            this.mProgressInfo = new no.nordicsemi.android.dfu.DfuProgressInfo(this);
                                            if (!this.mAborted) {
                                                this.sendLogBroadcast(1, "Connecting to DFU target...");
                                                this.mProgressInfo.setProgress(-1);
                                                android.bluetooth.BluetoothGatt v6 = this.connect(v10);
                                                if (v6 != null) {
                                                    if (this.mConnectionState != 0) {
                                                        if (this.mError <= 0) {
                                                            if (!this.mAborted) {
                                                                this.sendLogBroadcast(5, "Services discovered");
                                                                p38.putExtra("no.nordicsemi.android.dfu.extra.EXTRA_ATTEMPT", 0);
                                                                try {
                                                                    no.nordicsemi.android.dfu.DfuServiceProvider v29_1 = new no.nordicsemi.android.dfu.DfuServiceProvider();
                                                                    this.mDfuServiceImpl = v29_1;
                                                                    no.nordicsemi.android.dfu.DfuService v4 = v29_1.getServiceImpl(p38, this, v6);
                                                                    this.mDfuServiceImpl = v4;
                                                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13) {
                                                                    this.logw("Upload aborted");
                                                                    this.sendLogBroadcast(15, "Upload aborted");
                                                                    this.terminateConnection(v6, 0);
                                                                    this.mProgressInfo.setProgress(-7);
                                                                    if (v4 == null) {
                                                                        if (!v19) {
                                                                            return;
                                                                        } else {
                                                                            this.stopForeground(v12);
                                                                            return;
                                                                        }
                                                                    } else {
                                                                        v4.release();
                                                                    }
                                                                    if (v4 == null) {
                                                                    } else {
                                                                        v4.release();
                                                                    }
                                                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_1) {
                                                                    this.sendLogBroadcast(20, "Device has disconnected");
                                                                    this.loge(v13_1.getMessage());
                                                                    this.close(v6);
                                                                    this.report(4096);
                                                                    if (v4 == null) {
                                                                    } else {
                                                                        v4.release();
                                                                    }
                                                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_0) {
                                                                    int v14_0 = v13_0.getErrorNumber();
                                                                    if ((32768 & v14_0) <= 0) {
                                                                        int v14_1 = (v14_0 & -16385);
                                                                        void v0_51 = new Object[2];
                                                                        Object[] v34_1 = v0_51;
                                                                        v34_1[0] = Integer.valueOf(v14_1);
                                                                        v34_1[1] = no.nordicsemi.android.error.GattError.parse(v14_1);
                                                                        this.sendLogBroadcast(20, String.format(java.util.Locale.US, "Error (0x%02X): %s", v34_1));
                                                                    } else {
                                                                        int v14_2 = (v14_0 & -32769);
                                                                        void v0_55 = new Object[2];
                                                                        Object[] v34_3 = v0_55;
                                                                        v34_3[0] = Integer.valueOf(v14_2);
                                                                        v34_3[1] = no.nordicsemi.android.error.GattError.parseConnectionError(v14_2);
                                                                        this.sendLogBroadcast(20, String.format(java.util.Locale.US, "Error (0x%02X): %s", v34_3));
                                                                    }
                                                                    this.loge(v13_0.getMessage());
                                                                    this.terminateConnection(v6, v13_0.getErrorNumber());
                                                                    if (v4 == null) {
                                                                    } else {
                                                                        v4.release();
                                                                    }
                                                                } catch (int v5_67) {
                                                                    if (v4 != null) {
                                                                        v4.release();
                                                                    }
                                                                    throw v5_67;
                                                                }
                                                                if (v4 != null) {
                                                                    if (v4.initialize(p38, v6, v7, v8, v9_2)) {
                                                                        v4.performDfu(p38);
                                                                    }
                                                                } else {
                                                                    android.util.Log.w("DfuBaseService", "DFU Service not found.");
                                                                    this.sendLogBroadcast(15, "DFU Service not found");
                                                                    this.terminateConnection(v6, 4102);
                                                                    if (v4 != null) {
                                                                        v4.release();
                                                                    }
                                                                    if (!v19) {
                                                                        return;
                                                                    } else {
                                                                        this.stopForeground(v12);
                                                                        return;
                                                                    }
                                                                }
                                                            } else {
                                                                this.logw("Upload aborted");
                                                                this.sendLogBroadcast(15, "Upload aborted");
                                                                this.terminateConnection(v6, 0);
                                                                this.mProgressInfo.setProgress(-7);
                                                                if (!v19) {
                                                                    return;
                                                                } else {
                                                                    this.stopForeground(v12);
                                                                    return;
                                                                }
                                                            }
                                                        } else {
                                                            if ((this.mError & 32768) <= 0) {
                                                                int v14_3 = (this.mError & -16385);
                                                                this.loge(new StringBuilder().append("An error occurred during discovering services:").append(v14_3).toString());
                                                                void v0_87 = new Object[2];
                                                                Object[] v34_5 = v0_87;
                                                                v34_5[0] = Integer.valueOf(v14_3);
                                                                v34_5[1] = no.nordicsemi.android.error.GattError.parse(v14_3);
                                                                this.sendLogBroadcast(20, String.format(java.util.Locale.US, "Connection failed (0x%02X): %s", v34_5));
                                                            } else {
                                                                int v14_4 = (this.mError & -32769);
                                                                this.loge(new StringBuilder().append("An error occurred while connecting to the device:").append(v14_4).toString());
                                                                void v0_94 = new Object[2];
                                                                Object[] v34_7 = v0_94;
                                                                v34_7[0] = Integer.valueOf(v14_4);
                                                                v34_7[1] = no.nordicsemi.android.error.GattError.parseConnectionError(v14_4);
                                                                this.sendLogBroadcast(20, String.format(java.util.Locale.US, "Connection failed (0x%02X): %s", v34_7));
                                                            }
                                                            if (p38.getIntExtra("no.nordicsemi.android.dfu.extra.EXTRA_ATTEMPT", 0) != 0) {
                                                                this.terminateConnection(v6, this.mError);
                                                                if (!v19) {
                                                                    return;
                                                                } else {
                                                                    this.stopForeground(v12);
                                                                    return;
                                                                }
                                                            } else {
                                                                this.sendLogBroadcast(15, "Retrying...");
                                                                if (this.mConnectionState != 0) {
                                                                    this.disconnect(v6);
                                                                }
                                                                this.refreshDeviceCache(v6, 1);
                                                                this.close(v6);
                                                                this.logi("Restarting the service");
                                                                android.content.Intent v27_1 = new android.content.Intent();
                                                                v27_1.fillIn(p38, 24);
                                                                v27_1.putExtra("no.nordicsemi.android.dfu.extra.EXTRA_ATTEMPT", 1);
                                                                this.startService(v27_1);
                                                                if (!v19) {
                                                                    return;
                                                                } else {
                                                                    this.stopForeground(v12);
                                                                    return;
                                                                }
                                                            }
                                                        }
                                                    } else {
                                                        if (this.mError != 32901) {
                                                            this.loge("Device got disconnected before service discovery finished");
                                                            this.sendLogBroadcast(20, "Disconnected");
                                                        } else {
                                                            this.loge(new StringBuilder().append("Device not reachable. Check if the device with address ").append(v10).append(" is in range, is advertising and is connectable").toString());
                                                            this.sendLogBroadcast(20, "Error 133: Connection timeout");
                                                        }
                                                        this.terminateConnection(v6, 4096);
                                                        if (v19) {
                                                            this.stopForeground(v12);
                                                        }
                                                        return;
                                                    }
                                                } else {
                                                    this.loge("Bluetooth adapter disabled");
                                                    this.sendLogBroadcast(20, "Bluetooth adapter disabled");
                                                    this.report(4106);
                                                    if (!v19) {
                                                        return;
                                                    } else {
                                                        this.stopForeground(v12);
                                                        return;
                                                    }
                                                }
                                            } else {
                                                this.logw("Upload aborted");
                                                this.sendLogBroadcast(15, "Upload aborted");
                                                this.mProgressInfo.setProgress(-7);
                                                if (v19) {
                                                    this.stopForeground(v12);
                                                }
                                                return;
                                            }
                                        } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_5) {
                                            this.loge("Firmware not word-aligned", v13_5);
                                            this.sendLogBroadcast(20, "Opening file failed: Firmware size must be word-aligned");
                                            this.report(4108);
                                            if (!v19) {
                                                return;
                                            } else {
                                                this.stopForeground(v12);
                                                return;
                                            }
                                        } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_4) {
                                            this.loge("An exception occurred while calculating file size", v13_4);
                                            this.sendLogBroadcast(20, new StringBuilder().append("Opening file failed: ").append(v13_4.getLocalizedMessage()).toString());
                                            this.report(4098);
                                            if (!v19) {
                                                return;
                                            } else {
                                                this.stopForeground(v12);
                                                return;
                                            }
                                        } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_3) {
                                            this.loge("An exception occurred while opening files. Did you set the firmware file?", v13_3);
                                            this.sendLogBroadcast(20, new StringBuilder().append("Opening file failed: ").append(v13_3.getLocalizedMessage()).toString());
                                            this.report(4098);
                                            if (!v19) {
                                                return;
                                            } else {
                                                this.stopForeground(v12);
                                                return;
                                            }
                                        }
                                        if (v18 != 0) {
                                            v8.mark(v8.available());
                                            if (v9_2 != null) {
                                                v9_2.mark(v9_2.available());
                                            }
                                        }
                                    } else {
                                        this.sendLogBroadcast(1, "Opening file...");
                                        if (v17_1 == null) {
                                            if (v15 == null) {
                                                if (v16 > 0) {
                                                    v8 = this.openInputStream(v16, v26, v25, v7);
                                                }
                                            } else {
                                                v8 = this.openInputStream(v15, v26, v25, v7);
                                            }
                                        } else {
                                            v8 = this.openInputStream(v17_1, v26, v25, v7);
                                        }
                                        if (v23_1 == null) {
                                            if (v21 == null) {
                                                if (v22 > 0) {
                                                    v9_0 = this.getResources().openRawResource(v22);
                                                }
                                            } else {
                                                java.io.FileInputStream v24_0 = new java.io.FileInputStream;
                                                v24_0(v21);
                                                v9_0 = v24_0;
                                            }
                                        } else {
                                            v9_0 = this.getContentResolver().openInputStream(v23_1);
                                        }
                                        if ((v8.available() % 4) == 0) {
                                        } else {
                                            throw new no.nordicsemi.android.dfu.internal.exception.SizeValidationException("The new firmware is not word-aligned.");
                                        }
                                    }
                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_2) {
                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_6) {
                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_5) {
                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_4) {
                                } catch (no.nordicsemi.android.dfu.internal.exception.DfuException v13_3) {
                                }
                                this.loge("A security exception occurred while opening file", v13_2);
                                this.sendLogBroadcast(20, "Opening file failed: Permission required");
                                this.report(4097);
                                if (!v19) {
                                    return;
                                } else {
                                    this.stopForeground(v12);
                                    return;
                                }
                            } else {
                                v18 = 1;
                            }
                        } catch (int v5_129) {
                        }
                    }
                    if (v25 >= 0) {
                    } else {
                        v25 = 0;
                    }
                } else {
                    throw new NullPointerException("getNotificationTarget() must not return null if notifications are enabled");
                }
            } else {
                this.logw("Unable to determine file type");
                this.sendLogBroadcast(15, "Unable to determine file type");
                this.report(4105);
            }
        } else {
            this.logw("File type or file mime-type not supported");
            this.sendLogBroadcast(15, "File type or file mime-type not supported");
            this.report(4105);
        }
        return;
    }

Method no.nordicsemi.android.dfu.DfuBaseService.openInputStream() calling method java.io.FileInputStream.<init>()


    private java.io.InputStream openInputStream(String p4, String p5, int p6, int p7)
    {
        no.nordicsemi.android.dfu.internal.HexInputStream v0_1 = new java.io.FileInputStream(p4);
        if (!"application/zip".equals(p5)) {
            if (p4.toLowerCase(java.util.Locale.US).endsWith("hex")) {
                v0_1 = new no.nordicsemi.android.dfu.internal.HexInputStream(v0_1, p6);
            }
        } else {
            v0_1 = new no.nordicsemi.android.dfu.internal.ArchiveInputStream(v0_1, p6, p7);
        }
        return v0_1;
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.readObject() calling method java.io.FileInputStream.<init>()


    public static java.io.Serializable readObject(java.io.File p2)
    {
        java.io.ObjectInputStream v0_1 = new java.io.ObjectInputStream(new java.io.FileInputStream(p2));
        try {
            Throwable v1_3 = ((java.io.Serializable) v0_1.readObject());
            v0_1.close();
            return v1_3;
        } catch (Throwable v1_4) {
            v0_1.close();
            throw v1_4;
        }
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.readBytes() calling method java.io.FileInputStream.<init>()


    public static byte[] readBytes(java.io.File p7)
    {
        int v2 = new byte[((int) p7.length())];
        try {
            java.io.FileInputStream v3_1 = new java.io.FileInputStream(p7);
        } catch (java.io.IOException v1) {
            com.microsoft.appcenter.utils.AppCenterLog.error("AppCenter", new StringBuilder().append("Could not read file ").append(p7.getAbsolutePath()).toString(), v1);
            v2 = 0;
            return v2;
        }
        new java.io.DataInputStream(v3_1).readFully(v2);
        v3_1.close();
        return v2;
    }

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.TypefaceCompatApi21Impl.createFromFontInfo() calling method java.io.FileInputStream.<init>()


    public android.graphics.Typeface createFromFontInfo(android.content.Context p12, android.os.CancellationSignal p13, android.support.v4.provider.FontsContractCompat$FontInfo[] p14, int p15)
    {
        Throwable v6_2;
        if (p14.length >= 1) {
            try {
                android.os.ParcelFileDescriptor v4 = p12.getContentResolver().openFileDescriptor(this.findBestInfo(p14, p15).getUri(), "r", p13);
                try {
                    java.io.File v2 = this.getFile(v4);
                } catch (Throwable v6_6) {
                    Throwable v7_4 = 0;
                    if (v4 != null) {
                        if (v7_4 == null) {
                            v4.close();
                        } else {
                            v4.close();
                        }
                    }
                    throw v6_6;
                } catch (Throwable v6_5) {
                    try {
                        throw v6_5;
                    } catch (Throwable v7_3) {
                        v7_4 = v6_5;
                        v6_6 = v7_3;
                    }
                }
                if ((v2 != null) && (v2.canRead())) {
                    v6_2 = android.graphics.Typeface.createFromFile(v2);
                    if (v4 != null) {
                        if (0 == 0) {
                            v4.close();
                        } else {
                            try {
                                v4.close();
                            } catch (Throwable v7_1) {
                                0.addSuppressed(v7_1);
                            }
                        }
                    }
                } else {
                    java.io.FileInputStream v3_1 = new java.io.FileInputStream(v4.getFileDescriptor());
                    Throwable v7_2 = 0;
                    try {
                        v6_2 = super.createFromInputStream(p12, v3_1);
                    } catch (Throwable v7_2) {
                        throw v7_2;
                    } catch (Throwable v6_4) {
                        if (v3_1 != null) {
                            if (v7_2 == null) {
                                v3_1.close();
                            } else {
                                v3_1.close();
                            }
                        }
                        throw v6_4;
                    }
                    if (v3_1 != null) {
                        if (0 == 0) {
                            v3_1.close();
                        } else {
                            try {
                                v3_1.close();
                            } catch (Throwable v9_1) {
                                0.addSuppressed(v9_1);
                            }
                        }
                    }
                    if (v4 != null) {
                        if (0 == 0) {
                            v4.close();
                        } else {
                            try {
                                v4.close();
                            } catch (Throwable v7_5) {
                                0.addSuppressed(v7_5);
                            }
                        }
                    }
                }
            } catch (java.io.IOException v1) {
                v6_2 = 0;
            }
        } else {
            v6_2 = 0;
        }
        return v6_2;
    }

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


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

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


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

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


    public static java.nio.ByteBuffer mmap(android.content.Context p13, android.os.CancellationSignal p14, android.net.Uri p15)
    {
        Throwable v1_1;
        android.os.ParcelFileDescriptor v8 = p13.getContentResolver().openFileDescriptor(p15, "r", p14);
        if (v8 != null) {
            try {
                java.io.FileInputStream v7_0 = new java.io.FileInputStream(v8.getFileDescriptor());
                try {
                    java.nio.channels.FileChannel v0 = v7_0.getChannel();
                    v1_1 = v0.map(java.nio.channels.FileChannel$MapMode.READ_ONLY, 0, v0.size());
                } catch (Throwable v1_4) {
                    Throwable v2_2 = 0;
                    if (v7_0 != null) {
                        if (v2_2 == null) {
                            v7_0.close();
                        } else {
                            v7_0.close();
                        }
                    }
                    throw v1_4;
                } catch (Throwable v1_3) {
                    try {
                        throw v1_3;
                    } catch (Throwable v2_1) {
                        v2_2 = v1_3;
                        v1_4 = v2_1;
                    }
                }
                if (v7_0 != null) {
                    if (0 == 0) {
                        v7_0.close();
                    } else {
                        try {
                            v7_0.close();
                        } catch (Throwable v2_3) {
                            0.addSuppressed(v2_3);
                        }
                    }
                }
                if (v8 == null) {
                    return v1_1;
                } else {
                    if (0 == 0) {
                        v8.close();
                        return v1_1;
                    } else {
                        try {
                            v8.close();
                        } catch (Throwable v2_6) {
                            0.addSuppressed(v2_6);
                        }
                        return v1_1;
                    }
                }
            } catch (Throwable v1_6) {
                Throwable v2_5 = 0;
                if (v8 != null) {
                    if (v2_5 == null) {
                        v8.close();
                    } else {
                        try {
                            v8.close();
                        } catch (Throwable v3_1) {
                            v2_5.addSuppressed(v3_1);
                        }
                    }
                }
                throw v1_6;
            } catch (Throwable v1_5) {
                try {
                    throw v1_5;
                } catch (Throwable v2_4) {
                    v2_5 = v1_5;
                    v1_6 = v2_4;
                }
            }
        } else {
            v1_1 = 0;
            if (v8 == null) {
                return v1_1;
            } else {
                if (0 == 0) {
                    v8.close();
                    return v1_1;
                } else {
                    try {
                        v8.close();
                    } catch (Throwable v2_7) {
                        0.addSuppressed(v2_7);
                    }
                    return v1_1;
                }
            }
        }
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.read() calling method java.io.FileReader.<init>()


    public static String read(java.io.File p8)
    {
        try {
            java.io.BufferedReader v4_1 = new java.io.BufferedReader(new java.io.FileReader(p8));
            try {
                String v3 = System.getProperty("line.separator");
                StringBuilder v0_1 = new StringBuilder();
            } catch (String v5_1) {
                v4_1.close();
                throw v5_1;
            }
            while(true) {
                String v2 = v4_1.readLine();
                if (v2 == null) {
                    break;
                }
                v0_1.append(v2).append(v3);
            }
            v4_1.close();
            String v5_2 = v0_1.toString();
            return v5_2;
        } catch (java.io.IOException v1) {
            com.microsoft.appcenter.utils.AppCenterLog.error("AppCenter", new StringBuilder().append("Could not read file ").append(p8.getAbsolutePath()).toString(), v1);
            v5_2 = 0;
            return v5_2;
        }
    }

Method com.squareup.picasso.Utils.createDefaultCacheDir() calling method java.io.File.<init>()


    static java.io.File createDefaultCacheDir(android.content.Context p3)
    {
        java.io.File v0_1 = new java.io.File(p3.getApplicationContext().getCacheDir(), "picasso-cache");
        if (!v0_1.exists()) {
            v0_1.mkdirs();
        }
        return v0_1;
    }

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


    DiskLruCache(com.squareup.okhttp.internal.io.FileSystem p8, java.io.File p9, int p10, int p11, long p12, java.util.concurrent.Executor p14)
    {
        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 = p8;
        this.directory = p9;
        this.appVersion = p10;
        this.journalFile = new java.io.File(p9, "journal");
        this.journalFileTmp = new java.io.File(p9, "journal.tmp");
        this.journalFileBackup = new java.io.File(p9, "journal.bkp");
        this.valueCount = p11;
        this.maxSize = p12;
        this.executor = p14;
        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;
        java.io.File[] v3_9 = new long[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.lengths = v3_9;
        java.io.File[] v3_11 = new java.io.File[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.cleanFiles = v3_11;
        java.io.File[] v3_1 = new java.io.File[com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)];
        this.dirtyFiles = v3_1;
        StringBuilder v0 = new StringBuilder(p9).append(46);
        int v2 = v0.length();
        int v1 = 0;
        while (v1 < com.squareup.okhttp.internal.DiskLruCache.access$2300(p8)) {
            v0.append(v1);
            this.cleanFiles[v1] = new java.io.File(com.squareup.okhttp.internal.DiskLruCache.access$2800(p8), v0.toString());
            v0.append(".tmp");
            this.dirtyFiles[v1] = new java.io.File(com.squareup.okhttp.internal.DiskLruCache.access$2800(p8), v0.toString());
            v0.setLength(v2);
            v1++;
        }
        return;
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.write() calling method java.io.File.<init>()


    public static void write(String p1, String p2)
    {
        com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.write(new java.io.File(p1), p2);
        return;
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.read() calling method java.io.File.<init>()


    public static String read(String p1)
    {
        return com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.read(new java.io.File(p1));
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.mkdir() calling method java.io.File.<init>()


    public static void mkdir(String p1)
    {
        new java.io.File(p1).mkdirs();
        return;
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.lastModifiedFile() calling method java.io.File.<init>()


    public static java.io.File lastModifiedFile(String p1, java.io.FilenameFilter p2)
    {
        return com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.lastModifiedFile(new java.io.File(p1), p2);
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.getFilenames() calling method java.io.File.<init>()


    public static String[] getFilenames(String p2, java.io.FilenameFilter p3)
    {
        String[] v1_2;
        java.io.File v0_1 = new java.io.File(p2);
        if (!v0_1.exists()) {
            v1_2 = new String[0];
        } else {
            v1_2 = v0_1.list(p3);
        }
        return v1_2;
    }

Method com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.delete() calling method java.io.File.<init>()


    public static boolean delete(String p1)
    {
        return com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.delete(new java.io.File(p1));
    }

Method com.microsoft.appcenter.persistence.DatabasePersistence.getLargePayloadGroupDirectory() calling method java.io.File.<init>()


    java.io.File getLargePayloadGroupDirectory(String p3)
    {
        return new java.io.File(this.mLargePayloadDirectory, p3);
    }

Method com.microsoft.appcenter.persistence.DatabasePersistence.getLargePayloadFile() calling method java.io.File.<init>()


    java.io.File getLargePayloadFile(java.io.File p5, long p6)
    {
        return new java.io.File(p5, new StringBuilder().append(p6).append(".json").toString());
    }

Method com.microsoft.appcenter.persistence.DatabasePersistence.<init>() calling method java.io.File.<init>()


    DatabasePersistence(android.content.Context p7, int p8, android.content.ContentValues p9, int p10)
    {
        this.mContext = p7;
        this.mPendingDbIdentifiersGroups = new java.util.HashMap();
        this.mPendingDbIdentifiers = new java.util.HashSet();
        this.mDatabaseStorage = com.microsoft.appcenter.utils.storage.StorageHelper$DatabaseStorage.getDatabaseStorage("com.microsoft.appcenter.persistence", "logs", p8, p9, p10, new com.microsoft.appcenter.persistence.DatabasePersistence$1(this));
        this.mLargePayloadDirectory = new java.io.File(new StringBuilder().append(com.microsoft.appcenter.Constants.FILES_PATH).append("/appcenter/database_large_payloads").toString());
        this.mLargePayloadDirectory.mkdirs();
        return;
    }

Method com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getPendingMinidumpDirectory() calling method java.io.File.<init>()


    public static declared_synchronized java.io.File getPendingMinidumpDirectory()
    {
        try {
            if (com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sPendingMinidumpDirectory == null) {
                com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sPendingMinidumpDirectory = new java.io.File(new java.io.File(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getErrorStorageDirectory().getAbsolutePath(), "minidump"), "pending");
                com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.mkdir(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sPendingMinidumpDirectory.getPath());
            }
        } catch (java.io.File v2_5) {
            throw v2_5;
        }
        return com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sPendingMinidumpDirectory;
    }

Method com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getNewMinidumpDirectory() calling method java.io.File.<init>()


    public static declared_synchronized java.io.File getNewMinidumpDirectory()
    {
        try {
            if (com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sNewMinidumpDirectory == null) {
                com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sNewMinidumpDirectory = new java.io.File(new java.io.File(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getErrorStorageDirectory().getAbsolutePath(), "minidump"), "new");
                com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.mkdir(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sNewMinidumpDirectory.getPath());
            }
        } catch (java.io.File v2_5) {
            throw v2_5;
        }
        return com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sNewMinidumpDirectory;
    }

Method com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getErrorStorageDirectory() calling method java.io.File.<init>()


    public static declared_synchronized java.io.File getErrorStorageDirectory()
    {
        try {
            if (com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sErrorLogDirectory == null) {
                com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sErrorLogDirectory = new java.io.File(com.microsoft.appcenter.Constants.FILES_PATH, "error");
                com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.mkdir(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sErrorLogDirectory.getAbsolutePath());
            }
        } catch (java.io.File v0_2) {
            throw v0_2;
        }
        return com.microsoft.appcenter.crashes.utils.ErrorLogHelper.sErrorLogDirectory;
    }

Method com.microsoft.appcenter.crashes.WrapperSdkExceptionManager.getFile() calling method java.io.File.<init>()


    private static java.io.File getFile(java.util.UUID p4)
    {
        return new java.io.File(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getErrorStorageDirectory(), new StringBuilder().append(p4.toString()).append(".dat").toString());
    }

Method com.microsoft.appcenter.crashes.Crashes.saveErrorLogFiles() calling method java.io.File.<init>()


    private java.util.UUID saveErrorLogFiles(Throwable p10, com.microsoft.appcenter.crashes.ingestion.models.ManagedErrorLog p11)
    {
        java.io.File v3 = com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getErrorStorageDirectory();
        java.util.UUID v1 = p11.getId();
        String v4 = v1.toString();
        com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", "Saving uncaught exception.");
        java.io.File v0_0 = new java.io.File(v3, new StringBuilder().append(v4).append(".json").toString());
        com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.write(v0_0, this.mLogSerializer.serializeLog(p11));
        com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", new StringBuilder().append("Saved JSON content for ingestion into ").append(v0_0).toString());
        java.io.File v5_1 = new java.io.File(v3, new StringBuilder().append(v4).append(".throwable").toString());
        if (p10 == null) {
            if (v5_1.createNewFile()) {
                com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", new StringBuilder().append("Saved empty Throwable file in ").append(v5_1).toString());
            } else {
                throw new java.io.IOException(v5_1.getName());
            }
        } else {
            com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.writeObject(v5_1, p10);
            com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", new StringBuilder().append("Saved Throwable as is for client side inspection in ").append(v5_1).append(" throwable:").toString(), p10);
        }
        return v1;
    }

Method com.microsoft.appcenter.crashes.Crashes.initialize() calling method java.io.File.<init>()


    private void initialize()
    {
        int v14_7;
        boolean v4 = this.isInstanceEnabled();
        if (!v4) {
            v14_7 = -1;
        } else {
            v14_7 = System.currentTimeMillis();
        }
        this.mInitializeTimestamp = v14_7;
        if (v4) {
            this.mUncaughtExceptionHandler = new com.microsoft.appcenter.crashes.UncaughtExceptionHandler();
            this.mUncaughtExceptionHandler.register();
            String v15_0 = com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getNewMinidumpFiles();
            int v16 = v15_0.length;
            int v14_2 = 0;
            while (v14_2 < v16) {
                java.io.File v7_1 = v15_0[v14_2];
                com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", new StringBuilder().append("Process pending minidump file: ").append(v7_1).toString());
                long v10 = v7_1.lastModified();
                java.io.File v2_1 = new java.io.File(com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getPendingMinidumpDirectory(), v7_1.getName());
                com.microsoft.appcenter.crashes.model.NativeException v12_1 = new com.microsoft.appcenter.crashes.model.NativeException();
                com.microsoft.appcenter.crashes.ingestion.models.Exception v9_1 = new com.microsoft.appcenter.crashes.ingestion.models.Exception();
                v9_1.setType("minidump");
                v9_1.setWrapperSdkName("appcenter.ndk");
                v9_1.setStackTrace(v2_1.getPath());
                com.microsoft.appcenter.crashes.ingestion.models.ManagedErrorLog v5_1 = new com.microsoft.appcenter.crashes.ingestion.models.ManagedErrorLog();
                v5_1.setException(v9_1);
                java.io.IOException v17_23 = new java.util.Date;
                v17_23(v10);
                v5_1.setTimestamp(v17_23);
                v5_1.setFatal(Boolean.valueOf(1));
                v5_1.setId(java.util.UUID.randomUUID());
                com.microsoft.appcenter.SessionContext$SessionInfo v13 = com.microsoft.appcenter.SessionContext.getInstance().getSessionAt(v10);
                if ((v13 == null) || (v13.getAppLaunchTimestamp() > v10)) {
                    v5_1.setAppLaunchTimestamp(v5_1.getTimestamp());
                } else {
                    v5_1.setAppLaunchTimestamp(new java.util.Date(v13.getAppLaunchTimestamp()));
                }
                v5_1.setProcessId(Integer.valueOf(0));
                v5_1.setProcessName("");
                try {
                    v5_1.setDevice(com.microsoft.appcenter.utils.DeviceInfoHelper.getDeviceInfo(this.mContext));
                    v5_1.getDevice().setWrapperSdkName("appcenter.ndk");
                    this.saveErrorLogFiles(v12_1, v5_1);
                } catch (Exception v3_0) {
                    v7_1.delete();
                    this.removeAllStoredErrorLogFiles(v5_1.getId());
                    com.microsoft.appcenter.utils.AppCenterLog.error("AppCenterCrashes", new StringBuilder().append("Failed to process new minidump file: ").append(v7_1).toString(), v3_0);
                    v14_2++;
                }
                if (v7_1.renameTo(v2_1)) {
                } else {
                    throw new java.io.IOException("Failed to move file");
                }
            }
            java.io.File v7_0 = com.microsoft.appcenter.crashes.utils.ErrorLogHelper.getLastErrorLogFile();
            if (v7_0 != null) {
                com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", "Processing crash report for the last session.");
                String v8 = com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.read(v7_0);
                if (v8 != null) {
                    try {
                        this.mLastSessionErrorReport = this.buildErrorReport(((com.microsoft.appcenter.crashes.ingestion.models.ManagedErrorLog) this.mLogSerializer.deserializeLog(v8, 0)));
                        com.microsoft.appcenter.utils.AppCenterLog.debug("AppCenterCrashes", "Processed crash report for the last session.");
                    } catch (Exception v3_1) {
                        com.microsoft.appcenter.utils.AppCenterLog.error("AppCenterCrashes", "Error parsing last session error log.", v3_1);
                    }
                } else {
                    com.microsoft.appcenter.utils.AppCenterLog.error("AppCenterCrashes", "Error reading last session error log.");
                }
            }
        } else {
            if (this.mUncaughtExceptionHandler != null) {
                this.mUncaughtExceptionHandler.unregister();
                this.mUncaughtExceptionHandler = 0;
            }
        }
        return;
    }

Method com.microsoft.appcenter.crashes.Crashes$9.run() calling method java.io.File.<init>()


    public void run()
    {
        if (this.val$userConfirmation != 1) {
            if (this.val$userConfirmation == 2) {
                com.microsoft.appcenter.utils.storage.StorageHelper$PreferencesStorage.putBoolean("com.microsoft.appcenter.crashes.always.send", 1);
            }
            java.util.Iterator v9 = com.microsoft.appcenter.crashes.Crashes.access$600(this.this$0).entrySet().iterator();
            while (v9.hasNext()) {
                java.io.File v2_0 = 0;
                com.microsoft.appcenter.crashes.ingestion.models.ErrorAttachmentLog v1 = 0;
                java.util.Map$Entry v8_1 = ((java.util.Map$Entry) v9.next());
                com.microsoft.appcenter.crashes.Crashes$ErrorLogReport v3_1 = ((com.microsoft.appcenter.crashes.Crashes$ErrorLogReport) v8_1.getValue());
                if ((com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$900(v3_1).getThrowable() instanceof com.microsoft.appcenter.crashes.model.NativeException)) {
                    com.microsoft.appcenter.crashes.ingestion.models.Exception v4 = com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$1200(v3_1).getException();
                    v2_0 = new java.io.File(v4.getStackTrace());
                    v4.setStackTrace(0);
                    v1 = com.microsoft.appcenter.crashes.ingestion.models.ErrorAttachmentLog.attachmentWithBinary(com.microsoft.appcenter.utils.storage.StorageHelper$InternalStorage.readBytes(v2_0), "minidump.dmp", "application/octet-stream");
                }
                com.microsoft.appcenter.crashes.Crashes.access$1300(this.this$0).enqueue(com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$1200(v3_1), "groupErrors");
                if (v1 != null) {
                    com.microsoft.appcenter.crashes.Crashes.access$1400(this.this$0, com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$1200(v3_1).getId(), java.util.Collections.singleton(v1));
                    v2_0.delete();
                }
                if (com.microsoft.appcenter.crashes.Crashes.access$800(this.this$0)) {
                    com.microsoft.appcenter.crashes.Crashes.access$1400(this.this$0, com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$1200(v3_1).getId(), com.microsoft.appcenter.crashes.Crashes.access$400(this.this$0).getErrorAttachments(com.microsoft.appcenter.crashes.Crashes$ErrorLogReport.access$900(v3_1)));
                }
                v9.remove();
                com.microsoft.appcenter.crashes.utils.ErrorLogHelper.removeStoredErrorLogFile(((java.util.UUID) v8_1.getKey()));
            }
        } else {
            java.util.Iterator v6 = com.microsoft.appcenter.crashes.Crashes.access$600(this.this$0).keySet().iterator();
            while (v6.hasNext()) {
                java.util.UUID v5_0 = ((java.util.UUID) v6.next());
                v6.remove();
                com.microsoft.appcenter.crashes.Crashes.access$1100(this.this$0, v5_0);
            }
        }
        return;
    }

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


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

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


    public boolean renameTo(String p3)
    {
        int v1_1;
        java.io.File v0_1 = new java.io.File(this.mFile.getParentFile(), p3);
        if (!this.mFile.renameTo(v0_1)) {
            v1_1 = 0;
        } else {
            this.mFile = v0_1;
            v1_1 = 1;
        }
        return v1_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 v1 = android.webkit.MimeTypeMap.getSingleton().getExtensionFromMimeType(p7);
        if (v1 != null) {
            p8 = new StringBuilder().append(p8).append(".").append(v1).toString();
        }
        java.io.File v2_1 = new java.io.File(this.mFile, p8);
        try {
            v2_1.createNewFile();
            int v3_5 = new android.support.v4.provider.RawDocumentFile(this, v2_1);
        } catch (java.io.IOException v0) {
            android.util.Log.w("DocumentFile", new StringBuilder().append("Failed to createFile: ").append(v0).toString());
            v3_5 = 0;
        }
        return v3_5;
    }

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


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

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


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

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)
    {
        int v4 = p6.length;
        int v3 = 0;
        java.io.File v1 = p5;
        while (v3 < v4) {
            java.io.File v0_1;
            String v2 = p6[v3];
            if (v2 == null) {
                v0_1 = v1;
            } else {
                v0_1 = new java.io.File(v1, v2);
            }
            v3++;
            v1 = v0_1;
        }
        return v1;
    }

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.FileProvider$SimplePathStrategy.getFileForUri() calling method java.io.File.<init>()


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

Method mono.MonoPackageManager.LoadApplication() calling method java.io.File.<init>()


    public static void LoadApplication(android.content.Context p11, android.content.pm.ApplicationInfo p12, String[] p13)
    {
        try {
            if ((p11 instanceof android.app.Application)) {
                mono.MonoPackageManager.Context = p11;
            }
        } catch (int v0_2) {
            throw v0_2;
        }
        if (!mono.MonoPackageManager.initialized) {
            p11.registerReceiver(new mono.android.app.NotifyTimeZoneChanges(), new android.content.IntentFilter("android.intent.action.TIMEZONE_CHANGED"));
            int v0_3 = java.util.Locale.getDefault();
            int v0_6 = new StringBuilder().append(v0_3.getLanguage()).append("-").append(v0_3.getCountry()).toString();
            String[] v1_7 = p11.getFilesDir().getAbsolutePath();
            String[] v5_0 = p11.getCacheDir().getAbsolutePath();
            String[] v6_0 = mono.MonoPackageManager.getNativeLibraryPath(p11);
            ClassLoader v4 = p11.getClassLoader();
            String v2_3 = android.os.Environment.getExternalStorageDirectory();
            String v7_6 = new java.io.File(v2_3, new StringBuilder().append("Android/data/").append(p11.getPackageName()).append("/files/.__override__").toString()).getAbsolutePath();
            int v8_10 = new java.io.File(v2_3, new StringBuilder().append("../legacy/Android/data/").append(p11.getPackageName()).append("/files/.__override__").toString()).getAbsolutePath();
            System.loadLibrary("monodroid");
            String v2_5 = mono.MonoPackageManager.getNativeLibraryPath(p12);
            String[] v3_5 = new String[3];
            v3_5[0] = v1_7;
            v3_5[1] = v5_0;
            v3_5[2] = v6_0;
            String[] v5_1 = new String[2];
            v5_1[0] = v7_6;
            v5_1[1] = v8_10;
            mono.android.Runtime.init(v0_6, p13, v2_5, v3_5, v4, v5_1, mono.MonoPackageManager_Resources.Assemblies, p11.getPackageName(), android.os.Build$VERSION.SDK_INT, mono.android.app.XamarinAndroidEnvironmentVariables.Variables);
            mono.android.app.ApplicationRegistration.registerApplications();
            mono.MonoPackageManager.initialized = 1;
        }
        return;
    }

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


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

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


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

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


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

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


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

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


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

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)
    {
        int v4 = p6.length;
        int v3 = 0;
        java.io.File v1 = p5;
        while (v3 < v4) {
            java.io.File v0_2;
            String v2 = p6[v3];
            if (v1 != null) {
                if (v2 == null) {
                    v0_2 = v1;
                } else {
                    v0_2 = new java.io.File(v1, v2);
                }
            } else {
                v0_2 = new java.io.File(v2);
            }
            v3++;
            v1 = v0_2;
        }
        return v1;
    }

Method android.support.multidex.MultiDexExtractor.performExtractions() calling method java.io.File.<init>()


    private static java.util.List performExtractions(java.io.File p14, java.io.File p15)
    {
        String v4 = new StringBuilder().append(p14.getName()).append(".classes").toString();
        android.support.multidex.MultiDexExtractor.prepareDexDir(p15, v4);
        java.util.ArrayList v6_1 = new java.util.ArrayList();
        java.util.zip.ZipFile v0_1 = new java.util.zip.ZipFile(p14);
        int v9 = 2;
        try {
            java.util.zip.ZipEntry v1 = v0_1.getEntry(new StringBuilder().append("classes").append(2).append(".dex").toString());
        } catch (String v10_13) {
            try {
                v0_1.close();
            } catch (java.io.IOException v2_0) {
                android.util.Log.w("MultiDex", "Failed to close resource", v2_0);
            }
            throw v10_13;
        }
        while (v1 != null) {
            java.io.File v3_1 = new java.io.File(p15, new StringBuilder().append(v4).append(v9).append(".zip").toString());
            v6_1.add(v3_1);
            android.util.Log.i("MultiDex", new StringBuilder().append("Extraction is needed for file ").append(v3_1).toString());
            int v8 = 0;
            boolean v7 = 0;
            while ((v8 < 3) && (!v7)) {
                String v10_5;
                v8++;
                android.support.multidex.MultiDexExtractor.extract(v0_1, v1, v3_1, v4);
                v7 = android.support.multidex.MultiDexExtractor.verifyZipFile(v3_1);
                StringBuilder vtmp22 = new StringBuilder().append("Extraction ");
                if (!v7) {
                    v10_5 = "failed";
                } else {
                    v10_5 = "success";
                }
                android.util.Log.i("MultiDex", vtmp22.append(v10_5).append(" - length ").append(v3_1.getAbsolutePath()).append(": ").append(v3_1.length()).toString());
                if (!v7) {
                    v3_1.delete();
                    if (v3_1.exists()) {
                        android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete corrupted secondary dex \'").append(v3_1.getPath()).append("\'").toString());
                    }
                }
            }
            if (v7) {
                v9++;
                v1 = v0_1.getEntry(new StringBuilder().append("classes").append(v9).append(".dex").toString());
            } else {
                throw new java.io.IOException(new StringBuilder().append("Could not create zip file ").append(v3_1.getAbsolutePath()).append(" for secondary dex (").append(v9).append(")").toString());
            }
        }
        try {
            v0_1.close();
        } catch (java.io.IOException v2_1) {
            android.util.Log.w("MultiDex", "Failed to close resource", v2_1);
        }
        return v6_1;
    }

Method android.support.multidex.MultiDexExtractor.loadExistingExtractions() calling method java.io.File.<init>()


    private static java.util.List loadExistingExtractions(android.content.Context p9, java.io.File p10, java.io.File p11)
    {
        android.util.Log.i("MultiDex", "loading existing secondary dex files");
        String v1 = new StringBuilder().append(p10.getName()).append(".classes").toString();
        int v5 = android.support.multidex.MultiDexExtractor.getMultiDexPreferences(p9).getInt("dex.number", 1);
        java.util.ArrayList v3_1 = new java.util.ArrayList(v5);
        int v4 = 2;
        while (v4 <= v5) {
            java.io.File v0_1 = new java.io.File(p11, new StringBuilder().append(v1).append(v4).append(".zip").toString());
            if (!v0_1.isFile()) {
                throw new java.io.IOException(new StringBuilder().append("Missing extracted secondary dex file \'").append(v0_1.getPath()).append("\'").toString());
            } else {
                v3_1.add(v0_1);
                if (android.support.multidex.MultiDexExtractor.verifyZipFile(v0_1)) {
                    v4++;
                } else {
                    android.util.Log.i("MultiDex", new StringBuilder().append("Invalid zip file: ").append(v0_1).toString());
                    throw new java.io.IOException("Invalid ZIP file.");
                }
            }
        }
        return v3_1;
    }

Method android.support.multidex.MultiDexExtractor.load() calling method java.io.File.<init>()


    static java.util.List load(android.content.Context p9, android.content.pm.ApplicationInfo p10, java.io.File p11, boolean p12)
    {
        java.util.List v0;
        android.util.Log.i("MultiDex", new StringBuilder().append("MultiDexExtractor.load(").append(p10.sourceDir).append(", ").append(p12).append(")").toString());
        java.io.File v8_1 = new java.io.File(p10.sourceDir);
        long v4 = android.support.multidex.MultiDexExtractor.getZipCrc(v8_1);
        if ((p12) || (android.support.multidex.MultiDexExtractor.isModified(p9, v8_1, v4))) {
            android.util.Log.i("MultiDex", "Detected that extraction must be performed.");
            v0 = android.support.multidex.MultiDexExtractor.performExtractions(v8_1, p11);
            android.support.multidex.MultiDexExtractor.putStoredApkInfo(p9, android.support.multidex.MultiDexExtractor.getTimeStamp(v8_1), v4, (v0.size() + 1));
        } else {
            try {
                v0 = android.support.multidex.MultiDexExtractor.loadExistingExtractions(p9, v8_1, p11);
            } catch (java.io.IOException v7) {
                android.util.Log.w("MultiDex", "Failed to reload existing extracted secondary dex files, falling back to fresh extraction", v7);
                v0 = android.support.multidex.MultiDexExtractor.performExtractions(v8_1, p11);
                android.support.multidex.MultiDexExtractor.putStoredApkInfo(p9, android.support.multidex.MultiDexExtractor.getTimeStamp(v8_1), v4, (v0.size() + 1));
            }
        }
        android.util.Log.i("MultiDex", new StringBuilder().append("load found ").append(v0.size()).append(" secondary dex files").toString());
        return v0;
    }

Method android.support.multidex.MultiDex.install() calling method java.io.File.<init>()


    public static void install(android.content.Context p11)
    {
        android.util.Log.i("MultiDex", "install");
        if (!android.support.multidex.MultiDex.IS_VM_MULTIDEX_CAPABLE) {
            if (android.os.Build$VERSION.SDK_INT >= 4) {
                try {
                    android.content.pm.ApplicationInfo v1 = android.support.multidex.MultiDex.getApplicationInfo(p11);
                } catch (RuntimeException v3_0) {
                    android.util.Log.e("MultiDex", "Multidex installation failure", v3_0);
                    throw new RuntimeException(new StringBuilder().append("Multi dex installation failed (").append(v3_0.getMessage()).append(").").toString());
                }
                if (v1 != null) {
                    String v0 = v1.sourceDir;
                    if (!android.support.multidex.MultiDex.installedApk.contains(v0)) {
                        android.support.multidex.MultiDex.installedApk.add(v0);
                        if (android.os.Build$VERSION.SDK_INT > 20) {
                            android.util.Log.w("MultiDex", new StringBuilder().append("MultiDex is not guaranteed to work in SDK version ").append(android.os.Build$VERSION.SDK_INT).append(": SDK version higher than ").append(20).append(" should be backed by ").append("runtime with built-in multidex capabilty but it\'s not the ").append("case here: java.vm.version=\"").append(System.getProperty("java.vm.version")).append("\"").toString());
                        }
                        try {
                            ClassLoader v5 = p11.getClassLoader();
                        } catch (RuntimeException v3_1) {
                            android.util.Log.w("MultiDex", "Failure while trying to obtain Context class loader. Must be running in test mode. Skip patching.", v3_1);
                        }
                        if (v5 != null) {
                            try {
                                android.support.multidex.MultiDex.clearOldDexDir(p11);
                            } catch (Throwable v6) {
                                android.util.Log.w("MultiDex", "Something went wrong when trying to clear old MultiDex extraction, continuing without cleaning.", v6);
                            }
                            java.io.File v2_1 = new java.io.File(v1.dataDir, android.support.multidex.MultiDex.SECONDARY_FOLDER_NAME);
                            java.util.List v4_0 = android.support.multidex.MultiDexExtractor.load(p11, v1, v2_1, 0);
                            if (!android.support.multidex.MultiDex.checkValidZipFiles(v4_0)) {
                                android.util.Log.w("MultiDex", "Files were not valid zip files.  Forcing a reload.");
                                java.util.List v4_1 = android.support.multidex.MultiDexExtractor.load(p11, v1, v2_1, 1);
                                if (!android.support.multidex.MultiDex.checkValidZipFiles(v4_1)) {
                                    throw new RuntimeException("Zip files were not valid.");
                                } else {
                                    android.support.multidex.MultiDex.installSecondaryDexes(v5, v2_1, v4_1);
                                }
                            } else {
                                android.support.multidex.MultiDex.installSecondaryDexes(v5, v2_1, v4_0);
                            }
                            android.util.Log.i("MultiDex", "install done");
                        } else {
                            android.util.Log.e("MultiDex", "Context class loader is null. Must be running in test mode. Skip patching.");
                        }
                    } else {
                    }
                }
            } else {
                throw new RuntimeException(new StringBuilder().append("Multi dex installation failed. SDK ").append(android.os.Build$VERSION.SDK_INT).append(" is unsupported. Min SDK version is ").append(4).append(".").toString());
            }
        } else {
            android.util.Log.i("MultiDex", "VM has multidex support, MultiDex support library is disabled.");
        }
        return;
    }

Method android.support.multidex.MultiDex.clearOldDexDir() calling method java.io.File.<init>()


    private static void clearOldDexDir(android.content.Context p10)
    {
        java.io.File v1_1 = new java.io.File(p10.getFilesDir(), "secondary-dexes");
        if (v1_1.isDirectory()) {
            android.util.Log.i("MultiDex", new StringBuilder().append("Clearing old secondary dex dir (").append(v1_1.getPath()).append(").").toString());
            java.io.File[] v2 = v1_1.listFiles();
            if (v2 != null) {
                java.io.File[] v0 = v2;
                int v4 = v0.length;
                int v3 = 0;
                while (v3 < v4) {
                    java.io.File v5 = v0[v3];
                    android.util.Log.i("MultiDex", new StringBuilder().append("Trying to delete old file ").append(v5.getPath()).append(" of size ").append(v5.length()).toString());
                    if (v5.delete()) {
                        android.util.Log.i("MultiDex", new StringBuilder().append("Deleted old file ").append(v5.getPath()).toString());
                    } else {
                        android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete old file ").append(v5.getPath()).toString());
                    }
                    v3++;
                }
                if (v1_1.delete()) {
                    android.util.Log.i("MultiDex", new StringBuilder().append("Deleted old secondary dex dir ").append(v1_1.getPath()).toString());
                } else {
                    android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete secondary dex dir ").append(v1_1.getPath()).toString());
                }
            } else {
                android.util.Log.w("MultiDex", new StringBuilder().append("Failed to list secondary dex dir content (").append(v1_1.getPath()).append(").").toString());
            }
        }
        return;
    }

Method android.support.multidex.ZipUtil.getZipCrc() calling method java.io.RandomAccessFile.<init>()


    static long getZipCrc(java.io.File p4)
    {
        java.io.RandomAccessFile v1_1 = new java.io.RandomAccessFile(p4, "r");
        try {
            Throwable v2_1 = android.support.multidex.ZipUtil.computeCrcOfCentralDir(v1_1, android.support.multidex.ZipUtil.findCentralDirectory(v1_1));
            v1_1.close();
            return v2_1;
        } catch (Throwable v2_2) {
            v1_1.close();
            throw v2_2;
        }
    }

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


    public varargs Void doInBackground(Object[] p19)
    {
        java.util.List v4_1 = ((java.util.List) p19[0]);
        String v5_1 = ((String) p19[1]);
        try {
            java.io.FileOutputStream v3 = this.this$0.mContext.openFileOutput(v5_1, 0);
            org.xmlpull.v1.XmlSerializer v12 = android.util.Xml.newSerializer();
            try {
                v12.setOutput(v3, 0);
                v12.startDocument("UTF-8", Boolean.valueOf(1));
                v12.startTag(0, "historical-records");
                int v11 = v4_1.size();
                int v6 = 0;
            } catch (IllegalArgumentException v7) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v7);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                    java.io.IOException v13_3 = 0;
                    return v13_3;
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (IllegalStateException v9) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v9);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (java.io.IOException v8) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v8);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (java.io.IOException v13_2) {
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 != null) {
                    try {
                        v3.close();
                    } catch (int v14) {
                    }
                }
                throw v13_2;
            }
            while (v6 < v11) {
                android.support.v7.widget.ActivityChooserModel$HistoricalRecord v10_1 = ((android.support.v7.widget.ActivityChooserModel$HistoricalRecord) v4_1.remove(0));
                v12.startTag(0, "historical-record");
                v12.attribute(0, "activity", v10_1.activity.flattenToString());
                v12.attribute(0, "time", String.valueOf(v10_1.time));
                v12.attribute(0, "weight", String.valueOf(v10_1.weight));
                v12.endTag(0, "historical-record");
                v6++;
            }
            v12.endTag(0, "historical-records");
            v12.endDocument();
            this.this$0.mCanReadHistoricalData = 1;
            if (v3 == null) {
            } else {
                try {
                    v3.close();
                } catch (java.io.IOException v13) {
                }
            }
        } catch (java.io.FileNotFoundException v2) {
            android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(v5_1).toString(), v2);
            v13_3 = 0;
            return v13_3;
        }
    }