Regarding stop button functionality about swiftaudio HOT 15 OPEN

player?.event.playbackEnd.addListener(self, handleAudioPlayerStatePlayBackEnd)
func handleAudioPlayerStatePlayBackEnd(state: AudioPlayer.PlaybackEndEventData) {
            if state == .playedUntilEnd{
      // Reload your audio again and reset UI also            
   }
 }
}

    if let url = self.audioURL {
        let item = DefaultAudioItem(audioUrl: url, sourceType: .stream)
        try? self.audioPlayer.load(item: item, playWhenReady: true)
        self.playPauseBtn.setImage(UIImage(named: "ic_audio_pause"), for: .normal)
        self.scaleInBookCover(isFirstLoad: false)
        self.nowPlayingImageView.startAnimating()
    }
}

func updateTimeValues() {
    self.trackSlider.maximumValue = CGFloat(self.audioPlayer.duration)
    self.trackSlider.setValue(CGFloat(self.audioPlayer.currentTime), animated: true)
    self.currentTimeLbl.text = getTimeString(time: self.audioPlayer.currentTime)
    self.durationLbl.text = getTimeString(time: (self.audioPlayer.duration - self.audioPlayer.currentTime))
}

func setPlayButtonState(forAudioPlayerState state: AudioPlayerState) {
    if state == .playing {
        playPauseBtn.setImage(UIImage(named: "ic_audio_pause"), for: .normal)
        self.scaleInBookCover(isFirstLoad: false)
        self.nowPlayingImageView.startAnimating()
    } else {
        playPauseBtn.setImage(UIImage(named: "ic_audio_play"), for: .normal)
        self.scaleOutBookCover()
        self.nowPlayingImageView.stopAnimating()
    }
}

func handleAudioPlayerStateChange(data: AudioPlayer.StateChangeEventData) {
    print(data)
    DispatchQueue.main.async {
        self.setPlayButtonState(forAudioPlayerState: data)
        switch data {
        case .loading:
            self.startLoader()
            self.updateTimeValues()
        case .buffering:
            self.startLoader()
        case .ready:
            self.stopLoader()
            self.updateTimeValues()
        case .playing, .paused, .idle:
            self.stopLoader()
            self.updateTimeValues()
        }
    }
}

func handlePlayEnd(data: AudioPlayer.PlaybackEndEventData) {
    DispatchQueue.main.async {
        switch data {

        case .playedUntilEnd:
            if let url = self.audioURL {
                let item = DefaultAudioItem(audioUrl: url, sourceType: .stream)
                try? self.audioPlayer.load(item: item, playWhenReady: false)
            }
        case .playerStopped:
            self.audioPlayer.stop()
            self.stopLoader()
        case .skippedToNext:
            self.stopLoader()
        case .skippedToPrevious:
            self.stopLoader()
        case .jumpedToIndex:
            self.stopLoader()
        }
    }
}

func handleAudioPlayerSecondElapsed(data: AudioPlayer.SecondElapseEventData) {
    if !isScrubbing {
        DispatchQueue.main.async {
            self.updateTimeValues()
        }
    }
}

func handleAudioPlayerDidSeek(data: AudioPlayer.SeekEventData) {
    isScrubbing = false
}

func handleAudioPlayerUpdateDuration(data: AudioPlayer.UpdateDurationEventData) {
    DispatchQueue.main.async {
        self.updateTimeValues()
    }
}

func handleAVPlayerRecreated() {
    try? audioSessionController.set(category: .playback)
}

func handlePlayerFailure(data: AudioPlayer.FailEventData) {
    if let error = data as NSError? {
        if error.code == -1009 {
            DispatchQueue.main.async {
                print("Network disconnected. Please try again...")
            }
        }
    }
}

func handlePlayEnd(data: AudioPlayer.PlaybackEndEventData) {
    DispatchQueue.main.async {
        switch data {
        case .playedUntilEnd:
// pause audio player when  playedUntilEnd and reload next song or previous song
         self.audioPlayer.pause()
            if let url = self.audioURL {
                let item = DefaultAudioItem(audioUrl: url, sourceType: .stream)
                try? self.audioPlayer.load(item: item, playWhenReady: false)
            }
        case .playerStopped:
            self.audioPlayer.stop()
            self.stopLoader()
        case .skippedToNext:
            self.stopLoader()
        case .skippedToPrevious:
            self.stopLoader()
        case .jumpedToIndex:
            self.stopLoader()
        }
    }
}

var isAudioStops : Bool = false

@IBAction func onClick_playAudioBtnTapped(_ sender: UIButton) {
 if isAudioStops == true{
   if let url = self.audioURL {
        let item = DefaultAudioItem(audioUrl: url, sourceType: .stream)
        try? self.audioPlayer.load(item: item, playWhenReady: true)
        self.playPauseBtn.setImage(UIImage(named: "ic_audio_pause"), for: .normal)
        self.scaleInBookCover(isFirstLoad: false)
        self.nowPlayingImageView.startAnimating()
    }
  isAudioStops = false
}else{
if !audioSessionController.audioSessionIsActive {
try? audioSessionController.activateSession()
}
audioPlayer.togglePlaying()
 }
}
@IBAction func onClick_stopBtnTapped(_ sender: UIButton) {
self.audioPlayer.stop()
self.nowPlayingImageView.stopAnimating()
self.isAudioStops = true // bool true
}

func handlePlayEnd(data: AudioPlayer.PlaybackEndEventData) {
    DispatchQueue.main.async {
        switch data {
        case .playedUntilEnd:
            self.isAudioStops = true // bool true
        case .playerStopped:
            self.audioPlayer.stop()
            self.stopLoader()
        case .skippedToNext:
            self.stopLoader()
        case .skippedToPrevious:
            self.stopLoader()
        case .jumpedToIndex:
            self.stopLoader()
        }
    }
}