Android上的OpenSL音频在我锁定屏幕时停止5.0.1正常6.0.1不正常

我制作了一个android应用程序，可以从本地wifi网络传输语音。为了监听和流媒体，我使用JNI中的Opus C API进行解码，并使用OpenSL音频进行读取

我从服务中调用JNI，就像这样

    public class StreamService extends Service {

        private NativeReceiver mNativeReceiver;
...

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // Gérer la requête
        mNativeReceiver = new NativeReceiver();
        mCanPlay = mNativeReceiver.init();
            mNativeReceiver.startNativeReceiver();
    ...        
    return Service.START_NOT_STICKY;
}

它工作得非常好，当我点击我的按钮时，这个服务被调用，我从我的android智能手机中听到声音

但是，当我锁定我的智能手机屏幕时，声音就像“静音”，当我解锁声音播放时。仅在6.0.X上，不在5.0.X上

所以我的第一个想法是网络数据包停止了，我进行了调试，我的智能手机继续接收网络数据包

我的服务正在运行，只是声音被静音了

对于JNI OpenSL，我使用以下代码片段：

要调用我的JNI：

public void startNativeReceiver() {
    new Thread(new Runnable() {
        @Override
        public void run() {
                // set priority
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
                 start();
           }
        }).start();
    }

这就叫：

   const int queue_elements_num = 20;
    const int start_after = 4;
    SpscCircularQueue *queue = NULL;

    OpusDecoder *opus_dec = NULL;
    uint32_t samplerate = 24000;
    float frame_length = 20;

    bool player_initialized = false;
    bool player_started = false;
    int frames_in_queue = 0;

    while (!rcv_th_terminate) {
        ssize_t rcv_len = read(udp_sock, rcv_buf, sizeof(rcv_buf));
        if (rcv_len <= 0) {
            __android_log_print(ANDROID_LOG_WARN, "SMPlayer",
                            "Failed to receive UDP data");
            continue;
        }
        __android_log_print(ANDROID_LOG_INFO, "SMPlayer",
                            "reading");
        if (!player_initialized) {
            if (rcv_buf[0] != 0x01) {
                __android_log_print(ANDROID_LOG_ERROR, "SMPlayer",
                                    "Unsupported version of SMPlayer "
                                    "streaming protocol");
                return NULL;
            }
            /* initialize decoder */
            int opus_err = 0;
            opus_dec = opus_decoder_create(samplerate, 1, &opus_err);
            if (!opus_dec) {
                __android_log_print(ANDROID_LOG_ERROR, "SMPlayer",
                                    "unable to initialize OPUS decoder, "
                                    "error code - %d", opus_err);
                return NULL;
            }

            /* initialize circular queue */
            uint32_t frame_buf_size = samplerate / 1000 * frame_length * 2;
            queue = spsc_circular_queue_alloc(queue_elements_num, frame_buf_size);
            if (!queue) {
                __android_log_print(ANDROID_LOG_ERROR, "SMPlayer",
                                    "unable to allocate SPSC Circular Queue");
                opus_decoder_destroy(opus_dec);
                return NULL;
            }

            /* initialize the play and start the playback */
            osl_player_init(queue, samplerate);
            player_initialized = true;
        } else {
            int dec_samples = opus_decode(opus_dec, rcv_buf + 2, rcv_len - 2,
                                        (int16_t *)dec_buf, sizeof(dec_buf), 0);
            if (dec_samples <= 0) {
                __android_log_print(ANDROID_LOG_ERROR, "SMPlayer",
                                    "failed to decode the data");
                osl_player_terminate();
                spsc_circular_queue_free(queue);
                opus_decoder_destroy(opus_dec);
                exit(EXIT_FAILURE);
            }

            while (!spsc_circular_queue_push(queue, dec_buf) && !rcv_th_terminate)
                usleep((useconds_t)(frame_length * 1000.0));

            if (!player_started) {
                frames_in_queue++;

                if (frames_in_queue == start_after) {
                    osl_player_jumpstart(queue);
                    player_started = true;
                }
            }
        }
    }

    osl_player_terminate();

    if (empty_buf_cnt)
        __android_log_print(ANDROID_LOG_DEBUG, "SMPlayer",
                            "Empty buffers played: %" PRIu64, empty_buf_cnt);

    spsc_circular_queue_free(queue);
    opus_decoder_destroy(opus_dec);
}

const int queue\u elements\u num=20；
const int start_after=4；
SpscCircularQueue*队列=NULL；
OpusDecoder*opus_dec=NULL；
uint32_t采样器=24000；
浮动框架长度=20；
bool player_initialized=false；
bool player_start=false；
队列中的整数帧=0；
而（！rcv_th_终止）{
ssize_t rcv_len=read（udp_sock，rcv_buf，sizeof（rcv_buf））；
如果（rcv_len我认为您的权限在6.0及更高版本的android中过期，因此如果您的权限处于危险权限，请检查您的权限，然后动态授予它。
我不理解您处理的权限？在我的清单中？查看此项检查您的权限并添加所需的权限。录制音频是一种危险的permission…你需要在运行时添加它来修复Marshmallow我添加它来尝试，但我不认为我需要此权限，因为我不录制，但只通过wifi网络收听，但我会快速尝试；）我设置了权限，我录制了音频，但没有区别！
  <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

    <application
        android:allowBackup="true"