QQ浏览器 v12.2.3.7053版本的 MD5 值为：8285ab3059e5c8b521a264dfbc5c3685

以下内容为反编译后的 ThirdFileOpenManager.java 源代码，内容仅作参考

package com.tencent.mtt.browser.file.open.third;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import android.system.ErrnoException;
import android.text.TextUtils;
import android.util.Log;
import com.tencent.common.utils.FdToFilePath;
import com.tencent.common.utils.LogUtils;
import com.tencent.mtt.browser.utils.FileLog;
import com.tencent.mtt.compliance.MethodDelegate;
import com.tencent.mtt.external.reader.thirdcall.FileThirdUtils;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Iterator;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Ref;
import kotlin.text.StringsKt;

public final class ThirdFileOpenManager {

    public static final ThirdFileOpenManager f38644a = new ThirdFileOpenManager();

    private ThirdFileOpenManager() {
    }

    private final Uri a(Uri uri, int i) {
        if (i <= 0 || uri == null) {
            return null;
        }
        String uri2 = uri.toString();
        Intrinsics.checkExpressionValueIsNotNull(uri2, "orgUri.toString()");
        if (TextUtils.isEmpty(uri2)) {
            return null;
        }
        return Uri.parse(StringsKt.replace$default(uri2, "content://", "content://" + i + '@', false, 4, (Object) null));
    }

    private final String a(Context context, StringBuilder sb, ArrayList<Integer> arrayList, Uri uri, String str, String str2) {
        String str3 = (String) null;
        if (arrayList != null && arrayList.size() > 0) {
            Iterator<Integer> it = arrayList.iterator();
            while (it.hasNext()) {
                Integer uid = it.next();
                Intrinsics.checkExpressionValueIsNotNull(uid, "uid");
                Uri a2 = a(uri, uid.intValue());
                if (a2 != null) {
                    str3 = a(a2, str, str2, context, sb);
                }
                if (!TextUtils.isEmpty(str3)) {
                    break;
                }
            }
        }
        return str3;
    }

    private final String a(Uri uri, String str, Context context, StringBuilder sb) {
        Cursor cursor;
        Cursor cursor2;
        Cursor cursor3 = null;
        if (uri == null || context == null || TextUtils.isEmpty(uri.toString())) {
            String[] strArr = new String[2];
            strArr[0] = "ThirdUriTransfer";
            StringBuilder sb2 = new StringBuilder();
            sb2.append("cannot transfer, context null:");
            sb2.append(context == null);
            sb2.append(", uri:");
            sb2.append(uri);
            strArr[1] = sb2.toString();
            FileLog.a(strArr);
            return null;
        }
        Cursor cursor4 = (Cursor) null;
        try {
            try {
                sb.append("Uri:into");
                cursor = MethodDelegate.query(context.getContentResolver(), uri, new String[]{"_data"}, null, null, null);
                if (cursor != null) {
                    try {
                        cursor.moveToFirst();
                        int columnIndex = cursor.getColumnIndex("_data");
                        sb.append(columnIndex);
                        if (columnIndex > -1) {
                            String string = cursor.getString(columnIndex);
                            if (FileThirdUtils.a(string)) {
                                sb.append("cursor:1");
                                cursor.close();
                                a(cursor);
                                return string;
                            }
                            FileLog.a("ThirdUriTransfer", "read cursor from 1: file cannot read:" + string);
                        }
                        cursor.close();
                    } catch (Exception e) {
                        e = e;
                        FileLog.a("ThirdUriTransfer", "read cursor error from 1:" + Log.getStackTraceString(e));
                        e.printStackTrace(System.err);
                        a(cursor);
                        try {
                            cursor2 = MethodDelegate.query(context.getContentResolver(), uri, null, null, null, null);
                            if (cursor2 != null) {
                            }
                            a(cursor2);
                            sb.append("ifsp:exits");
                            return a(context, uri, sb, str);
                        } catch (Throwable th) {
                            th = th;
                            a(cursor);
                            throw th;
                        }
                    }
                }
            } catch (Throwable th2) {
                th = th2;
                a(cursor3);
                throw th;
            }
        } catch (Exception e2) {
            e = e2;
            cursor = cursor4;
        } catch (Throwable th3) {
            th = th3;
            cursor3 = cursor4;
            a(cursor3);
            throw th;
        }
        a(cursor);
        try {
            cursor2 = MethodDelegate.query(context.getContentResolver(), uri, null, null, null, null);
            if (cursor2 != null) {
                try {
                    cursor2.moveToFirst();
                    String columnName = cursor2.getColumnName(0);
                    if (!TextUtils.isEmpty(columnName)) {
                        String string2 = cursor2.getString(cursor2.getColumnIndex(columnName));
                        if (FileThirdUtils.a(string2)) {
                            sb.append("cursor:2");
                            cursor2.close();
                            a(cursor2);
                            return string2;
                        }
                        FileLog.a("ThirdUriTransfer", "read cursor from 2: file cannot read:" + string2);
                    }
                    cursor2.close();
                } catch (Exception e3) {
                    e = e3;
                    e.printStackTrace(System.err);
                    FileLog.a("ThirdUriTransfer", "read cursor from 2: file cannot read:" + Log.getStackTraceString(e));
                    a(cursor2);
                    sb.append("ifsp:exits");
                    return a(context, uri, sb, str);
                }
            }
        } catch (Exception e4) {
            e = e4;
            cursor2 = cursor4;
        } catch (Throwable th4) {
            th = th4;
            cursor = cursor4;
            a(cursor);
            throw th;
        }
        a(cursor2);
        sb.append("ifsp:exits");
        return a(context, uri, sb, str);
    }

    private final String a(Uri uri, String str, String str2, Context context, StringBuilder sb) {
        try {
            sb.append("transfer:into");
            String b2 = b(uri, str, str2, context, sb);
            if (b2 == null) {
                b2 = "";
            }
            ContentResolver contentResolver = context.getContentResolver();
            if (uri == null) {
                Intrinsics.throwNpe();
            }
            InputStream openInputStream = contentResolver.openInputStream(uri);
            if (openInputStream == null) {
                Intrinsics.throwNpe();
            }
            long available = openInputStream.available();
            sb.append(",transfer:fileSize=" + available);
            if (new File(b2).length() == available) {
                openInputStream.close();
                return b2;
            }
            sb.append(",transfer:dat=" + uri);
            if (a(openInputStream, b2, sb)) {
                return b2;
            }
            return null;
        } catch (IOException e) {
            e.printStackTrace(System.err);
            sb.append(",transfer:IoExce=" + e.getMessage());
            FileLog.a("ThirdUriTransfer", "transfer write IOException:" + Log.getStackTraceString(e));
            return null;
        } catch (Exception e2) {
            e2.printStackTrace(System.err);
            sb.append(",transfer:IExce=" + e2.getMessage());
            FileLog.a("ThirdUriTransfer", "transfer write Exception:" + Log.getStackTraceString(e2));
            return null;
        }
    }

    private final void a(Intent intent, String str) {
        LogUtils.a("setIntentNewData", "path:" + str);
        Uri fromFile = Uri.fromFile(new File(str));
        LogUtils.a("setIntentNewData", "newDataUri:" + fromFile);
        String type = intent.getType();
        if (type != null) {
            Intrinsics.checkExpressionValueIsNotNull(intent.setDataAndType(fromFile, type), "intent.setDataAndType(newDataUri, dataType)");
        } else {
            intent.setData(fromFile);
        }
    }

    private final void a(Cursor cursor) {
        if (cursor != null) {
            try {
                if (cursor.isClosed()) {
                    return;
                }
                cursor.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private final boolean a(Context context, Intent intent) {
        StringBuilder sb = new StringBuilder();
        String stringExtra = intent.getStringExtra("toPath");
        if (stringExtra == null) {
            stringExtra = "";
        }
        new File(stringExtra).mkdirs();
        String d2 = d(intent, context, sb);
        if (d2 == null) {
            d2 = "";
        }
        LogUtils.a("transferContentUri", "tmpFilePath:" + d2);
        LogUtils.a("transferContentUri", "tmpFilePath record:" + ((Object) sb));
        intent.putExtra("intent_exception", sb.toString());
        if (TextUtils.isEmpty(d2)) {
            return a(intent, context, sb);
        }
        a(intent, d2);
        return true;
    }

    private final String b(Uri uri, String str, String str2, Context context, StringBuilder sb) {
        String str3 = "";
        String[] strArr = {"_display_name"};
        Cursor cursor = (Cursor) null;
        try {
            try {
                ContentResolver contentResolver = context.getContentResolver();
                if (uri == null) {
                    Intrinsics.throwNpe();
                }
                cursor = MethodDelegate.query(contentResolver, uri, strArr, null, null, null);
                if (cursor != null && cursor.getCount() != 0) {
                    int columnIndexOrThrow = cursor.getColumnIndexOrThrow("_display_name");
                    sb.append("transfer:idx=" + columnIndexOrThrow);
                    cursor.moveToFirst();
                    String string = cursor.getString(columnIndexOrThrow);
                    Intrinsics.checkExpressionValueIsNotNull(string, "cursor.getString(columnIndex)");
                    str3 = string;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
    }

    private final boolean b(Intent intent, Context context, StringBuilder sb) {
        if (FileThirdUtils.a(intent.getDataString())) {
            return true;
        }
        FileLog.a("ThirdUriTransfer", "file cannot read, do transfer");
        String a2 = a(intent.getData(), intent.getType(), context, sb);
        if (a2 == null) {
            a2 = "";
        }
        LogUtils.a("transferUri", "after convertUriToPath record:" + ((Object) sb));
        if (TextUtils.isEmpty(a2)) {
            return false;
        }
        a(intent, a2);
        return true;
    }

    private final boolean c(Intent intent, Context context, StringBuilder sb) {
        String stringExtra = intent.getStringExtra("toPath");
        if (stringExtra == null) {
            stringExtra = "";
        }
        ArrayList<Integer> b2 = FileThirdUtils.b(stringExtra);
        Uri data = intent.getData();
        String type = intent.getType();
        String stringExtra2 = intent.getStringExtra("toPath");
        String a2 = a(context, sb, b2, data, type, stringExtra2 != null ? stringExtra2 : "");
        if (a2 == null) {
            a2 = "";
        }
        if (TextUtils.isEmpty(a2)) {
            return false;
        }
        a(intent, a2);
        return true;
    }

    private final String d(Intent intent, Context context, StringBuilder sb) {
        Uri data = intent.getData();
        String type = intent.getType();
        String stringExtra = intent.getStringExtra("toPath");
        if (stringExtra == null) {
            stringExtra = "";
        }
        return a(data, type, stringExtra, context, sb);
    }

    public final String a(Context context, Uri uri, StringBuilder record, String str) {
        Intrinsics.checkParameterIsNotNull(context, "context");
        Intrinsics.checkParameterIsNotNull(uri, "uri");
        Intrinsics.checkParameterIsNotNull(record, "record");
        ParcelFileDescriptor parcelFileDescriptor = (ParcelFileDescriptor) null;
        FileDescriptor fileDescriptor = (FileDescriptor) null;
        try {
            parcelFileDescriptor = context.getContentResolver().openFileDescriptor(uri, "r");
            record.append("pfd:");
            record.append(parcelFileDescriptor != null);
            if (parcelFileDescriptor != null) {
                fileDescriptor = parcelFileDescriptor.getFileDescriptor();
            }
        } catch (Throwable th) {
            record.append("pfd:exception=");
            record.append(th.getMessage());
            FileLog.a("ThirdUriTransfer", "pfd:exception:" + Log.getStackTraceString(th));
        }
        return a(fileDescriptor, parcelFileDescriptor, record, str);
    }

    public final String a(FileDescriptor fileDescriptor, ParcelFileDescriptor parcelFileDescriptor, StringBuilder record, String str) {
        String a2;
        Intrinsics.checkParameterIsNotNull(record, "record");
        if (fileDescriptor == null) {
            if (parcelFileDescriptor != null) {
                try {
                    parcelFileDescriptor.close();
                } catch (Exception unused) {
                }
            }
            record.append("fd:null");
            FileLog.a("ThirdUriTransfer", "fd is null");
            return null;
        }
        try {
            try {
                try {
                    try {
                        Field declaredField = fileDescriptor.getClass().getDeclaredField("descriptor");
                        Intrinsics.checkExpressionValueIsNotNull(declaredField, "classType.getDeclaredField(\"descriptor\")");
                        declaredField.setAccessible(true);
                        Object obj = declaredField.get(fileDescriptor);
                        String str2 = "";
                        if ((obj instanceof Integer) && (a2 = FdToFilePath.a(((Number) obj).intValue())) != null) {
                            str2 = a2;
                        }
                        boolean a3 = FileThirdUtils.a(str2);
                        record.append("FdToFile:isLocal=" + a3);
                        if (a3) {
                            record.append("FdToFile:len=" + new File(str2).length());
                            if (str != null) {
                                record.append("FdToFile:type=" + str);
                            }
                            if (parcelFileDescriptor == null) {
                                try {
                                    Intrinsics.throwNpe();
                                } catch (Exception unused2) {
                                }
                            }
                            parcelFileDescriptor.close();
                            return str2;
                        }
                        FileLog.a("ThirdUriTransfer", "FdToFile failed: cannot read path:" + str2);
                    } catch (NoSuchFieldException e) {
                        e.printStackTrace(System.err);
                        record.append("FdToFile:Nofile=" + e.getMessage());
                        FileLog.a("ThirdUriTransfer", "FdToFile failed: " + Log.getStackTraceString(e));
                    }
                } catch (IllegalAccessException e2) {
                    e2.printStackTrace(System.err);
                    record.append("FdToFile:Illegalfile=" + e2.getMessage());
                    FileLog.a("ThirdUriTransfer", "FdToFile failed: " + Log.getStackTraceString(e2));
                    if (parcelFileDescriptor == null) {
                        try {
                            Intrinsics.throwNpe();
                        } catch (Exception unused3) {
                            return null;
                        }
                    }
                    parcelFileDescriptor.close();
                    return null;
                }
            } catch (ErrnoException e3) {
                e3.printStackTrace(System.err);
                record.append("FdToFile:ErrnoException=");
                record.append(e3.getMessage());
                FileLog.a("ThirdUriTransfer", "FdToFile failed: " + Log.getStackTraceString(e3));
                if (parcelFileDescriptor == null) {
                    Intrinsics.throwNpe();
                }
                parcelFileDescriptor.close();
                return null;
            }
        } catch (Throwable th) {
            if (parcelFileDescriptor == null) {
                try {
                    Intrinsics.throwNpe();
                } catch (Exception unused4) {
                    throw th;
                }
            }
            parcelFileDescriptor.close();
            throw th;
        }
    }

    public final boolean a(Intent intent, Context context) {
        if (context == null || intent == null) {
            return false;
        }
        if (TextUtils.isEmpty(intent.getDataString())) {
            FileLog.a("ThirdUriTransfer", "intent no data");
            return false;
        }
        if (b(intent, context, new StringBuilder())) {
            return true;
        }
        return a(context, intent);
    }

    public final boolean a(Intent intent, Context context, StringBuilder record) {
        Intrinsics.checkParameterIsNotNull(intent, "intent");
        Intrinsics.checkParameterIsNotNull(context, "context");
        Intrinsics.checkParameterIsNotNull(record, "record");
        FileLog.a("ThirdUriTransfer", "generateTmpFile failed: path is null, using UID");
        try {
            boolean c2 = c(intent, context, record);
            if (!c2) {
                FileLog.a("ThirdUriTransfer", "transferPathByUid failed");
            }
            return c2;
        } catch (Exception e) {
            record.append(",transferPathByUid:" + e.getMessage());
            FileLog.a("ThirdUriTransfer", "transferPathByUid:" + Log.getStackTraceString(e));
            return false;
        }
    }

    public final boolean a(InputStream ins, String tempFilePath, StringBuilder record) {
        FileOutputStream fileOutputStream;
        Intrinsics.checkParameterIsNotNull(ins, "ins");
        Intrinsics.checkParameterIsNotNull(tempFilePath, "tempFilePath");
        Intrinsics.checkParameterIsNotNull(record, "record");
        FileOutputStream fileOutputStream2 = (FileOutputStream) null;
        try {
            try {
                fileOutputStream = new FileOutputStream(tempFilePath);
            } catch (Exception e) {
                e = e;
            }
        } catch (Throwable th) {
            th = th;
        }
        try {
            Ref.IntRef intRef = new Ref.IntRef();
            byte[] bArr = new byte[10240];
            long j = 0;
            while (true) {
                int read = ins.read(bArr, 0, 10240);
                intRef.element = read;
                if (read == -1) {
                    record.append(",transfer:count=" + j);
                    ins.close();
                    fileOutputStream.close();
                    return true;
                }
                fileOutputStream.write(bArr, 0, intRef.element);
                j += intRef.element;
            }
        } catch (Exception e2) {
            e = e2;
            fileOutputStream2 = fileOutputStream;
            e.printStackTrace(System.err);
            record.append(",transfer:writeExce=" + e.getMessage());
            FileLog.a("ThirdUriTransfer", "transfer write error:" + Log.getStackTraceString(e));
            ins.close();
            if (fileOutputStream2 != null) {
                fileOutputStream2.close();
            }
            return false;
        } catch (Throwable th2) {
            th = th2;
            fileOutputStream2 = fileOutputStream;
            ins.close();
            if (fileOutputStream2 != null) {
                fileOutputStream2.close();
            }
            throw th;
        }
    }
}