From 4b107fa0fa009d3f18f0a3aff0213a85591f6c27 Mon Sep 17 00:00:00 2001 From: Anton Utkin Date: Fri, 9 Jun 2023 17:54:09 +0300 Subject: [PATCH 1/3] [media]: refactoring AudioSystem.cpp to C++ style * goto operator is removed. In C++ there is no need for goto usage, RAII idiom is the replacement for goto. * C++ has smart pointers for automatic memory management. There is no need for using calloc(), realloc(). Test: Every API was called from priv-app and success operation result was returned Merged-In: I6e61ba1cd8ce279a69389e7cc66f7961d92f8c35 Change-Id: I6e61ba1cd8ce279a69389e7cc66f7961d92f8c35 --- core/jni/android_media_AudioSystem.cpp | 555 ++++++++++--------------- 1 file changed, 211 insertions(+), 344 deletions(-) diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp index 56c2a8647168b..7c03a4fbeaa25 100644 --- a/core/jni/android_media_AudioSystem.cpp +++ b/core/jni/android_media_AudioSystem.cpp @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -1023,22 +1024,18 @@ static jint convertAudioPortConfigToNativeWithDevicePort(JNIEnv *env, return jStatus; } -static jint convertAudioPortConfigFromNative(JNIEnv *env, - jobject jAudioPort, - jobject *jAudioPortConfig, - const struct audio_port_config *nAudioPortConfig) -{ - jint jStatus = AUDIO_JAVA_SUCCESS; - jobject jAudioGainConfig = NULL; - jobject jAudioGain = NULL; +static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRef *jAudioPort, + ScopedLocalRef *jAudioPortConfig, + const struct audio_port_config *nAudioPortConfig) { jintArray jGainValues; bool audioportCreated = false; ALOGV("convertAudioPortConfigFromNative jAudioPort %p", jAudioPort); - if (jAudioPort == NULL) { - jobject jHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, - nAudioPortConfig->id); + if (*jAudioPort == nullptr) { + ScopedLocalRef jHandle(env, + env->NewObject(gAudioHandleClass, gAudioHandleCstor, + nAudioPortConfig->id)); ALOGV("convertAudioPortConfigFromNative handle %d is a %s", nAudioPortConfig->id, nAudioPortConfig->type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix"); @@ -1050,17 +1047,17 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, // and configuration data. The actual AudioPortConfig objects will be // constructed by java code with correct class type (device, mix etc...) // and reference to AudioPort instance in this client - jAudioPort = env->NewObject(gAudioPortClass, gAudioPortCstor, - jHandle, // handle - 0, // role - NULL, // name - NULL, // samplingRates - NULL, // channelMasks - NULL, // channelIndexMasks - NULL, // formats - NULL); // gains - env->DeleteLocalRef(jHandle); - if (jAudioPort == NULL) { + jAudioPort->reset(env->NewObject(gAudioPortClass, gAudioPortCstor, + jHandle.get(), // handle + 0, // role + NULL, // name + NULL, // samplingRates + NULL, // channelMasks + NULL, // channelIndexMasks + NULL, // formats + NULL)); // gains + + if (*jAudioPort == nullptr) { return (jint)AUDIO_JAVA_ERROR; } ALOGV("convertAudioPortConfigFromNative jAudioPort created for handle %d", @@ -1069,6 +1066,9 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, audioportCreated = true; } + ScopedLocalRef jAudioGainConfig(env, nullptr); + ScopedLocalRef jAudioGain(env, nullptr); + bool useInMask = audio_port_config_has_input_direction(nAudioPortConfig); audio_channel_mask_t nMask; @@ -1082,36 +1082,26 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, gainIndex, nAudioPortConfig->gain.mode); if (audioportCreated) { ALOGV("convertAudioPortConfigFromNative creating gain"); - jAudioGain = env->NewObject(gAudioGainClass, gAudioGainCstor, - gainIndex, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0); + jAudioGain.reset(env->NewObject(gAudioGainClass, gAudioGainCstor, gainIndex, 0, 0, 0, 0, + 0, 0, 0, 0)); if (jAudioGain == NULL) { ALOGV("convertAudioPortConfigFromNative creating gain FAILED"); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return AUDIO_JAVA_ERROR; } } else { ALOGV("convertAudioPortConfigFromNative reading gain from port"); - jobjectArray jGains = (jobjectArray)env->GetObjectField(jAudioPort, - gAudioPortFields.mGains); + ScopedLocalRef jGains(env, + (jobjectArray)env + ->GetObjectField(jAudioPort->get(), + gAudioPortFields.mGains)); if (jGains == NULL) { ALOGV("convertAudioPortConfigFromNative could not get gains from port"); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } - jAudioGain = env->GetObjectArrayElement(jGains, gainIndex); - env->DeleteLocalRef(jGains); + jAudioGain.reset(env->GetObjectArrayElement(jGains.get(), gainIndex)); if (jAudioGain == NULL) { ALOGV("convertAudioPortConfigFromNative could not get gain at index %d", gainIndex); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } } int numValues; @@ -1123,8 +1113,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, jGainValues = env->NewIntArray(numValues); if (jGainValues == NULL) { ALOGV("convertAudioPortConfigFromNative could not create gain values %d", numValues); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } env->SetIntArrayRegion(jGainValues, 0, numValues, nAudioPortConfig->gain.values); @@ -1138,19 +1127,14 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask); } - jAudioGainConfig = env->NewObject(gAudioGainConfigClass, - gAudioGainConfigCstor, - gainIndex, - jAudioGain, - nAudioPortConfig->gain.mode, - jMask, - jGainValues, - nAudioPortConfig->gain.ramp_duration_ms); + jAudioGainConfig.reset(env->NewObject(gAudioGainConfigClass, gAudioGainConfigCstor, + gainIndex, jAudioGain.get(), + nAudioPortConfig->gain.mode, jMask, jGainValues, + nAudioPortConfig->gain.ramp_duration_ms)); env->DeleteLocalRef(jGainValues); if (jAudioGainConfig == NULL) { ALOGV("convertAudioPortConfigFromNative could not create gain config"); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } } jclass clazz; @@ -1160,17 +1144,16 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, methodID = gAudioPortConfigCstor; ALOGV("convertAudioPortConfigFromNative building a generic port config"); } else { - if (env->IsInstanceOf(jAudioPort, gAudioDevicePortClass)) { + if (env->IsInstanceOf(jAudioPort->get(), gAudioDevicePortClass)) { clazz = gAudioDevicePortConfigClass; methodID = gAudioDevicePortConfigCstor; ALOGV("convertAudioPortConfigFromNative building a device config"); - } else if (env->IsInstanceOf(jAudioPort, gAudioMixPortClass)) { + } else if (env->IsInstanceOf(jAudioPort->get(), gAudioMixPortClass)) { clazz = gAudioMixPortConfigClass; methodID = gAudioMixPortConfigCstor; ALOGV("convertAudioPortConfigFromNative building a mix config"); } else { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } } nMask = (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) @@ -1184,8 +1167,8 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ALOGV("convertAudioPortConfigFromNative OUT mask java %x native %x", jMask, nMask); } - *jAudioPortConfig = - env->NewObject(clazz, methodID, jAudioPort, + jAudioPortConfig->reset( + env->NewObject(clazz, methodID, jAudioPort->get(), (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) ? nAudioPortConfig->sample_rate : AUDIO_CONFIG_BASE_INITIALIZER.sample_rate, @@ -1194,31 +1177,14 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, (nAudioPortConfig->config_mask & AUDIO_PORT_CONFIG_FORMAT) ? nAudioPortConfig->format : AUDIO_CONFIG_BASE_INITIALIZER.format), - jAudioGainConfig); + jAudioGainConfig.get())); if (*jAudioPortConfig == NULL) { ALOGV("convertAudioPortConfigFromNative could not create new port config"); - jStatus = (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } else { ALOGV("convertAudioPortConfigFromNative OK"); } - -exit: - if (audioportCreated) { - env->DeleteLocalRef(jAudioPort); - if (jAudioGain != NULL) { - env->DeleteLocalRef(jAudioGain); - } - } - if (jAudioGainConfig != NULL) { - env->DeleteLocalRef(jAudioGainConfig); - } - return jStatus; -} - -// TODO: pull out to separate file -template -static constexpr size_t array_size(const T (&)[N]) { - return N; + return AUDIO_JAVA_SUCCESS; } static jintArray convertEncapsulationInfoFromNative(JNIEnv *env, uint32_t encapsulationInfo) { @@ -1240,8 +1206,8 @@ static bool isAudioPortArrayCountOutOfBounds(const struct audio_port_v7 *nAudioP std::stringstream &ss) { ss << " num_audio_profiles " << nAudioPort->num_audio_profiles << " num_gains " << nAudioPort->num_gains; - if (nAudioPort->num_audio_profiles > array_size(nAudioPort->audio_profiles) || - nAudioPort->num_gains > array_size(nAudioPort->gains)) { + if (nAudioPort->num_audio_profiles > std::size(nAudioPort->audio_profiles) || + nAudioPort->num_gains > std::size(nAudioPort->gains)) { return true; } for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) { @@ -1249,9 +1215,9 @@ static bool isAudioPortArrayCountOutOfBounds(const struct audio_port_v7 *nAudioP << " num_sample_rates " << nAudioPort->audio_profiles[i].num_sample_rates << " num_channel_masks " << nAudioPort->audio_profiles[i].num_channel_masks; if (nAudioPort->audio_profiles[i].num_sample_rates > - array_size(nAudioPort->audio_profiles[i].sample_rates) || + std::size(nAudioPort->audio_profiles[i].sample_rates) || nAudioPort->audio_profiles[i].num_channel_masks > - array_size(nAudioPort->audio_profiles[i].channel_masks)) { + std::size(nAudioPort->audio_profiles[i].channel_masks)) { return true; } } @@ -1322,18 +1288,8 @@ static jint convertAudioProfileFromNative(JNIEnv *env, jobject *jAudioProfile, return AUDIO_JAVA_SUCCESS; } -static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, +static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAudioPort, const struct audio_port_v7 *nAudioPort) { - jint jStatus = (jint)AUDIO_JAVA_SUCCESS; - jintArray jEncapsulationModes = NULL; - jintArray jEncapsulationMetadataTypes = NULL; - jobjectArray jGains = NULL; - jobject jHandle = NULL; - jobject jAudioPortConfig = NULL; - jstring jDeviceName = NULL; - jobject jAudioProfiles = NULL; - jobject jAudioDescriptors = nullptr; - ScopedLocalRef jPcmFloatProfileFromExtendedInteger(env, nullptr); bool hasFloat = false; bool useInMask; @@ -1357,19 +1313,21 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, } else { ALOGE("%s", s.c_str()); } - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } useInMask = audio_has_input_direction(nAudioPort->type, nAudioPort->role); - jAudioProfiles = env->NewObject(gArrayListClass, gArrayListMethods.cstor); + ScopedLocalRef jAudioProfiles(env, + env->NewObject(gArrayListClass, + gArrayListMethods.cstor)); if (jAudioProfiles == nullptr) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } + ScopedLocalRef jPcmFloatProfileFromExtendedInteger(env, nullptr); for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) { jobject jAudioProfile = nullptr; + jint jStatus = AUDIO_JAVA_SUCCESS; jStatus = convertAudioProfileFromNative(env, &jAudioProfile, &nAudioPort->audio_profiles[i], useInMask); if (jStatus == AUDIO_JAVA_BAD_VALUE) { @@ -1377,10 +1335,9 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, continue; } if (jStatus != NO_ERROR) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } - env->CallBooleanMethod(jAudioProfiles, gArrayListMethods.add, jAudioProfile); + env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jAudioProfile); if (nAudioPort->audio_profiles[i].format == AUDIO_FORMAT_PCM_FLOAT) { hasFloat = true; @@ -1421,14 +1378,15 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, // (replacing the zero pad). This ensures pre-S apps that look // for ENCODING_PCM_FLOAT continue to see that encoding if the device supports // extended precision integers. - env->CallBooleanMethod(jAudioProfiles, gArrayListMethods.add, + env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jPcmFloatProfileFromExtendedInteger.get()); } - jAudioDescriptors = env->NewObject(gArrayListClass, gArrayListMethods.cstor); + ScopedLocalRef jAudioDescriptors(env, + env->NewObject(gArrayListClass, + gArrayListMethods.cstor)); if (jAudioDescriptors == nullptr) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } for (size_t i = 0; i < nAudioPort->num_extra_audio_descriptors; ++i) { const auto &extraAudioDescriptor = nAudioPort->extra_audio_descriptors[i]; @@ -1458,15 +1416,16 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, env->NewObject(gAudioDescriptorClass, gAudioDescriptorCstor, standard, encapsulationType, jDescriptor.get())); - env->CallBooleanMethod(jAudioDescriptors, gArrayListMethods.add, jAudioDescriptor.get()); + env->CallBooleanMethod(jAudioDescriptors.get(), gArrayListMethods.add, + jAudioDescriptor.get()); } // gains - jGains = env->NewObjectArray(nAudioPort->num_gains, - gAudioGainClass, NULL); - if (jGains == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + ScopedLocalRef jGains(env, + env->NewObjectArray(nAudioPort->num_gains, gAudioGainClass, + NULL)); + if (jGains == nullptr) { + return (jint)AUDIO_JAVA_ERROR; } for (size_t j = 0; j < nAudioPort->num_gains; j++) { @@ -1491,88 +1450,71 @@ static jint convertAudioPortFromNative(JNIEnv *env, jobject *jAudioPort, nAudioPort->gains[j].min_ramp_ms, nAudioPort->gains[j].max_ramp_ms); if (jGain == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } - env->SetObjectArrayElement(jGains, j, jGain); + env->SetObjectArrayElement(jGains.get(), j, jGain); env->DeleteLocalRef(jGain); } - jHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, - nAudioPort->id); - if (jHandle == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + ScopedLocalRef jHandle(env, + env->NewObject(gAudioHandleClass, gAudioHandleCstor, + nAudioPort->id)); + if (jHandle == nullptr) { + return (jint)AUDIO_JAVA_ERROR; } - jDeviceName = env->NewStringUTF(nAudioPort->name); - + ScopedLocalRef jDeviceName(env, env->NewStringUTF(nAudioPort->name)); if (nAudioPort->type == AUDIO_PORT_TYPE_DEVICE) { - ALOGV("convertAudioPortFromNative is a device %08x", nAudioPort->ext.device.type); - jstring jAddress = env->NewStringUTF(nAudioPort->ext.device.address); - jEncapsulationModes = - convertEncapsulationInfoFromNative(env, nAudioPort->ext.device.encapsulation_modes); - jEncapsulationMetadataTypes = + ScopedLocalRef jEncapsulationModes( + env, + convertEncapsulationInfoFromNative(env, + nAudioPort->ext.device.encapsulation_modes)); + ScopedLocalRef jEncapsulationMetadataTypes( + env, convertEncapsulationInfoFromNative(env, nAudioPort->ext.device - .encapsulation_metadata_types); - *jAudioPort = - env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, jHandle, jDeviceName, - jAudioProfiles, jGains, nAudioPort->ext.device.type, jAddress, - jEncapsulationModes, jEncapsulationMetadataTypes, jAudioDescriptors); + .encapsulation_metadata_types)); + ALOGV("convertAudioPortFromNative is a device %08x", nAudioPort->ext.device.type); + jstring jAddress = env->NewStringUTF(nAudioPort->ext.device.address); + jAudioPort->reset( + env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, jHandle.get(), + jDeviceName.get(), jAudioProfiles.get(), jGains.get(), + nAudioPort->ext.device.type, jAddress, jEncapsulationModes.get(), + jEncapsulationMetadataTypes.get(), jAudioDescriptors.get())); env->DeleteLocalRef(jAddress); } else if (nAudioPort->type == AUDIO_PORT_TYPE_MIX) { ALOGV("convertAudioPortFromNative is a mix"); - *jAudioPort = env->NewObject(gAudioMixPortClass, gAudioMixPortCstor, jHandle, - nAudioPort->ext.mix.handle, nAudioPort->role, jDeviceName, - jAudioProfiles, jGains); + jAudioPort->reset(env->NewObject(gAudioMixPortClass, gAudioMixPortCstor, jHandle.get(), + nAudioPort->ext.mix.handle, nAudioPort->role, + jDeviceName.get(), jAudioProfiles.get(), jGains.get())); } else { ALOGE("convertAudioPortFromNative unknown nAudioPort type %d", nAudioPort->type); - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } if (*jAudioPort == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + return (jint)AUDIO_JAVA_ERROR; } - jStatus = convertAudioPortConfigFromNative(env, - *jAudioPort, - &jAudioPortConfig, + ScopedLocalRef jAudioPortConfig(env, nullptr); + + if (int jStatus = convertAudioPortConfigFromNative(env, jAudioPort, &jAudioPortConfig, &nAudioPort->active_config); - if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + jStatus != AUDIO_JAVA_SUCCESS) { + return jStatus; } - env->SetObjectField(*jAudioPort, gAudioPortFields.mActiveConfig, jAudioPortConfig); + env->SetObjectField(jAudioPort->get(), gAudioPortFields.mActiveConfig, jAudioPortConfig.get()); + return AUDIO_JAVA_SUCCESS; +} -exit: - if (jDeviceName != NULL) { - env->DeleteLocalRef(jDeviceName); +static bool setGeneration(JNIEnv *env, jintArray jGeneration, unsigned int generation1) { + ScopedIntArrayRW nGeneration(env, jGeneration); + if (nGeneration.get() == nullptr) { + return false; + } else { + nGeneration[0] = generation1; + return true; } - if (jEncapsulationModes != NULL) { - env->DeleteLocalRef(jEncapsulationModes); - } - if (jEncapsulationMetadataTypes != NULL) { - env->DeleteLocalRef(jEncapsulationMetadataTypes); - } - if (jAudioProfiles != NULL) { - env->DeleteLocalRef(jAudioProfiles); - } - if (jGains != NULL) { - env->DeleteLocalRef(jGains); - } - if (jHandle != NULL) { - env->DeleteLocalRef(jHandle); - } - if (jAudioPortConfig != NULL) { - env->DeleteLocalRef(jAudioPortConfig); - } - if (jAudioDescriptors != nullptr) { - env->DeleteLocalRef(jAudioDescriptors); - } - - return jStatus; } static jint @@ -1598,8 +1540,7 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz, unsigned int generation1; unsigned int generation; unsigned int numPorts; - jint *nGeneration; - struct audio_port_v7 *nPorts = nullptr; + std::vector nPorts; int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS; jint jStatus; @@ -1618,43 +1559,39 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz, break; } if (numPorts == 0) { - jStatus = (jint)AUDIO_JAVA_SUCCESS; - goto exit; + return setGeneration(env, jGeneration, generation1) ? AUDIO_JAVA_SUCCESS + : AUDIO_JAVA_ERROR; } - nPorts = (struct audio_port_v7 *)realloc(nPorts, numPorts * sizeof(struct audio_port_v7)); + nPorts.resize(numPorts); status = AudioSystem::listAudioPorts(AUDIO_PORT_ROLE_NONE, AUDIO_PORT_TYPE_NONE, &numPorts, - nPorts, &generation); + &nPorts[0], &generation); ALOGV("listAudioPorts AudioSystem::listAudioPorts numPorts %d generation %d generation1 %d", numPorts, generation, generation1); } while (generation1 != generation && status == NO_ERROR); jStatus = nativeToJavaStatus(status); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; + } + return jStatus; } for (size_t i = 0; i < numPorts; i++) { - jobject jAudioPort = NULL; + ScopedLocalRef jAudioPort(env, nullptr); jStatus = convertAudioPortFromNative(env, &jAudioPort, &nPorts[i]); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; - } - env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort); - if (jAudioPort != NULL) { - env->DeleteLocalRef(jAudioPort); + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; + } + return jStatus; } + env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort.get()); } - -exit: - nGeneration = env->GetIntArrayElements(jGeneration, NULL); - if (nGeneration == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - } else { - nGeneration[0] = generation1; - env->ReleaseIntArrayElements(jGeneration, nGeneration, 0); + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; } - free(nPorts); return jStatus; } @@ -1684,47 +1621,38 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, } audio_patch_handle_t handle = (audio_patch_handle_t)0; - jobject jPatch = env->GetObjectArrayElement(jPatches, 0); - jobject jPatchHandle = NULL; + ScopedLocalRef jPatch(env, env->GetObjectArrayElement(jPatches, 0)); + ScopedLocalRef jPatchHandle(env, nullptr); if (jPatch != NULL) { - if (!env->IsInstanceOf(jPatch, gAudioPatchClass)) { + if (!env->IsInstanceOf(jPatch.get(), gAudioPatchClass)) { return (jint)AUDIO_JAVA_BAD_VALUE; } - jPatchHandle = env->GetObjectField(jPatch, gAudioPatchFields.mHandle); - handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle, gAudioHandleFields.mId); + jPatchHandle.reset(env->GetObjectField(jPatch.get(), gAudioPatchFields.mHandle)); + handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle.get(), gAudioHandleFields.mId); } struct audio_patch nPatch = { .id = handle }; - jobject jSource = NULL; - jobject jSink = NULL; - for (jint i = 0; i < numSources; i++) { - jSource = env->GetObjectArrayElement(jSources, i); - if (!env->IsInstanceOf(jSource, gAudioPortConfigClass)) { - jStatus = (jint)AUDIO_JAVA_BAD_VALUE; - goto exit; + ScopedLocalRef jSource(env, env->GetObjectArrayElement(jSources, i)); + if (!env->IsInstanceOf(jSource.get(), gAudioPortConfigClass)) { + return (jint)AUDIO_JAVA_BAD_VALUE; } - jStatus = convertAudioPortConfigToNative(env, &nPatch.sources[i], jSource, false); - env->DeleteLocalRef(jSource); - jSource = NULL; + jStatus = convertAudioPortConfigToNative(env, &nPatch.sources[i], jSource.get(), false); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + return jStatus; } nPatch.num_sources++; } for (jint i = 0; i < numSinks; i++) { - jSink = env->GetObjectArrayElement(jSinks, i); - if (!env->IsInstanceOf(jSink, gAudioPortConfigClass)) { - jStatus = (jint)AUDIO_JAVA_BAD_VALUE; - goto exit; + ScopedLocalRef jSink(env, env->GetObjectArrayElement(jSinks, i)); + if (!env->IsInstanceOf(jSink.get(), gAudioPortConfigClass)) { + return (jint)AUDIO_JAVA_BAD_VALUE; } - jStatus = convertAudioPortConfigToNative(env, &nPatch.sinks[i], jSink, false); - env->DeleteLocalRef(jSink); - jSink = NULL; + jStatus = convertAudioPortConfigToNative(env, &nPatch.sinks[i], jSink.get(), false); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + return jStatus; } nPatch.num_sinks++; } @@ -1735,38 +1663,22 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, jStatus = nativeToJavaStatus(status); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + return jStatus; } - if (jPatchHandle == NULL) { - jPatchHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, - handle); - if (jPatchHandle == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + if (jPatchHandle == nullptr) { + jPatchHandle.reset(env->NewObject(gAudioHandleClass, gAudioHandleCstor, handle)); + if (jPatchHandle == nullptr) { + return (jint)AUDIO_JAVA_ERROR; } - jPatch = env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatchHandle, jSources, jSinks); - if (jPatch == NULL) { - jStatus = (jint)AUDIO_JAVA_ERROR; - goto exit; + jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatchHandle.get(), + jSources, jSinks)); + if (jPatch == nullptr) { + return (jint)AUDIO_JAVA_ERROR; } - env->SetObjectArrayElement(jPatches, 0, jPatch); + env->SetObjectArrayElement(jPatches, 0, jPatch.get()); } else { - env->SetIntField(jPatchHandle, gAudioHandleFields.mId, handle); - } - -exit: - if (jPatchHandle != NULL) { - env->DeleteLocalRef(jPatchHandle); - } - if (jPatch != NULL) { - env->DeleteLocalRef(jPatch); - } - if (jSource != NULL) { - env->DeleteLocalRef(jSource); - } - if (jSink != NULL) { - env->DeleteLocalRef(jSink); + env->SetIntField(jPatchHandle.get(), gAudioHandleFields.mId, handle); } return jStatus; } @@ -1818,13 +1730,7 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, unsigned int generation1; unsigned int generation; unsigned int numPatches; - jint *nGeneration; - struct audio_patch *nPatches = NULL; - jobjectArray jSources = NULL; - jobject jSource = NULL; - jobjectArray jSinks = NULL; - jobject jSink = NULL; - jobject jPatch = NULL; + std::vector nPatches; int attempts = MAX_PORT_GENERATION_SYNC_ATTEMPTS; jint jStatus; @@ -1845,15 +1751,13 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, break; } if (numPatches == 0) { - jStatus = (jint)AUDIO_JAVA_SUCCESS; - goto exit; + return setGeneration(env, jGeneration, generation1) ? AUDIO_JAVA_SUCCESS + : AUDIO_JAVA_ERROR; } - nPatches = (struct audio_patch *)realloc(nPatches, numPatches * sizeof(struct audio_patch)); + nPatches.resize(numPatches); - status = AudioSystem::listAudioPatches(&numPatches, - nPatches, - &generation); + status = AudioSystem::listAudioPatches(&numPatches, &nPatches[0], &generation); ALOGV("listAudioPatches AudioSystem::listAudioPatches numPatches %d generation %d generation1 %d", numPatches, generation, generation1); @@ -1861,15 +1765,21 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, jStatus = nativeToJavaStatus(status); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; + } + return jStatus; } for (size_t i = 0; i < numPatches; i++) { + ScopedLocalRef jPatch(env, nullptr); + ScopedLocalRef jSources(env, nullptr); + ScopedLocalRef jSinks(env, nullptr); jobject patchHandle = env->NewObject(gAudioHandleClass, gAudioHandleCstor, nPatches[i].id); if (patchHandle == NULL) { - jStatus = AUDIO_JAVA_ERROR; - goto exit; + setGeneration(env, jGeneration, generation1); + return AUDIO_JAVA_ERROR; } ALOGV("listAudioPatches patch %zu num_sources %d num_sinks %d", i, nPatches[i].num_sources, nPatches[i].num_sinks); @@ -1877,96 +1787,67 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, env->SetIntField(patchHandle, gAudioHandleFields.mId, nPatches[i].id); // load sources - jSources = env->NewObjectArray(nPatches[i].num_sources, - gAudioPortConfigClass, NULL); - if (jSources == NULL) { - jStatus = AUDIO_JAVA_ERROR; - goto exit; + jSources.reset(env->NewObjectArray(nPatches[i].num_sources, gAudioPortConfigClass, NULL)); + if (jSources == nullptr) { + setGeneration(env, jGeneration, generation1); + return AUDIO_JAVA_ERROR; } for (size_t j = 0; j < nPatches[i].num_sources; j++) { - jStatus = convertAudioPortConfigFromNative(env, - NULL, - &jSource, - &nPatches[i].sources[j]); + ScopedLocalRef jSource(env, nullptr); + ScopedLocalRef jAudioPort(env, nullptr); + jStatus = convertAudioPortConfigFromNative(env, &jAudioPort, &jSource, + &nPatches[i].sources[j]); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; + } + return jStatus; } - env->SetObjectArrayElement(jSources, j, jSource); - env->DeleteLocalRef(jSource); - jSource = NULL; + env->SetObjectArrayElement(jSources.get(), j, jSource.get()); ALOGV("listAudioPatches patch %zu source %zu is a %s handle %d", i, j, nPatches[i].sources[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix", nPatches[i].sources[j].id); } // load sinks - jSinks = env->NewObjectArray(nPatches[i].num_sinks, - gAudioPortConfigClass, NULL); - if (jSinks == NULL) { - jStatus = AUDIO_JAVA_ERROR; - goto exit; + jSinks.reset(env->NewObjectArray(nPatches[i].num_sinks, gAudioPortConfigClass, NULL)); + if (jSinks == nullptr) { + setGeneration(env, jGeneration, generation1); + return AUDIO_JAVA_ERROR; } for (size_t j = 0; j < nPatches[i].num_sinks; j++) { - jStatus = convertAudioPortConfigFromNative(env, - NULL, - &jSink, - &nPatches[i].sinks[j]); + ScopedLocalRef jSink(env, nullptr); + ScopedLocalRef jAudioPort(env, nullptr); + jStatus = convertAudioPortConfigFromNative(env, &jAudioPort, &jSink, + &nPatches[i].sinks[j]); if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + if (!setGeneration(env, jGeneration, generation1)) { + jStatus = AUDIO_JAVA_ERROR; + } + return jStatus; } - env->SetObjectArrayElement(jSinks, j, jSink); - env->DeleteLocalRef(jSink); - jSink = NULL; + env->SetObjectArrayElement(jSinks.get(), j, jSink.get()); ALOGV("listAudioPatches patch %zu sink %zu is a %s handle %d", i, j, nPatches[i].sinks[j].type == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix", nPatches[i].sinks[j].id); } - jPatch = env->NewObject(gAudioPatchClass, gAudioPatchCstor, - patchHandle, jSources, jSinks); - env->DeleteLocalRef(jSources); - jSources = NULL; - env->DeleteLocalRef(jSinks); - jSinks = NULL; - if (jPatch == NULL) { + jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, patchHandle, jSources.get(), + jSinks.get())); + if (jPatch == nullptr) { jStatus = AUDIO_JAVA_ERROR; - goto exit; + setGeneration(env, jGeneration, generation1); + return AUDIO_JAVA_ERROR; } - env->CallBooleanMethod(jPatches, gArrayListMethods.add, jPatch); - env->DeleteLocalRef(jPatch); - jPatch = NULL; + env->CallBooleanMethod(jPatches, gArrayListMethods.add, jPatch.get()); } - -exit: - - nGeneration = env->GetIntArrayElements(jGeneration, NULL); - if (nGeneration == NULL) { + if (!setGeneration(env, jGeneration, generation1)) { jStatus = AUDIO_JAVA_ERROR; - } else { - nGeneration[0] = generation1; - env->ReleaseIntArrayElements(jGeneration, nGeneration, 0); } - - if (jSources != NULL) { - env->DeleteLocalRef(jSources); - } - if (jSource != NULL) { - env->DeleteLocalRef(jSource); - } - if (jSinks != NULL) { - env->DeleteLocalRef(jSinks); - } - if (jSink != NULL) { - env->DeleteLocalRef(jSink); - } - if (jPatch != NULL) { - env->DeleteLocalRef(jPatch); - } - free(nPatches); return jStatus; } @@ -2207,21 +2088,16 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz, } status_t status; - jint jStatus; - jobject jAudioMix = NULL; Vector mixes; for (jint i = 0; i < numMixes; i++) { - jAudioMix = env->GetObjectArrayElement(jMixes, i); - if (!env->IsInstanceOf(jAudioMix, gAudioMixClass)) { - jStatus = (jint)AUDIO_JAVA_BAD_VALUE; - goto exit; + ScopedLocalRef jAudioMix(env, env->GetObjectArrayElement(jMixes, i)); + if (!env->IsInstanceOf(jAudioMix.get(), gAudioMixClass)) { + return (jint)AUDIO_JAVA_BAD_VALUE; } AudioMix mix; - jStatus = convertAudioMixToNative(env, &mix, jAudioMix); - env->DeleteLocalRef(jAudioMix); - jAudioMix = NULL; - if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; + if (jint jStatus = convertAudioMixToNative(env, &mix, jAudioMix.get()); + jStatus != AUDIO_JAVA_SUCCESS) { + return jStatus; } mixes.add(mix); } @@ -2230,16 +2106,7 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz, status = AudioSystem::registerPolicyMixes(mixes, registration); ALOGV("AudioSystem::registerPolicyMixes() returned %d", status); - jStatus = nativeToJavaStatus(status); - if (jStatus != AUDIO_JAVA_SUCCESS) { - goto exit; - } - -exit: - if (jAudioMix != NULL) { - env->DeleteLocalRef(jAudioMix); - } - return jStatus; + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_setUidDeviceAffinities(JNIEnv *env, jobject clazz, From 8e1146c0f120509daa35755d1518d5da735cc63c Mon Sep 17 00:00:00 2001 From: Anton Utkin Date: Tue, 13 Jun 2023 12:38:03 +0300 Subject: [PATCH 2/3] [media]: refactoring AudioSystem.cpp to C++ style, part 2 * get rid of C style casting, static_cast, reinterpret_cast and const_cast should be used instead. Test: m Merged-In: Ie4161bb9376ec6aabc45a5348226bbecf30ab775 Change-Id: Ie4161bb9376ec6aabc45a5348226bbecf30ab775 Signed-off-by: Anton Utkin --- core/jni/android_media_AudioSystem.cpp | 810 ++++++++++++------------- 1 file changed, 404 insertions(+), 406 deletions(-) diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp index 7c03a4fbeaa25..abd5416971de1 100644 --- a/core/jni/android_media_AudioSystem.cpp +++ b/core/jni/android_media_AudioSystem.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -266,7 +267,7 @@ JNIAudioPortCallback::JNIAudioPortCallback(JNIEnv* env, jobject thiz, jobject we ALOGE("Can't find class %s", kEventHandlerClassPathName); return; } - mClass = (jclass)env->NewGlobalRef(clazz); + mClass = static_cast(env->NewGlobalRef(clazz)); // We use a weak reference so the AudioPortEventHandler object can be garbage collected. // The reference is only used as a proxy for callbacks. @@ -318,15 +319,16 @@ static sp setJniCallback(JNIEnv* env, const sp& callback) { Mutex::Autolock l(gLock); - sp old = - (JNIAudioPortCallback*)env->GetLongField(thiz, gEventHandlerFields.mJniCallback); + sp old = reinterpret_cast( + env->GetLongField(thiz, gEventHandlerFields.mJniCallback)); if (callback.get()) { - callback->incStrong((void*)setJniCallback); + callback->incStrong(reinterpret_cast(setJniCallback)); } if (old != 0) { - old->decStrong((void*)setJniCallback); + old->decStrong(reinterpret_cast(setJniCallback)); } - env->SetLongField(thiz, gEventHandlerFields.mJniCallback, (jlong)callback.get()); + env->SetLongField(thiz, gEventHandlerFields.mJniCallback, + reinterpret_cast(callback.get())); return old; } @@ -355,43 +357,44 @@ static jint getVectorOfAudioDeviceTypeAddr(JNIEnv *env, jintArray deviceTypes, jobjectArray deviceAddresses, AudioDeviceTypeAddrVector &audioDeviceTypeAddrVector) { if (deviceTypes == nullptr || deviceAddresses == nullptr) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jsize deviceCount = env->GetArrayLength(deviceTypes); if (deviceCount == 0 || deviceCount != env->GetArrayLength(deviceAddresses)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } // retrieve all device types std::vector deviceTypesVector; jint *typesPtr = nullptr; typesPtr = env->GetIntArrayElements(deviceTypes, 0); if (typesPtr == nullptr) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } for (jint i = 0; i < deviceCount; i++) { - deviceTypesVector.push_back((audio_devices_t)typesPtr[i]); + deviceTypesVector.push_back(static_cast(typesPtr[i])); } // check each address is a string and add device type/address to list jclass stringClass = FindClassOrDie(env, "java/lang/String"); for (jint i = 0; i < deviceCount; i++) { jobject addrJobj = env->GetObjectArrayElement(deviceAddresses, i); if (!env->IsInstanceOf(addrJobj, stringClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } - const char *address = env->GetStringUTFChars((jstring)addrJobj, NULL); - AudioDeviceTypeAddr dev = AudioDeviceTypeAddr((audio_devices_t)typesPtr[i], address); + const char *address = env->GetStringUTFChars(static_cast(addrJobj), NULL); + AudioDeviceTypeAddr dev = + AudioDeviceTypeAddr(static_cast(typesPtr[i]), address); audioDeviceTypeAddrVector.push_back(dev); - env->ReleaseStringUTFChars((jstring)addrJobj, address); + env->ReleaseStringUTFChars(static_cast(addrJobj), address); } env->ReleaseIntArrayElements(deviceTypes, typesPtr, 0); - return (jint)NO_ERROR; + return NO_ERROR; } static jint android_media_AudioSystem_muteMicrophone(JNIEnv *env, jobject thiz, jboolean on) { - return (jint) check_AudioSystem_Command(AudioSystem::muteMicrophone(on)); + return check_AudioSystem_Command(AudioSystem::muteMicrophone(on)); } static jboolean @@ -406,7 +409,7 @@ static jboolean android_media_AudioSystem_isStreamActive(JNIEnv *env, jobject thiz, jint stream, jint inPastMs) { bool state = false; - AudioSystem::isStreamActive((audio_stream_type_t) stream, &state, inPastMs); + AudioSystem::isStreamActive(static_cast(stream), &state, inPastMs); return state; } @@ -415,7 +418,7 @@ android_media_AudioSystem_isStreamActiveRemotely(JNIEnv *env, jobject thiz, jint jint inPastMs) { bool state = false; - AudioSystem::isStreamActiveRemotely((audio_stream_type_t) stream, &state, inPastMs); + AudioSystem::isStreamActiveRemotely(static_cast(stream), &state, inPastMs); return state; } @@ -423,7 +426,7 @@ static jboolean android_media_AudioSystem_isSourceActive(JNIEnv *env, jobject thiz, jint source) { bool state = false; - AudioSystem::isSourceActive((audio_source_t) source, &state); + AudioSystem::isSourceActive(static_cast(source), &state); return state; } @@ -459,7 +462,7 @@ android_media_AudioSystem_setParameters(JNIEnv *env, jobject thiz, jstring keyVa env->ReleaseStringCritical(keyValuePairs, c_keyValuePairs); } int status = check_AudioSystem_Command(AudioSystem::setParameters(c_keyValuePairs8)); - return (jint) status; + return status; } static jstring @@ -539,15 +542,15 @@ android_media_AudioSystem_recording_callback(int event, return; } jint recParamData[REC_PARAM_SIZE]; - recParamData[0] = (jint) audioFormatFromNative(clientConfig->format); + recParamData[0] = audioFormatFromNative(clientConfig->format); // FIXME this doesn't support index-based masks - recParamData[1] = (jint) inChannelMaskFromNative(clientConfig->channel_mask); - recParamData[2] = (jint) clientConfig->sample_rate; - recParamData[3] = (jint) audioFormatFromNative(deviceConfig->format); + recParamData[1] = inChannelMaskFromNative(clientConfig->channel_mask); + recParamData[2] = clientConfig->sample_rate; + recParamData[3] = audioFormatFromNative(deviceConfig->format); // FIXME this doesn't support index-based masks - recParamData[4] = (jint) inChannelMaskFromNative(deviceConfig->channel_mask); - recParamData[5] = (jint) deviceConfig->sample_rate; - recParamData[6] = (jint) patchHandle; + recParamData[4] = inChannelMaskFromNative(deviceConfig->channel_mask); + recParamData[5] = deviceConfig->sample_rate; + recParamData[6] = patchHandle; env->SetIntArrayRegion(recParamArray, 0, REC_PARAM_SIZE, recParamData); jobjectArray jClientEffects; @@ -561,10 +564,9 @@ android_media_AudioSystem_recording_callback(int event, env->CallStaticVoidMethod(clazz, gAudioPolicyEventHandlerMethods.postRecordConfigEventFromNative, - event, (jint) clientInfo->riid, (jint) clientInfo->uid, - clientInfo->session, clientInfo->source, clientInfo->port_id, - clientInfo->silenced, recParamArray, jClientEffects, jEffects, - source); + event, clientInfo->riid, clientInfo->uid, clientInfo->session, + clientInfo->source, clientInfo->port_id, clientInfo->silenced, + recParamArray, jClientEffects, jEffects, source); env->DeleteLocalRef(clazz); env->DeleteLocalRef(recParamArray); env->DeleteLocalRef(jClientEffects); @@ -607,11 +609,9 @@ static jint android_media_AudioSystem_setDeviceConnectionState(JNIEnv *env, jobj if (Parcel *parcel = parcelForJavaObject(env, jParcel); parcel != nullptr) { android::media::audio::common::AudioPort port{}; if (status_t statusOfParcel = port.readFromParcel(parcel); statusOfParcel == OK) { - status = check_AudioSystem_Command( - AudioSystem::setDeviceConnectionState(static_cast( - state), - port, - static_cast(codec))); + status = check_AudioSystem_Command( + AudioSystem::setDeviceConnectionState(static_cast(state), + port, static_cast(codec))); } else { ALOGE("Failed to read from parcel: %s", statusToString(statusOfParcel).c_str()); status = kAudioStatusError; @@ -620,17 +620,17 @@ static jint android_media_AudioSystem_setDeviceConnectionState(JNIEnv *env, jobj ALOGE("Failed to retrieve the native parcel from Java parcel"); status = kAudioStatusError; } - return (jint) status; + return status; } static jint android_media_AudioSystem_getDeviceConnectionState(JNIEnv *env, jobject thiz, jint device, jstring device_address) { const char *c_address = env->GetStringUTFChars(device_address, NULL); - int state = static_cast (AudioSystem::getDeviceConnectionState(static_cast (device), - c_address)); + int state = static_cast( + AudioSystem::getDeviceConnectionState(static_cast(device), c_address)); env->ReleaseStringUTFChars(device_address, c_address); - return (jint) state; + return state; } static jint @@ -639,38 +639,41 @@ android_media_AudioSystem_handleDeviceConfigChange(JNIEnv *env, jobject thiz, ji { const char *c_address = env->GetStringUTFChars(device_address, NULL); const char *c_name = env->GetStringUTFChars(device_name, NULL); - int status = check_AudioSystem_Command(AudioSystem::handleDeviceConfigChange(static_cast (device), - c_address, c_name, static_cast (codec))); + int status = check_AudioSystem_Command( + AudioSystem::handleDeviceConfigChange(static_cast(device), c_address, + c_name, static_cast(codec))); env->ReleaseStringUTFChars(device_address, c_address); env->ReleaseStringUTFChars(device_name, c_name); - return (jint) status; + return status; } static jint android_media_AudioSystem_setPhoneState(JNIEnv *env, jobject thiz, jint state, jint uid) { - return (jint)check_AudioSystem_Command( - AudioSystem::setPhoneState((audio_mode_t)state, (uid_t)uid)); + return check_AudioSystem_Command( + AudioSystem::setPhoneState(static_cast(state), static_cast(uid))); } static jint android_media_AudioSystem_setForceUse(JNIEnv *env, jobject thiz, jint usage, jint config) { - return (jint) check_AudioSystem_Command(AudioSystem::setForceUse(static_cast (usage), - static_cast (config))); + return check_AudioSystem_Command( + AudioSystem::setForceUse(static_cast(usage), + static_cast(config))); } static jint android_media_AudioSystem_getForceUse(JNIEnv *env, jobject thiz, jint usage) { - return static_cast (AudioSystem::getForceUse(static_cast (usage))); + return static_cast( + AudioSystem::getForceUse(static_cast(usage))); } static jint android_media_AudioSystem_initStreamVolume(JNIEnv *env, jobject thiz, jint stream, jint indexMin, jint indexMax) { - return (jint) check_AudioSystem_Command(AudioSystem::initStreamVolume(static_cast (stream), - indexMin, - indexMax)); + return check_AudioSystem_Command( + AudioSystem::initStreamVolume(static_cast(stream), indexMin, + indexMax)); } static jint @@ -680,10 +683,9 @@ android_media_AudioSystem_setStreamVolumeIndex(JNIEnv *env, jint index, jint device) { - return (jint) check_AudioSystem_Command( - AudioSystem::setStreamVolumeIndex(static_cast (stream), - index, - (audio_devices_t)device)); + return check_AudioSystem_Command( + AudioSystem::setStreamVolumeIndex(static_cast(stream), index, + static_cast(device))); } static jint @@ -693,13 +695,11 @@ android_media_AudioSystem_getStreamVolumeIndex(JNIEnv *env, jint device) { int index; - if (AudioSystem::getStreamVolumeIndex(static_cast (stream), - &index, - (audio_devices_t)device) - != NO_ERROR) { + if (AudioSystem::getStreamVolumeIndex(static_cast(stream), &index, + static_cast(device)) != NO_ERROR) { index = -1; } - return (jint) index; + return index; } static jint @@ -712,11 +712,12 @@ android_media_AudioSystem_setVolumeIndexForAttributes(JNIEnv *env, // read the AudioAttributes values JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } - return (jint) check_AudioSystem_Command( - AudioSystem::setVolumeIndexForAttributes(*(paa.get()), index, (audio_devices_t)device)); + return check_AudioSystem_Command( + AudioSystem::setVolumeIndexForAttributes(*(paa.get()), index, + static_cast(device))); } static jint @@ -728,15 +729,16 @@ android_media_AudioSystem_getVolumeIndexForAttributes(JNIEnv *env, // read the AudioAttributes values JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } int index; - if (AudioSystem::getVolumeIndexForAttributes(*(paa.get()), index, (audio_devices_t)device) - != NO_ERROR) { + if (AudioSystem::getVolumeIndexForAttributes(*(paa.get()), index, + static_cast(device)) != + NO_ERROR) { index = -1; } - return (jint) index; + return index; } static jint @@ -747,7 +749,7 @@ android_media_AudioSystem_getMinVolumeIndexForAttributes(JNIEnv *env, // read the AudioAttributes values JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } int index; @@ -755,7 +757,7 @@ android_media_AudioSystem_getMinVolumeIndexForAttributes(JNIEnv *env, != NO_ERROR) { index = -1; } - return (jint) index; + return index; } static jint @@ -766,7 +768,7 @@ android_media_AudioSystem_getMaxVolumeIndexForAttributes(JNIEnv *env, // read the AudioAttributes values JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } int index; @@ -774,13 +776,13 @@ android_media_AudioSystem_getMaxVolumeIndexForAttributes(JNIEnv *env, != NO_ERROR) { index = -1; } - return (jint) index; + return index; } static jint android_media_AudioSystem_setMasterVolume(JNIEnv *env, jobject thiz, jfloat value) { - return (jint) check_AudioSystem_Command(AudioSystem::setMasterVolume(value)); + return check_AudioSystem_Command(AudioSystem::setMasterVolume(value)); } static jfloat @@ -796,7 +798,7 @@ android_media_AudioSystem_getMasterVolume(JNIEnv *env, jobject thiz) static jint android_media_AudioSystem_setMasterMute(JNIEnv *env, jobject thiz, jboolean mute) { - return (jint) check_AudioSystem_Command(AudioSystem::setMasterMute(mute)); + return check_AudioSystem_Command(AudioSystem::setMasterMute(mute)); } static jboolean @@ -812,7 +814,7 @@ android_media_AudioSystem_getMasterMute(JNIEnv *env, jobject thiz) static jint android_media_AudioSystem_setMasterMono(JNIEnv *env, jobject thiz, jboolean mono) { - return (jint) check_AudioSystem_Command(AudioSystem::setMasterMono(mono)); + return check_AudioSystem_Command(AudioSystem::setMasterMono(mono)); } static jboolean @@ -828,7 +830,7 @@ android_media_AudioSystem_getMasterMono(JNIEnv *env, jobject thiz) static jint android_media_AudioSystem_setMasterBalance(JNIEnv *env, jobject thiz, jfloat balance) { - return (jint) check_AudioSystem_Command(AudioSystem::setMasterBalance(balance)); + return check_AudioSystem_Command(AudioSystem::setMasterBalance(balance)); } static jfloat @@ -846,37 +848,37 @@ android_media_AudioSystem_getMasterBalance(JNIEnv *env, jobject thiz) static jint android_media_AudioSystem_getPrimaryOutputSamplingRate(JNIEnv *env, jobject clazz) { - return (jint) AudioSystem::getPrimaryOutputSamplingRate(); + return AudioSystem::getPrimaryOutputSamplingRate(); } static jint android_media_AudioSystem_getPrimaryOutputFrameCount(JNIEnv *env, jobject clazz) { - return (jint) AudioSystem::getPrimaryOutputFrameCount(); + return AudioSystem::getPrimaryOutputFrameCount(); } static jint android_media_AudioSystem_getOutputLatency(JNIEnv *env, jobject clazz, jint stream) { uint32_t afLatency; - if (AudioSystem::getOutputLatency(&afLatency, static_cast (stream)) - != NO_ERROR) { + if (AudioSystem::getOutputLatency(&afLatency, static_cast(stream)) != + NO_ERROR) { afLatency = -1; } - return (jint) afLatency; + return afLatency; } static jint android_media_AudioSystem_setLowRamDevice( JNIEnv *env, jobject clazz, jboolean isLowRamDevice, jlong totalMemory) { - return (jint) AudioSystem::setLowRamDevice((bool) isLowRamDevice, (int64_t) totalMemory); + return AudioSystem::setLowRamDevice(isLowRamDevice, totalMemory); } static jint android_media_AudioSystem_checkAudioFlinger(JNIEnv *env, jobject clazz) { - return (jint) check_AudioSystem_Command(AudioSystem::checkAudioFlinger()); + return check_AudioSystem_Command(AudioSystem::checkAudioFlinger()); } static void android_media_AudioSystem_setAudioFlingerBinder(JNIEnv *env, jobject clazz, @@ -890,8 +892,8 @@ static void convertAudioGainConfigToNative(JNIEnv *env, bool useInMask) { nAudioGainConfig->index = env->GetIntField(jAudioGainConfig, gAudioGainConfigFields.mIndex); - nAudioGainConfig->mode = - (audio_gain_mode_t)env->GetIntField(jAudioGainConfig, gAudioGainConfigFields.mMode); + nAudioGainConfig->mode = static_cast( + env->GetIntField(jAudioGainConfig, gAudioGainConfigFields.mMode)); ALOGV("convertAudioGainConfigToNative got gain index %d", nAudioGainConfig->index); jint jMask = env->GetIntField(jAudioGainConfig, gAudioGainConfigFields.mChannelMask); audio_channel_mask_t nMask; @@ -905,8 +907,8 @@ static void convertAudioGainConfigToNative(JNIEnv *env, nAudioGainConfig->channel_mask = nMask; nAudioGainConfig->ramp_duration_ms = env->GetIntField(jAudioGainConfig, gAudioGainConfigFields.mRampDurationMs); - jintArray jValues = (jintArray)env->GetObjectField(jAudioGainConfig, - gAudioGainConfigFields.mValues); + jintArray jValues = static_cast( + env->GetObjectField(jAudioGainConfig, gAudioGainConfigFields.mValues)); int *nValues = env->GetIntArrayElements(jValues, NULL); size_t size = env->GetArrayLength(jValues); memcpy(nAudioGainConfig->values, nValues, size * sizeof(int)); @@ -921,8 +923,8 @@ static jint convertAudioPortConfigToNative(JNIEnv *env, jobject jAudioPort = env->GetObjectField(jAudioPortConfig, gAudioPortConfigFields.mPort); jobject jHandle = env->GetObjectField(jAudioPort, gAudioPortFields.mHandle); nAudioPortConfig->id = env->GetIntField(jHandle, gAudioHandleFields.mId); - nAudioPortConfig->role = (audio_port_role_t)env->GetIntField(jAudioPort, - gAudioPortFields.mRole); + nAudioPortConfig->role = + static_cast(env->GetIntField(jAudioPort, gAudioPortFields.mRole)); if (env->IsInstanceOf(jAudioPort, gAudioDevicePortClass)) { nAudioPortConfig->type = AUDIO_PORT_TYPE_DEVICE; } else if (env->IsInstanceOf(jAudioPort, gAudioMixPortClass)) { @@ -930,7 +932,7 @@ static jint convertAudioPortConfigToNative(JNIEnv *env, } else { env->DeleteLocalRef(jAudioPort); env->DeleteLocalRef(jHandle); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } ALOGV("convertAudioPortConfigToNative handle %d role %d type %d", nAudioPortConfig->id, nAudioPortConfig->role, nAudioPortConfig->type); @@ -985,7 +987,7 @@ static jint convertAudioPortConfigToNative(JNIEnv *env, } env->DeleteLocalRef(jAudioPort); env->DeleteLocalRef(jHandle); - return (jint)AUDIO_JAVA_SUCCESS; + return AUDIO_JAVA_SUCCESS; } /** @@ -1006,15 +1008,15 @@ static jint convertAudioPortConfigToNativeWithDevicePort(JNIEnv *env, } // Supports AUDIO_PORT_TYPE_DEVICE only if (nAudioPortConfig->type != AUDIO_PORT_TYPE_DEVICE) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jobject jAudioDevicePort = env->GetObjectField(jAudioPortConfig, gAudioPortConfigFields.mPort); - nAudioPortConfig->ext.device.type = - (audio_devices_t)env->GetIntField(jAudioDevicePort, gAudioPortFields.mType); - jstring jDeviceAddress = (jstring)env->GetObjectField(jAudioDevicePort, - gAudioPortFields.mAddress); + nAudioPortConfig->ext.device.type = static_cast( + env->GetIntField(jAudioDevicePort, gAudioPortFields.mType)); + jstring jDeviceAddress = + static_cast(env->GetObjectField(jAudioDevicePort, gAudioPortFields.mAddress)); const char *nDeviceAddress = env->GetStringUTFChars(jDeviceAddress, NULL); strncpy(nAudioPortConfig->ext.device.address, nDeviceAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN - 1); @@ -1041,7 +1043,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalReftype == AUDIO_PORT_TYPE_DEVICE ? "device" : "mix"); if (jHandle == NULL) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } // create placeholder port and port config objects with just the correct handle // and configuration data. The actual AudioPortConfig objects will be @@ -1058,7 +1060,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefid); @@ -1090,18 +1092,18 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRef jGains(env, - (jobjectArray)env - ->GetObjectField(jAudioPort->get(), - gAudioPortFields.mGains)); + ScopedLocalRef + jGains(env, + static_cast(env->GetObjectField(jAudioPort->get(), + gAudioPortFields.mGains))); if (jGains == NULL) { ALOGV("convertAudioPortConfigFromNative could not get gains from port"); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } jAudioGain.reset(env->GetObjectArrayElement(jGains.get(), gainIndex)); if (jAudioGain == NULL) { ALOGV("convertAudioPortConfigFromNative could not get gain at index %d", gainIndex); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } } int numValues; @@ -1113,7 +1115,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefNewIntArray(numValues); if (jGainValues == NULL) { ALOGV("convertAudioPortConfigFromNative could not create gain values %d", numValues); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } env->SetIntArrayRegion(jGainValues, 0, numValues, nAudioPortConfig->gain.values); @@ -1134,7 +1136,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefDeleteLocalRef(jGainValues); if (jAudioGainConfig == NULL) { ALOGV("convertAudioPortConfigFromNative could not create gain config"); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } } jclass clazz; @@ -1153,7 +1155,7 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefconfig_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) @@ -1198,7 +1200,8 @@ static jintArray convertEncapsulationInfoFromNative(JNIEnv *env, uint32_t encaps } } jintArray result = env->NewIntArray(encapsulation.size()); - env->SetIntArrayRegion(result, 0, encapsulation.size(), (jint *)encapsulation.data()); + env->SetIntArrayRegion(result, 0, encapsulation.size(), + reinterpret_cast(encapsulation.data())); return result; } @@ -1255,7 +1258,8 @@ static jint convertAudioProfileFromNative(JNIEnv *env, jobject *jAudioProfile, if (nAudioProfile->num_sample_rates) { env->SetIntArrayRegion(jSamplingRates.get(), 0 /*start*/, nAudioProfile->num_sample_rates, - (jint *)nAudioProfile->sample_rates); + const_cast(reinterpret_cast( + nAudioProfile->sample_rates))); } // put the masks in the output arrays @@ -1313,7 +1317,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu } else { ALOGE("%s", s.c_str()); } - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } useInMask = audio_has_input_direction(nAudioPort->type, nAudioPort->role); @@ -1321,7 +1325,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu env->NewObject(gArrayListClass, gArrayListMethods.cstor)); if (jAudioProfiles == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } ScopedLocalRef jPcmFloatProfileFromExtendedInteger(env, nullptr); @@ -1335,7 +1339,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu continue; } if (jStatus != NO_ERROR) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jAudioProfile); @@ -1346,19 +1350,21 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu audio_bytes_per_sample(nAudioPort->audio_profiles[i].format) > 2) { ScopedLocalRef jSamplingRates(env, - (jintArray) + static_cast( env->GetObjectField(jAudioProfile, - gAudioProfileFields.mSamplingRates)); + gAudioProfileFields + .mSamplingRates))); ScopedLocalRef jChannelMasks(env, - (jintArray) + static_cast( env->GetObjectField(jAudioProfile, - gAudioProfileFields.mChannelMasks)); + gAudioProfileFields.mChannelMasks))); ScopedLocalRef jChannelIndexMasks(env, - (jintArray)env->GetObjectField(jAudioProfile, - gAudioProfileFields - .mChannelIndexMasks)); + static_cast( + env->GetObjectField(jAudioProfile, + gAudioProfileFields + .mChannelIndexMasks))); int encapsulationType = env->GetIntField(jAudioProfile, gAudioProfileFields.mEncapsulationType); @@ -1386,7 +1392,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu env->NewObject(gArrayListClass, gArrayListMethods.cstor)); if (jAudioDescriptors == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } for (size_t i = 0; i < nAudioPort->num_extra_audio_descriptors; ++i) { const auto &extraAudioDescriptor = nAudioPort->extra_audio_descriptors[i]; @@ -1425,7 +1431,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu env->NewObjectArray(nAudioPort->num_gains, gAudioGainClass, NULL)); if (jGains == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } for (size_t j = 0; j < nAudioPort->num_gains; j++) { @@ -1450,7 +1456,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu nAudioPort->gains[j].min_ramp_ms, nAudioPort->gains[j].max_ramp_ms); if (jGain == NULL) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } env->SetObjectArrayElement(jGains.get(), j, jGain); env->DeleteLocalRef(jGain); @@ -1460,7 +1466,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu env->NewObject(gAudioHandleClass, gAudioHandleCstor, nAudioPort->id)); if (jHandle == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } ScopedLocalRef jDeviceName(env, env->NewStringUTF(nAudioPort->name)); @@ -1489,10 +1495,10 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu jDeviceName.get(), jAudioProfiles.get(), jGains.get())); } else { ALOGE("convertAudioPortFromNative unknown nAudioPort type %d", nAudioPort->type); - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } if (*jAudioPort == NULL) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } ScopedLocalRef jAudioPortConfig(env, nullptr); @@ -1525,15 +1531,15 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz, if (jPorts == NULL) { ALOGE("listAudioPorts NULL AudioPort ArrayList"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (!env->IsInstanceOf(jPorts, gArrayListClass)) { ALOGE("listAudioPorts not an arraylist"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (jGeneration == NULL || env->GetArrayLength(jGeneration) != 1) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } status_t status; @@ -1604,31 +1610,32 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, ALOGV("createAudioPatch"); if (jPatches == NULL || jSources == NULL || jSinks == NULL) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (env->GetArrayLength(jPatches) != 1) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jint numSources = env->GetArrayLength(jSources); if (numSources == 0 || numSources > AUDIO_PATCH_PORTS_MAX) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jint numSinks = env->GetArrayLength(jSinks); if (numSinks == 0 || numSinks > AUDIO_PATCH_PORTS_MAX) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } - audio_patch_handle_t handle = (audio_patch_handle_t)0; + audio_patch_handle_t handle = static_cast(AUDIO_PATCH_HANDLE_NONE); ScopedLocalRef jPatch(env, env->GetObjectArrayElement(jPatches, 0)); ScopedLocalRef jPatchHandle(env, nullptr); if (jPatch != NULL) { if (!env->IsInstanceOf(jPatch.get(), gAudioPatchClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jPatchHandle.reset(env->GetObjectField(jPatch.get(), gAudioPatchFields.mHandle)); - handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle.get(), gAudioHandleFields.mId); + handle = static_cast( + env->GetIntField(jPatchHandle.get(), gAudioHandleFields.mId)); } struct audio_patch nPatch = { .id = handle }; @@ -1636,7 +1643,7 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, for (jint i = 0; i < numSources; i++) { ScopedLocalRef jSource(env, env->GetObjectArrayElement(jSources, i)); if (!env->IsInstanceOf(jSource.get(), gAudioPortConfigClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jStatus = convertAudioPortConfigToNative(env, &nPatch.sources[i], jSource.get(), false); if (jStatus != AUDIO_JAVA_SUCCESS) { @@ -1648,7 +1655,7 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, for (jint i = 0; i < numSinks; i++) { ScopedLocalRef jSink(env, env->GetObjectArrayElement(jSinks, i)); if (!env->IsInstanceOf(jSink.get(), gAudioPortConfigClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jStatus = convertAudioPortConfigToNative(env, &nPatch.sinks[i], jSink.get(), false); if (jStatus != AUDIO_JAVA_SUCCESS) { @@ -1669,12 +1676,12 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, if (jPatchHandle == nullptr) { jPatchHandle.reset(env->NewObject(gAudioHandleClass, gAudioHandleCstor, handle)); if (jPatchHandle == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, jPatchHandle.get(), jSources, jSinks)); if (jPatch == nullptr) { - return (jint)AUDIO_JAVA_ERROR; + return AUDIO_JAVA_ERROR; } env->SetObjectArrayElement(jPatches, 0, jPatch.get()); } else { @@ -1689,16 +1696,17 @@ android_media_AudioSystem_releaseAudioPatch(JNIEnv *env, jobject clazz, { ALOGV("releaseAudioPatch"); if (jPatch == NULL) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } - audio_patch_handle_t handle = (audio_patch_handle_t)0; + audio_patch_handle_t handle = static_cast(AUDIO_PATCH_HANDLE_NONE); jobject jPatchHandle = NULL; if (!env->IsInstanceOf(jPatch, gAudioPatchClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jPatchHandle = env->GetObjectField(jPatch, gAudioPatchFields.mHandle); - handle = (audio_patch_handle_t)env->GetIntField(jPatchHandle, gAudioHandleFields.mId); + handle = static_cast( + env->GetIntField(jPatchHandle, gAudioHandleFields.mId)); env->DeleteLocalRef(jPatchHandle); ALOGV("AudioSystem::releaseAudioPatch"); @@ -1715,15 +1723,15 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, ALOGV("listAudioPatches"); if (jPatches == NULL) { ALOGE("listAudioPatches NULL AudioPatch ArrayList"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (!env->IsInstanceOf(jPatches, gArrayListClass)) { ALOGE("listAudioPatches not an arraylist"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (jGeneration == NULL || env->GetArrayLength(jGeneration) != 1) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } status_t status; @@ -1896,7 +1904,7 @@ android_media_AudioSystem_startAudioSource(JNIEnv *env, jobject clazz, } auto paa = JNIAudioAttributeHelper::makeUnique(); jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jAudioAttributes, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } audio_port_handle_t handle; @@ -1913,8 +1921,7 @@ static jint android_media_AudioSystem_stopAudioSource(JNIEnv *env, jobject clazz, jint handle) { ALOGV("stopAudioSource"); - status_t status = AudioSystem::stopAudioSource( - static_cast (handle)); + status_t status = AudioSystem::stopAudioSource(static_cast(handle)); ALOGV("AudioSystem::stopAudioSource() returned %d", status); return nativeToJavaStatus(status); } @@ -1946,7 +1953,7 @@ android_media_AudioSystem_eventHandlerFinalize(JNIEnv *env, jobject thiz) static jint android_media_AudioSystem_getAudioHwSyncForSession(JNIEnv *env, jobject thiz, jint sessionId) { - return (jint) AudioSystem::getAudioHwSyncForSession((audio_session_t) sessionId); + return AudioSystem::getAudioHwSyncForSession(static_cast(sessionId)); } static void @@ -1991,11 +1998,11 @@ static jint convertAudioMixToNative(JNIEnv *env, { nAudioMix->mMixType = env->GetIntField(jAudioMix, gAudioMixFields.mMixType); nAudioMix->mRouteFlags = env->GetIntField(jAudioMix, gAudioMixFields.mRouteFlags); - nAudioMix->mDeviceType = (audio_devices_t) - env->GetIntField(jAudioMix, gAudioMixFields.mDeviceType); + nAudioMix->mDeviceType = + static_cast(env->GetIntField(jAudioMix, gAudioMixFields.mDeviceType)); - jstring jDeviceAddress = (jstring)env->GetObjectField(jAudioMix, - gAudioMixFields.mDeviceAddress); + jstring jDeviceAddress = + static_cast(env->GetObjectField(jAudioMix, gAudioMixFields.mDeviceAddress)); const char *nDeviceAddress = env->GetStringUTFChars(jDeviceAddress, NULL); nAudioMix->mDeviceAddress = String8(nDeviceAddress); env->ReleaseStringUTFChars(jDeviceAddress, nDeviceAddress); @@ -2014,8 +2021,8 @@ static jint convertAudioMixToNative(JNIEnv *env, nAudioMix->mVoiceCommunicationCaptureAllowed = env->GetBooleanField(jRule, gAudioMixingRuleFields.mVoiceCommunicationCaptureAllowed); env->DeleteLocalRef(jRule); - jobjectArray jCriteria = (jobjectArray)env->CallObjectMethod(jRuleCriteria, - gArrayListMethods.toArray); + jobjectArray jCriteria = static_cast( + env->CallObjectMethod(jRuleCriteria, gArrayListMethods.toArray)); env->DeleteLocalRef(jRuleCriteria); jint numCriteria = env->GetArrayLength(jCriteria); @@ -2046,8 +2053,8 @@ static jint convertAudioMixToNative(JNIEnv *env, auto paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jAttributes, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { - return jStatus; + if (jStatus != AUDIO_JAVA_SUCCESS) { + return jStatus; } if (match_rule == RULE_MATCH_ATTRIBUTE_USAGE) { nCriterion.mValue.mUsage = paa->usage; @@ -2065,7 +2072,7 @@ static jint convertAudioMixToNative(JNIEnv *env, env->DeleteLocalRef(jCriteria); - return (jint)AUDIO_JAVA_SUCCESS; + return AUDIO_JAVA_SUCCESS; } static jint @@ -2075,13 +2082,13 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz, ALOGV("registerPolicyMixes"); if (jMixesList == NULL) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (!env->IsInstanceOf(jMixesList, gArrayListClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } - jobjectArray jMixes = (jobjectArray)env->CallObjectMethod(jMixesList, - gArrayListMethods.toArray); + jobjectArray jMixes = + static_cast(env->CallObjectMethod(jMixesList, gArrayListMethods.toArray)); jint numMixes = env->GetArrayLength(jMixes); if (numMixes > MAX_MIXES_PER_POLICY) { numMixes = MAX_MIXES_PER_POLICY; @@ -2092,7 +2099,7 @@ android_media_AudioSystem_registerPolicyMixes(JNIEnv *env, jobject clazz, for (jint i = 0; i < numMixes; i++) { ScopedLocalRef jAudioMix(env, env->GetObjectArrayElement(jMixes, i)); if (!env->IsInstanceOf(jAudioMix.get(), gAudioMixClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } AudioMix mix; if (jint jStatus = convertAudioMixToNative(env, &mix, jAudioMix.get()); @@ -2116,14 +2123,14 @@ static jint android_media_AudioSystem_setUidDeviceAffinities(JNIEnv *env, jobjec if (results != NO_ERROR) { return results; } - status_t status = AudioSystem::setUidDeviceAffinities((uid_t) uid, deviceVector); - return (jint) nativeToJavaStatus(status); + status_t status = AudioSystem::setUidDeviceAffinities(uid, deviceVector); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_removeUidDeviceAffinities(JNIEnv *env, jobject clazz, jint uid) { - status_t status = AudioSystem::removeUidDeviceAffinities((uid_t) uid); - return (jint) nativeToJavaStatus(status); + status_t status = AudioSystem::removeUidDeviceAffinities(static_cast(uid)); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_setUserIdDeviceAffinities(JNIEnv *env, jobject clazz, @@ -2134,14 +2141,14 @@ static jint android_media_AudioSystem_setUserIdDeviceAffinities(JNIEnv *env, job if (results != NO_ERROR) { return results; } - status_t status = AudioSystem::setUserIdDeviceAffinities((int)userId, deviceVector); - return (jint)nativeToJavaStatus(status); + status_t status = AudioSystem::setUserIdDeviceAffinities(userId, deviceVector); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_removeUserIdDeviceAffinities(JNIEnv *env, jobject clazz, jint userId) { - status_t status = AudioSystem::removeUserIdDeviceAffinities((int)userId); - return (jint)nativeToJavaStatus(status); + status_t status = AudioSystem::removeUserIdDeviceAffinities(userId); + return nativeToJavaStatus(status); } static jint @@ -2154,19 +2161,18 @@ static jfloat android_media_AudioSystem_getStreamVolumeDB(JNIEnv *env, jobject thiz, jint stream, jint index, jint device) { - return (jfloat)AudioSystem::getStreamVolumeDB((audio_stream_type_t)stream, - (int)index, - (audio_devices_t)device); + return AudioSystem::getStreamVolumeDB(static_cast(stream), index, + static_cast(device)); } static jint android_media_AudioSystem_getOffloadSupport(JNIEnv *env, jobject thiz, jint encoding, jint sampleRate, jint channelMask, jint channelIndexMask, jint streamType) { audio_offload_info_t format = AUDIO_INFO_INITIALIZER; - format.format = (audio_format_t) audioFormatToNative(encoding); - format.sample_rate = (uint32_t) sampleRate; + format.format = static_cast(audioFormatToNative(encoding)); + format.sample_rate = sampleRate; format.channel_mask = nativeChannelMaskFromJavaChannelMasks(channelMask, channelIndexMask); - format.stream_type = (audio_stream_type_t) streamType; + format.stream_type = static_cast(streamType); format.has_video = false; format.is_streaming = false; // offload duration unknown at this point: @@ -2183,11 +2189,11 @@ android_media_AudioSystem_getMicrophones(JNIEnv *env, jobject thiz, jobject jMic if (jMicrophonesInfo == NULL) { ALOGE("jMicrophonesInfo NULL MicrophoneInfo ArrayList"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (!env->IsInstanceOf(jMicrophonesInfo, gArrayListClass)) { ALOGE("getMicrophones not an arraylist"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } jint jStatus; @@ -2199,7 +2205,7 @@ android_media_AudioSystem_getMicrophones(JNIEnv *env, jobject thiz, jobject jMic return jStatus; } if (microphones.size() == 0) { - jStatus = (jint)AUDIO_JAVA_SUCCESS; + jStatus = AUDIO_JAVA_SUCCESS; return jStatus; } for (size_t i = 0; i < microphones.size(); i++) { @@ -2221,7 +2227,7 @@ static jint android_media_AudioSystem_getHwOffloadFormatsSupportedForBluetoothMe jint jStatus = AUDIO_JAVA_SUCCESS; if (!env->IsInstanceOf(jEncodingFormatList, gArrayListClass)) { ALOGE("%s: jEncodingFormatList not an ArrayList", __FUNCTION__); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } std::vector encodingFormats; status_t status = @@ -2340,12 +2346,12 @@ static jint android_media_AudioSystem_setSurroundFormatEnabled(JNIEnv *env, jobject thiz, jint audioFormat, jboolean enabled) { - status_t status = AudioSystem::setSurroundFormatEnabled(audioFormatToNative(audioFormat), - (bool)enabled); + status_t status = + AudioSystem::setSurroundFormatEnabled(audioFormatToNative(audioFormat), enabled); if (status != NO_ERROR) { ALOGE_IF(status != NO_ERROR, "AudioSystem::setSurroundFormatEnabled error %d", status); } - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_getMaxChannelCount(JNIEnv *env, jobject thiz) { @@ -2386,7 +2392,7 @@ static jint android_media_AudioSystem_setAssistantServicesUids(JNIEnv *env, jobj status_t status = AudioSystem::setAssistantServicesUids(nativeUidsVector); - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_setActiveAssistantServicesUids(JNIEnv *env, jobject thiz, @@ -2395,7 +2401,7 @@ static jint android_media_AudioSystem_setActiveAssistantServicesUids(JNIEnv *env status_t status = AudioSystem::setActiveAssistantServicesUids(nativeActiveUidsVector); - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jint @@ -2403,12 +2409,12 @@ android_media_AudioSystem_setA11yServicesUids(JNIEnv *env, jobject thiz, jintArr std::vector nativeUidsVector = convertJIntArrayToUidVector(env, uids); status_t status = AudioSystem::setA11yServicesUids(nativeUidsVector); - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jint android_media_AudioSystem_setCurrentImeUid(JNIEnv *env, jobject thiz, jint uid) { status_t status = AudioSystem::setCurrentImeUid(uid); - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jboolean @@ -2426,7 +2432,7 @@ static jint android_media_AudioSystem_setSupportedSystemUsages(JNIEnv *env, jobj std::vector nativeSystemUsagesVector; if (systemUsages == nullptr) { - return (jint) AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } int *nativeSystemUsages = nullptr; @@ -2443,7 +2449,7 @@ static jint android_media_AudioSystem_setSupportedSystemUsages(JNIEnv *env, jobj } status_t status = AudioSystem::setSupportedSystemUsages(nativeSystemUsagesVector); - return (jint)nativeToJavaStatus(status); + return nativeToJavaStatus(status); } static jint @@ -2454,16 +2460,16 @@ android_media_AudioSystem_setAllowedCapturePolicy(JNIEnv *env, jobject thiz, jin static jint android_media_AudioSystem_setRttEnabled(JNIEnv *env, jobject thiz, jboolean enabled) { - return (jint) check_AudioSystem_Command(AudioSystem::setRttEnabled(enabled)); + return check_AudioSystem_Command(AudioSystem::setRttEnabled(enabled)); } static jint android_media_AudioSystem_setAudioHalPids(JNIEnv *env, jobject clazz, jintArray jPids) { if (jPids == NULL) { - return (jint) AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } - pid_t *nPidsArray = (pid_t *) env->GetIntArrayElements(jPids, NULL); + pid_t *nPidsArray = reinterpret_cast(env->GetIntArrayElements(jPids, NULL)); std::vector nPids(nPidsArray, nPidsArray + env->GetArrayLength(jPids)); status_t status = AudioSystem::setAudioHalPids(nPids); env->ReleaseIntArrayElements(jPids, nPidsArray, 0); @@ -2487,19 +2493,17 @@ static jint android_media_AudioSystem_setDevicesRoleForStrategy(JNIEnv *env, job return results; } int status = check_AudioSystem_Command( - AudioSystem::setDevicesRoleForStrategy((product_strategy_t)strategy, - (device_role_t)role, nDevices)); - return (jint) status; + AudioSystem::setDevicesRoleForStrategy(static_cast(strategy), + static_cast(role), nDevices)); + return status; } static jint android_media_AudioSystem_removeDevicesRoleForStrategy(JNIEnv *env, jobject thiz, jint strategy, jint role) { - return (jint) - check_AudioSystem_Command(AudioSystem::removeDevicesRoleForStrategy((product_strategy_t) - strategy, - (device_role_t) - role), - {NAME_NOT_FOUND}); + return check_AudioSystem_Command( + AudioSystem::removeDevicesRoleForStrategy(static_cast(strategy), + static_cast(role)), + {NAME_NOT_FOUND}); } static jint android_media_AudioSystem_getDevicesForRoleAndStrategy(JNIEnv *env, jobject thiz, @@ -2507,10 +2511,10 @@ static jint android_media_AudioSystem_getDevicesForRoleAndStrategy(JNIEnv *env, jobject jDevices) { AudioDeviceTypeAddrVector nDevices; status_t status = check_AudioSystem_Command( - AudioSystem::getDevicesForRoleAndStrategy((product_strategy_t)strategy, - (device_role_t)role, nDevices)); + AudioSystem::getDevicesForRoleAndStrategy(static_cast(strategy), + static_cast(role), nDevices)); if (status != NO_ERROR) { - return (jint) status; + return status; } for (const auto &device : nDevices) { jobject jAudioDeviceAttributes = NULL; @@ -2533,9 +2537,10 @@ static jint android_media_AudioSystem_setDevicesRoleForCapturePreset( return results; } int status = check_AudioSystem_Command( - AudioSystem::setDevicesRoleForCapturePreset((audio_source_t)capturePreset, - (device_role_t)role, nDevices)); - return (jint)status; + AudioSystem::setDevicesRoleForCapturePreset(static_cast(capturePreset), + static_cast(role), + nDevices)); + return status; } static jint android_media_AudioSystem_addDevicesRoleForCapturePreset( @@ -2547,9 +2552,10 @@ static jint android_media_AudioSystem_addDevicesRoleForCapturePreset( return results; } int status = check_AudioSystem_Command( - AudioSystem::addDevicesRoleForCapturePreset((audio_source_t)capturePreset, - (device_role_t)role, nDevices)); - return (jint)status; + AudioSystem::addDevicesRoleForCapturePreset(static_cast(capturePreset), + static_cast(role), + nDevices)); + return status; } static jint android_media_AudioSystem_removeDevicesRoleForCapturePreset( @@ -2561,17 +2567,20 @@ static jint android_media_AudioSystem_removeDevicesRoleForCapturePreset( return results; } int status = check_AudioSystem_Command( - AudioSystem::removeDevicesRoleForCapturePreset((audio_source_t)capturePreset, - (device_role_t)role, nDevices)); - return (jint)status; + AudioSystem::removeDevicesRoleForCapturePreset(static_cast( + capturePreset), + static_cast(role), + nDevices)); + return status; } static jint android_media_AudioSystem_clearDevicesRoleForCapturePreset(JNIEnv *env, jobject thiz, jint capturePreset, jint role) { - return (jint)check_AudioSystem_Command( - AudioSystem::clearDevicesRoleForCapturePreset((audio_source_t)capturePreset, - (device_role_t)role)); + return static_cast(check_AudioSystem_Command( + AudioSystem::clearDevicesRoleForCapturePreset(static_cast( + capturePreset), + static_cast(role)))); } static jint android_media_AudioSystem_getDevicesForRoleAndCapturePreset(JNIEnv *env, jobject thiz, @@ -2580,10 +2589,12 @@ static jint android_media_AudioSystem_getDevicesForRoleAndCapturePreset(JNIEnv * jobject jDevices) { AudioDeviceTypeAddrVector nDevices; status_t status = check_AudioSystem_Command( - AudioSystem::getDevicesForRoleAndCapturePreset((audio_source_t)capturePreset, - (device_role_t)role, nDevices)); + AudioSystem::getDevicesForRoleAndCapturePreset(static_cast( + capturePreset), + static_cast(role), + nDevices)); if (status != NO_ERROR) { - return (jint)status; + return status; } for (const auto &device : nDevices) { jobject jAudioDeviceAttributes = NULL; @@ -2608,12 +2619,12 @@ static jint android_media_AudioSystem_getDevicesForAttributes(JNIEnv *env, jobje // components call this method often if (jDeviceArray == nullptr || maxResultSize == 0) { ALOGE("%s invalid array to store AudioDeviceAttributes", __FUNCTION__); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint) AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } @@ -2642,7 +2653,7 @@ static jint android_media_AudioSystem_getDevicesForAttributes(JNIEnv *env, jobje static jint android_media_AudioSystem_setVibratorInfos(JNIEnv *env, jobject thiz, jobject jVibrators) { if (!env->IsInstanceOf(jVibrators, gListClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } const jint size = env->CallIntMethod(jVibrators, gListMethods.size); std::vector vibratorInfos; @@ -2650,7 +2661,7 @@ static jint android_media_AudioSystem_setVibratorInfos(JNIEnv *env, jobject thiz ScopedLocalRef jVibrator(env, env->CallObjectMethod(jVibrators, gListMethods.get, i)); if (!env->IsInstanceOf(jVibrator.get(), gVibratorClass)) { - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } media::AudioVibratorInfo vibratorInfo; vibratorInfo.id = env->CallIntMethod(jVibrator.get(), gVibratorMethods.getId); @@ -2661,7 +2672,7 @@ static jint android_media_AudioSystem_setVibratorInfos(JNIEnv *env, jobject thiz env->CallFloatMethod(jVibrator.get(), gVibratorMethods.getMaxAmplitude); vibratorInfos.push_back(vibratorInfo); } - return (jint)check_AudioSystem_Command(AudioSystem::setVibratorInfos(vibratorInfos)); + return check_AudioSystem_Command(AudioSystem::setVibratorInfos(vibratorInfos)); } static jobject android_media_AudioSystem_getSpatializer(JNIEnv *env, jobject thiz, @@ -2683,8 +2694,8 @@ static jboolean android_media_AudioSystem_canBeSpatialized(JNIEnv *env, jobject jobjectArray jDeviceArray) { JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { - return false; + if (jStatus != AUDIO_JAVA_SUCCESS) { + return false; } AudioDeviceTypeAddrVector nDevices; @@ -2697,7 +2708,7 @@ static jboolean android_media_AudioSystem_canBeSpatialized(JNIEnv *env, jobject return false; } jStatus = createAudioDeviceTypeAddrFromJava(env, &device, jDevice); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return false; } nDevices.push_back(device); @@ -2740,7 +2751,7 @@ static jint android_media_AudioSystem_getDirectPlaybackSupport(JNIEnv *env, jobj jobject jFormat, jobject jaa) { JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jaa, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return DIRECT_NOT_SUPPORTED; } @@ -2763,20 +2774,20 @@ static jint android_media_AudioSystem_getDirectProfilesForAttributes(JNIEnv *env if (jAudioAttributes == nullptr) { ALOGE("jAudioAttributes is NULL"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (jAudioProfilesList == nullptr) { ALOGE("jAudioProfilesList is NULL"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } if (!env->IsInstanceOf(jAudioProfilesList, gArrayListClass)) { ALOGE("jAudioProfilesList not an ArrayList"); - return (jint)AUDIO_JAVA_BAD_VALUE; + return AUDIO_JAVA_BAD_VALUE; } JNIAudioAttributeHelper::UniqueAaPtr paa = JNIAudioAttributeHelper::makeUnique(); jint jStatus = JNIAudioAttributeHelper::nativeFromJava(env, jAudioAttributes, paa.get()); - if (jStatus != (jint)AUDIO_JAVA_SUCCESS) { + if (jStatus != AUDIO_JAVA_SUCCESS) { return jStatus; } @@ -2816,8 +2827,7 @@ static jboolean android_media_AudioSystem_supportsBluetoothVariableLatency(JNIEn static int android_media_AudioSystem_setBluetoothVariableLatencyEnabled(JNIEnv *env, jobject thiz, jboolean enabled) { - return (jint)check_AudioSystem_Command( - AudioSystem::setBluetoothVariableLatencyEnabled(enabled)); + return check_AudioSystem_Command(AudioSystem::setBluetoothVariableLatencyEnabled(enabled)); } static jboolean android_media_AudioSystem_isBluetoothVariableLatencyEnabled(JNIEnv *env, @@ -2831,178 +2841,165 @@ static jboolean android_media_AudioSystem_isBluetoothVariableLatencyEnabled(JNIE // ---------------------------------------------------------------------------- +#define MAKE_AUDIO_SYSTEM_METHOD(x) \ + MAKE_JNI_NATIVE_METHOD_AUTOSIG(#x, android_media_AudioSystem_##x) + static const JNINativeMethod gMethods[] = - {{"setParameters", "(Ljava/lang/String;)I", - (void *)android_media_AudioSystem_setParameters}, - {"getParameters", "(Ljava/lang/String;)Ljava/lang/String;", - (void *)android_media_AudioSystem_getParameters}, - {"muteMicrophone", "(Z)I", (void *)android_media_AudioSystem_muteMicrophone}, - {"isMicrophoneMuted", "()Z", (void *)android_media_AudioSystem_isMicrophoneMuted}, - {"isStreamActive", "(II)Z", (void *)android_media_AudioSystem_isStreamActive}, - {"isStreamActiveRemotely", "(II)Z", - (void *)android_media_AudioSystem_isStreamActiveRemotely}, - {"isSourceActive", "(I)Z", (void *)android_media_AudioSystem_isSourceActive}, - {"newAudioSessionId", "()I", (void *)android_media_AudioSystem_newAudioSessionId}, - {"newAudioPlayerId", "()I", (void *)android_media_AudioSystem_newAudioPlayerId}, - {"newAudioRecorderId", "()I", (void *)android_media_AudioSystem_newAudioRecorderId}, - {"setDeviceConnectionState", "(ILandroid/os/Parcel;I)I", - (void *)android_media_AudioSystem_setDeviceConnectionState}, - {"getDeviceConnectionState", "(ILjava/lang/String;)I", - (void *)android_media_AudioSystem_getDeviceConnectionState}, - {"handleDeviceConfigChange", "(ILjava/lang/String;Ljava/lang/String;I)I", - (void *)android_media_AudioSystem_handleDeviceConfigChange}, - {"setPhoneState", "(II)I", (void *)android_media_AudioSystem_setPhoneState}, - {"setForceUse", "(II)I", (void *)android_media_AudioSystem_setForceUse}, - {"getForceUse", "(I)I", (void *)android_media_AudioSystem_getForceUse}, - {"initStreamVolume", "(III)I", (void *)android_media_AudioSystem_initStreamVolume}, - {"setStreamVolumeIndex", "(III)I", (void *)android_media_AudioSystem_setStreamVolumeIndex}, - {"getStreamVolumeIndex", "(II)I", (void *)android_media_AudioSystem_getStreamVolumeIndex}, - {"setVolumeIndexForAttributes", "(Landroid/media/AudioAttributes;II)I", - (void *)android_media_AudioSystem_setVolumeIndexForAttributes}, - {"getVolumeIndexForAttributes", "(Landroid/media/AudioAttributes;I)I", - (void *)android_media_AudioSystem_getVolumeIndexForAttributes}, - {"getMinVolumeIndexForAttributes", "(Landroid/media/AudioAttributes;)I", - (void *)android_media_AudioSystem_getMinVolumeIndexForAttributes}, - {"getMaxVolumeIndexForAttributes", "(Landroid/media/AudioAttributes;)I", - (void *)android_media_AudioSystem_getMaxVolumeIndexForAttributes}, - {"setMasterVolume", "(F)I", (void *)android_media_AudioSystem_setMasterVolume}, - {"getMasterVolume", "()F", (void *)android_media_AudioSystem_getMasterVolume}, - {"setMasterMute", "(Z)I", (void *)android_media_AudioSystem_setMasterMute}, - {"getMasterMute", "()Z", (void *)android_media_AudioSystem_getMasterMute}, - {"setMasterMono", "(Z)I", (void *)android_media_AudioSystem_setMasterMono}, - {"getMasterMono", "()Z", (void *)android_media_AudioSystem_getMasterMono}, - {"setMasterBalance", "(F)I", (void *)android_media_AudioSystem_setMasterBalance}, - {"getMasterBalance", "()F", (void *)android_media_AudioSystem_getMasterBalance}, - {"getPrimaryOutputSamplingRate", "()I", - (void *)android_media_AudioSystem_getPrimaryOutputSamplingRate}, - {"getPrimaryOutputFrameCount", "()I", - (void *)android_media_AudioSystem_getPrimaryOutputFrameCount}, - {"getOutputLatency", "(I)I", (void *)android_media_AudioSystem_getOutputLatency}, - {"setLowRamDevice", "(ZJ)I", (void *)android_media_AudioSystem_setLowRamDevice}, - {"checkAudioFlinger", "()I", (void *)android_media_AudioSystem_checkAudioFlinger}, - {"setAudioFlingerBinder", "(Landroid/os/IBinder;)V", - (void *)android_media_AudioSystem_setAudioFlingerBinder}, - {"listAudioPorts", "(Ljava/util/ArrayList;[I)I", - (void *)android_media_AudioSystem_listAudioPorts}, - {"createAudioPatch", - "([Landroid/media/AudioPatch;[Landroid/media/AudioPortConfig;[Landroid/media/" - "AudioPortConfig;)I", - (void *)android_media_AudioSystem_createAudioPatch}, - {"releaseAudioPatch", "(Landroid/media/AudioPatch;)I", - (void *)android_media_AudioSystem_releaseAudioPatch}, - {"listAudioPatches", "(Ljava/util/ArrayList;[I)I", - (void *)android_media_AudioSystem_listAudioPatches}, - {"setAudioPortConfig", "(Landroid/media/AudioPortConfig;)I", - (void *)android_media_AudioSystem_setAudioPortConfig}, - {"startAudioSource", "(Landroid/media/AudioPortConfig;Landroid/media/AudioAttributes;)I", - (void *)android_media_AudioSystem_startAudioSource}, - {"stopAudioSource", "(I)I", (void *)android_media_AudioSystem_stopAudioSource}, - {"getAudioHwSyncForSession", "(I)I", - (void *)android_media_AudioSystem_getAudioHwSyncForSession}, - {"registerPolicyMixes", "(Ljava/util/ArrayList;Z)I", - (void *)android_media_AudioSystem_registerPolicyMixes}, - {"setUidDeviceAffinities", "(I[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_setUidDeviceAffinities}, - {"removeUidDeviceAffinities", "(I)I", - (void *)android_media_AudioSystem_removeUidDeviceAffinities}, - {"native_register_dynamic_policy_callback", "()V", - (void *)android_media_AudioSystem_registerDynPolicyCallback}, - {"native_register_recording_callback", "()V", - (void *)android_media_AudioSystem_registerRecordingCallback}, - {"native_register_routing_callback", "()V", - (void *)android_media_AudioSystem_registerRoutingCallback}, - {"native_register_vol_range_init_req_callback", "()V", - (void *)android_media_AudioSystem_registerVolRangeInitReqCallback}, - {"systemReady", "()I", (void *)android_media_AudioSystem_systemReady}, - {"getStreamVolumeDB", "(III)F", (void *)android_media_AudioSystem_getStreamVolumeDB}, - {"native_get_offload_support", "(IIIII)I", - (void *)android_media_AudioSystem_getOffloadSupport}, - {"getMicrophones", "(Ljava/util/ArrayList;)I", - (void *)android_media_AudioSystem_getMicrophones}, - {"getSurroundFormats", "(Ljava/util/Map;)I", - (void *)android_media_AudioSystem_getSurroundFormats}, - {"getReportedSurroundFormats", "(Ljava/util/ArrayList;)I", - (void *)android_media_AudioSystem_getReportedSurroundFormats}, - {"setSurroundFormatEnabled", "(IZ)I", - (void *)android_media_AudioSystem_setSurroundFormatEnabled}, - {"setAssistantServicesUids", "([I)I", - (void *)android_media_AudioSystem_setAssistantServicesUids}, - {"setActiveAssistantServicesUids", "([I)I", - (void *)android_media_AudioSystem_setActiveAssistantServicesUids}, - {"setA11yServicesUids", "([I)I", (void *)android_media_AudioSystem_setA11yServicesUids}, - {"isHapticPlaybackSupported", "()Z", - (void *)android_media_AudioSystem_isHapticPlaybackSupported}, - {"isUltrasoundSupported", "()Z", (void *)android_media_AudioSystem_isUltrasoundSupported}, - {"getHwOffloadFormatsSupportedForBluetoothMedia", "(ILjava/util/ArrayList;)I", - (void *)android_media_AudioSystem_getHwOffloadFormatsSupportedForBluetoothMedia}, - {"setSupportedSystemUsages", "([I)I", - (void *)android_media_AudioSystem_setSupportedSystemUsages}, - {"setAllowedCapturePolicy", "(II)I", - (void *)android_media_AudioSystem_setAllowedCapturePolicy}, - {"setRttEnabled", "(Z)I", (void *)android_media_AudioSystem_setRttEnabled}, - {"setAudioHalPids", "([I)I", (void *)android_media_AudioSystem_setAudioHalPids}, - {"isCallScreeningModeSupported", "()Z", - (void *)android_media_AudioSystem_isCallScreeningModeSupported}, - {"setDevicesRoleForStrategy", "(II[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_setDevicesRoleForStrategy}, - {"removeDevicesRoleForStrategy", "(II)I", - (void *)android_media_AudioSystem_removeDevicesRoleForStrategy}, - {"getDevicesForRoleAndStrategy", "(IILjava/util/List;)I", - (void *)android_media_AudioSystem_getDevicesForRoleAndStrategy}, - {"setDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_setDevicesRoleForCapturePreset}, - {"addDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_addDevicesRoleForCapturePreset}, - {"removeDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_removeDevicesRoleForCapturePreset}, - {"clearDevicesRoleForCapturePreset", "(II)I", - (void *)android_media_AudioSystem_clearDevicesRoleForCapturePreset}, - {"getDevicesForRoleAndCapturePreset", "(IILjava/util/List;)I", - (void *)android_media_AudioSystem_getDevicesForRoleAndCapturePreset}, - {"getDevicesForAttributes", - "(Landroid/media/AudioAttributes;[Landroid/media/AudioDeviceAttributes;Z)I", - (void *)android_media_AudioSystem_getDevicesForAttributes}, - {"setUserIdDeviceAffinities", "(I[I[Ljava/lang/String;)I", - (void *)android_media_AudioSystem_setUserIdDeviceAffinities}, - {"removeUserIdDeviceAffinities", "(I)I", - (void *)android_media_AudioSystem_removeUserIdDeviceAffinities}, - {"setCurrentImeUid", "(I)I", (void *)android_media_AudioSystem_setCurrentImeUid}, - {"setVibratorInfos", "(Ljava/util/List;)I", - (void *)android_media_AudioSystem_setVibratorInfos}, - {"nativeGetSpatializer", - "(Landroid/media/INativeSpatializerCallback;)Landroid/os/IBinder;", - (void *)android_media_AudioSystem_getSpatializer}, - {"canBeSpatialized", - "(Landroid/media/AudioAttributes;Landroid/media/AudioFormat;" - "[Landroid/media/AudioDeviceAttributes;)Z", - (void *)android_media_AudioSystem_canBeSpatialized}, - {"getDirectPlaybackSupport", - "(Landroid/media/AudioFormat;Landroid/media/AudioAttributes;)I", - (void *)android_media_AudioSystem_getDirectPlaybackSupport}, - {"getDirectProfilesForAttributes", - "(Landroid/media/AudioAttributes;Ljava/util/ArrayList;)I", - (void *)android_media_AudioSystem_getDirectProfilesForAttributes}, - {"supportsBluetoothVariableLatency", "()Z", - (void *)android_media_AudioSystem_supportsBluetoothVariableLatency}, - {"setBluetoothVariableLatencyEnabled", "(Z)I", - (void *)android_media_AudioSystem_setBluetoothVariableLatencyEnabled}, - {"isBluetoothVariableLatencyEnabled", "()Z", - (void *)android_media_AudioSystem_isBluetoothVariableLatencyEnabled}}; + {MAKE_AUDIO_SYSTEM_METHOD(setParameters), + MAKE_AUDIO_SYSTEM_METHOD(getParameters), + MAKE_AUDIO_SYSTEM_METHOD(muteMicrophone), + MAKE_AUDIO_SYSTEM_METHOD(isMicrophoneMuted), + MAKE_AUDIO_SYSTEM_METHOD(isStreamActive), + MAKE_AUDIO_SYSTEM_METHOD(isStreamActiveRemotely), + MAKE_AUDIO_SYSTEM_METHOD(isSourceActive), + MAKE_AUDIO_SYSTEM_METHOD(newAudioSessionId), + MAKE_AUDIO_SYSTEM_METHOD(newAudioPlayerId), + MAKE_AUDIO_SYSTEM_METHOD(newAudioRecorderId), + MAKE_JNI_NATIVE_METHOD("setDeviceConnectionState", "(ILandroid/os/Parcel;I)I", + android_media_AudioSystem_setDeviceConnectionState), + MAKE_AUDIO_SYSTEM_METHOD(getDeviceConnectionState), + MAKE_AUDIO_SYSTEM_METHOD(handleDeviceConfigChange), + MAKE_AUDIO_SYSTEM_METHOD(setPhoneState), + MAKE_AUDIO_SYSTEM_METHOD(setForceUse), + MAKE_AUDIO_SYSTEM_METHOD(getForceUse), + MAKE_AUDIO_SYSTEM_METHOD(initStreamVolume), + MAKE_AUDIO_SYSTEM_METHOD(setStreamVolumeIndex), + MAKE_AUDIO_SYSTEM_METHOD(getStreamVolumeIndex), + MAKE_JNI_NATIVE_METHOD("setVolumeIndexForAttributes", + "(Landroid/media/AudioAttributes;II)I", + android_media_AudioSystem_setVolumeIndexForAttributes), + MAKE_JNI_NATIVE_METHOD("getVolumeIndexForAttributes", + "(Landroid/media/AudioAttributes;I)I", + android_media_AudioSystem_getVolumeIndexForAttributes), + MAKE_JNI_NATIVE_METHOD("getMinVolumeIndexForAttributes", + "(Landroid/media/AudioAttributes;)I", + android_media_AudioSystem_getMinVolumeIndexForAttributes), + MAKE_JNI_NATIVE_METHOD("getMaxVolumeIndexForAttributes", + "(Landroid/media/AudioAttributes;)I", + android_media_AudioSystem_getMaxVolumeIndexForAttributes), + MAKE_AUDIO_SYSTEM_METHOD(setMasterVolume), + MAKE_AUDIO_SYSTEM_METHOD(getMasterVolume), + MAKE_AUDIO_SYSTEM_METHOD(setMasterMute), + MAKE_AUDIO_SYSTEM_METHOD(getMasterMute), + MAKE_AUDIO_SYSTEM_METHOD(setMasterMono), + MAKE_AUDIO_SYSTEM_METHOD(getMasterMono), + MAKE_AUDIO_SYSTEM_METHOD(setMasterBalance), + MAKE_AUDIO_SYSTEM_METHOD(getMasterBalance), + MAKE_AUDIO_SYSTEM_METHOD(getPrimaryOutputSamplingRate), + MAKE_AUDIO_SYSTEM_METHOD(getPrimaryOutputFrameCount), + MAKE_AUDIO_SYSTEM_METHOD(getOutputLatency), + MAKE_AUDIO_SYSTEM_METHOD(setLowRamDevice), + MAKE_AUDIO_SYSTEM_METHOD(checkAudioFlinger), + MAKE_JNI_NATIVE_METHOD("setAudioFlingerBinder", "(Landroid/os/IBinder;)V", + android_media_AudioSystem_setAudioFlingerBinder), + MAKE_JNI_NATIVE_METHOD("listAudioPorts", "(Ljava/util/ArrayList;[I)I", + android_media_AudioSystem_listAudioPorts), + MAKE_JNI_NATIVE_METHOD("createAudioPatch", + "([Landroid/media/AudioPatch;[Landroid/media/" + "AudioPortConfig;[Landroid/media/AudioPortConfig;)I", + android_media_AudioSystem_createAudioPatch), + MAKE_JNI_NATIVE_METHOD("releaseAudioPatch", "(Landroid/media/AudioPatch;)I", + android_media_AudioSystem_releaseAudioPatch), + MAKE_JNI_NATIVE_METHOD("listAudioPatches", "(Ljava/util/ArrayList;[I)I", + android_media_AudioSystem_listAudioPatches), + MAKE_JNI_NATIVE_METHOD("setAudioPortConfig", "(Landroid/media/AudioPortConfig;)I", + android_media_AudioSystem_setAudioPortConfig), + MAKE_JNI_NATIVE_METHOD("startAudioSource", + "(Landroid/media/AudioPortConfig;Landroid/media/AudioAttributes;)I", + android_media_AudioSystem_startAudioSource), + MAKE_AUDIO_SYSTEM_METHOD(stopAudioSource), + MAKE_AUDIO_SYSTEM_METHOD(getAudioHwSyncForSession), + MAKE_JNI_NATIVE_METHOD("registerPolicyMixes", "(Ljava/util/ArrayList;Z)I", + android_media_AudioSystem_registerPolicyMixes), + MAKE_JNI_NATIVE_METHOD("setUidDeviceAffinities", "(I[I[Ljava/lang/String;)I", + android_media_AudioSystem_setUidDeviceAffinities), + MAKE_AUDIO_SYSTEM_METHOD(removeUidDeviceAffinities), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_register_dynamic_policy_callback", + android_media_AudioSystem_registerDynPolicyCallback), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_register_recording_callback", + android_media_AudioSystem_registerRecordingCallback), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_register_routing_callback", + android_media_AudioSystem_registerRoutingCallback), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_register_vol_range_init_req_callback", + android_media_AudioSystem_registerVolRangeInitReqCallback), + MAKE_AUDIO_SYSTEM_METHOD(systemReady), + MAKE_AUDIO_SYSTEM_METHOD(getStreamVolumeDB), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_get_offload_support", + android_media_AudioSystem_getOffloadSupport), + MAKE_JNI_NATIVE_METHOD("getMicrophones", "(Ljava/util/ArrayList;)I", + android_media_AudioSystem_getMicrophones), + MAKE_JNI_NATIVE_METHOD("getSurroundFormats", "(Ljava/util/Map;)I", + android_media_AudioSystem_getSurroundFormats), + MAKE_JNI_NATIVE_METHOD("getReportedSurroundFormats", "(Ljava/util/ArrayList;)I", + android_media_AudioSystem_getReportedSurroundFormats), + MAKE_AUDIO_SYSTEM_METHOD(setSurroundFormatEnabled), + MAKE_AUDIO_SYSTEM_METHOD(setAssistantServicesUids), + MAKE_AUDIO_SYSTEM_METHOD(setActiveAssistantServicesUids), + MAKE_AUDIO_SYSTEM_METHOD(setA11yServicesUids), + MAKE_AUDIO_SYSTEM_METHOD(isHapticPlaybackSupported), + MAKE_AUDIO_SYSTEM_METHOD(isUltrasoundSupported), + MAKE_JNI_NATIVE_METHOD( + "getHwOffloadFormatsSupportedForBluetoothMedia", "(ILjava/util/ArrayList;)I", + android_media_AudioSystem_getHwOffloadFormatsSupportedForBluetoothMedia), + MAKE_AUDIO_SYSTEM_METHOD(setSupportedSystemUsages), + MAKE_AUDIO_SYSTEM_METHOD(setAllowedCapturePolicy), + MAKE_AUDIO_SYSTEM_METHOD(setRttEnabled), + MAKE_AUDIO_SYSTEM_METHOD(setAudioHalPids), + MAKE_AUDIO_SYSTEM_METHOD(isCallScreeningModeSupported), + MAKE_JNI_NATIVE_METHOD("setDevicesRoleForStrategy", "(II[I[Ljava/lang/String;)I", + android_media_AudioSystem_setDevicesRoleForStrategy), + MAKE_AUDIO_SYSTEM_METHOD(removeDevicesRoleForStrategy), + MAKE_JNI_NATIVE_METHOD("getDevicesForRoleAndStrategy", "(IILjava/util/List;)I", + android_media_AudioSystem_getDevicesForRoleAndStrategy), + MAKE_JNI_NATIVE_METHOD("setDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", + android_media_AudioSystem_setDevicesRoleForCapturePreset), + MAKE_JNI_NATIVE_METHOD("addDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", + android_media_AudioSystem_addDevicesRoleForCapturePreset), + MAKE_JNI_NATIVE_METHOD("removeDevicesRoleForCapturePreset", "(II[I[Ljava/lang/String;)I", + android_media_AudioSystem_removeDevicesRoleForCapturePreset), + MAKE_AUDIO_SYSTEM_METHOD(clearDevicesRoleForCapturePreset), + MAKE_JNI_NATIVE_METHOD("getDevicesForRoleAndCapturePreset", "(IILjava/util/List;)I", + android_media_AudioSystem_getDevicesForRoleAndCapturePreset), + MAKE_JNI_NATIVE_METHOD("getDevicesForAttributes", + "(Landroid/media/AudioAttributes;[Landroid/media/" + "AudioDeviceAttributes;Z)I", + android_media_AudioSystem_getDevicesForAttributes), + MAKE_JNI_NATIVE_METHOD("setUserIdDeviceAffinities", "(I[I[Ljava/lang/String;)I", + android_media_AudioSystem_setUserIdDeviceAffinities), + MAKE_AUDIO_SYSTEM_METHOD(removeUserIdDeviceAffinities), + MAKE_AUDIO_SYSTEM_METHOD(setCurrentImeUid), + MAKE_JNI_NATIVE_METHOD("setVibratorInfos", "(Ljava/util/List;)I", + android_media_AudioSystem_setVibratorInfos), + MAKE_JNI_NATIVE_METHOD("nativeGetSpatializer", + "(Landroid/media/INativeSpatializerCallback;)Landroid/os/IBinder;", + android_media_AudioSystem_getSpatializer), + MAKE_JNI_NATIVE_METHOD("canBeSpatialized", + "(Landroid/media/AudioAttributes;Landroid/media/AudioFormat;" + "[Landroid/media/AudioDeviceAttributes;)Z", + android_media_AudioSystem_canBeSpatialized), + MAKE_JNI_NATIVE_METHOD("getDirectPlaybackSupport", + "(Landroid/media/AudioFormat;Landroid/media/AudioAttributes;)I", + android_media_AudioSystem_getDirectPlaybackSupport), + MAKE_JNI_NATIVE_METHOD("getDirectProfilesForAttributes", + "(Landroid/media/AudioAttributes;Ljava/util/ArrayList;)I", + android_media_AudioSystem_getDirectProfilesForAttributes), + MAKE_AUDIO_SYSTEM_METHOD(supportsBluetoothVariableLatency), + MAKE_AUDIO_SYSTEM_METHOD(setBluetoothVariableLatencyEnabled), + MAKE_AUDIO_SYSTEM_METHOD(isBluetoothVariableLatencyEnabled)}; -static const JNINativeMethod gEventHandlerMethods[] = { - {"native_setup", - "(Ljava/lang/Object;)V", - (void *)android_media_AudioSystem_eventHandlerSetup}, - {"native_finalize", - "()V", - (void *)android_media_AudioSystem_eventHandlerFinalize}, -}; +static const JNINativeMethod gEventHandlerMethods[] = + {MAKE_JNI_NATIVE_METHOD("native_setup", "(Ljava/lang/Object;)V", + android_media_AudioSystem_eventHandlerSetup), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_finalize", + android_media_AudioSystem_eventHandlerFinalize)}; -static const JNINativeMethod gFrameworkCapabilities[] = { - {"native_getMaxChannelCount", "()I", (void *)android_media_AudioSystem_getMaxChannelCount}, - {"native_getMaxSampleRate", "()I", (void *)android_media_AudioSystem_getMaxSampleRate}, - {"native_getMinSampleRate", "()I", (void *)android_media_AudioSystem_getMinSampleRate}, -}; +static const JNINativeMethod gFrameworkCapabilities[] = + {MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_getMaxChannelCount", + android_media_AudioSystem_getMaxChannelCount), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_getMaxSampleRate", + android_media_AudioSystem_getMaxSampleRate), + MAKE_JNI_NATIVE_METHOD_AUTOSIG("native_getMinSampleRate", + android_media_AudioSystem_getMinSampleRate)}; int register_android_media_AudioSystem(JNIEnv *env) { @@ -3177,7 +3174,7 @@ int register_android_media_AudioSystem(JNIEnv *env) gClsAudioTrackRoutingProxy = android::FindClassOrDie(env, "android/media/AudioTrackRoutingProxy"); // make sure this reference doesn't get deleted - gClsAudioTrackRoutingProxy = (jclass)env->NewGlobalRef(gClsAudioTrackRoutingProxy); + gClsAudioTrackRoutingProxy = static_cast(env->NewGlobalRef(gClsAudioTrackRoutingProxy)); gMidAudioTrackRoutingProxy_ctor = android::GetMethodIDOrDie(env, gClsAudioTrackRoutingProxy, "", "(J)V"); @@ -3188,7 +3185,8 @@ int register_android_media_AudioSystem(JNIEnv *env) gClsAudioRecordRoutingProxy = android::FindClassOrDie(env, "android/media/AudioRecordRoutingProxy"); // make sure this reference doesn't get deleted - gClsAudioRecordRoutingProxy = (jclass)env->NewGlobalRef(gClsAudioRecordRoutingProxy); + gClsAudioRecordRoutingProxy = + static_cast(env->NewGlobalRef(gClsAudioRecordRoutingProxy)); gMidAudioRecordRoutingProxy_ctor = android::GetMethodIDOrDie(env, gClsAudioRecordRoutingProxy, "", "(J)V"); From 20e7cf46eac2345d797ade05b1f6ac49fa07d5e4 Mon Sep 17 00:00:00 2001 From: Mikhail Naganov Date: Tue, 11 Jul 2023 11:48:38 -0700 Subject: [PATCH 3/3] [media]: Address post-refactoring comments Test: m Change-Id: I86b19e65ec5bcd56b282037e49ad836bf333f741 --- core/jni/android_media_AudioSystem.cpp | 107 ++++++++++--------------- 1 file changed, 44 insertions(+), 63 deletions(-) diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp index abd5416971de1..b7a30e518c134 100644 --- a/core/jni/android_media_AudioSystem.cpp +++ b/core/jni/android_media_AudioSystem.cpp @@ -461,8 +461,7 @@ android_media_AudioSystem_setParameters(JNIEnv *env, jobject thiz, jstring keyVa env->GetStringLength(keyValuePairs)); env->ReleaseStringCritical(keyValuePairs, c_keyValuePairs); } - int status = check_AudioSystem_Command(AudioSystem::setParameters(c_keyValuePairs8)); - return status; + return check_AudioSystem_Command(AudioSystem::setParameters(c_keyValuePairs8)); } static jstring @@ -1052,12 +1051,12 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefreset(env->NewObject(gAudioPortClass, gAudioPortCstor, jHandle.get(), // handle 0, // role - NULL, // name - NULL, // samplingRates - NULL, // channelMasks - NULL, // channelIndexMasks - NULL, // formats - NULL)); // gains + nullptr, // name + nullptr, // samplingRates + nullptr, // channelMasks + nullptr, // channelIndexMasks + nullptr, // formats + nullptr)); // gains if (*jAudioPort == nullptr) { return AUDIO_JAVA_ERROR; @@ -1084,8 +1083,10 @@ static jint convertAudioPortConfigFromNative(JNIEnv *env, ScopedLocalRefgain.mode); if (audioportCreated) { ALOGV("convertAudioPortConfigFromNative creating gain"); - jAudioGain.reset(env->NewObject(gAudioGainClass, gAudioGainCstor, gainIndex, 0, 0, 0, 0, - 0, 0, 0, 0)); + jAudioGain.reset(env->NewObject(gAudioGainClass, gAudioGainCstor, gainIndex, 0 /*mode*/, + 0 /*channelMask*/, 0 /*minValue*/, 0 /*maxValue*/, + 0 /*defaultValue*/, 0 /*stepValue*/, + 0 /*rampDurationMinMs*/, 0 /*rampDurationMaxMs*/)); if (jAudioGain == NULL) { ALOGV("convertAudioPortConfigFromNative creating gain FAILED"); return AUDIO_JAVA_ERROR; @@ -1227,7 +1228,7 @@ static bool isAudioPortArrayCountOutOfBounds(const struct audio_port_v7 *nAudioP return false; } -static jint convertAudioProfileFromNative(JNIEnv *env, jobject *jAudioProfile, +static jint convertAudioProfileFromNative(JNIEnv *env, ScopedLocalRef *jAudioProfile, const audio_profile *nAudioProfile, bool useInMask) { size_t numPositionMasks = 0; size_t numIndexMasks = 0; @@ -1281,10 +1282,9 @@ static jint convertAudioProfileFromNative(JNIEnv *env, jobject *jAudioProfile, ALOGW("Unknown encapsulation type for JAVA API: %u", nAudioProfile->encapsulation_type); } - *jAudioProfile = env->NewObject(gAudioProfileClass, gAudioProfileCstor, audioFormat, - jSamplingRates.get(), jChannelMasks.get(), - jChannelIndexMasks.get(), encapsulationType); - + jAudioProfile->reset(env->NewObject(gAudioProfileClass, gAudioProfileCstor, audioFormat, + jSamplingRates.get(), jChannelMasks.get(), + jChannelIndexMasks.get(), encapsulationType)); if (*jAudioProfile == nullptr) { return AUDIO_JAVA_ERROR; } @@ -1330,10 +1330,9 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu ScopedLocalRef jPcmFloatProfileFromExtendedInteger(env, nullptr); for (size_t i = 0; i < nAudioPort->num_audio_profiles; ++i) { - jobject jAudioProfile = nullptr; - jint jStatus = AUDIO_JAVA_SUCCESS; - jStatus = convertAudioProfileFromNative(env, &jAudioProfile, &nAudioPort->audio_profiles[i], - useInMask); + ScopedLocalRef jAudioProfile(env); + jint jStatus = convertAudioProfileFromNative(env, &jAudioProfile, + &nAudioPort->audio_profiles[i], useInMask); if (jStatus == AUDIO_JAVA_BAD_VALUE) { // skipping Java layer unsupported audio formats continue; @@ -1341,7 +1340,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu if (jStatus != NO_ERROR) { return AUDIO_JAVA_ERROR; } - env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jAudioProfile); + env->CallBooleanMethod(jAudioProfiles.get(), gArrayListMethods.add, jAudioProfile.get()); if (nAudioPort->audio_profiles[i].format == AUDIO_FORMAT_PCM_FLOAT) { hasFloat = true; @@ -1351,22 +1350,22 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu ScopedLocalRef jSamplingRates(env, static_cast( - env->GetObjectField(jAudioProfile, + env->GetObjectField(jAudioProfile.get(), gAudioProfileFields .mSamplingRates))); ScopedLocalRef jChannelMasks(env, static_cast( - env->GetObjectField(jAudioProfile, + env->GetObjectField(jAudioProfile.get(), gAudioProfileFields.mChannelMasks))); ScopedLocalRef jChannelIndexMasks(env, static_cast( - env->GetObjectField(jAudioProfile, + env->GetObjectField(jAudioProfile.get(), gAudioProfileFields .mChannelIndexMasks))); int encapsulationType = - env->GetIntField(jAudioProfile, gAudioProfileFields.mEncapsulationType); + env->GetIntField(jAudioProfile.get(), gAudioProfileFields.mEncapsulationType); jPcmFloatProfileFromExtendedInteger.reset( env->NewObject(gAudioProfileClass, gAudioProfileCstor, @@ -1374,10 +1373,6 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu jSamplingRates.get(), jChannelMasks.get(), jChannelIndexMasks.get(), encapsulationType)); } - - if (jAudioProfile != nullptr) { - env->DeleteLocalRef(jAudioProfile); - } } if (!hasFloat && jPcmFloatProfileFromExtendedInteger.get() != nullptr) { // R and earlier compatibility - add ENCODING_PCM_FLOAT to the end @@ -1429,7 +1424,7 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu // gains ScopedLocalRef jGains(env, env->NewObjectArray(nAudioPort->num_gains, gAudioGainClass, - NULL)); + nullptr)); if (jGains == nullptr) { return AUDIO_JAVA_ERROR; } @@ -1481,13 +1476,13 @@ static jint convertAudioPortFromNative(JNIEnv *env, ScopedLocalRef *jAu nAudioPort->ext.device .encapsulation_metadata_types)); ALOGV("convertAudioPortFromNative is a device %08x", nAudioPort->ext.device.type); - jstring jAddress = env->NewStringUTF(nAudioPort->ext.device.address); - jAudioPort->reset( - env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, jHandle.get(), - jDeviceName.get(), jAudioProfiles.get(), jGains.get(), - nAudioPort->ext.device.type, jAddress, jEncapsulationModes.get(), - jEncapsulationMetadataTypes.get(), jAudioDescriptors.get())); - env->DeleteLocalRef(jAddress); + ScopedLocalRef jAddress(env, env->NewStringUTF(nAudioPort->ext.device.address)); + jAudioPort->reset(env->NewObject(gAudioDevicePortClass, gAudioDevicePortCstor, + jHandle.get(), jDeviceName.get(), jAudioProfiles.get(), + jGains.get(), nAudioPort->ext.device.type, jAddress.get(), + jEncapsulationModes.get(), + jEncapsulationMetadataTypes.get(), + jAudioDescriptors.get())); } else if (nAudioPort->type == AUDIO_PORT_TYPE_MIX) { ALOGV("convertAudioPortFromNative is a mix"); jAudioPort->reset(env->NewObject(gAudioMixPortClass, gAudioMixPortCstor, jHandle.get(), @@ -1543,7 +1538,7 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz, } status_t status; - unsigned int generation1; + unsigned int generation1 = 0; unsigned int generation; unsigned int numPorts; std::vector nPorts; @@ -1577,23 +1572,13 @@ android_media_AudioSystem_listAudioPorts(JNIEnv *env, jobject clazz, } while (generation1 != generation && status == NO_ERROR); jStatus = nativeToJavaStatus(status); - if (jStatus != AUDIO_JAVA_SUCCESS) { - if (!setGeneration(env, jGeneration, generation1)) { - jStatus = AUDIO_JAVA_ERROR; + if (jStatus == AUDIO_JAVA_SUCCESS) { + for (size_t i = 0; i < numPorts; i++) { + ScopedLocalRef jAudioPort(env, nullptr); + jStatus = convertAudioPortFromNative(env, &jAudioPort, &nPorts[i]); + if (jStatus != AUDIO_JAVA_SUCCESS) break; + env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort.get()); } - return jStatus; - } - - for (size_t i = 0; i < numPorts; i++) { - ScopedLocalRef jAudioPort(env, nullptr); - jStatus = convertAudioPortFromNative(env, &jAudioPort, &nPorts[i]); - if (jStatus != AUDIO_JAVA_SUCCESS) { - if (!setGeneration(env, jGeneration, generation1)) { - jStatus = AUDIO_JAVA_ERROR; - } - return jStatus; - } - env->CallBooleanMethod(jPorts, gArrayListMethods.add, jAudioPort.get()); } if (!setGeneration(env, jGeneration, generation1)) { jStatus = AUDIO_JAVA_ERROR; @@ -1629,7 +1614,7 @@ android_media_AudioSystem_createAudioPatch(JNIEnv *env, jobject clazz, audio_patch_handle_t handle = static_cast(AUDIO_PATCH_HANDLE_NONE); ScopedLocalRef jPatch(env, env->GetObjectArrayElement(jPatches, 0)); ScopedLocalRef jPatchHandle(env, nullptr); - if (jPatch != NULL) { + if (jPatch != nullptr) { if (!env->IsInstanceOf(jPatch.get(), gAudioPatchClass)) { return AUDIO_JAVA_BAD_VALUE; } @@ -1765,7 +1750,7 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, nPatches.resize(numPatches); - status = AudioSystem::listAudioPatches(&numPatches, &nPatches[0], &generation); + status = AudioSystem::listAudioPatches(&numPatches, nPatches.data(), &generation); ALOGV("listAudioPatches AudioSystem::listAudioPatches numPatches %d generation %d generation1 %d", numPatches, generation, generation1); @@ -1847,7 +1832,6 @@ android_media_AudioSystem_listAudioPatches(JNIEnv *env, jobject clazz, jPatch.reset(env->NewObject(gAudioPatchClass, gAudioPatchCstor, patchHandle, jSources.get(), jSinks.get())); if (jPatch == nullptr) { - jStatus = AUDIO_JAVA_ERROR; setGeneration(env, jGeneration, generation1); return AUDIO_JAVA_ERROR; } @@ -2348,9 +2332,7 @@ android_media_AudioSystem_setSurroundFormatEnabled(JNIEnv *env, jobject thiz, { status_t status = AudioSystem::setSurroundFormatEnabled(audioFormatToNative(audioFormat), enabled); - if (status != NO_ERROR) { - ALOGE_IF(status != NO_ERROR, "AudioSystem::setSurroundFormatEnabled error %d", status); - } + ALOGE_IF(status != NO_ERROR, "AudioSystem::setSurroundFormatEnabled error %d", status); return nativeToJavaStatus(status); } @@ -2469,7 +2451,7 @@ android_media_AudioSystem_setAudioHalPids(JNIEnv *env, jobject clazz, jintArray if (jPids == NULL) { return AUDIO_JAVA_BAD_VALUE; } - pid_t *nPidsArray = reinterpret_cast(env->GetIntArrayElements(jPids, NULL)); + pid_t *nPidsArray = reinterpret_cast(env->GetIntArrayElements(jPids, nullptr)); std::vector nPids(nPidsArray, nPidsArray + env->GetArrayLength(jPids)); status_t status = AudioSystem::setAudioHalPids(nPids); env->ReleaseIntArrayElements(jPids, nPidsArray, 0); @@ -2800,7 +2782,7 @@ static jint android_media_AudioSystem_getDirectProfilesForAttributes(JNIEnv *env } for (const auto &audioProfile : audioProfiles) { - jobject jAudioProfile; + ScopedLocalRef jAudioProfile(env); jint jConvertProfileStatus = convertAudioProfileFromNative( env, &jAudioProfile, &audioProfile, false); if (jConvertProfileStatus == AUDIO_JAVA_BAD_VALUE) { @@ -2810,8 +2792,7 @@ static jint android_media_AudioSystem_getDirectProfilesForAttributes(JNIEnv *env if (jConvertProfileStatus != AUDIO_JAVA_SUCCESS) { return jConvertProfileStatus; } - env->CallBooleanMethod(jAudioProfilesList, gArrayListMethods.add, jAudioProfile); - env->DeleteLocalRef(jAudioProfile); + env->CallBooleanMethod(jAudioProfilesList, gArrayListMethods.add, jAudioProfile.get()); } return jStatus; }