package defpackage;

import android.app.Notification;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.display.DisplayManager;
import android.media.AudioFocusRequest;
import android.media.AudioManager;
import android.os.Build;
import android.os.Looper;
import android.view.Display;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.textclassifier.TextClassificationManager;
import android.view.textclassifier.TextClassifier;
import android.widget.TextView;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.DosFileAttributes;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFilePermission;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import net.lingala.zip4j.exception.ZipException;

/* renamed from: ᵴʒ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public abstract class AbstractC4618 {

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public static AudioManager f17098;

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public static final byte[] f17099 = {0, 0, -92, -127};

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public static final byte[] f17097 = {0, 0, -19, 65};

    /* renamed from: ˀᵗᵝᵭ, reason: contains not printable characters */
    public static void m9781(TextView textView) {
        textView.setImportantForAutofill(2);
    }

    /* renamed from: ˇʼʤˎ, reason: contains not printable characters */
    public static File[] m9782(File file) {
        String name = file.getName();
        int iLastIndexOf = name.lastIndexOf(".");
        if (iLastIndexOf != -1) {
            name = name.substring(0, iLastIndexOf);
        }
        File[] fileArrListFiles = file.getParentFile().listFiles(new C4403(name));
        if (fileArrListFiles == null) {
            return new File[0];
        }
        Arrays.sort(fileArrListFiles);
        return fileArrListFiles;
    }

    /* renamed from: ˌʾˀ, reason: contains not printable characters */
    public static boolean m9783(File file) {
        try {
            return Files.isSymbolicLink(file.toPath());
        } catch (Error | Exception unused) {
            return false;
        }
    }

    /* renamed from: ˌᵜᵹᵩ, reason: contains not printable characters */
    public static float m9784(ViewConfiguration viewConfiguration) {
        return viewConfiguration.getScaledVerticalScrollFactor();
    }

    /* renamed from: ˎˏʜʾ, reason: contains not printable characters */
    public static byte[] m9785(File file) {
        try {
            if (!Files.isSymbolicLink(file.toPath()) && !file.exists()) {
                return new byte[4];
            }
            Path path = file.toPath();
            if (m9793()) {
                return m9801(path);
            }
            if (!System.getProperty("os.name").toLowerCase().contains("mac") && !System.getProperty("os.name").toLowerCase().contains("nux")) {
                return new byte[4];
            }
            return m9791(path);
        } catch (NoSuchMethodError unused) {
            return new byte[4];
        }
    }

    /* renamed from: ˎˑː, reason: contains not printable characters */
    public static void m9786(Notification.Builder builder) {
        builder.setTimeoutAfter(0L);
    }

    /* renamed from: ˏˋٴ, reason: contains not printable characters */
    public static synchronized AudioManager m9787(Context context) {
        try {
            Context applicationContext = context.getApplicationContext();
            if (applicationContext != null) {
                f17098 = null;
            }
            AudioManager audioManager = f17098;
            if (audioManager != null) {
                return audioManager;
            }
            Looper looperMyLooper = Looper.myLooper();
            if (looperMyLooper != null && looperMyLooper != Looper.getMainLooper()) {
                C1790 c1790 = new C1790();
                ˋᵮᵯᵔ.ᵯٴᵦ().execute(new RunnableC0421(applicationContext, 4, c1790));
                c1790.m5101();
                AudioManager audioManager2 = f17098;
                audioManager2.getClass();
                return audioManager2;
            }
            AudioManager audioManager3 = (AudioManager) applicationContext.getSystemService("audio");
            f17098 = audioManager3;
            audioManager3.getClass();
            return audioManager3;
        } catch (Throwable th) {
            throw th;
        }
    }

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public static Notification.Builder m9788(Context context, String str) {
        return new Notification.Builder(context, str);
    }

    /* renamed from: ˑᵥˁ, reason: contains not printable characters */
    public static void m9789(Notification.Builder builder) {
        builder.setShortcutId(null);
    }

    /* renamed from: ˑᵱ, reason: contains not printable characters */
    public static Intent m9790(Context context, BroadcastReceiver broadcastReceiver, IntentFilter intentFilter, String str, int i) {
        return context.registerReceiver(broadcastReceiver, intentFilter, str, null, i);
    }

    /* renamed from: ᵝᵵᵺ, reason: contains not printable characters */
    public static byte[] m9791(Path path) {
        byte[] bArr = new byte[4];
        try {
            Set<PosixFilePermission> setPermissions = ((PosixFileAttributeView) Files.getFileAttributeView(path, PosixFileAttributeView.class, LinkOption.NOFOLLOW_LINKS)).readAttributes().permissions();
            boolean zIsSymbolicLink = Files.isSymbolicLink(path);
            if (zIsSymbolicLink) {
                byte b = ᵯᵽᵦ.ᵡᵘˎʽ(bArr[3], 7);
                bArr[3] = b;
                bArr[3] = ᵯᵽᵦ.ᵳᵹᵺˋ(b, 6);
            } else {
                bArr[3] = m9811(Files.isRegularFile(path, new LinkOption[0]), bArr[3], 7);
                bArr[3] = m9811(Files.isDirectory(path, new LinkOption[0]), bArr[3], 6);
            }
            bArr[3] = m9811(zIsSymbolicLink, bArr[3], 5);
            bArr[3] = m9811(setPermissions.contains(PosixFilePermission.OWNER_READ), bArr[3], 0);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.OWNER_WRITE), bArr[2], 7);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.OWNER_EXECUTE), bArr[2], 6);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.GROUP_READ), bArr[2], 5);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.GROUP_WRITE), bArr[2], 4);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.GROUP_EXECUTE), bArr[2], 3);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.OTHERS_READ), bArr[2], 2);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.OTHERS_WRITE), bArr[2], 1);
            bArr[2] = m9811(setPermissions.contains(PosixFilePermission.OTHERS_EXECUTE), bArr[2], 0);
        } catch (IOException unused) {
        }
        return bArr;
    }

    /* renamed from: ᵞʡ, reason: contains not printable characters */
    public static boolean m9792(File file, File file2) throws IOException {
        try {
            Files.move(file.toPath(), file2.toPath(), StandardCopyOption.REPLACE_EXISTING);
            return true;
        } catch (IOException unused) {
            return false;
        }
    }

    /* renamed from: ᵡʠ, reason: contains not printable characters */
    public static boolean m9793() {
        return System.getProperty("os.name").toLowerCase().contains("win");
    }

    /* renamed from: ᵡˎ, reason: contains not printable characters */
    public static void m9794(Notification.Builder builder) {
        builder.setSettingsText(null);
    }

    /* renamed from: ᵡⁱᵥ, reason: contains not printable characters */
    public static void m9795(Notification.Builder builder) {
        builder.setGroupAlertBehavior(0);
    }

    /* renamed from: ᵢˇᵭ, reason: contains not printable characters */
    public static void m9796(TextView textView) {
        textView.setAutofillHints(null);
    }

    /* renamed from: ᵤᵙᵷ, reason: contains not printable characters */
    public static void m9797(Path path, byte[] bArr) throws IOException {
        DosFileAttributeView dosFileAttributeViewM8826;
        if (bArr == null || bArr.length == 0) {
            return;
        }
        try {
            if (m9793()) {
                if (bArr[0] == 0 || (dosFileAttributeViewM8826 = C3994.m8826(Files.getFileAttributeView(path, C3994.m8824(), LinkOption.NOFOLLOW_LINKS))) == null) {
                    return;
                }
                dosFileAttributeViewM8826.setReadOnly(ᵯᵽᵦ.ˎˑː(bArr[0], 0));
                dosFileAttributeViewM8826.setHidden(ᵯᵽᵦ.ˎˑː(bArr[0], 1));
                dosFileAttributeViewM8826.setSystem(ᵯᵽᵦ.ˎˑː(bArr[0], 2));
                dosFileAttributeViewM8826.setArchive(ᵯᵽᵦ.ˎˑː(bArr[0], 5));
            } else {
                if (!System.getProperty("os.name").toLowerCase().contains("mac") && !System.getProperty("os.name").toLowerCase().contains("nux")) {
                    return;
                }
                if (bArr[2] == 0 && bArr[3] == 0) {
                    return;
                }
                HashSet hashSet = new HashSet();
                m9805(bArr[3], 0, hashSet, PosixFilePermission.OWNER_READ);
                m9805(bArr[2], 7, hashSet, PosixFilePermission.OWNER_WRITE);
                m9805(bArr[2], 6, hashSet, PosixFilePermission.OWNER_EXECUTE);
                m9805(bArr[2], 5, hashSet, PosixFilePermission.GROUP_READ);
                m9805(bArr[2], 4, hashSet, PosixFilePermission.GROUP_WRITE);
                m9805(bArr[2], 3, hashSet, PosixFilePermission.GROUP_EXECUTE);
                m9805(bArr[2], 2, hashSet, PosixFilePermission.OTHERS_READ);
                m9805(bArr[2], 1, hashSet, PosixFilePermission.OTHERS_WRITE);
                m9805(bArr[2], 0, hashSet, PosixFilePermission.OTHERS_EXECUTE);
                Files.setPosixFilePermissions(path, hashSet);
            }
        } catch (IOException unused) {
        }
    }

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public static void m9798(AudioManager audioManager, C2885 c2885) {
        if (Build.VERSION.SDK_INT < 26) {
            audioManager.abandonAudioFocus(c2885.f11183);
            return;
        }
        Object obj = c2885.f11180;
        obj.getClass();
        audioManager.abandonAudioFocusRequest((AudioFocusRequest) obj);
    }

    /* renamed from: ᵧᵾˀˈ, reason: contains not printable characters */
    public static int m9799(AudioManager audioManager, C2885 c2885) {
        if (Build.VERSION.SDK_INT >= 26) {
            Object obj = c2885.f11180;
            obj.getClass();
            return audioManager.requestAudioFocus((AudioFocusRequest) obj);
        }
        AudioManager.OnAudioFocusChangeListener onAudioFocusChangeListener = c2885.f11183;
        C1028 c1028 = c2885.f11184;
        c1028.getClass();
        int i = 3;
        if (Build.VERSION.SDK_INT >= 26) {
            try {
                int volumeControlStream = c1028.m3392().getVolumeControlStream();
                if (volumeControlStream != Integer.MIN_VALUE) {
                    i = volumeControlStream;
                }
            } catch (RuntimeException unused) {
            }
        }
        return audioManager.requestAudioFocus(onAudioFocusChangeListener, i, c2885.f11182);
    }

    /* renamed from: ᵨᵳʝ, reason: contains not printable characters */
    public static String m9800(File file) {
        try {
            return Files.readSymbolicLink(file.toPath()).toString();
        } catch (Error | Exception unused) {
            return "";
        }
    }

    /* renamed from: ᵪʩ, reason: contains not printable characters */
    public static byte[] m9801(Path path) throws IOException {
        byte[] bArr = new byte[4];
        try {
            DosFileAttributeView dosFileAttributeViewM8826 = C3994.m8826(Files.getFileAttributeView(path, C3994.m8824(), LinkOption.NOFOLLOW_LINKS));
            if (dosFileAttributeViewM8826 != null) {
                DosFileAttributes attributes = dosFileAttributeViewM8826.readAttributes();
                bArr[0] = m9811(attributes.isArchive(), m9811(attributes.isDirectory(), m9811(attributes.isSystem(), m9811(attributes.isHidden(), m9811(attributes.isReadOnly(), (byte) 0, 0), 1), 2), 4), 5);
            }
        } catch (IOException unused) {
        }
        return bArr;
    }

    /* renamed from: ᵮᵠـˌ, reason: contains not printable characters */
    public static void m9802(View view, CharSequence charSequence) {
        view.setTooltipText(charSequence);
    }

    /* renamed from: ᵯٴᵦ, reason: contains not printable characters */
    public static TextClassifier m9803(TextView textView) {
        TextClassificationManager textClassificationManager = (TextClassificationManager) textView.getContext().getSystemService(TextClassificationManager.class);
        return textClassificationManager != null ? textClassificationManager.getTextClassifier() : TextClassifier.NO_OP;
    }

    /* renamed from: ᵳٴᵶ, reason: contains not printable characters */
    public static String m9804(String str) throws ZipException {
        if (!ᵙᵛᵯ.ᵢˇᵭ(str)) {
            C0190.m1425("zip file name is empty or null, cannot determine zip file name");
            return null;
        }
        if (str.contains(System.getProperty("file.separator"))) {
            str = str.substring(str.lastIndexOf(System.getProperty("file.separator")) + 1);
        }
        return str.endsWith(".zip") ? str.substring(0, str.lastIndexOf(".")) : str;
    }

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public static void m9805(byte b, int i, HashSet hashSet, PosixFilePermission posixFilePermission) {
        if (ᵯᵽᵦ.ˎˑː(b, i)) {
            hashSet.add(posixFilePermission);
        }
    }

    /* renamed from: ᵶᵷᵕ, reason: contains not printable characters */
    public static String m9806(File file, C5254 c5254) throws ZipException {
        try {
            File file2 = new File(file.getCanonicalPath());
            String string = c5254.f19676;
            if (!ᵙᵛᵯ.ᵢˇᵭ(string)) {
                string = m9783(file2) ? file2.toPath().toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString() : file2.getName();
            }
            if (file2.isDirectory()) {
                string = string + "/";
            }
            if (ᵙᵛᵯ.ᵢˇᵭ(string)) {
                return string;
            }
            String strM9550 = "fileName to add to zip is empty or null. fileName: '" + string + "' DefaultFolderPath: 'null' FileNameInZip: " + c5254.f19676;
            if (m9783(file)) {
                strM9550 = strM9550.concat("isSymlink: true ");
            }
            if (ᵙᵛᵯ.ᵢˇᵭ((String) null)) {
                strM9550 = AbstractC4486.m9550("rootFolderNameInZip: '", null, "' ");
            }
            C0190.m1425(strM9550);
            return null;
        } catch (IOException e) {
            throw new ZipException(e);
        }
    }

    /* renamed from: ᵸʓᵠ, reason: contains not printable characters */
    public static boolean m9807(String str) {
        return str.endsWith("/") || str.endsWith("\\");
    }

    /* renamed from: ᵸˑ, reason: contains not printable characters */
    public static float m9808(ViewConfiguration viewConfiguration) {
        return viewConfiguration.getScaledHorizontalScrollFactor();
    }

    /* renamed from: ᵹᵝᵶ, reason: contains not printable characters */
    public static ArrayList m9809(File file, C5254 c5254) throws ZipException {
        if (file == null) {
            C0190.m1425("input path is null, cannot read files in the directory");
            return null;
        }
        ArrayList arrayList = new ArrayList();
        File[] fileArrListFiles = file.listFiles();
        if (file.isDirectory() && file.canRead() && fileArrListFiles != null) {
            for (File file2 : fileArrListFiles) {
                if (!file2.isHidden() || c5254.f19671) {
                    arrayList.add(file2);
                    int i = c5254.f19678;
                    boolean zM9783 = m9783(file2);
                    if ((zM9783 && !AbstractC1327.m4108(1, i)) || (!zM9783 && file2.isDirectory())) {
                        arrayList.addAll(m9809(file2, c5254));
                    }
                }
            }
        }
        return arrayList;
    }

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public static boolean m9810(Context context) {
        Display.HdrCapabilities hdrCapabilities;
        DisplayManager displayManager = (DisplayManager) context.getSystemService("display");
        Display display = displayManager != null ? displayManager.getDisplay(0) : null;
        if (display == null || !display.isHdr() || (hdrCapabilities = display.getHdrCapabilities()) == null) {
            return false;
        }
        for (int i : hdrCapabilities.getSupportedHdrTypes()) {
            if (i == 1) {
                return true;
            }
        }
        return false;
    }

    /* renamed from: ᵾᵬ, reason: contains not printable characters */
    public static byte m9811(boolean z, byte b, int i) {
        return z ? ᵯᵽᵦ.ᵡᵘˎʽ(b, i) : b;
    }

    /* renamed from: ᵿʗᵝʽ, reason: contains not printable characters */
    public static void m9812(Notification.Builder builder) {
        builder.setBadgeIconType(0);
    }
}