androidMain.com.dyte.mobilecorekmm.DyteAndroidClient.kt Maven / Gradle / Ivy

Go to download
package com.dyte.mobilecorekmm

import android.annotation.SuppressLint
import android.bluetooth.BluetoothA2dp
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothProfile
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.media.AudioManager
import android.os.Build.VERSION
import com.dyte.mobilecorekmm.dependency.DependencyProvider
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import kotlinx.serialization.ExperimentalSerializationApi

@OptIn(ExperimentalSerializationApi::class)
@DelicateCoroutinesApi
class DyteAndroidClient : DyteMobileClient() {
  fun start(androidMeetingInfo: AndroidMeetingInfo) {

    if (DependencyProvider.getPlatformUtils().isBluetoothDeviceConnected()) {
      setupAudioManagerForBluetoothDevices(androidMeetingInfo.context)
    }

    startWiredHeadsetEvent(androidMeetingInfo.context)
    startBluetoothHeadsetEvent(androidMeetingInfo.context)

    GlobalScope.launch(Dispatchers.Main) {
      DependencyProvider.init(androidMeetingInfo.context)
      start(androidMeetingInfo.meetingInfo, this)
    }
  }

  private fun startBluetoothHeadsetEvent(context: Context) {
    val intentFilter = IntentFilter(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED)
    intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
    val receiver = object : BroadcastReceiver() {
      override fun onReceive(context: Context, intent: Intent) {
        val action = intent.action
        if (action == BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED) {
          val device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
          val state =
            intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothProfile.STATE_DISCONNECTED)
          if (state == BluetoothProfile.STATE_CONNECTED) {
            // Device has connected, report it
            onChange(device!!.name, context)
          } else if (state == BluetoothProfile.STATE_DISCONNECTED) {
            // Device has disconnected, report it
            onChange("", context)
          }
        } else if (action == BluetoothAdapter.ACTION_STATE_CHANGED) {
          val state = intent.getIntExtra(
            BluetoothProfile.EXTRA_STATE,
            BluetoothProfile.STATE_DISCONNECTED
          )
          if (state == BluetoothProfile.STATE_DISCONNECTED) {
            // Bluetooth is disabled
            onChange("", context)
          }
        }
      }
    }
    context.registerReceiver(receiver, intentFilter)
  }

  private fun startWiredHeadsetEvent(context: Context) {
      val filter = IntentFilter(ACTION_HEADSET_PLUG)
      val wiredHeadsetReceiver = object : BroadcastReceiver() {
        var hasWiredHeadset = false
        override fun onReceive(context: Context, intent: Intent) {
          hasWiredHeadset = if (ACTION_HEADSET_PLUG == intent.action) {
            intent.getIntExtra("state", 0) == 1
          } else {
            false
          }
          onWiredHeadsetStatusChanged(hasWiredHeadset)
        }
      }
    context.registerReceiver(wiredHeadsetReceiver, filter)
  }

  private fun setupAudioManagerForBluetoothDevices(context: Context) {
    val audioManager: AudioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
    audioManager.mode = AudioManager.MODE_IN_COMMUNICATION
    if (!audioManager.isBluetoothScoOn) {
      audioManager.startBluetoothSco()
    }
    audioManager.isBluetoothScoOn = true
  }

  private fun disableAudioManagerForBluetoothDevices(context: Context) {
    val audioManager: AudioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
    audioManager.isBluetoothScoOn = false
    audioManager.stopBluetoothSco()
  }

  private fun onChange(deviceName: String?, context: Context) {
    if (deviceName?.isNotEmpty() == true) {
      onBluetoothDeviceConnected(deviceName)
      setupAudioManagerForBluetoothDevices(context)
    } else {
      onBluetoothDeviceDisconnected()
      disableAudioManagerForBluetoothDevices(context)
    }
  }

  private fun onWiredHeadsetStatusChanged(isConnected: Boolean) {
    onWiredHeadsetConnected(isConnected)
  }

  companion object {
    @SuppressLint("ObsoleteSdkInt")
    private val ACTION_HEADSET_PLUG =
      if (VERSION.SDK_INT >= 21) AudioManager.ACTION_HEADSET_PLUG else Intent.ACTION_HEADSET_PLUG
  }
}