当我锁定屏幕时，Android 上的 OpenSL 音频停止 5.0.1 OK 6.0.1 Not OK

Question

我制作了一个安卓应用，可以从本地 wifi 网络传输语音。为了收听和串流，我使用 JNI 中的 Opus C API 进行解码，并使用 OpenSL Audio 进行读取。

我像这样从 Service 调用 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;
}

效果很好，当我点击我的按钮时，这个服务被调用，我的安卓智能手机发出声音。

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

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

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

对于 JNI OpenSL，我使用以下 sn-p 代码：

调用我的 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);
}

有什么想法吗？！感谢战利品！

编辑：在 Android 5.0.1 上有效，在 Android 6.0.1 上无效？！为什么？？

EDIT2：我的权限

  <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"

编辑 3：我不录音，我只听

编辑 4：在我锁定屏幕时，在 Android Marshmallow (Samsung S5) 上设置权限后，RECORD AUDIO，没有变化，我的应用就像静音！

Answer 1

我认为您的权限在 6.0 及更高版本的 android 版本中过期，因此如果您的权限处于危险权限中，请检查您的权限，然后动态授予它。