bunnypad/android_device_samsung_a20
Watch
1
0
Fork
You've already forked android_device_samsung_a20
 0
mirror of https://github.com/chararomandroid/android_device_samsung_a20 synced 2026-08-22 04:05:31 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

universal7885: fm-aidl: Run clang-format

Browse source
This commit is contained in:
roynatech2544 2022-11-09 19:03:21 +09:00
commit 7d23777f39
8 changed files with 203 additions and 188 deletions
Download patch file Download diff file Expand all files Collapse all files

14
universal7885-common/apps/aidl-support/fm/default/CommonMacro.h
View file

@ -2,14 +2,14 @@
#include <android-base/logging.h>
#define RETURN_IF_FAILED_LOCK \
({ \
if (!lock.try_lock_for(std::chrono::milliseconds(100))) \
return ::ndk::ScopedAStatus::fromServiceSpecificError(-ETIME); \
})
#define RETURN_IF_FAILED_LOCK \
({ \
if (!lock.try_lock_for(std::chrono::milliseconds(100))) \
return ::ndk::ScopedAStatus::fromServiceSpecificError(-ETIME); \
})
#define NOT_SUPPORTED \
({ \
({ \
LOG(ERROR) << __func__ << ": Attempted to invoke unsupported operation"; \
return ::ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); \
})
})

263
universal7885-common/apps/aidl-support/fm/default/FMDevControl.cpp
View file

@ -16,16 +16,16 @@
#include "FMDevControl.h"
#include <fm_slsi-impl.h>
#include <LogFormat.h>
#include <fm_slsi-impl.h>
#include <android/binder_manager.h>
#include <log/log.h>
#include <algorithm>
#include <cassert>
#include <cerrno>
#include <chrono>
#include <algorithm>
#include <fcntl.h>
#include <signal.h>
@ -37,145 +37,154 @@
namespace aidl::vendor::eureka::hardware::fmradio {
::ndk::ScopedAStatus FMDevControl::open(void) {
fd = fm_radio_slsi::open_device();
assert(fd > 0);
fm_radio_slsi::bootctrl(fd);
return ::ndk::ScopedAStatus::ok();
fd = fm_radio_slsi::open_device();
assert(fd > 0);
fm_radio_slsi::bootctrl(fd);
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus FMDevControl::getValue(GetType type, int *_aidl_return) {
LOG_D("%s: type %d", __func__, type);
if (type != GetType::GET_TYPE_FM_MUTEX_LOCKED) {
RETURN_IF_FAILED_LOCK;
}
assert(fd > 0);
switch (type) {
case GetType::GET_TYPE_FM_FREQ:
fm_radio_slsi::get_frequency(fd, _aidl_return);
break;
case GetType::GET_TYPE_FM_UPPER_LIMIT:
*_aidl_return = fm_radio_slsi::get_upperband_limit(fd);
break;
case GetType::GET_TYPE_FM_LOWER_LIMIT:
*_aidl_return = fm_radio_slsi::get_lowerband_limit(fd);
break;
case GetType::GET_TYPE_FM_RMSSI:
*_aidl_return = fm_radio_slsi::get_rmssi(fd);
break;
case GetType::GET_TYPE_FM_BEFORE_CHANNEL:
if (index > 0) index -= 1;
if (kMiddleState != nullptr) {
index = kMiddleState->first;
delete kMiddleState;
kMiddleState = nullptr;
}
fm_radio_slsi::set_frequency(fd, freqs_list[index]);
*_aidl_return = freqs_list[index];
break;
case GetType::GET_TYPE_FM_NEXT_CHANNEL:
if (index < freqs_list.size() - 1) index += 1;
if (kMiddleState != nullptr) {
index = kMiddleState->second;
delete kMiddleState;
kMiddleState = nullptr;
}
fm_radio_slsi::set_frequency(fd, freqs_list[index]);
*_aidl_return = freqs_list[index];
break;
case GetType::GET_TYPE_FM_SYSFS_IF:
NOT_SUPPORTED;
case GetType::GET_TYPE_FM_MUTEX_LOCKED:
if (lock.try_lock()){
*_aidl_return = false;
lock.unlock();
} else {
*_aidl_return = true;
}
break;
default:
break;
};
if (type != GetType::GET_TYPE_FM_MUTEX_LOCKED) {
lock.unlock();
}
LOG_D("%s: returning %d", __func__, *_aidl_return);
LOG_D("%s: type %d", __func__, type);
if (type != GetType::GET_TYPE_FM_MUTEX_LOCKED) {
RETURN_IF_FAILED_LOCK;
}
assert(fd > 0);
switch (type) {
case GetType::GET_TYPE_FM_FREQ:
fm_radio_slsi::get_frequency(fd, _aidl_return);
break;
case GetType::GET_TYPE_FM_UPPER_LIMIT:
*_aidl_return = fm_radio_slsi::get_upperband_limit(fd);
break;
case GetType::GET_TYPE_FM_LOWER_LIMIT:
*_aidl_return = fm_radio_slsi::get_lowerband_limit(fd);
break;
case GetType::GET_TYPE_FM_RMSSI:
*_aidl_return = fm_radio_slsi::get_rmssi(fd);
break;
case GetType::GET_TYPE_FM_BEFORE_CHANNEL:
if (index > 0)
index -= 1;
if (kMiddleState != nullptr) {
index = kMiddleState->first;
delete kMiddleState;
kMiddleState = nullptr;
}
fm_radio_slsi::set_frequency(fd, freqs_list[index]);
*_aidl_return = freqs_list[index];
break;
case GetType::GET_TYPE_FM_NEXT_CHANNEL:
if (index < freqs_list.size() - 1)
index += 1;
if (kMiddleState != nullptr) {
index = kMiddleState->second;
delete kMiddleState;
kMiddleState = nullptr;
}
fm_radio_slsi::set_frequency(fd, freqs_list[index]);
*_aidl_return = freqs_list[index];
break;
case GetType::GET_TYPE_FM_SYSFS_IF:
NOT_SUPPORTED;
case GetType::GET_TYPE_FM_MUTEX_LOCKED:
if (lock.try_lock()) {
*_aidl_return = false;
lock.unlock();
} else {
*_aidl_return = true;
}
break;
default:
break;
};
if (type != GetType::GET_TYPE_FM_MUTEX_LOCKED) {
lock.unlock();
}
LOG_D("%s: returning %d", __func__, *_aidl_return);
return ::ndk::ScopedAStatus::ok();
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus FMDevControl::setValue(SetType type, int value) {
using audio_route::IAudioRoute;
using audio_route::IAudioRoute;
LOG_D("%s: type %d, value %d", __func__, type, value);
LOG_D("%s: type %d, value %d", __func__, type, value);
RETURN_IF_FAILED_LOCK;
assert(fd > 0);
switch (type) {
case SetType::SET_TYPE_FM_FREQ:
fm_radio_slsi::set_frequency(fd, value);
if (std::find(freqs_list.begin(), freqs_list.end(), value) == freqs_list.end())
kMiddleState = saveMiddleState(value, freqs_list);
break;
case SetType::SET_TYPE_FM_MUTE:
fm_radio_slsi::set_mute(fd, value);
break;
case SetType::SET_TYPE_FM_VOLUME:
fm_radio_slsi::set_volume(fd, value);
break;
case SetType::SET_TYPE_FM_THREAD:
fm_radio_slsi::fm_thread_set(fd, value);
break;
case SetType::SET_TYPE_FM_RMSSI:
fm_radio_slsi::set_rssi(fd, value);
break;
case SetType::SET_TYPE_FM_SEARCH_CANCEL:
fm_radio_slsi::stop_search(fd);
break;
case SetType::SET_TYPE_FM_SPEAKER_ROUTE: {
auto svc = IAudioRoute::fromBinder(ndk::SpAIBinder(AServiceManager_waitForService("vendor.eureka.hardware.audio_route.IAudioRoute/default")));
svc->setParam(value ? "routing=2": "routing=8");
break;
}
case SetType::SET_TYPE_FM_SEARCH_START:
lock.unlock();
search_thread = new std::thread([this] {
const std::lock_guard<std::timed_mutex> guard(lock);
freqs_list = fm_radio_slsi::get_freqs(fd);
std::sort(freqs_list.begin(), freqs_list.end(), std::less<int>());
});
break;
case SetType::SET_TYPE_FM_APP_PID: {
client_observe_thread = new std::thread([=] {
pid_t pid = value;
RETURN_IF_FAILED_LOCK;
assert(fd > 0);
switch (type) {
case SetType::SET_TYPE_FM_FREQ:
fm_radio_slsi::set_frequency(fd, value);
if (std::find(freqs_list.begin(), freqs_list.end(), value) ==
freqs_list.end())
kMiddleState = saveMiddleState(value, freqs_list);
break;
case SetType::SET_TYPE_FM_MUTE:
fm_radio_slsi::set_mute(fd, value);
break;
case SetType::SET_TYPE_FM_VOLUME:
fm_radio_slsi::set_volume(fd, value);
break;
case SetType::SET_TYPE_FM_THREAD:
fm_radio_slsi::fm_thread_set(fd, value);
break;
case SetType::SET_TYPE_FM_RMSSI:
fm_radio_slsi::set_rssi(fd, value);
break;
case SetType::SET_TYPE_FM_SEARCH_CANCEL:
fm_radio_slsi::stop_search(fd);
break;
case SetType::SET_TYPE_FM_SPEAKER_ROUTE: {
auto svc =
IAudioRoute::fromBinder(ndk::SpAIBinder(AServiceManager_waitForService(
"vendor.eureka.hardware.audio_route.IAudioRoute/default")));
svc->setParam(value ? "routing=2" : "routing=8");
break;
}
case SetType::SET_TYPE_FM_SEARCH_START:
lock.unlock();
search_thread = new std::thread([this] {
const std::lock_guard<std::timed_mutex> guard(lock);
freqs_list = fm_radio_slsi::get_freqs(fd);
std::sort(freqs_list.begin(), freqs_list.end(), std::less<int>());
});
break;
case SetType::SET_TYPE_FM_APP_PID: {
client_observe_thread = new std::thread([=] {
pid_t pid = value;
LOG_D("FM_APP_PID: received value %d", pid);
while (true) {
if (kill(pid, 0) < 0 && errno == ESRCH) break;
std::this_thread::sleep_for(std::chrono::seconds(2));
}
LOG_W("FM_APP_PID: Starting client death receiver");
fm_radio_slsi::fm_thread_set(fd, 0);
close();
});
break;
}
default:
break;
};
if (type != SetType::SET_TYPE_FM_SEARCH_START) lock.unlock();
return ::ndk::ScopedAStatus::ok();
LOG_D("FM_APP_PID: received value %d", pid);
while (true) {
if (kill(pid, 0) < 0 && errno == ESRCH)
break;
std::this_thread::sleep_for(std::chrono::seconds(2));
}
LOG_W("FM_APP_PID: Starting client death receiver");
fm_radio_slsi::fm_thread_set(fd, 0);
close();
});
break;
}
default:
break;
};
if (type != SetType::SET_TYPE_FM_SEARCH_START)
lock.unlock();
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus FMDevControl::getFreqsList(std::vector<int> *_aidl_return){
RETURN_IF_FAILED_LOCK;
*_aidl_return = freqs_list;
lock.unlock();
return ::ndk::ScopedAStatus::ok();
::ndk::ScopedAStatus
FMDevControl::getFreqsList(std::vector<int> *_aidl_return) {
RETURN_IF_FAILED_LOCK;
*_aidl_return = freqs_list;
lock.unlock();
return ::ndk::ScopedAStatus::ok();
}
::ndk::ScopedAStatus FMDevControl::close() {
if (fd > 0) ::close(fd);
fd = -1;
return ::ndk::ScopedAStatus::ok();
if (fd > 0)
::close(fd);
fd = -1;
return ::ndk::ScopedAStatus::ok();
}
} // namespace aidl::vendor::eureka::hardware::fmradio

9
universal7885-common/apps/aidl-support/fm/default/FMDevControl.h
View file

@ -24,17 +24,16 @@
namespace aidl::vendor::eureka::hardware::fmradio {
struct FMDevControl : public BnFMDevControl {
public:
FMDevControl(void) {
index = 0;
}
public:
FMDevControl(void) { index = 0; }
// Methods from aidl::vendor::eureka::hardware::fmradio::IFMRadio follow.
::ndk::ScopedAStatus open(void) override;
::ndk::ScopedAStatus getValue(GetType type, int *_aidl_return) override;
::ndk::ScopedAStatus setValue(SetType type, int value) override;
::ndk::ScopedAStatus getFreqsList(std::vector<int> *_aidl_return) override;
::ndk::ScopedAStatus close(void) override;
private:
private:
int fd;
unsigned int index;
std::timed_mutex lock;

51
universal7885-common/apps/aidl-support/fm/default/FMSupport.cpp
View file

@ -45,21 +45,23 @@ constexpr const char *FM_FREQ_SEEK = FM_SYSFS_BASE "/radio_freq_seek";
case GetType::GET_TYPE_FM_RMSSI:
NOT_SUPPORTED;
case GetType::GET_TYPE_FM_BEFORE_CHANNEL:
if (index > 0) index -= 1;
if (index > 0)
index -= 1;
if (kMiddleState != nullptr) {
index = kMiddleState->first;
delete kMiddleState;
kMiddleState = nullptr;
index = kMiddleState->first;
delete kMiddleState;
kMiddleState = nullptr;
}
FileIO::writeline(FM_FREQ_CTL, freqs_list[index]);
*_aidl_return = freqs_list[index];
break;
case GetType::GET_TYPE_FM_NEXT_CHANNEL:
if (index < freqs_list.size() - 1) index += 1;
if (index < freqs_list.size() - 1)
index += 1;
if (kMiddleState != nullptr) {
index = kMiddleState->second;
delete kMiddleState;
kMiddleState = nullptr;
index = kMiddleState->second;
delete kMiddleState;
kMiddleState = nullptr;
}
FileIO::writeline(FM_FREQ_CTL, freqs_list[index]);
*_aidl_return = freqs_list[index];
@ -69,10 +71,10 @@ constexpr const char *FM_FREQ_SEEK = FM_SYSFS_BASE "/radio_freq_seek";
break;
case GetType::GET_TYPE_FM_MUTEX_LOCKED:
if (lock.try_lock()) {
*_aidl_return = false;
lock.unlock();
*_aidl_return = false;
lock.unlock();
} else {
*_aidl_return = true;
*_aidl_return = true;
}
break;
default:
@ -88,8 +90,9 @@ constexpr const char *FM_FREQ_SEEK = FM_SYSFS_BASE "/radio_freq_seek";
switch (type) {
case SetType::SET_TYPE_FM_FREQ:
FileIO::writeline(FM_FREQ_CTL, value);
if (std::find(freqs_list.begin(), freqs_list.end(), value) == freqs_list.end())
kMiddleState = saveMiddleState(value, freqs_list);
if (std::find(freqs_list.begin(), freqs_list.end(), value) ==
freqs_list.end())
kMiddleState = saveMiddleState(value, freqs_list);
break;
case SetType::SET_TYPE_FM_MUTE:
case SetType::SET_TYPE_FM_VOLUME:
@ -102,20 +105,24 @@ constexpr const char *FM_FREQ_SEEK = FM_SYSFS_BASE "/radio_freq_seek";
case SetType::SET_TYPE_FM_SEARCH_START:
lock.unlock();
search_thread = new std::thread([this] {
const std::lock_guard<std::timed_mutex> guard(lock);
for (int i = 0; i < TRACK_SIZE; i++) {
FileIO::writeline(FM_FREQ_SEEK, "1 " + std::to_string(SYSFS_SPACING * 10));
int freq = FileIO::readline(FM_FREQ_CTL);
if (std::find(freqs_list.begin(), freqs_list.end(), freq) != freqs_list.end()) continue;
freqs_list.push_back(freq);
}
std::sort(freqs_list.begin(), freqs_list.end(), std::less<int>());
const std::lock_guard<std::timed_mutex> guard(lock);
for (int i = 0; i < TRACK_SIZE; i++) {
FileIO::writeline(FM_FREQ_SEEK,
"1 " + std::to_string(SYSFS_SPACING * 10));
int freq = FileIO::readline(FM_FREQ_CTL);
if (std::find(freqs_list.begin(), freqs_list.end(), freq) !=
freqs_list.end())
continue;
freqs_list.push_back(freq);
}
std::sort(freqs_list.begin(), freqs_list.end(), std::less<int>());
});
break;
default:
break;
};
if (type != SetType::SET_TYPE_FM_SEARCH_START) lock.unlock();
if (type != SetType::SET_TYPE_FM_SEARCH_START)
lock.unlock();
return ::ndk::ScopedAStatus::ok();
}

9
universal7885-common/apps/aidl-support/fm/default/FMSupport.h
View file

@ -16,24 +16,23 @@
#include <aidl/vendor/eureka/hardware/fmradio/BnFMDevControl.h>
#include "MiddleState.h"
#include <mutex>
#include <thread>
#include "MiddleState.h"
namespace aidl::vendor::eureka::hardware::fmradio {
struct FMSupport : public BnFMDevControl {
public:
FMSupport(void) {
index = 0;
};
FMSupport(void) { index = 0; };
// Methods from aidl::vendor::eureka::hardware::fmradio::IFMRadio follow.
::ndk::ScopedAStatus open(void) override;
::ndk::ScopedAStatus getValue(GetType type, int *_aidl_return) override;
::ndk::ScopedAStatus setValue(SetType type, int value) override;
::ndk::ScopedAStatus getFreqsList(std::vector<int> *_aidl_return) override;
::ndk::ScopedAStatus close(void) override;
private:
private:
std::timed_mutex lock;
std::thread *search_thread;
std::vector<int> freqs_list;

28
universal7885-common/apps/aidl-support/fm/default/MiddleState.cpp
View file

@ -1,20 +1,20 @@
#include "MiddleState.h"
middlestate_t *saveMiddleState(const int value, const std::vector<int> &vec)
{
unsigned int i;
middlestate_t *saveMiddleState(const int value, const std::vector<int> &vec) {
unsigned int i;
// Bounds checking, we need at least 2 elements on the vector.
// If it doesn't meet the requirements, return nullptr to keep it
// as-is.
if (vec.size() <= 1) return nullptr;
// Bounds checking, we need at least 2 elements on the vector.
// If it doesn't meet the requirements, return nullptr to keep it
// as-is.
if (vec.size() <= 1)
return nullptr;
for (i = 0; i < vec.size() - 1; i++) {
const int first = vec[i] - value;
const int second = vec[i + 1] - value;
if (first * second < 0)
break;
}
for (i = 0; i < vec.size() - 1; i++) {
const int first = vec[i] - value;
const int second = vec[i + 1] - value;
if (first * second < 0)
break;
}
return new middlestate_t {i, i + 1};
return new middlestate_t{i, i + 1};
}

4
universal7885-common/apps/aidl-support/fm/default/MiddleState.h
View file

@ -3,8 +3,8 @@
#pragma once
struct pair {
unsigned int first;
unsigned int second;
unsigned int first;
unsigned int second;
};
using middlestate_t = struct pair;

5
universal7885-common/apps/aidl-support/fm/default/service.cpp
View file

@ -16,13 +16,14 @@
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include "FMSupport.h"
#include "FMDevControl.h"
#include "FMSupport.h"
using ::aidl::vendor::eureka::hardware::fmradio::FMDevControl;
using ::aidl::vendor::eureka::hardware::fmradio::FMSupport;
template <class C> static void registerAsService(std::shared_ptr<C> service, const char *inst) {
template <class C>
static void registerAsService(std::shared_ptr<C> service, const char *inst) {
const std::string instance = std::string() + C::descriptor + "/" + inst;
binder_status_t status =
AServiceManager_addService(service->asBinder().get(), instance.c_str());