夜猫麻将 v24.1.1 - AudioDispatcher.java 源代码

package com.gme.av.audiodispatcher;

import com.gme.av.utils.QLog;
import com.gme.av.wrapper.GMEJavaInstance;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;

public class AudioDispatcher {
    private static final String TAG = "AudioDispatcher";
    private static final int TRY_BIND_SOCKET_TIMES = 20;
    private static AudioDispatcher mAudioDispatcher;
    private static ArrayBlockingQueue<byte[]> mQueue = new ArrayBlockingQueue<>(10);
    private ServerSocket mServerSocket;
    private SocketClient mSocketClient;
    private int mPort = 7878;
    private AtomicBoolean mIsSendingAudioData = new AtomicBoolean(false);
    private AtomicBoolean mIsWaitingClient = new AtomicBoolean(false);

    public static AudioDispatcher getInstance() {
        if (mAudioDispatcher == null) {
            mAudioDispatcher = new AudioDispatcher();
        }
        return mAudioDispatcher;
    }

    public void offerAudioData(byte[] data) {
        if (data != null) {
            if (mQueue.remainingCapacity() <= 1) {
                mQueue.poll();
            }
            mQueue.add(data);
        }
    }

    public boolean isNeedOfferAudioData() {
        return this.mIsSendingAudioData.get();
    }

    public void onAudioCaptureChange(boolean enable) {
        GMEAudioBroadcast.getInstance().onAudioCaptureChange(enable);
    }

    public void onAudioEnableBroadcast(boolean enable) {
        if (enable) {
            GMEAudioBroadcast.getInstance().registerBroadcast(GMEJavaInstance.getmActivity());
        } else {
            GMEAudioBroadcast.getInstance().unRegisterBroadcast(GMEJavaInstance.getmActivity());
        }
    }

    public byte[] pollAudioData() {
        return mQueue.poll();
    }

    public void clearAudioQueue() {
        mQueue.clear();
    }

    boolean startServer() {
        QLog.e(TAG, "startServer");
        if (this.mIsSendingAudioData.get()) {
            QLog.i(TAG, "AudioDispatcher is sending audio data. request refuse");
            return false;
        }
        if (this.mIsWaitingClient.get()) {
            QLog.i(TAG, "AudioDispatcher Server is ready and waiting accept.");
            return true;
        }
        ServerSocket TryBindSocket = TryBindSocket();
        this.mServerSocket = TryBindSocket;
        if (TryBindSocket == null) {
            QLog.i(TAG, "AudioDispatcher Server TryBindSocket failed");
            return false;
        }
        QLog.i(TAG, "AudioDispatcher Server start");
        new AudioServer().start();
        return true;
    }

    public int getPort() {
        return this.mPort;
    }

    public void onRecordStateChange(boolean isRecord) {
        if (!isRecord) {
            QLog.e(TAG, "onRecordStateChange:" + isRecord + " try closeSocketClient");
            closeSocketClient();
        }
    }

    public void closeSocketClient() {
        SocketClient socketClient = this.mSocketClient;
        if (socketClient != null) {
            socketClient.stopClient();
        }
    }

    class AudioServer extends Thread {
        private AudioServer() {
            QLog.e(AudioDispatcher.TAG, "AudioServer start");
            AudioDispatcher.this.mIsWaitingClient.set(true);
        }

        @Override
        public void run() {
            try {
                Socket socketClient = AudioDispatcher.this.mServerSocket.accept();
                AudioDispatcher.this.mSocketClient = AudioDispatcher.this.new SocketClient(socketClient);
                AudioDispatcher.this.mSocketClient.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
            AudioDispatcher.this.mIsWaitingClient.set(false);
            QLog.e(AudioDispatcher.TAG, "AudioServer end");
        }
    }

    private ServerSocket TryBindSocket() {
        ServerSocket serverSocket = null;
        int tryTimes = 0;
        boolean run = true;
        do {
            try {
                int i = this.mPort + 1;
                this.mPort = i;
                serverSocket = new ServerSocket(i);
                QLog.e(TAG, "try to bind Socket" + this.mPort);
                run = false;
            } catch (BindException e) {
                e.printStackTrace();
                tryTimes++;
                if (tryTimes >= 20) {
                    break;
                }
                QLog.e(TAG, "BindException" + e.getMessage());
            } catch (IOException e2) {
                QLog.e(TAG, "IOException" + e2.getMessage());
            }
        } while (run);
        return serverSocket;
    }

    class SocketClient extends Thread {
        private boolean mFlag = true;
        private Socket mSocket;

        public SocketClient(Socket socket) {
            this.mSocket = socket;
            AudioDispatcher.this.clearAudioQueue();
            AudioDispatcher.this.mIsSendingAudioData.set(true);
        }

        public void stopClient() {
            this.mFlag = false;
        }

        @Override
        public void run() {
            super.run();
            QLog.e(AudioDispatcher.TAG, "start Send audio data");
            try {
                try {
                    try {
                        DataOutputStream dos = new DataOutputStream(this.mSocket.getOutputStream());
                        do {
                            byte[] outData = AudioDispatcher.this.pollAudioData();
                            if (outData == null) {
                                Thread.sleep(10L);
                            } else {
                                dos.write(outData);
                            }
                        } while (this.mFlag);
                        dos.close();
                        this.mSocket.close();
                    } catch (Throwable th) {
                        try {
                            this.mSocket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        throw th;
                    }
                } catch (IOException e2) {
                    e2.printStackTrace();
                    QLog.e(AudioDispatcher.TAG, e2.getMessage());
                    this.mSocket.close();
                } catch (InterruptedException e3) {
                    e3.printStackTrace();
                    this.mSocket.close();
                }
            } catch (IOException e4) {
                e4.printStackTrace();
            }
            AudioDispatcher.this.mIsSendingAudioData.set(false);
            QLog.e(AudioDispatcher.TAG, "stop Send audio data");
        }
    }
}