android - samsung - Grabación de llamadas con OpenSL

grabador de llamadas apk

Question

Intento arreglar la grabación de llamadas en mi aplicación desde la actualización de lolipop en mi Galaxy S5. Como base, estoy usando el proyecto de muestra de Google desde aquí: Muestra .

Y esta es la parte principal del código:

AudioRecorder :: AudioRecorder (SampleFormat * sampleFormat, SLEngineItf slEngine): freeQueue_ (nullptr), recQueue_ (nullptr), devShadowQueue_ (nullptr), callback_ (nullptr)

SLresult result;
sampleInfo_ = *sampleFormat;
SLAndroidDataFormat_PCM_EX format_pcm;
ConvertToSLSampleFormat(&format_pcm, &sampleInfo_);

gFp = fopen("/storage/emulated/0/file.pcm", "w");

// configure audio source
SLDataLocator_IODevice loc_dev = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT,
                                  SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
SLDataSource audioSrc = {&loc_dev, NULL};


// configure audio sink
SLDataLocator_AndroidSimpleBufferQueue loc_bq = {
        SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
        DEVICE_SHADOW_BUFFER_QUEUE_LEN};

SLDataSink audioSnk = {&loc_bq, &format_pcm};

// create audio recorder
// (requires the RECORD_AUDIO permission)
const SLInterfaceID id[2] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                             SL_IID_ANDROIDCONFIGURATION};

const SLboolean req[2] = {SL_BOOLEAN_FALSE, SL_BOOLEAN_FALSE};

result = (*slEngine)->CreateAudioRecorder(slEngine,
                                          &recObjectItf_,
                                          &audioSrc,
                                          &audioSnk,
                                          2,
                                          id, req);
SLASSERT(result);

// Configure the voice recognition preset which has no
// signal processing for lower latency.
SLAndroidConfigurationItf inputConfig;
result = (*recObjectItf_)->GetInterface(recObjectItf_,
                                        SL_IID_ANDROIDCONFIGURATION,
                                        &inputConfig);

SLuint32 presetValue = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
result = (*inputConfig)->SetConfiguration(inputConfig,
                                          SL_ANDROID_KEY_RECORDING_PRESET,
                                          &presetValue,
                                          sizeof(SLint32));
SLASSERT(result);


result = (*recObjectItf_)->Realize(recObjectItf_, SL_BOOLEAN_FALSE);
SLASSERT(result);

result = (*recObjectItf_)->GetInterface(recObjectItf_, SL_IID_RECORD, &recItf_);
SLASSERT(result);

result = (*recObjectItf_)->GetInterface(recObjectItf_, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                                        &recBufQueueItf_);
SLASSERT(result);

result = (*recBufQueueItf_)->RegisterCallback(recBufQueueItf_, bqRecorderCallback, this);
SLASSERT(result);

devShadowQueue_ = new AudioQueue(DEVICE_SHADOW_BUFFER_QUEUE_LEN);
assert(devShadowQueue_);

Y aquí está mi problema: este código no registra el otro lado de la llamada, en el archivo de salida solo puedo escuchar la voz desde el micrófono. Traté de cambiar los parámetros pero con el mismo resultado. ¿Alguien sabe lo que estoy haciendo mal?

Answer 1

Encontré la solución para arreglar la grabación de llamadas de Galaxy S5.

Lo principal es llamar a esto: status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) en el ciclo cuando se inicia la llamada.

Primero obtén la función deseada:

open_media = dlopen("/system/lib/libmedia.so", RTLD_LAZY);

set_parameters = (int (*)(int, void *)) dlsym(open_media,
                                                  "_ZN7android11AudioSystem13setParametersEiRKNS_7String8E");

Luego necesitamos audio_io_handle_t y String8& object:

1. audio_io_handle_t - es la ID de la sesión de audio aumentada en 1, puede obtenerla desde AudioRecord.getAudioSessionId

2. String8& esto es más difícil:

   //First inicialize function 
   create_string = (void (*)(void *, const char *)) dlsym(open_util, 
   "_ZN7android7String8C2EPKc");
   
   //next call this function to convert string to required object 
   create_string(&str8, str);

Cuando tenemos todas las partes necesarias, podemos llamar a la función setParameters:

//remember to call this in loop when recording is starting
set_parameters(id + 1, &str8);

Que cómo se ve la declaración de variables:

int (*set_parameters)(int, void *);

void (*create_string)(void *, const char *);

void *str8 = 0;
const char *str = "input_source=4";

@ChanchalShelar

@Peter @AkshatVajpayee

Así es como se ve mi archivo .cpp:

void *open_media;
void *open_util;

int (*set_parameters)(int, void *);

void (*create_string)(void *, const char *);

void *str8 = 0;
const char *str = "input_source=4";


extern "C" {
    JNIEXPORT bool JNICALL
    Java_com_sample_NativeAudio_init(JNIEnv *env, jclass);
    JNIEXPORT int JNICALL
    Java_com_sample_NativeAudio_setParameters(JNIEnv *env, jclass, int id);
}


void get_string8() {
    create_string = (void (*)(void *, const char *)) dlsym(open_util, "_ZN7android7String8C2EPKc");

    if (!create_string) {
        LOGD("There is no create_string function");
    } else {
        LOGD("create_string function OK");
    }

    create_string(&str8, str);
    if (!str8) {
        LOGD("Filed to create str8");
    } else {
        LOGD("create str8 success");
    }

}

JNIEXPORT int JNICALL Java_com_sample_NativeAudio_setParameters(JNIEnv *env,
                                                                  jclass     type, int id) {
    if (set_parameters) {
        return set_parameters(id + 1, &str8);
    }

    return 0;
}


JNIEXPORT bool JNICALL Java_com_sample_NativeAudio_init(JNIEnv *env, jclass type) {

    open_util = dlopen("/system/lib/libutils.so", RTLD_LAZY);

    if (open_util) {
        get_string8();
    } else {
        return false;
    }

    open_media = dlopen("/system/lib/libmedia.so", RTLD_LAZY);

    if (open_media) {
        set_parameters = (int (*)(int, void *)) dlsym(open_media,
                                              "_ZN7android11AudioSystem13setParametersEiRKNS_7String8E");
    } else {
        return false;
    }

    return true;
}

Answer 2

Necesitas usar ndk. Aquí hay ejemplos de las funciones que deben hacerse.

Carga libmedia.so y libutils.so

int load(JNIEnv *env, jobject thiz) {
    void *handleLibMedia;
    void *handleLibUtils;
    int result = -1;
    lspr func = NULL;

    pthread_t newthread = (pthread_t) thiz;

    handleLibMedia = dlopen("libmedia.so", RTLD_NOW | RTLD_GLOBAL);
    if (handleLibMedia != NULL) {
        func = dlsym(handleLibMedia, "_ZN7android11AudioSystem13setParametersEiRKNS_7String8E");
        if (func != NULL) {
            result = 0;
        }
        audioSetParameters = (lasp) func;
    } else {
        result = -1;
    }

    handleLibUtils = dlopen("libutils.so", RTLD_NOW | RTLD_GLOBAL);
    if (handleLibUtils != NULL) {
        fstr = dlsym(handleLibUtils, "_ZN7android7String8C2EPKc");
        if (fstr == NULL) {
            result = -1;
        }
    } else {
        result = -1;
    }

    cmd = CM_D;

    int resultTh = pthread_create(&newthread, NULL, taskAudioSetParam, NULL);

    return result;}

Función setParameters

int setParam(jint i, jint as) {
pthread_mutex_lock(&mt);

audioSession = (int) (as + 1);

kvp = "input_source=4";
kvps = toString8(kvp);

cmd = (int) i;

pthread_cond_signal(&cnd);
pthread_mutex_unlock(&mt);

return 0;}

Task AudioSetParameters

void *taskAudioSetParam(void *threadid) {
    while (1) {
        pthread_mutex_lock(&mt);
        if (cmd == CM_D) {
            pthread_cond_wait(&cnd, &mt);
        } else if (audioSetParameters != NULL) {
             audioSetParameters(audioSession, kvps);
        }
        pthread_mutex_unlock(&mt);
    }
}

Hay una biblioteca y un ejemplo de uso https://github.com/ViktorDegtyarev/CallRecLib