package com.mstar.android.tv.widget;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioDevicePort;
import android.media.AudioManager;
import android.media.AudioPatch;
import android.media.AudioPort;
import android.media.AudioSystem;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import com.mstar.android.tv.TvCommonManager;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import okhttp3.HttpUrl;

/* JADX INFO: loaded from: classes.dex */
public class AudioConfig {
    private static final String TAG = "AudioConfig";
    private AudioDevicePort mAudioSource;
    private Context mContext;
    private Handler mHandler;
    private int mCurrentInputSource = 50;
    private AudioManager mAudioManager = null;
    private int mOverrideAudioType = 0;
    private String mOverrideAudioAddress = HttpUrl.FRAGMENT_ENCODE_SET;
    private List<AudioDevicePort> mAudioSink = new ArrayList();
    private AudioPatch mAudioPatch = null;
    private float mCommittedVolume = -1.0f;
    private float mSourceVolume = 0.0f;
    private int mDesiredSamplingRate = 0;
    private int mDesiredChannelMask = 1;
    private int mDesiredFormat = 1;
    private int mCurrentIndex = 0;
    private int mCurrentMaxIndex = 0;
    private BroadcastReceiver mVolumeReceiver = null;
    private TvCommonManager.OnInputSourceEventListener mInputSourceEventListener = null;
    private final AudioManager.OnAudioPortUpdateListener mAudioListener = new AudioManager.OnAudioPortUpdateListener() { // from class: com.mstar.android.tv.widget.AudioConfig.3
        public void onAudioPatchListUpdate(AudioPatch[] audioPatchArr) {
        }

        public void onAudioPortListUpdate(AudioPort[] audioPortArr) {
            AudioConfig.this.updateAudioConfigLocked();
        }

        public void onServiceDied() {
            AudioConfig.this.mAudioSource = null;
            AudioConfig.this.mAudioSink.clear();
            AudioConfig.this.mAudioPatch = null;
        }
    };

    private class InputSourceEventListener implements TvCommonManager.OnInputSourceEventListener {
        private InputSourceEventListener() {
        }

        @Override // com.mstar.android.tv.TvCommonManager.OnInputSourceEventListener
        public boolean onInputSourceEvent(int i2, int i3, int i4, Object obj) {
            if (7001 != i2 || AudioConfig.this.mAudioManager == null) {
                return true;
            }
            Log.d(AudioConfig.TAG, "onInputSourceEvent winId = " + i3 + " , newSrc = " + i4);
            if (i3 != 0) {
                return true;
            }
            AudioConfig.this.mCurrentInputSource = i4;
            if (AudioConfig.this.mCurrentInputSource == 34 || AudioConfig.this.mCurrentInputSource == 38) {
                return true;
            }
            AudioConfig.this.mCommittedVolume = -1.0f;
            Log.e(AudioConfig.TAG, "onInputSourceEvent() updateAudioConfigLocked");
            AudioConfig.this.mHandler.removeCallbacksAndMessages(null);
            AudioConfig.this.updateAudioConfigLocked();
            return true;
        }
    }

    public AudioConfig(Context context) {
        this.mContext = null;
        this.mContext = context;
    }

    private AudioDevicePort findAudioDevicePort() {
        ArrayList<AudioDevicePort> arrayList = new ArrayList();
        try {
            if (Integer.parseInt(Class.forName("android.media.AudioManager").getDeclaredMethod("listAudioDevicePorts", ArrayList.class).invoke(this.mAudioManager, arrayList).toString()) != 0) {
                return null;
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
        int inpitSourceDevIn = getInpitSourceDevIn();
        for (AudioDevicePort audioDevicePort : arrayList) {
            if (audioDevicePort.type() == inpitSourceDevIn) {
                Log.w(TAG, "findAudioDevicePort(), return port = " + audioDevicePort + ", devIn = " + inpitSourceDevIn);
                return audioDevicePort;
            }
        }
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            Log.i(TAG, "audio device port.type() = " + ((AudioDevicePort) it.next()).type());
        }
        Log.e(TAG, "Can not find the audio device! devIn = " + inpitSourceDevIn);
        return null;
    }

    private void findAudioSinkFromAudioPolicy(List<AudioDevicePort> list) {
        list.clear();
        AudioManager.resetAudioPortGeneration();
        ArrayList<AudioDevicePort> arrayList = new ArrayList();
        try {
            if (Integer.parseInt(Class.forName("android.media.AudioManager").getDeclaredMethod("listAudioDevicePorts", ArrayList.class).invoke(this.mAudioManager, arrayList).toString()) != 0) {
                return;
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
        int devicesForStream = this.mAudioManager.getDevicesForStream(3);
        for (AudioDevicePort audioDevicePort : arrayList) {
            if ((audioDevicePort.type() & devicesForStream) != 0 && AudioManager.isOutputDevice(audioDevicePort.type())) {
                list.add(audioDevicePort);
            }
        }
    }

    private int getInpitSourceDevIn() {
        switch (this.mCurrentInputSource) {
            case 0:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 11:
            case 12:
            case 13:
            case 14:
            case 16:
            case 17:
            case 18:
            case 20:
            case 21:
            case 29:
            case 30:
            case 31:
            case 32:
            case 42:
            case 43:
                Log.i(TAG, "devIn = DEVICE_IN_LINE");
                return -2147450880;
            case 1:
            case 28:
                Log.i(TAG, "devIn = DEVICE_IN_TV_TUNER");
                return -2147467264;
            case 10:
            case 15:
            case 19:
            case 22:
            case 27:
            case 33:
            case 34:
            case 35:
            case 36:
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            default:
                Log.i(TAG, "devIn = DEVICE_NONE");
                return 0;
            case 23:
            case 24:
            case 25:
            case 26:
                Log.i(TAG, "devIn = DEVICE_IN_HDMI");
                return -2147483616;
        }
    }

    private float getMediaStreamVolume() {
        return this.mCurrentIndex / this.mCurrentMaxIndex;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void handleA2dpChange(Context context, Intent intent) {
        String action = intent.getAction();
        if (TextUtils.isEmpty(action)) {
            return;
        }
        action.hashCode();
        if (action.equals("android.bluetooth.adapter.action.STATE_CHANGED")) {
            if (intent.getIntExtra("android.bluetooth.adapter.extra.STATE", 10) == 10) {
                Log.i(TAG, "ACTION_STATE_CHANGED STATE_OFF");
                this.mHandler.removeCallbacksAndMessages(null);
                this.mHandler.sendEmptyMessageDelayed(0, 1000L);
                return;
            }
            return;
        }
        if (action.equals("android.bluetooth.a2dp.profile.action.CONNECTION_STATE_CHANGED")) {
            int intExtra = intent.getIntExtra("android.bluetooth.profile.extra.STATE", 0);
            if (intExtra == 2 || intExtra == 0) {
                Log.i(TAG, "ACTION_CONNECTION_STATE_CHANGED");
                this.mHandler.removeCallbacksAndMessages(null);
                this.mHandler.sendEmptyMessageDelayed(0, 1000L);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void handleVolumeChange(Context context, Intent intent) {
        String action = intent.getAction();
        action.hashCode();
        if (action.equals("android.media.VOLUME_CHANGED_ACTION")) {
            if (intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1) == 3 && intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_VALUE", 0) != this.mCurrentIndex) {
                Log.i(TAG, "VOLUME_CHANGED_ACTION!");
                updateAudioConfigLocked();
                return;
            }
            return;
        }
        if (action.equals("android.media.STREAM_MUTE_CHANGED_ACTION") && intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1) == 3) {
            Log.i(TAG, "STREAM_MUTE_CHANGED_ACTION!");
            updateAudioConfigLocked();
        }
    }

    private static boolean intArrayContains(int[] iArr, int i2) {
        for (int i3 : iArr) {
            if (i3 == i2) {
                return true;
            }
        }
        return false;
    }

    private void releaseAudioPatch() {
        AudioPatch audioPatch = this.mAudioPatch;
        if (audioPatch != null) {
            if (AudioManager.releaseAudioPatch(audioPatch) != 0) {
                Log.w(TAG, "releaseAudioPatch fail!" + this.mAudioPatch);
            }
            this.mAudioPatch = null;
        }
    }

    private void releaseInputSourceEventListener() {
        AudioManager.OnAudioPortUpdateListener onAudioPortUpdateListener = this.mAudioListener;
        if (onAudioPortUpdateListener != null) {
            this.mAudioManager.unregisterAudioPortUpdateListener(onAudioPortUpdateListener);
        }
        if (this.mInputSourceEventListener != null) {
            TvCommonManager.getInstance().unregisterOnInputSourceEventListener(this.mInputSourceEventListener);
            this.mInputSourceEventListener = null;
        }
    }

    private void releaseVolumeReceiver() {
        BroadcastReceiver broadcastReceiver = this.mVolumeReceiver;
        if (broadcastReceiver != null) {
            Context context = this.mContext;
            if (context != null) {
                context.unregisterReceiver(broadcastReceiver);
            }
            this.mVolumeReceiver = null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:54:0x00f0  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public void updateAudioConfigLocked() {
        /*
            Method dump skipped, instruction units count: 652
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.mstar.android.tv.widget.AudioConfig.updateAudioConfigLocked():void");
    }

    private boolean updateAudioSinkLocked() {
        List<AudioDevicePort> list = this.mAudioSink;
        ArrayList arrayList = new ArrayList();
        this.mAudioSink = arrayList;
        if (this.mOverrideAudioType == 0) {
            findAudioSinkFromAudioPolicy(arrayList);
        } else {
            AudioDevicePort audioDevicePortFindAudioDevicePort = findAudioDevicePort();
            if (audioDevicePortFindAudioDevicePort != null) {
                this.mAudioSink.add(audioDevicePortFindAudioDevicePort);
            }
        }
        if (this.mAudioSink.size() != list.size()) {
            return true;
        }
        list.removeAll(this.mAudioSink);
        return !list.isEmpty();
    }

    private boolean updateAudioSourceLocked() {
        AudioDevicePort audioDevicePort = this.mAudioSource;
        AudioDevicePort audioDevicePortFindAudioDevicePort = findAudioDevicePort();
        this.mAudioSource = audioDevicePortFindAudioDevicePort;
        if (audioDevicePortFindAudioDevicePort == null) {
            if (audioDevicePort == null) {
                return false;
            }
        } else if (audioDevicePortFindAudioDevicePort.equals(audioDevicePort)) {
            return false;
        }
        return true;
    }

    private void updateVolume() {
        this.mCurrentMaxIndex = this.mAudioManager.getStreamMaxVolume(3);
        this.mCurrentIndex = this.mAudioManager.getStreamVolume(3);
    }

    public void create() {
        if (this.mContext == null) {
            return;
        }
        this.mHandler = new Handler(Looper.getMainLooper()) { // from class: com.mstar.android.tv.widget.AudioConfig.1
            @Override // android.os.Handler
            public void handleMessage(Message message) {
                AudioConfig.this.mCommittedVolume = -1.0f;
                AudioSystem.setMasterVolume(1.0f);
                AudioConfig.this.updateAudioConfigLocked();
            }
        };
        this.mCurrentInputSource = TvCommonManager.getInstance().getCurrentTvInputSource();
        this.mAudioManager = (AudioManager) this.mContext.getSystemService("audio");
        releaseAudioPatch();
        releaseVolumeReceiver();
        releaseInputSourceEventListener();
        updateAudioConfigLocked();
        this.mVolumeReceiver = new BroadcastReceiver() { // from class: com.mstar.android.tv.widget.AudioConfig.2
            @Override // android.content.BroadcastReceiver
            public void onReceive(Context context, Intent intent) {
                AudioConfig.this.handleVolumeChange(context, intent);
                AudioConfig.this.handleA2dpChange(context, intent);
            }
        };
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction("android.media.VOLUME_CHANGED_ACTION");
        intentFilter.addAction("android.media.STREAM_MUTE_CHANGED_ACTION");
        intentFilter.addAction("android.bluetooth.adapter.action.STATE_CHANGED");
        intentFilter.addAction("android.bluetooth.a2dp.profile.action.CONNECTION_STATE_CHANGED");
        this.mContext.registerReceiver(this.mVolumeReceiver, intentFilter);
        this.mInputSourceEventListener = new InputSourceEventListener();
        TvCommonManager.getInstance().registerOnInputSourceEventListener(this.mInputSourceEventListener);
        this.mAudioManager.registerAudioPortUpdateListener(this.mAudioListener);
    }

    public void release() {
        releaseAudioPatch();
        releaseVolumeReceiver();
        releaseInputSourceEventListener();
        this.mAudioManager = null;
        this.mHandler = null;
    }
}