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-24 04:45:32 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

universal7885: format code using clang-format-15

Browse source
This commit is contained in:
roynatech2544 2022-04-12 17:26:15 +09:00
commit cb072badd5
No known key found for this signature in database
GPG key ID: 50ABF73F0D19445D
55 changed files with 3946 additions and 3783 deletions
Download patch file Download diff file Expand all files Collapse all files

303
universal7885-common/apps/FMRadio/jni/fm_ioctl.cpp
View file

@ -17,27 +17,27 @@
#include <hidl/Status.h>
#include <vendor/eureka/hardware/fmradio/1.2/IFMRadio.h>
using android::sp;
using vendor::eureka::hardware::fmradio::V1_2::IFMRadio;
using vendor::eureka::hardware::fmradio::V1_0::Direction;
using vendor::eureka::hardware::fmradio::V1_1::Status;
using vendor::eureka::hardware::fmradio::V1_2::IFMRadio;
//#define DEBUG
// #define DEBUG
#define TRACK_SIZE 30
long tracks[TRACK_SIZE] = { 0 };
long tracks[TRACK_SIZE] = {0};
bool FMThread = false;
int open_fm_device(){
int open_fm_device() {
int fd;
if ((fd = open("/dev/radio0", O_RDWR)) < 0){
if ((fd = open("/dev/radio0", O_RDWR)) < 0) {
printf("Cannot open /dev/radio0.\n");
return -1;
}
return fd;
}
static int fm_radio_get_frequency(int fd, long *channel)
{
struct v4l2_frequency freq{};
static int fm_radio_get_frequency(int fd, long *channel) {
struct v4l2_frequency freq {};
int ret;
freq.tuner = 0;
@ -49,19 +49,18 @@ static int fm_radio_get_frequency(int fd, long *channel)
return FM_FAILURE;
}
*channel = (long)freq.frequency/16000;
*channel = (long)freq.frequency / 16000;
return FM_SUCCESS;
}
static int fm_radio_set_frequency(int fd, long channel)
{
struct v4l2_frequency freq{};
static int fm_radio_set_frequency(int fd, long channel) {
struct v4l2_frequency freq {};
int ret;
freq.tuner = 0;
freq.type = V4L2_TUNER_RADIO;
freq.frequency = (unsigned int) channel * 16000;
freq.frequency = (unsigned int)channel * 16000;
ret = ioctl(fd, VIDIOC_S_FREQUENCY, &freq);
if (ret < 0) {
@ -72,9 +71,8 @@ static int fm_radio_set_frequency(int fd, long channel)
return FM_SUCCESS;
}
static int fm_radio_set_control(int fd, unsigned int id, long val)
{
struct v4l2_control ctrl{};
static int fm_radio_set_control(int fd, unsigned int id, long val) {
struct v4l2_control ctrl {};
int ret;
#ifdef DEBUG
printf("FmRadioController:fm_radio_set_control: id(%d) val(%ld)\n", id, val);
@ -94,9 +92,10 @@ static int fm_radio_set_control(int fd, unsigned int id, long val)
return FM_SUCCESS;
}
static int fm_radio_seek_frequency(int fd, unsigned int upward, unsigned int wrap_around, unsigned int spacing)
{
struct v4l2_hw_freq_seek seek{};
static int fm_radio_seek_frequency(int fd, unsigned int upward,
unsigned int wrap_around,
unsigned int spacing) {
struct v4l2_hw_freq_seek seek {};
int ret;
seek.tuner = 0;
@ -113,11 +112,13 @@ static int fm_radio_seek_frequency(int fd, unsigned int upward, unsigned int wra
return FM_SUCCESS;
}
static int fm_radio_channel_searching(int fd, unsigned int upward, unsigned int wrap_around, unsigned int spacing, long *channel)
{
static int fm_radio_channel_searching(int fd, unsigned int upward,
unsigned int wrap_around,
unsigned int spacing, long *channel) {
int ret;
ret = fm_radio_set_control(fd, V4L2_CID_S610_SEEK_MODE, FM_TUNER_AUTONOMOUS_SEARCH_MODE);
ret = fm_radio_set_control(fd, V4L2_CID_S610_SEEK_MODE,
FM_TUNER_AUTONOMOUS_SEARCH_MODE);
if (ret < 0)
return ret;
@ -131,9 +132,8 @@ static int fm_radio_channel_searching(int fd, unsigned int upward, unsigned int
return ret;
}
static int fm_radio_set_tuner(int fd, unsigned int mode)
{
struct v4l2_tuner tuner{};
static int fm_radio_set_tuner(int fd, unsigned int mode) {
struct v4l2_tuner tuner {};
int ret;
tuner.index = 0;
@ -148,9 +148,8 @@ static int fm_radio_set_tuner(int fd, unsigned int mode)
return FM_SUCCESS;
}
static int fm_radio_get_tuner(int fd)
{
struct v4l2_tuner tuner{};
static int fm_radio_get_tuner(int fd) {
struct v4l2_tuner tuner {};
int ret;
tuner.index = 0;
@ -164,10 +163,10 @@ static int fm_radio_get_tuner(int fd)
return tuner.audmode;
}
static int fm_radio_set_mute(int fd, bool mute)
{
static int fm_radio_set_mute(int fd, bool mute) {
int muteint = 1;
if (mute) muteint = 0;
if (mute)
muteint = 0;
int ret = fm_radio_set_control(fd, V4L2_CID_AUDIO_MUTE, muteint);
if (ret < 0) {
printf("FmRadioController: failed to set mute\n");
@ -177,8 +176,7 @@ static int fm_radio_set_mute(int fd, bool mute)
return FM_SUCCESS;
}
static int fm_radio_set_volume(int fd, int volume /* 1 ~ 15 */)
{
static int fm_radio_set_volume(int fd, int volume /* 1 ~ 15 */) {
int ret = fm_radio_set_control(fd, V4L2_CID_AUDIO_VOLUME, volume);
if (ret < 0) {
printf("FmRadioController: failed to set volume\n");
@ -188,22 +186,24 @@ static int fm_radio_set_volume(int fd, int volume /* 1 ~ 15 */)
return FM_SUCCESS;
}
template<class C, typename T>
bool contains(C&& c, T e) { return std::find(std::begin(c), std::end(c), e) != std::end(c); }
template <class C, typename T> bool contains(C &&c, T e) {
return std::find(std::begin(c), std::end(c), e) != std::end(c);
}
static long fm_radio_get_freqs(int fd){
static long fm_radio_get_freqs(int fd) {
long ret = 0;
fm_radio_set_mute(fd, true);
sp<IFMRadio> service = IFMRadio::getService();
bool mSysfs = service->isAvailable() == Status::YES;
for (long & track : tracks){
for (long &track : tracks) {
if (mSysfs) {
service->adjustFreqByStep(Direction::UP);
ret = (long) service->getFreqFromSysfs();
ret = (long)service->getFreqFromSysfs();
} else {
fm_radio_channel_searching(fd, 1, 0, FM_CHANNEL_SPACING_50KHZ, &ret);
}
if (contains(tracks, ret)) break;
if (contains(tracks, ret))
break;
track = ret;
printf("Found Freq %ld\n", ret);
}
@ -211,8 +211,7 @@ static long fm_radio_get_freqs(int fd){
return ret;
}
static int fm_radio_poll(int fd, struct pollfd *poll_fd)
{
static int fm_radio_poll(int fd, struct pollfd *poll_fd) {
int ret;
poll_fd->fd = fd;
@ -239,8 +238,7 @@ static int fm_radio_poll(int fd, struct pollfd *poll_fd)
return FM_FAILURE - 1;
}
static int fm_radio_read(int fd, unsigned char *buf)
{
static int fm_radio_read(int fd, unsigned char *buf) {
int ret;
ret = read(fd, buf, FM_RADIO_RDS_DATA_MAX);
@ -252,9 +250,8 @@ static int fm_radio_read(int fd, unsigned char *buf)
return ret;
}
static int fm_radio_thread(int fd)
{
struct pollfd radio_poll{};
static int fm_radio_thread(int fd) {
struct pollfd radio_poll {};
unsigned char read_buf[FM_RADIO_RDS_DATA_MAX];
int ret;
@ -273,113 +270,111 @@ static int fm_radio_thread(int fd)
}
return 0;
}
static unsigned int fm_radio_get_upperband_limit(int fd)
{
static unsigned int fm_radio_get_upperband_limit(int fd) {
int ret;
struct v4l2_tuner tuner{};
struct v4l2_tuner tuner {};
unsigned int freq;
tuner.index = 0;
ret = ioctl(fd, VIDIOC_G_TUNER, &tuner);
if(ret < 0) {
if (ret < 0) {
return FM_FAILURE;
}else {
} else {
freq = (tuner.rangehigh / 16000);
return freq;
}
}
static unsigned int fm_radio_get_lowerband_limit(int fd)
{
static unsigned int fm_radio_get_lowerband_limit(int fd) {
int ret;
unsigned int freq;
struct v4l2_tuner tuner{};
struct v4l2_tuner tuner {};
tuner.index = 0;
ret = ioctl(fd, VIDIOC_G_TUNER, &tuner);
if(ret < 0) {
if (ret < 0) {
return FM_FAILURE;
}else {
} else {
freq = (tuner.rangelow / 16000);
return freq;
}
}
static long fm_radio_get_rmssi(int fd)
{
struct v4l2_tuner tuner{};
static long fm_radio_get_rmssi(int fd) {
struct v4l2_tuner tuner {};
int ret;
long rmssi;
tuner.index = 0;
tuner.signal = 0;
ret = ioctl(fd, VIDIOC_G_TUNER, &tuner);
if(ret < 0) {
if (ret < 0) {
ret = FM_FAILURE;
}else {
} else {
rmssi = tuner.signal;
ret = rmssi;
}
return ret;
}
static int fm_radio_set_rssi(int fd, long rssi){
static int fm_radio_set_rssi(int fd, long rssi) {
int ret = fm_radio_set_control(fd, V4L2_CID_S610_RSSI_TH, rssi);
if (ret < 0){
if (ret < 0) {
return FM_FAILURE;
}
return FM_SUCCESS;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_openFMDevice
(__unused JNIEnv *env, __unused jobject thiz) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_openFMDevice(
__unused JNIEnv *env, __unused jobject thiz) {
return open_fm_device();
}
extern "C"
JNIEXPORT jlong JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMFreq
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jlong JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMFreq(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
long freq;
fm_radio_get_frequency(fd, &freq);
return freq;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMFreq
(__unused JNIEnv *env, __unused jobject thiz, jint fd, jint freq) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMFreq(__unused JNIEnv *env,
__unused jobject thiz,
jint fd, jint freq) {
return fm_radio_set_frequency(fd, freq);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMVolume
(__unused JNIEnv *env, __unused jobject thiz, jint fd, jint volume) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMVolume(__unused JNIEnv *env,
__unused jobject thiz,
jint fd,
jint volume) {
return fm_radio_set_volume(fd, volume);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMMute
(__unused JNIEnv *env, __unused jobject thiz, jint fd, jboolean mute) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMMute(__unused JNIEnv *env,
__unused jobject thiz,
jint fd,
jboolean mute) {
return fm_radio_set_mute(fd, mute);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFmUpper
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFmUpper(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
return fm_radio_get_upperband_limit(fd);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMLower
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMLower(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
return fm_radio_get_lowerband_limit(fd);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getRMSSI
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getRMSSI(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
return fm_radio_get_rmssi(fd);
}
extern "C"
JNIEXPORT jlongArray JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMTracks
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jlongArray JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getFMTracks(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
fm_radio_get_freqs(fd);
jlongArray result;
result = (*env).NewLongArray(TRACK_SIZE);
@ -390,57 +385,62 @@ Java_com_eurekateam_fmradio_NativeFMInterface_getFMTracks
// fill a temp structure to use to populate the java int array
jlong fill[TRACK_SIZE];
for (i = 0; i < TRACK_SIZE; i++) {
fill[i] = tracks[i]; // put whatever logic you want to populate the values here.
fill[i] =
tracks[i]; // put whatever logic you want to populate the values here.
}
// move from the temp structure to the java structure
(*env).SetLongArrayRegion(result, 0, TRACK_SIZE, fill);
return result;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMStereo
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMStereo(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
return fm_radio_set_tuner(fd, 1);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMMono
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMMono(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
return fm_radio_set_tuner(fd, 0);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMThread
(__unused JNIEnv *env, __unused jobject thiz, jint fd, jboolean run) {
if (run){
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMThread(__unused JNIEnv *env,
__unused jobject thiz,
jint fd,
jboolean run) {
if (run) {
FMThread = true;
fm_radio_thread(fd);
}else{
} else {
FMThread = false;
}
return FM_SUCCESS;
}
extern "C"
JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMBoot
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMBoot(__unused JNIEnv *env,
__unused jobject thiz,
jint fd) {
fm_radio_set_control(fd, V4L2_CID_S610_IF_COUNT1, 4800); // SetIFCount 1
fm_radio_set_control(fd, V4L2_CID_S610_IF_COUNT2, 5600); // SetIFCount 2
fm_radio_set_control(fd, V4L2_CID_S610_SOFT_STEREO_BLEND, 3172); // Set Soft Stereo Blend
fm_radio_set_control(fd, V4L2_CID_S610_SOFT_MUTE_COEFF, 16); // SetSoftMuteCoeff
fm_radio_set_control(fd, V4L2_CID_S610_CH_BAND, S610_BAND_FM); // Set Band (To FM)
fm_radio_set_control(fd, V4L2_CID_S610_CH_SPACING, FM_CHANNEL_SPACING_50KHZ); // Spacing 5kHz
fm_radio_set_control(fd, V4L2_CID_S610_SOFT_STEREO_BLEND,
3172); // Set Soft Stereo Blend
fm_radio_set_control(fd, V4L2_CID_S610_SOFT_MUTE_COEFF,
16); // SetSoftMuteCoeff
fm_radio_set_control(fd, V4L2_CID_S610_CH_BAND,
S610_BAND_FM); // Set Band (To FM)
fm_radio_set_control(fd, V4L2_CID_S610_CH_SPACING,
FM_CHANNEL_SPACING_50KHZ); // Spacing 5kHz
fm_radio_set_control(fd, V4L2_CID_S610_RDS_ON, FM_RDS_ENABLE); // RDS on
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getNextChannel
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getNextChannel(
__unused JNIEnv *env, __unused jobject thiz, jint fd) {
long ret;
sp<IFMRadio> service = IFMRadio::getService();
bool mSysfs = service->isAvailable() == Status::YES;
if (!mSysfs){
if (!mSysfs) {
fm_radio_channel_searching(fd, 1, 0, FM_CHANNEL_SPACING_100KHZ, &ret);
} else {
service->adjustFreqByStep(Direction::UP);
@ -448,14 +448,13 @@ Java_com_eurekateam_fmradio_NativeFMInterface_getNextChannel
}
return ret;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getBeforeChannel
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getBeforeChannel(
__unused JNIEnv *env, __unused jobject thiz, jint fd) {
long ret;
sp<IFMRadio> service = IFMRadio::getService();
bool mSysfs = service->isAvailable() == Status::YES;
if (!mSysfs){
if (!mSysfs) {
fm_radio_channel_searching(fd, 0, 0, FM_CHANNEL_SPACING_100KHZ, &ret);
} else {
service->adjustFreqByStep(Direction::DOWN);
@ -464,39 +463,35 @@ Java_com_eurekateam_fmradio_NativeFMInterface_getBeforeChannel
return ret;
}
extern "C"
JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getAudioChannel
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getAudioChannel(
__unused JNIEnv *env, __unused jobject thiz, jint fd) {
int channel = fm_radio_get_tuner(fd);
if (channel == V4L2_TUNER_MODE_STEREO){
if (channel == V4L2_TUNER_MODE_STEREO) {
return true; // Is EarPhones
}else{
} else {
return false; // Is Speaker
}
}
extern "C"
JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_stopSearching
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_stopSearching(
__unused JNIEnv *env, __unused jobject thiz, jint fd) {
fm_radio_set_control(fd, V4L2_CID_S610_SEEK_CANCEL, 1);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMRSSI
(__unused JNIEnv *env, __unused jobject thiz, jint fd, jlong rssi) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setFMRSSI(__unused JNIEnv *env,
__unused jobject thiz,
jint fd, jlong rssi) {
return fm_radio_set_rssi(fd, rssi);
}
extern "C"
JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_closeFMDevice
(__unused JNIEnv *env, __unused jobject thiz, jint fd) {
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_closeFMDevice(
__unused JNIEnv *env, __unused jobject thiz, jint fd) {
close(fd);
}
extern "C"
JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getSysfsSupport
(__unused JNIEnv *env, __unused jobject thiz) {
extern "C" JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_getSysfsSupport(
__unused JNIEnv *env, __unused jobject thiz) {
sp<IFMRadio> service = IFMRadio::getService();
return service->isAvailable() == Status::YES;
}

18
universal7885-common/apps/FMRadio/jni/fm_route.cpp
View file

@ -14,23 +14,23 @@
* limitations under the License.
*/
#include <jni.h>
#include <media/IAudioFlinger.h>
#include <media/AudioSystem.h>
#include <media/IAudioFlinger.h>
#define FM_FAILURE -1
#define FM_SUCCESS 0
#define IOHANDLE 13
using namespace android;
extern "C"
JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setAudioRoute
(__unused JNIEnv *env, __unused jobject thiz, jboolean speaker) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
if (speaker){
extern "C" JNIEXPORT jboolean JNICALL
Java_com_eurekateam_fmradio_NativeFMInterface_setAudioRoute(
__unused JNIEnv *env, __unused jobject thiz, jboolean speaker) {
const sp<IAudioFlinger> &af = AudioSystem::get_audio_flinger();
if (af == 0)
return PERMISSION_DENIED;
if (speaker) {
af->setParameters(IOHANDLE, String8("routing=2"));
}else{
} else {
af->setParameters(IOHANDLE, String8("routing=8"));
}
return FM_SUCCESS;

17
universal7885-common/apps/FMRadio/jni/s610_radio.h
View file

@ -6,7 +6,7 @@ enum s610_ctrl_id {
V4L2_CID_S610_CH_SPACING = (V4L2_CID_USER_S610_BASE + 0x01),
V4L2_CID_S610_CH_BAND = (V4L2_CID_USER_S610_BASE + 0x02),
V4L2_CID_S610_SOFT_STEREO_BLEND = (V4L2_CID_USER_S610_BASE + 0x03),
V4L2_CID_S610_SOFT_STEREO_BLEND_COEFF = (V4L2_CID_USER_S610_BASE+0x04),
V4L2_CID_S610_SOFT_STEREO_BLEND_COEFF = (V4L2_CID_USER_S610_BASE + 0x04),
V4L2_CID_S610_SOFT_MUTE_COEFF = (V4L2_CID_USER_S610_BASE + 0x5),
V4L2_CID_S610_RSSI_CURR = (V4L2_CID_USER_S610_BASE + 0x06),
V4L2_CID_S610_SNR_CURR = (V4L2_CID_USER_S610_BASE + 0x07),
@ -17,7 +17,7 @@ enum s610_ctrl_id {
V4L2_CID_S610_IF_COUNT2 = (V4L2_CID_USER_S610_BASE + 0x0C),
V4L2_CID_S610_RSSI_TH = (V4L2_CID_USER_S610_BASE + 0x0D),
V4L2_CID_S610_KERNEL_VER = (V4L2_CID_USER_S610_BASE + 0x0E),
V4L2_CID_S610_SOFT_STEREO_BLEND_REF = (V4L2_CID_USER_S610_BASE+0x0F),
V4L2_CID_S610_SOFT_STEREO_BLEND_REF = (V4L2_CID_USER_S610_BASE + 0x0F),
V4L2_CID_S610_REG_RW_ADDR = (V4L2_CID_USER_S610_BASE + 0x10),
V4L2_CID_S610_REG_RW = (V4L2_CID_USER_S610_BASE + 0x11),
};
@ -38,17 +38,10 @@ enum fm_channel_spacing {
};
/* Mute modes */
enum fm_mute_mode {
FM_MUTE_ON = 0,
FM_MUTE_OFF = 1,
FM_MUTE_ATTENUATE = 2
};
enum fm_mute_mode { FM_MUTE_ON = 0, FM_MUTE_OFF = 1, FM_MUTE_ATTENUATE = 2 };
/* FM RDS modes */
enum fm_rds_mode {
FM_RDS_DISABLE = 0,
FM_RDS_ENABLE = 1
};
enum fm_rds_mode { FM_RDS_DISABLE = 0, FM_RDS_ENABLE = 1 };
#define FM_RADIO_RDS_DATA_MAX 48
@ -61,5 +54,3 @@ enum s610_aud_mode {
S610_AUD_ENABLE = 1,
S610_AUD_DISABLE = 0,
};

10
universal7885-common/apps/FMRadio/jni/v4l2_api.h
View file

@ -24,7 +24,6 @@ struct v4l2_frequency {
__u32 reserved[8];
};
struct v4l2_hw_freq_seek {
__u32 tuner;
__u32 type; /* enum v4l2_tuner_type */
@ -48,7 +47,8 @@ struct v4l2_control {
__s32 value;
};
/**
* struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
* struct v4l2_capability - Describes V4L2 device caps returned by
* VIDIOC_QUERYCAP
*
* @driver: name of the driver module (e.g. "bttv")
* @card: name of the card (e.g. "Hauppauge WinTV")
@ -119,7 +119,5 @@ struct v4l2_buffer {
#define V4L2_CTRL_CLASS_USER 0x00980000 /* Old-style 'user' controls */
#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900)
#define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5)
#define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9)
#define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE + 5)
#define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE + 9)

25
universal7885-common/apps/SamsungParts/jni/BatteryBridge.cpp
View file

@ -1,9 +1,9 @@
#include "jni.h"
#include <hardware/hardware.h>
#include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/parts/1.0/IBatteryStats.h>
#include "jni.h"
using android::sp;
using vendor::eureka::hardware::parts::V1_0::IBatteryStats;
@ -12,9 +12,8 @@ using vendor::eureka::hardware::parts::V1_0::SysfsType;
static android::sp<IBatteryStats> service = IBatteryStats::getService();
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env,
__unused jclass obj,
jint enable) {
Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(
JNIEnv *env, __unused jclass obj, jint enable) {
if (enable == 1) {
service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE);
} else {
@ -23,16 +22,15 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env,
}
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs(JNIEnv* env,
__unused jclass obj) {
Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs(
JNIEnv *env, __unused jclass obj) {
int ret = service->getBatteryStats(SysfsType::CHARGE);
return ret;
}
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv* env,
__unused jobject obj,
jint enable) {
Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(
JNIEnv *env, __unused jobject obj, jint enable) {
if (enable == 1) {
service->setBatteryWritable(SysfsType::FASTCHARGE, Number::ENABLE);
} else {
@ -40,15 +38,14 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv* env,
}
}
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(JNIEnv* env,
__unused jclass obj) {
Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(
JNIEnv *env, __unused jclass obj) {
int ret = service->getBatteryStats(SysfsType::FASTCHARGE);
return ret;
}
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(JNIEnv* env,
__unused jobject obj,
jint id) {
Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(
JNIEnv *env, __unused jobject obj, jint id) {
/**
* id:
* 1 = BATTERY_CAPACITY_MAX

17
universal7885-common/apps/SamsungParts/jni/DisplayBridge.cpp
View file

@ -1,30 +1,31 @@
#include "jni.h"
#include <hardware/hardware.h>
#include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/parts/1.0/IDisplayConfigs.h>
#include "jni.h"
using android::sp;
using vendor::eureka::hardware::parts::V1_0::Number;
using vendor::eureka::hardware::parts::V1_0::Display;
using vendor::eureka::hardware::parts::V1_0::IDisplayConfigs;
using vendor::eureka::hardware::parts::V1_0::Number;
static android::sp<IDisplayConfigs> service = IDisplayConfigs::getService();
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Display_setDT2W(JNIEnv* env, jclass clazz, jboolean enable) {
Java_com_eurekateam_samsungextras_interfaces_Display_setDT2W(JNIEnv *env,
jclass clazz,
jboolean enable) {
if (enable) {
service->writeDisplay(Number::ENABLE,
Display::DOUBLE_TAP);
service->writeDisplay(Number::ENABLE, Display::DOUBLE_TAP);
} else {
service->writeDisplay(Number::DISABLE,
Display::DOUBLE_TAP);
service->writeDisplay(Number::DISABLE, Display::DOUBLE_TAP);
}
}
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Display_setGloveMode(JNIEnv* env, jclass clazz, jboolean enable) {
Java_com_eurekateam_samsungextras_interfaces_Display_setGloveMode(
JNIEnv *env, jclass clazz, jboolean enable) {
if (enable) {
service->writeDisplay(Number::ENABLE, Display::GLOVE_MODE);
} else {

15
universal7885-common/apps/SamsungParts/jni/FlashlightBridge.cpp
View file

@ -1,20 +1,21 @@
#include "jni.h"
#include <hardware/hardware.h>
#include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h>
#include <hidl/Status.h>
#include <vendor/eureka/hardware/parts/1.0/IFlashBrightness.h>
#include "jni.h"
using android::sp;
using vendor::eureka::hardware::parts::V1_0::Device;
using vendor::eureka::hardware::parts::V1_0::Value;
using vendor::eureka::hardware::parts::V1_0::IFlashBrightness;
using vendor::eureka::hardware::parts::V1_0::Number;
using vendor::eureka::hardware::parts::V1_0::Value;
static android::sp<IFlashBrightness> service = IFlashBrightness::getService();
extern "C" JNIEXPORT void JNICALL Java_com_eurekateam_samsungextras_interfaces_Flashlight_setFlash(
JNIEnv* env, __unused jobject obj, jint value) {
extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Flashlight_setFlash(
JNIEnv *env, __unused jobject obj, jint value) {
service->setFlashlightEnable(Number::ENABLE);
switch (value) {
case 1:
@ -51,8 +52,10 @@ extern "C" JNIEXPORT void JNICALL Java_com_eurekateam_samsungextras_interfaces_F
break;
}
}
extern "C" JNIEXPORT jint JNICALL Java_com_eurekateam_samsungextras_interfaces_Flashlight_getFlash(
JNIEnv* env, jobject clazz, jint isA10) {
extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Flashlight_getFlash(JNIEnv *env,
jobject clazz,
jint isA10) {
int ret;
if (isA10 == 1) {
ret = service->readFlashlightstats(Device::A10);

17
universal7885-common/bluetooth/bdroid_buildcfg.h
View file

@ -6,15 +6,20 @@
#include <cutils/properties.h>
#include <string.h>
static inline const char* BtmGetDefaultName() {
static inline const char *BtmGetDefaultName() {
char product_device[PROPERTY_VALUE_MAX];
property_get("ro.product.device", product_device, "");
if (strstr(product_device, "a10")) return "Galaxy A10";
if (strstr(product_device, "a20e")) return "Galaxy A20e";
if (strstr(product_device, "a20")) return "Galaxy A20";
if (strstr(product_device, "a30")) return "Galaxy A30";
if (strstr(product_device, "a40")) return "Galaxy A40";
if (strstr(product_device, "a10"))
return "Galaxy A10";
if (strstr(product_device, "a20e"))
return "Galaxy A20e";
if (strstr(product_device, "a20"))
return "Galaxy A20";
if (strstr(product_device, "a30"))
return "Galaxy A30";
if (strstr(product_device, "a40"))
return "Galaxy A40";
// Fallback to Generic
return "Samsung Galaxy";
}

42
universal7885-common/hardware/interfaces/hardware/fmradio/1.2/default/FMRadio.cpp
View file

@ -16,8 +16,8 @@
#include <fstream>
#include <iostream>
#include <sstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
static int mChannelSpacing = 3;
@ -34,9 +34,9 @@ Return<void> FMRadio::setManualFreq(float freq) {
Return<void> FMRadio::adjustFreqByStep(fmradio::V1_0::Direction dir) {
std::ofstream file;
std::string value = "";
if (dir == V1_0::Direction::UP){
if (dir == V1_0::Direction::UP) {
value = "1 " + std::to_string(mChannelSpacing * 10);
} else if (dir == V1_0::Direction::DOWN){
} else if (dir == V1_0::Direction::DOWN) {
value = "0 " + std::to_string(mChannelSpacing * 10);
}
file.open("/sys/devices/virtual/s610_radio/s610_radio/radio_freq_seek");
@ -44,19 +44,19 @@ Return<void> FMRadio::adjustFreqByStep(fmradio::V1_0::Direction dir) {
file.close();
return Void();
}
Return<V1_1::Status> FMRadio::isAvailable(){
Return<V1_1::Status> FMRadio::isAvailable() {
struct stat info;
if(stat("/sys/devices/virtual/s610_radio/s610_radio/", &info ) != 0) {
if (stat("/sys/devices/virtual/s610_radio/s610_radio/", &info) != 0) {
return V1_1::Status::NO;
} else {
return V1_1::Status::YES;
}
}
Return<void> FMRadio::setChannelSpacing(V1_2::Space space){
mChannelSpacing = (int) space;
Return<void> FMRadio::setChannelSpacing(V1_2::Space space) {
mChannelSpacing = (int)space;
return Void();
}
Return<int32_t> FMRadio::getFreqFromSysfs(){
Return<int32_t> FMRadio::getFreqFromSysfs() {
std::ifstream file;
std::string value;
file.open("/sys/devices/virtual/s610_radio/s610_radio/radio_freq_ctrl");
@ -64,17 +64,21 @@ Return<int32_t> FMRadio::getFreqFromSysfs(){
file.close();
return std::stoi(value);
}
Return<V1_2::Space> FMRadio::getChannelSpacing(){
Return<V1_2::Space> FMRadio::getChannelSpacing() {
switch (mChannelSpacing) {
case 1: return V1_2::Space::CHANNEL_SPACING_10HZ;
case 2: return V1_2::Space::CHANNEL_SPACING_20HZ;
case 3: return V1_2::Space::CHANNEL_SPACING_30HZ;
case 4: return V1_2::Space::CHANNEL_SPACING_40HZ;
case 5: return V1_2::Space::CHANNEL_SPACING_50HZ;
default: return V1_2::Space::CHANNEL_SPACING_30HZ;
case 1:
return V1_2::Space::CHANNEL_SPACING_10HZ;
case 2:
return V1_2::Space::CHANNEL_SPACING_20HZ;
case 3:
return V1_2::Space::CHANNEL_SPACING_30HZ;
case 4:
return V1_2::Space::CHANNEL_SPACING_40HZ;
case 5:
return V1_2::Space::CHANNEL_SPACING_50HZ;
default:
return V1_2::Space::CHANNEL_SPACING_30HZ;
}
}
IFMRadio* FMRadio::getInstance(void) {
return new FMRadio();
}
} // namespace vendor::eureka::hardware::fmradio::V1_0
IFMRadio *FMRadio::getInstance(void) { return new FMRadio(); }
} // namespace vendor::eureka::hardware::fmradio::V1_2

4
universal7885-common/hardware/interfaces/hardware/fmradio/1.2/default/FMRadio.h
View file

@ -39,6 +39,6 @@ struct FMRadio : public IFMRadio {
Return<void> setChannelSpacing(V1_2::Space space);
Return<V1_2::Space> getChannelSpacing();
// Methods from ::android::hidl::base::V1_0::IBase follow.
static IFMRadio* getInstance(void);
static IFMRadio *getInstance(void);
};
} // namespace vendor::eureka::hardware::parts::V1_0
} // namespace vendor::eureka::hardware::fmradio::V1_2

18
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/Battery.cpp
View file

@ -13,10 +13,10 @@
// limitations under the License.
#include "Battery.h"
#include <unistd.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <unistd.h>
namespace vendor::eureka::hardware::parts::V1_0 {
@ -41,7 +41,8 @@ Return<int32_t> BatteryStats::getBatteryStats(parts::V1_0::SysfsType stats) {
filename = "/sys/class/sec/switch/afc_disable";
break;
case SysfsType::CHARGE:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
filename =
"/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
break;
default:
filename = "";
@ -83,13 +84,15 @@ Return<void> BatteryStats::setBatteryWritable(parts::V1_0::SysfsType stats,
FastCharge = true;
break;
case SysfsType::CHARGE:
filename = "/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
filename =
"/sys/devices/platform/battery/power_supply/battery/batt_slate_mode";
break;
default:
filename = "";
break;
}
if (FastCharge) seteuid(ANDROID_SYSTEM_UID);
if (FastCharge)
seteuid(ANDROID_SYSTEM_UID);
file.open(filename);
int write;
if (value == Number::ENABLE) {
@ -99,11 +102,10 @@ Return<void> BatteryStats::setBatteryWritable(parts::V1_0::SysfsType stats,
}
file << write;
file.close();
if (FastCharge) seteuid(ANDROID_ROOT_UID);
if (FastCharge)
seteuid(ANDROID_ROOT_UID);
return Void();
}
IBatteryStats* BatteryStats::getInstance(void) {
return new BatteryStats();
}
IBatteryStats *BatteryStats::getInstance(void) { return new BatteryStats(); }
} // namespace vendor::eureka::hardware::parts::V1_0

2
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/Battery.h
View file

@ -37,6 +37,6 @@ struct BatteryStats : public IBatteryStats {
Return<void> setBatteryWritable(SysfsType stats, Number value) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
static IBatteryStats* getInstance(void);
static IBatteryStats *getInstance(void);
};
} // namespace vendor::eureka::hardware::parts::V1_0

9
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/Display.cpp
View file

@ -18,12 +18,13 @@
#include <sstream>
namespace vendor::eureka::hardware::parts::V1_0 {
Return<void> DisplayConfigs::writeDisplay(parts::V1_0::Number enable, parts::V1_0::Display type) {
Return<void> DisplayConfigs::writeDisplay(parts::V1_0::Number enable,
parts::V1_0::Display type) {
std::ofstream file;
std::string writevalue;
if (type == Display::DOUBLE_TAP){
if (type == Display::DOUBLE_TAP) {
writevalue = "aot_enable";
} else if (type == Display::GLOVE_MODE){
} else if (type == Display::GLOVE_MODE) {
writevalue = "glove_mode";
}
@ -38,7 +39,7 @@ Return<void> DisplayConfigs::writeDisplay(parts::V1_0::Number enable, parts::V1_
return Void();
}
IDisplayConfigs* DisplayConfigs::getInstance(void) {
IDisplayConfigs *DisplayConfigs::getInstance(void) {
return new DisplayConfigs();
}
} // namespace vendor::eureka::hardware::parts::V1_0

5
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/Display.h
View file

@ -29,9 +29,10 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
struct DisplayConfigs : public IDisplayConfigs {
// Methods from ::vendor::eureka::hardware::parts::V1_0::IDisplayConfigs follow.
// Methods from ::vendor::eureka::hardware::parts::V1_0::IDisplayConfigs
// follow.
Return<void> writeDisplay(Number enable, Display type);
// Methods from ::android::hidl::base::V1_0::IBase follow.
static IDisplayConfigs* getInstance(void);
static IDisplayConfigs *getInstance(void);
};
} // namespace vendor::eureka::hardware::parts::V1_0

5
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/FlashLight.cpp
View file

@ -83,7 +83,8 @@ Return<void> FlashBrightness::setFlashlightWritable(parts::V1_0::Value value) {
return Void();
}
Return<int32_t> FlashBrightness::readFlashlightstats(parts::V1_0::Device device) {
Return<int32_t>
FlashBrightness::readFlashlightstats(parts::V1_0::Device device) {
std::ifstream file;
std::string value;
int32_t intvalue;
@ -104,7 +105,7 @@ Return<int32_t> FlashBrightness::readFlashlightstats(parts::V1_0::Device device)
return -1;
}
IFlashBrightness* FlashBrightness::getInstance(void) {
IFlashBrightness *FlashBrightness::getInstance(void) {
return new FlashBrightness();
}
} // namespace vendor::eureka::hardware::parts::V1_0

5
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/FlashLight.h
View file

@ -29,11 +29,12 @@ using ::android::hardware::Return;
using ::android::hardware::Void;
struct FlashBrightness : public IFlashBrightness {
// Methods from ::vendor::eureka::hardware::parts::V1_0::IFlashBrightness follow.
// Methods from ::vendor::eureka::hardware::parts::V1_0::IFlashBrightness
// follow.
Return<void> setFlashlightEnable(Number enable);
Return<void> setFlashlightWritable(Value value);
Return<int32_t> readFlashlightstats(Device device);
// Methods from ::android::hidl::base::V1_0::IBase follow.
static IFlashBrightness* getInstance(void);
static IFlashBrightness *getInstance(void);
};
} // namespace vendor::eureka::hardware::parts::V1_0

17
universal7885-common/hardware/interfaces/hardware/parts/1.0/default/service.cpp
View file

@ -14,29 +14,30 @@
#define LOG_TAG "vendor.eureka.hardware.parts@1.0-service"
#include <vendor/eureka/hardware/parts/1.0/IBatteryStats.h>
#include <vendor/eureka/hardware/parts/1.0/IFlashBrightness.h>
#include <vendor/eureka/hardware/parts/1.0/IDisplayConfigs.h>
#include <hidl/LegacySupport.h>
#include <vendor/eureka/hardware/parts/1.0/IBatteryStats.h>
#include <vendor/eureka/hardware/parts/1.0/IDisplayConfigs.h>
#include <vendor/eureka/hardware/parts/1.0/IFlashBrightness.h>
#include "Battery.h"
#include "FlashLight.h"
#include "Display.h"
#include "FlashLight.h"
using android::sp;
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using vendor::eureka::hardware::parts::V1_0::BatteryStats;
using vendor::eureka::hardware::parts::V1_0::IBatteryStats;
using vendor::eureka::hardware::parts::V1_0::FlashBrightness;
using vendor::eureka::hardware::parts::V1_0::IFlashBrightness;
using vendor::eureka::hardware::parts::V1_0::DisplayConfigs;
using vendor::eureka::hardware::parts::V1_0::FlashBrightness;
using vendor::eureka::hardware::parts::V1_0::IBatteryStats;
using vendor::eureka::hardware::parts::V1_0::IDisplayConfigs;
using vendor::eureka::hardware::parts::V1_0::IFlashBrightness;
int main() {
int ret;
android::sp<IBatteryStats> mBatteryService = BatteryStats::getInstance();
android::sp<IFlashBrightness> mFlashLightService = FlashBrightness::getInstance();
android::sp<IFlashBrightness> mFlashLightService =
FlashBrightness::getInstance();
android::sp<IDisplayConfigs> mDisplayService = DisplayConfigs::getInstance();
configureRpcThreadpool(4, true /*callerWillJoin*/);

59
universal7885-common/hardware/samsung/aidl/light/Lights.cpp
View file

@ -22,14 +22,12 @@ namespace light {
/*
* Write value to path and close file.
*/
template <typename T>
static void set(const std::string& path, const T& value) {
template <typename T> static void set(const std::string &path, const T &value) {
std::ofstream file(path);
file << value << std::endl;
}
template <typename T>
static T get(const std::string& path, const T& def) {
template <typename T> static T get(const std::string &path, const T &def) {
std::ifstream file(path);
T result;
@ -38,23 +36,25 @@ static T get(const std::string& path, const T& def) {
}
Lights::Lights() {
mLights.emplace(LightType::BACKLIGHT,
std::bind(&Lights::handleBacklight, this, std::placeholders::_1));
mLights.emplace(LightType::BACKLIGHT, std::bind(&Lights::handleBacklight,
this, std::placeholders::_1));
#ifdef BUTTON_BRIGHTNESS_NODE
mLights.emplace(LightType::BUTTONS,
std::bind(&Lights::handleButtons, this, std::placeholders::_1));
mLights.emplace(LightType::BUTTONS, std::bind(&Lights::handleButtons, this,
std::placeholders::_1));
#endif /* BUTTON_BRIGHTNESS_NODE */
#ifdef LED_BLINK_NODE
mLights.emplace(LightType::BATTERY,
std::bind(&Lights::handleBattery, this, std::placeholders::_1));
mLights.emplace(LightType::NOTIFICATIONS,
mLights.emplace(LightType::BATTERY, std::bind(&Lights::handleBattery, this,
std::placeholders::_1));
mLights.emplace(
LightType::NOTIFICATIONS,
std::bind(&Lights::handleNotifications, this, std::placeholders::_1));
mLights.emplace(LightType::ATTENTION,
std::bind(&Lights::handleAttention, this, std::placeholders::_1));
mLights.emplace(LightType::ATTENTION, std::bind(&Lights::handleAttention,
this, std::placeholders::_1));
#endif /* LED_BLINK_NODE */
}
ndk::ScopedAStatus Lights::setLightState(int32_t id, const HwLightState& state) {
ndk::ScopedAStatus Lights::setLightState(int32_t id,
const HwLightState &state) {
LightType type = static_cast<LightType>(id);
auto it = mLights.find(type);
@ -72,8 +72,9 @@ ndk::ScopedAStatus Lights::setLightState(int32_t id, const HwLightState& state)
return ndk::ScopedAStatus::ok();
}
void Lights::handleBacklight(const HwLightState& state) {
uint32_t max_brightness = get(PANEL_MAX_BRIGHTNESS_NODE, MAX_INPUT_BRIGHTNESS);
void Lights::handleBacklight(const HwLightState &state) {
uint32_t max_brightness =
get(PANEL_MAX_BRIGHTNESS_NODE, MAX_INPUT_BRIGHTNESS);
uint32_t brightness = rgbToBrightness(state);
if (max_brightness != MAX_INPUT_BRIGHTNESS) {
@ -84,7 +85,7 @@ void Lights::handleBacklight(const HwLightState& state) {
}
#ifdef BUTTON_BRIGHTNESS_NODE
void Lights::handleButtons(const HwLightState& state) {
void Lights::handleButtons(const HwLightState &state) {
#ifdef VAR_BUTTON_BRIGHTNESS
uint32_t brightness = rgbToBrightness(state);
#else
@ -96,17 +97,17 @@ void Lights::handleButtons(const HwLightState& state) {
#endif
#ifdef LED_BLINK_NODE
void Lights::handleBattery(const HwLightState& state) {
void Lights::handleBattery(const HwLightState &state) {
mBatteryState = state;
setNotificationLED();
}
void Lights::handleNotifications(const HwLightState& state) {
void Lights::handleNotifications(const HwLightState &state) {
mNotificationState = state;
setNotificationLED();
}
void Lights::handleAttention(const HwLightState& state) {
void Lights::handleAttention(const HwLightState &state) {
mAttentionState = state;
setNotificationLED();
}
@ -128,7 +129,8 @@ void Lights::setNotificationLED() {
adjusted_brightness = LED_BRIGHTNESS_ATTENTION;
state = mAttentionState;
if (state.flashMode == FlashMode::HARDWARE) {
if (state.flashOnMs > 0 && state.flashOffMs == 0) state.flashMode = FlashMode::NONE;
if (state.flashOnMs > 0 && state.flashOffMs == 0)
state.flashMode = FlashMode::NONE;
state.color = 0x000000ff;
}
if (state.flashMode == FlashMode::NONE) {
@ -148,8 +150,9 @@ void Lights::setNotificationLED() {
}
state.color = calibrateColor(state.color & COLOR_MASK, adjusted_brightness);
set(LED_BLINK_NODE, ::android::base::StringPrintf("0x%08x %d %d", state.color, state.flashOnMs,
state.flashOffMs));
set(LED_BLINK_NODE,
::android::base::StringPrintf("0x%08x %d %d", state.color,
state.flashOnMs, state.flashOffMs));
#ifdef LED_BLN_NODE
if (bln) {
@ -163,23 +166,23 @@ uint32_t Lights::calibrateColor(uint32_t color, int32_t brightness) {
uint32_t green = ((color >> 8) & 0xFF) * LED_ADJUSTMENT_G;
uint32_t blue = (color & 0xFF) * LED_ADJUSTMENT_B;
return (((red * brightness) / 255) << 16) + (((green * brightness) / 255) << 8) +
((blue * brightness) / 255);
return (((red * brightness) / 255) << 16) +
(((green * brightness) / 255) << 8) + ((blue * brightness) / 255);
}
#endif /* LED_BLINK_NODE */
#define AutoHwLight(light) \
{ .id = (int32_t)light, .type = light, .ordinal = 0 }
ndk::ScopedAStatus Lights::getLights(std::vector<HwLight>* _aidl_return) {
for (auto const& light : mLights) {
ndk::ScopedAStatus Lights::getLights(std::vector<HwLight> *_aidl_return) {
for (auto const &light : mLights) {
_aidl_return->push_back(AutoHwLight(light.first));
}
return ndk::ScopedAStatus::ok();
}
uint32_t Lights::rgbToBrightness(const HwLightState& state) {
uint32_t Lights::rgbToBrightness(const HwLightState &state) {
uint32_t color = state.color & COLOR_MASK;
return ((77 * ((color >> 16) & 0xff)) + (150 * ((color >> 8) & 0xff)) +

26
universal7885-common/hardware/samsung/aidl/light/Lights.h
View file

@ -6,9 +6,9 @@
#pragma once
#include "samsung_lights.h"
#include <aidl/android/hardware/light/BnLights.h>
#include <unordered_map>
#include "samsung_lights.h"
using ::aidl::android::hardware::light::HwLight;
using ::aidl::android::hardware::light::HwLightState;
@ -19,21 +19,22 @@ namespace hardware {
namespace light {
class Lights : public BnLights {
public:
public:
Lights();
ndk::ScopedAStatus setLightState(int32_t id, const HwLightState& state) override;
ndk::ScopedAStatus getLights(std::vector<HwLight>* _aidl_return) override;
ndk::ScopedAStatus setLightState(int32_t id,
const HwLightState &state) override;
ndk::ScopedAStatus getLights(std::vector<HwLight> *_aidl_return) override;
private:
void handleBacklight(const HwLightState& state);
private:
void handleBacklight(const HwLightState &state);
#ifdef BUTTON_BRIGHTNESS_NODE
void handleButtons(const HwLightState& state);
void handleButtons(const HwLightState &state);
#endif /* BUTTON_BRIGHTNESS_NODE */
#ifdef LED_BLINK_NODE
void handleBattery(const HwLightState& state);
void handleNotifications(const HwLightState& state);
void handleAttention(const HwLightState& state);
void handleBattery(const HwLightState &state);
void handleNotifications(const HwLightState &state);
void handleAttention(const HwLightState &state);
void setNotificationLED();
uint32_t calibrateColor(uint32_t color, int32_t brightness);
@ -42,10 +43,11 @@ class Lights : public BnLights {
HwLightState mNotificationState;
#endif /* LED_BLINK_NODE */
uint32_t rgbToBrightness(const HwLightState& state);
uint32_t rgbToBrightness(const HwLightState &state);
std::mutex mLock;
std::unordered_map<LightType, std::function<void(const HwLightState&)>> mLights;
std::unordered_map<LightType, std::function<void(const HwLightState &)>>
mLights;
};
} // namespace light

2
universal7885-common/hardware/samsung/aidl/light/include/samsung_lights.h
View file

@ -32,7 +32,7 @@
#define LED_BLN_NODE "/sys/class/misc/backlightnotification/notification_led"
// Uncomment to enable variable button brightness
//#define VAR_BUTTON_BRIGHTNESS 1
// #define VAR_BUTTON_BRIGHTNESS 1
/*
* Brightness adjustment factors

3
universal7885-common/hardware/samsung/aidl/light/service.cpp
View file

@ -19,7 +19,8 @@ int main() {
std::shared_ptr<Lights> lights = ndk::SharedRefBase::make<Lights>();
const std::string instance = std::string() + Lights::descriptor + "/default";
binder_status_t status = AServiceManager_addService(lights->asBinder().get(), instance.c_str());
binder_status_t status =
AServiceManager_addService(lights->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool();

50
universal7885-common/hardware/samsung/aidl/power-libperfmgr/InteractionHandler.cpp
View file

@ -18,13 +18,13 @@
#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL)
#include <fcntl.h>
#include <memory>
#include <poll.h>
#include <sys/eventfd.h>
#include <time.h>
#include <unistd.h>
#include <utils/Log.h>
#include <utils/Trace.h>
#include <memory>
#include "InteractionHandler.h"
@ -33,26 +33,24 @@
#define MSINSEC 1000L
#define USINMS 1000000L
static const std::vector<std::string> fb_idle_patch = {"/sys/class/drm/card0/device/idle_state",
static const std::vector<std::string> fb_idle_patch = {
"/sys/class/drm/card0/device/idle_state",
"/sys/class/graphics/fb0/idle_state"};
InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const& hint_manager)
: mState(INTERACTION_STATE_UNINITIALIZED),
mWaitMs(100),
mMinDurationMs(1400),
mMaxDurationMs(5650),
mDurationMs(0),
InteractionHandler::InteractionHandler(
std::shared_ptr<HintManager> const &hint_manager)
: mState(INTERACTION_STATE_UNINITIALIZED), mWaitMs(100),
mMinDurationMs(1400), mMaxDurationMs(5650), mDurationMs(0),
mHintManager(hint_manager) {}
InteractionHandler::~InteractionHandler() {
Exit();
}
InteractionHandler::~InteractionHandler() { Exit(); }
static int fb_idle_open(void) {
int fd;
for (auto& path : fb_idle_patch) {
for (auto &path : fb_idle_patch) {
fd = open(path.c_str(), O_RDONLY);
if (fd >= 0) return fd;
if (fd >= 0)
return fd;
}
ALOGE("Unable to open fb idle state path (%d)", errno);
return -1;
@ -61,7 +59,8 @@ static int fb_idle_open(void) {
bool InteractionHandler::Init() {
std::lock_guard<std::mutex> lk(mLock);
if (mState != INTERACTION_STATE_UNINITIALIZED) return true;
if (mState != INTERACTION_STATE_UNINITIALIZED)
return true;
mIdleFd = fb_idle_open();
@ -75,14 +74,16 @@ bool InteractionHandler::Init() {
}
mState = INTERACTION_STATE_IDLE;
mThread = std::unique_ptr<std::thread>(new std::thread(&InteractionHandler::Routine, this));
mThread = std::unique_ptr<std::thread>(
new std::thread(&InteractionHandler::Routine, this));
return true;
}
void InteractionHandler::Exit() {
std::unique_lock<std::mutex> lk(mLock);
if (mState == INTERACTION_STATE_UNINITIALIZED) return;
if (mState == INTERACTION_STATE_UNINITIALIZED)
return;
AbortWaitLocked();
mState = INTERACTION_STATE_UNINITIALIZED;
@ -113,7 +114,8 @@ void InteractionHandler::PerfRel() {
ATRACE_INT("interaction_lock", 0);
}
size_t InteractionHandler::CalcTimespecDiffMs(struct timespec start, struct timespec end) {
size_t InteractionHandler::CalcTimespecDiffMs(struct timespec start,
struct timespec end) {
size_t diff_in_us = 0;
diff_in_us += (end.tv_sec - start.tv_sec) * MSINSEC;
diff_in_us += (end.tv_nsec - start.tv_nsec) / USINMS;
@ -144,8 +146,9 @@ void InteractionHandler::Acquire(int32_t duration) {
size_t elapsed_time = CalcTimespecDiffMs(mLastTimespec, cur_timespec);
// don't hint if previous hint's duration covers this hint's duration
if (elapsed_time <= (mDurationMs - finalDuration)) {
ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld", __func__,
static_cast<int>(mDurationMs), static_cast<int>(finalDuration),
ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld",
__func__, static_cast<int>(mDurationMs),
static_cast<int>(finalDuration),
static_cast<long long>(elapsed_time));
return;
}
@ -175,7 +178,8 @@ void InteractionHandler::Release() {
uint64_t val;
ssize_t ret = read(mEventFd, &val, sizeof(val));
ALOGW_IF(ret < 0, "%s: failed to clear eventfd (%zd, %d)", __func__, ret, errno);
ALOGW_IF(ret < 0, "%s: failed to clear eventfd (%zd, %d)", __func__, ret,
errno);
}
}
@ -183,7 +187,8 @@ void InteractionHandler::Release() {
void InteractionHandler::AbortWaitLocked() {
uint64_t val = 1;
ssize_t ret = write(mEventFd, &val, sizeof(val));
if (ret != sizeof(val)) ALOGW("Unable to write to event fd (%zd)", ret);
if (ret != sizeof(val))
ALOGW("Unable to write to event fd (%zd)", ret);
}
void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) {
@ -249,7 +254,8 @@ void InteractionHandler::Routine() {
while (true) {
lk.lock();
mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
if (mState == INTERACTION_STATE_UNINITIALIZED) return;
if (mState == INTERACTION_STATE_UNINITIALIZED)
return;
mState = INTERACTION_STATE_WAITING;
lk.unlock();

6
universal7885-common/hardware/samsung/aidl/power-libperfmgr/InteractionHandler.h
View file

@ -35,14 +35,14 @@ enum interaction_state {
};
class InteractionHandler {
public:
InteractionHandler(std::shared_ptr<HintManager> const& hint_manager);
public:
InteractionHandler(std::shared_ptr<HintManager> const &hint_manager);
~InteractionHandler();
bool Init();
void Exit();
void Acquire(int32_t duration);
private:
private:
void Release();
void WaitForIdle(int32_t wait_ms, int32_t timeout_ms);
void AbortWaitLocked();

26
universal7885-common/hardware/samsung/aidl/power-libperfmgr/Power.cpp
View file

@ -42,9 +42,7 @@ constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio";
constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering";
Power::Power(std::shared_ptr<HintManager> hm)
: mHintManager(hm),
mInteractionHandler(nullptr),
mVRModeOn(false),
: mHintManager(hm), mInteractionHandler(nullptr), mVRModeOn(false),
mSustainedPerfModeOn(false) {
mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager);
mInteractionHandler->Init();
@ -169,7 +167,7 @@ ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) {
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Power::isModeSupported(Mode type, bool* _aidl_return) {
ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) {
bool supported = mHintManager->IsHintSupported(toString(type));
switch (type) {
case Mode::LOW_POWER: // LOW_POWER handled insides PowerHAL specifically
@ -185,13 +183,15 @@ ndk::ScopedAStatus Power::isModeSupported(Mode type, bool* _aidl_return) {
break;
}
LOG(INFO) << "Power mode " << toString(type) << " isModeSupported: " << supported;
LOG(INFO) << "Power mode " << toString(type)
<< " isModeSupported: " << supported;
*_aidl_return = supported;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
LOG(DEBUG) << "Power setBoost: " << toString(type) << " duration: " << durationMs;
LOG(DEBUG) << "Power setBoost: " << toString(type)
<< " duration: " << durationMs;
ATRACE_INT(toString(type).c_str(), durationMs);
switch (type) {
case Boost::INTERACTION:
@ -215,7 +215,8 @@ ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
break;
}
if (durationMs > 0) {
mHintManager->DoHint(toString(type), std::chrono::milliseconds(durationMs));
mHintManager->DoHint(toString(type),
std::chrono::milliseconds(durationMs));
} else if (durationMs == 0) {
mHintManager->DoHint(toString(type));
} else {
@ -227,18 +228,17 @@ ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Power::isBoostSupported(Boost type, bool* _aidl_return) {
ndk::ScopedAStatus Power::isBoostSupported(Boost type, bool *_aidl_return) {
bool supported = mHintManager->IsHintSupported(toString(type));
LOG(INFO) << "Power boost " << toString(type) << " isBoostSupported: " << supported;
LOG(INFO) << "Power boost " << toString(type)
<< " isBoostSupported: " << supported;
*_aidl_return = supported;
return ndk::ScopedAStatus::ok();
}
constexpr const char* boolToString(bool b) {
return b ? "true" : "false";
}
constexpr const char *boolToString(bool b) { return b ? "true" : "false"; }
binder_status_t Power::dump(int fd, const char**, uint32_t) {
binder_status_t Power::dump(int fd, const char **, uint32_t) {
std::string buf(::android::base::StringPrintf(
"HintManager Running: %s\n"
"VRMode: %s\n"

10
universal7885-common/hardware/samsung/aidl/power-libperfmgr/Power.h
View file

@ -38,15 +38,15 @@ using ::aidl::android::hardware::power::Mode;
using ::android::perfmgr::HintManager;
class Power : public ::aidl::android::hardware::power::BnPower {
public:
public:
Power(std::shared_ptr<HintManager> hm);
ndk::ScopedAStatus setMode(Mode type, bool enabled) override;
ndk::ScopedAStatus isModeSupported(Mode type, bool* _aidl_return) override;
ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override;
ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(Boost type, bool* _aidl_return) override;
binder_status_t dump(int fd, const char** args, uint32_t numArgs) override;
ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override;
binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
private:
private:
std::shared_ptr<HintManager> mHintManager;
std::unique_ptr<InteractionHandler> mInteractionHandler;
std::atomic<bool> mVRModeOn;

11
universal7885-common/hardware/samsung/aidl/power-libperfmgr/PowerExt.cpp
View file

@ -37,7 +37,7 @@ namespace power {
namespace impl {
namespace pixel {
ndk::ScopedAStatus PowerExt::setMode(const std::string& mode, bool enabled) {
ndk::ScopedAStatus PowerExt::setMode(const std::string &mode, bool enabled) {
LOG(DEBUG) << "PowerExt setMode: " << mode << " to: " << enabled;
ATRACE_INT(mode.c_str(), enabled);
@ -50,14 +50,16 @@ ndk::ScopedAStatus PowerExt::setMode(const std::string& mode, bool enabled) {
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus PowerExt::isModeSupported(const std::string& mode, bool* _aidl_return) {
ndk::ScopedAStatus PowerExt::isModeSupported(const std::string &mode,
bool *_aidl_return) {
bool supported = mHintManager->IsHintSupported(mode);
LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported;
*_aidl_return = supported;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus PowerExt::setBoost(const std::string& boost, int32_t durationMs) {
ndk::ScopedAStatus PowerExt::setBoost(const std::string &boost,
int32_t durationMs) {
LOG(DEBUG) << "PowerExt setBoost: " << boost << " duration: " << durationMs;
ATRACE_INT(boost.c_str(), durationMs);
@ -72,7 +74,8 @@ ndk::ScopedAStatus PowerExt::setBoost(const std::string& boost, int32_t duration
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus PowerExt::isBoostSupported(const std::string& boost, bool* _aidl_return) {
ndk::ScopedAStatus PowerExt::isBoostSupported(const std::string &boost,
bool *_aidl_return) {
bool supported = mHintManager->IsHintSupported(boost);
LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported;
*_aidl_return = supported;

18
universal7885-common/hardware/samsung/aidl/power-libperfmgr/PowerExt.h
View file

@ -32,15 +32,19 @@ namespace pixel {
using ::android::perfmgr::HintManager;
class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt {
public:
class PowerExt
: public ::aidl::google::hardware::power::extension::pixel::BnPowerExt {
public:
PowerExt(std::shared_ptr<HintManager> hm) : mHintManager(hm) {}
ndk::ScopedAStatus setMode(const std::string& mode, bool enabled) override;
ndk::ScopedAStatus isModeSupported(const std::string& mode, bool* _aidl_return) override;
ndk::ScopedAStatus setBoost(const std::string& boost, int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(const std::string& boost, bool* _aidl_return) override;
ndk::ScopedAStatus setMode(const std::string &mode, bool enabled) override;
ndk::ScopedAStatus isModeSupported(const std::string &mode,
bool *_aidl_return) override;
ndk::ScopedAStatus setBoost(const std::string &boost,
int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(const std::string &boost,
bool *_aidl_return) override;
private:
private:
std::shared_ptr<HintManager> mHintManager;
};

9
universal7885-common/hardware/samsung/aidl/power-libperfmgr/service.cpp
View file

@ -37,7 +37,8 @@ int main() {
LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is starting.";
// Parse config but do not start the looper
std::shared_ptr<HintManager> hm = HintManager::GetFromJSON(kPowerHalConfigPath, false);
std::shared_ptr<HintManager> hm =
HintManager::GetFromJSON(kPowerHalConfigPath, false);
if (!hm) {
LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath;
}
@ -53,10 +54,12 @@ int main() {
std::shared_ptr<PowerExt> pwExt = ndk::SharedRefBase::make<PowerExt>(hm);
// attach the extension to the same binder we will be registering
CHECK(STATUS_OK == AIBinder_setExtension(pwBinder.get(), pwExt->asBinder().get()));
CHECK(STATUS_OK ==
AIBinder_setExtension(pwBinder.get(), pwExt->asBinder().get()));
const std::string instance = std::string() + Power::descriptor + "/default";
binder_status_t status = AServiceManager_addService(pw->asBinder().get(), instance.c_str());
binder_status_t status =
AServiceManager_addService(pw->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is started.";

111
universal7885-common/hardware/samsung/aidl/vibrator/Vibrator.cpp
View file

@ -19,19 +19,17 @@ namespace android {
namespace hardware {
namespace vibrator {
static std::map<Effect, int> CP_TRIGGER_EFFECTS {
{ Effect::CLICK, 10 },
{ Effect::DOUBLE_CLICK, 14 },
{ Effect::HEAVY_CLICK, 23 },
{ Effect::TEXTURE_TICK, 50 },
{ Effect::TICK, 50 }
};
static std::map<Effect, int> CP_TRIGGER_EFFECTS{{Effect::CLICK, 10},
{Effect::DOUBLE_CLICK, 14},
{Effect::HEAVY_CLICK, 23},
{Effect::TEXTURE_TICK, 50},
{Effect::TICK, 50}};
/*
* Write value to path and close file.
*/
template <typename T>
static ndk::ScopedAStatus writeNode(const std::string& path, const T& value) {
static ndk::ScopedAStatus writeNode(const std::string &path, const T &value) {
std::ofstream node(path);
if (!node) {
LOG(ERROR) << "Failed to open: " << path;
@ -49,7 +47,7 @@ static ndk::ScopedAStatus writeNode(const std::string& path, const T& value) {
return ndk::ScopedAStatus::ok();
}
static bool nodeExists(const std::string& path) {
static bool nodeExists(const std::string &path) {
std::ofstream f(path.c_str());
return f.good();
}
@ -60,10 +58,12 @@ Vibrator::Vibrator() {
mHasTimedOutEffect = nodeExists(VIBRATOR_CP_TRIGGER_PATH);
}
ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
*_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) {
*_aidl_return =
IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
IVibrator::CAP_ALWAYS_ON_CONTROL*/;
IVibrator::CAP_ALWAYS_ON_CONTROL*/
;
if (mHasTimedOutIntensity) {
*_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
@ -73,11 +73,11 @@ ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Vibrator::off() {
return activate(0);
}
ndk::ScopedAStatus Vibrator::off() { return activate(0); }
ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) {
ndk::ScopedAStatus
Vibrator::on(int32_t timeoutMs,
const std::shared_ptr<IVibratorCallback> &callback) {
ndk::ScopedAStatus status;
if (mHasTimedOutEffect)
@ -99,7 +99,10 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibrat
return status;
}
ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) {
ndk::ScopedAStatus
Vibrator::perform(Effect effect, EffectStrength strength,
const std::shared_ptr<IVibratorCallback> &callback,
int32_t *_aidl_return) {
ndk::ScopedAStatus status;
uint32_t amplitude = strengthToAmplitude(strength, &status);
uint32_t ms = 1000;
@ -110,7 +113,8 @@ ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, con
activate(0);
setAmplitude(amplitude);
if (mHasTimedOutEffect && CP_TRIGGER_EFFECTS.find(effect) != CP_TRIGGER_EFFECTS.end()) {
if (mHasTimedOutEffect &&
CP_TRIGGER_EFFECTS.find(effect) != CP_TRIGGER_EFFECTS.end()) {
writeNode(VIBRATOR_CP_TRIGGER_PATH, CP_TRIGGER_EFFECTS[effect]);
} else {
if (mHasTimedOutEffect)
@ -137,15 +141,17 @@ ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, con
return status;
}
ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) {
*_aidl_return = {Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK,
Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD, Effect::POP,
Effect::RINGTONE_1, Effect::RINGTONE_2, Effect::RINGTONE_3,
Effect::RINGTONE_4, Effect::RINGTONE_5, Effect::RINGTONE_6,
Effect::RINGTONE_7, Effect::RINGTONE_7, Effect::RINGTONE_8,
Effect::RINGTONE_9, Effect::RINGTONE_10, Effect::RINGTONE_11,
Effect::RINGTONE_12, Effect::RINGTONE_13, Effect::RINGTONE_14,
Effect::RINGTONE_15};
ndk::ScopedAStatus
Vibrator::getSupportedEffects(std::vector<Effect> *_aidl_return) {
*_aidl_return = {
Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK,
Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD,
Effect::POP, Effect::RINGTONE_1, Effect::RINGTONE_2,
Effect::RINGTONE_3, Effect::RINGTONE_4, Effect::RINGTONE_5,
Effect::RINGTONE_6, Effect::RINGTONE_7, Effect::RINGTONE_7,
Effect::RINGTONE_8, Effect::RINGTONE_9, Effect::RINGTONE_10,
Effect::RINGTONE_11, Effect::RINGTONE_12, Effect::RINGTONE_13,
Effect::RINGTONE_14, Effect::RINGTONE_15};
return ndk::ScopedAStatus::ok();
}
@ -183,31 +189,39 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) {
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getCompositionDelayMax(int32_t * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive>* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getSupportedPrimitives(
std::vector<CompositePrimitive> * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/,
int32_t * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
ndk::ScopedAStatus
Vibrator::compose(const std::vector<CompositeEffect> & /*composite*/,
const std::shared_ptr<IVibratorCallback> & /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect> * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) {
ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/,
EffectStrength /*strength*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
@ -215,39 +229,45 @@ ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getResonantFrequency(float* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getResonantFrequency(float * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getQFactor(float* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getQFactor(float * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getFrequencyResolution(float* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getFrequencyResolution(float * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float* /*_aidl_return*/) {
ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float>* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getBandwidthAmplitudeMap(std::vector<float> * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getPwlePrimitiveDurationMax(int32_t * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getPwleCompositionSizeMax(int32_t * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_aidl_return*/) {
ndk::ScopedAStatus
Vibrator::getSupportedBraking(std::vector<Braking> * /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
ndk::ScopedAStatus
Vibrator::composePwle(const std::vector<PrimitivePwle> & /*composite*/,
const std::shared_ptr<IVibratorCallback> & /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
@ -260,7 +280,8 @@ ndk::ScopedAStatus Vibrator::activate(uint32_t timeoutMs) {
return writeNode(VIBRATOR_TIMEOUT_PATH, timeoutMs);
}
uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status) {
uint8_t Vibrator::strengthToAmplitude(EffectStrength strength,
ndk::ScopedAStatus *status) {
*status = ndk::ScopedAStatus::ok();
switch (strength) {
@ -276,7 +297,7 @@ uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatu
return 0;
}
uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus* status) {
uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus *status) {
*status = ndk::ScopedAStatus::ok();
switch (effect) {
case Effect::CLICK:

70
universal7885-common/hardware/samsung/aidl/vibrator/Vibrator.h
View file

@ -14,14 +14,15 @@
#define VIBRATOR_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable"
#define VIBRATOR_INTENSITY_PATH "/sys/class/timed_output/vibrator/intensity"
#define VIBRATOR_CP_TRIGGER_PATH "/sys/class/timed_output/vibrator/cp_trigger_index"
#define VIBRATOR_CP_TRIGGER_PATH \
"/sys/class/timed_output/vibrator/cp_trigger_index"
using ::aidl::android::hardware::vibrator::IVibratorCallback;
using ::aidl::android::hardware::vibrator::Braking;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::CompositeEffect;
using ::aidl::android::hardware::vibrator::CompositePrimitive;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::IVibratorCallback;
using ::aidl::android::hardware::vibrator::PrimitivePwle;
namespace aidl {
@ -32,35 +33,52 @@ namespace vibrator {
class Vibrator : public BnVibrator {
public:
Vibrator();
ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
ndk::ScopedAStatus getCapabilities(int32_t *_aidl_return) override;
ndk::ScopedAStatus off() override;
ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus
on(int32_t timeoutMs,
const std::shared_ptr<IVibratorCallback> &callback) override;
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength,
const std::shared_ptr<IVibratorCallback> &callback,
int32_t *_aidl_return) override;
ndk::ScopedAStatus
getSupportedEffects(std::vector<Effect> *_aidl_return) override;
ndk::ScopedAStatus setAmplitude(float amplitude) override;
ndk::ScopedAStatus setExternalControl(bool enabled) override;
ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedPrimitives(std::vector<CompositePrimitive>* _aidl_return) override;
ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t* _aidl_return) override;
ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite, const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override;
ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override;
ndk::ScopedAStatus getCompositionDelayMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus getCompositionSizeMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus getSupportedPrimitives(
std::vector<CompositePrimitive> *_aidl_return) override;
ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive,
int32_t *_aidl_return) override;
ndk::ScopedAStatus
compose(const std::vector<CompositeEffect> &composite,
const std::shared_ptr<IVibratorCallback> &callback) override;
ndk::ScopedAStatus
getSupportedAlwaysOnEffects(std::vector<Effect> *_aidl_return) override;
ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect,
EffectStrength strength) override;
ndk::ScopedAStatus alwaysOnDisable(int32_t id) override;
ndk::ScopedAStatus getResonantFrequency(float* _aidl_return) override;
ndk::ScopedAStatus getQFactor(float* _aidl_return) override;
ndk::ScopedAStatus getFrequencyResolution(float* _aidl_return) override;
ndk::ScopedAStatus getFrequencyMinimum(float* _aidl_return) override;
ndk::ScopedAStatus getBandwidthAmplitudeMap(std::vector<float>* _aidl_return) override;
ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override;
ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override;
ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle>& composite, const std::shared_ptr<IVibratorCallback>& callback) override;
ndk::ScopedAStatus getResonantFrequency(float *_aidl_return) override;
ndk::ScopedAStatus getQFactor(float *_aidl_return) override;
ndk::ScopedAStatus getFrequencyResolution(float *_aidl_return) override;
ndk::ScopedAStatus getFrequencyMinimum(float *_aidl_return) override;
ndk::ScopedAStatus
getBandwidthAmplitudeMap(std::vector<float> *_aidl_return) override;
ndk::ScopedAStatus
getPwlePrimitiveDurationMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus
getSupportedBraking(std::vector<Braking> *_aidl_return) override;
ndk::ScopedAStatus
composePwle(const std::vector<PrimitivePwle> &composite,
const std::shared_ptr<IVibratorCallback> &callback) override;
private:
ndk::ScopedAStatus activate(uint32_t ms);
static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus* status);
static uint8_t strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status);
static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus *status);
static uint8_t strengthToAmplitude(EffectStrength strength,
ndk::ScopedAStatus *status);
bool mEnabled{false};
bool mExternalControl{false};

8
universal7885-common/hardware/samsung/aidl/vibrator/service.cpp
View file

@ -6,9 +6,9 @@
#include "Vibrator.h"
#include <android-base/logging.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <android-base/logging.h>
using ::aidl::android::hardware::vibrator::Vibrator;
@ -16,8 +16,10 @@ int main() {
ABinderProcess_setThreadPoolMaxThreadCount(0);
std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>();
const std::string instance = std::string() + Vibrator::descriptor + "/default";
binder_status_t status = AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
const std::string instance =
std::string() + Vibrator::descriptor + "/default";
binder_status_t status =
AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool();

25
universal7885-common/hardware/samsung/hidl/camera/provider/SamsungCameraProvider.cpp
View file

@ -23,13 +23,14 @@
using ::android::NO_ERROR;
using ::android::OK;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Void;
const int kMaxCameraIdLen = 16;
SamsungCameraProvider::SamsungCameraProvider() : LegacyCameraProviderImpl_2_5() {
SamsungCameraProvider::SamsungCameraProvider()
: LegacyCameraProviderImpl_2_5() {
mExtraIDs.push_back(50);
mDisabledIDs.push_back(2);
if (!mInitFailed) {
@ -66,20 +67,24 @@ SamsungCameraProvider::SamsungCameraProvider() : LegacyCameraProviderImpl_2_5()
Return<void> SamsungCameraProvider::getCameraIdList(
ICameraProvider::getCameraIdList_cb _hidl_cb) {
std::vector<hidl_string> deviceNameList;
for (auto const& deviceNamePair : mCameraDeviceNames) {
for (auto const &deviceNamePair : mCameraDeviceNames) {
int id = std::stoi(deviceNamePair.first);
if (id >= mNumberOfLegacyCameras || std::find(mDisabledIDs.begin(), mDisabledIDs.end(), id) != mDisabledIDs.end()) {
// External camera devices must be reported through the device status change callback,
// not in this list.
// Linux4: Also skip disabled camera IDs.
if (id >= mNumberOfLegacyCameras ||
std::find(mDisabledIDs.begin(), mDisabledIDs.end(), id) !=
mDisabledIDs.end()) {
// External camera devices must be reported through the device status
// change callback, not in this list. Linux4: Also skip disabled camera
// IDs.
continue;
}
if (mCameraStatusMap[deviceNamePair.first] == CAMERA_DEVICE_STATUS_PRESENT) {
if (mCameraStatusMap[deviceNamePair.first] ==
CAMERA_DEVICE_STATUS_PRESENT) {
deviceNameList.push_back(deviceNamePair.second);
}
}
hidl_vec<hidl_string> hidlDeviceNameList(deviceNameList);
_hidl_cb(::android::hardware::camera::common::V1_0::Status::OK, hidlDeviceNameList);
_hidl_cb(::android::hardware::camera::common::V1_0::Status::OK,
hidlDeviceNameList);
return Void();
}

6
universal7885-common/hardware/samsung/hidl/camera/provider/SamsungCameraProvider.h
View file

@ -20,9 +20,10 @@
#define SAMSUNG_CAMERA_DEBUG
using ::android::hardware::camera::provider::V2_5::ICameraProvider;
using ::android::hardware::camera::provider::V2_5::implementation::LegacyCameraProviderImpl_2_5;
using ::android::hardware::Return;
using ::android::hardware::camera::provider::V2_5::ICameraProvider;
using ::android::hardware::camera::provider::V2_5::implementation::
LegacyCameraProviderImpl_2_5;
class SamsungCameraProvider : public LegacyCameraProviderImpl_2_5 {
public:
@ -30,6 +31,7 @@ public:
~SamsungCameraProvider();
Return<void> getCameraIdList(ICameraProvider::getCameraIdList_cb _hidl_cb);
private:
std::vector<int> mExtraIDs;
std::vector<int> mDisabledIDs;

13
universal7885-common/hardware/samsung/hidl/camera/provider/service.cpp
View file

@ -28,19 +28,20 @@
using android::status_t;
using android::hardware::camera::provider::V2_5::ICameraProvider;
int main()
{
int main() {
using namespace android::hardware::camera::provider::V2_5::implementation;
ALOGI("CameraProvider@2.5 legacy service is starting.");
::android::hardware::configureRpcThreadpool(/*threads*/ HWBINDER_THREAD_COUNT, /*willJoin*/ true);
::android::hardware::configureRpcThreadpool(/*threads*/ HWBINDER_THREAD_COUNT,
/*willJoin*/ true);
::android::sp<ICameraProvider> provider = new CameraProvider<SamsungCameraProvider>();
::android::sp<ICameraProvider> provider =
new CameraProvider<SamsungCameraProvider>();
status_t status = provider->registerAsService("legacy/0");
LOG_ALWAYS_FATAL_IF(status != android::OK, "Error while registering provider service: %d",
status);
LOG_ALWAYS_FATAL_IF(status != android::OK,
"Error while registering provider service: %d", status);
::android::hardware::joinRpcThreadpool();

102
universal7885-common/hardware/samsung/hidl/fingerprint/BiometricsFingerprint.cpp
View file

@ -19,14 +19,14 @@
#include <hardware/hw_auth_token.h>
#include "BiometricsFingerprint.h"
#include <hardware/fingerprint.h>
#include <hardware/hardware.h>
#include "BiometricsFingerprint.h"
#include <dlfcn.h>
#include <fstream>
#include <inttypes.h>
#include <unistd.h>
#include <fstream>
#ifdef HAS_FINGERPRINT_GESTURES
#include <fcntl.h>
@ -39,9 +39,10 @@ namespace fingerprint {
namespace V2_3 {
namespace implementation {
using RequestStatus = android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
using RequestStatus =
android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
BiometricsFingerprint* BiometricsFingerprint::sInstance = nullptr;
BiometricsFingerprint *BiometricsFingerprint::sInstance = nullptr;
BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
sInstance = this; // keep track of the most recent instance
@ -58,7 +59,8 @@ BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
return;
}
int err = ioctl(uinputFd, UI_SET_EVBIT, EV_KEY) | ioctl(uinputFd, UI_SET_KEYBIT, KEY_UP) |
int err = ioctl(uinputFd, UI_SET_EVBIT, EV_KEY) |
ioctl(uinputFd, UI_SET_KEYBIT, KEY_UP) |
ioctl(uinputFd, UI_SET_KEYBIT, KEY_DOWN);
if (err != 0) {
LOG(ERROR) << "Unable to enable key events";
@ -99,13 +101,12 @@ Return<bool> BiometricsFingerprint::isUdfps(uint32_t) {
return false;
}
Return<void> BiometricsFingerprint::onFingerDown(uint32_t, uint32_t, float, float) {
Return<void> BiometricsFingerprint::onFingerDown(uint32_t, uint32_t, float,
float) {
return Void();
}
Return<void> BiometricsFingerprint::onFingerUp() {
return Void();
}
Return<void> BiometricsFingerprint::onFingerUp() { return Void(); }
Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
switch (error) {
@ -134,14 +135,16 @@ Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
case -110:
return RequestStatus::SYS_ETIMEDOUT;
default:
LOG(ERROR) << "An unknown error returned from fingerprint vendor library: " << error;
LOG(ERROR) << "An unknown error returned from fingerprint vendor library: "
<< error;
return RequestStatus::SYS_UNKNOWN;
}
}
// Translate from errors returned by traditional HAL (see fingerprint.h) to
// HIDL-compliant FingerprintError.
FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error, int32_t* vendorCode) {
FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error,
int32_t *vendorCode) {
*vendorCode = 0;
switch (error) {
case FINGERPRINT_ERROR_HW_UNAVAILABLE:
@ -171,8 +174,8 @@ FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error, int32_t
// Translate acquired messages returned by traditional HAL (see fingerprint.h)
// to HIDL-compliant FingerprintAcquiredInfo.
FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(int32_t info,
int32_t* vendorCode) {
FingerprintAcquiredInfo
BiometricsFingerprint::VendorAcquiredFilter(int32_t info, int32_t *vendorCode) {
*vendorCode = 0;
switch (info) {
case FINGERPRINT_ACQUIRED_GOOD:
@ -199,7 +202,7 @@ FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(int32_t info
}
Return<uint64_t> BiometricsFingerprint::setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) {
const sp<IBiometricsFingerprintClientCallback> &clientCallback) {
std::lock_guard<std::mutex> lock(mClientCallbackMutex);
mClientCallback = clientCallback;
// This is here because HAL 2.3 doesn't have a way to propagate a
@ -213,9 +216,11 @@ Return<uint64_t> BiometricsFingerprint::preEnroll() {
return ss_fingerprint_pre_enroll();
}
Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat,
uint32_t gid, uint32_t timeoutSec) {
const hw_auth_token_t* authToken = reinterpret_cast<const hw_auth_token_t*>(hat.data());
Return<RequestStatus>
BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69> &hat, uint32_t gid,
uint32_t timeoutSec) {
const hw_auth_token_t *authToken =
reinterpret_cast<const hw_auth_token_t *>(hat.data());
return ErrorFilter(ss_fingerprint_enroll(authToken, gid, timeoutSec));
}
@ -251,12 +256,14 @@ Return<RequestStatus> BiometricsFingerprint::enumerate() {
return RequestStatus::SYS_UNKNOWN;
}
Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid, uint32_t fid) {
Return<RequestStatus> BiometricsFingerprint::remove(uint32_t gid,
uint32_t fid) {
return ErrorFilter(ss_fingerprint_remove(gid, fid));
}
Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
const hidl_string& storePath) {
Return<RequestStatus>
BiometricsFingerprint::setActiveGroup(uint32_t gid,
const hidl_string &storePath) {
if (storePath.size() >= PATH_MAX || storePath.size() <= 0) {
LOG(ERROR) << "Bad path length: " << storePath.size();
return RequestStatus::SYS_EINVAL;
@ -269,11 +276,12 @@ Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid,
return ErrorFilter(ss_fingerprint_set_active_group(gid, storePath.c_str()));
}
Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId, uint32_t gid) {
Return<RequestStatus> BiometricsFingerprint::authenticate(uint64_t operationId,
uint32_t gid) {
return ErrorFilter(ss_fingerprint_authenticate(operationId, gid));
}
IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
IBiometricsFingerprint *BiometricsFingerprint::getInstance() {
if (!sInstance) {
sInstance = new BiometricsFingerprint();
}
@ -281,34 +289,40 @@ IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
}
bool BiometricsFingerprint::openHal() {
void* handle = dlopen("libbauthserver.so", RTLD_NOW);
void *handle = dlopen("libbauthserver.so", RTLD_NOW);
if (handle) {
int err;
ss_fingerprint_close = reinterpret_cast<typeof(ss_fingerprint_close)>(
dlsym(handle, "ss_fingerprint_close"));
ss_fingerprint_open =
reinterpret_cast<typeof(ss_fingerprint_open)>(dlsym(handle, "ss_fingerprint_open"));
ss_fingerprint_open = reinterpret_cast<typeof(ss_fingerprint_open)>(
dlsym(handle, "ss_fingerprint_open"));
ss_set_notify_callback = reinterpret_cast<typeof(ss_set_notify_callback)>(
dlsym(handle, "ss_set_notify_callback"));
ss_fingerprint_pre_enroll = reinterpret_cast<typeof(ss_fingerprint_pre_enroll)>(
ss_fingerprint_pre_enroll =
reinterpret_cast<typeof(ss_fingerprint_pre_enroll)>(
dlsym(handle, "ss_fingerprint_pre_enroll"));
ss_fingerprint_enroll = reinterpret_cast<typeof(ss_fingerprint_enroll)>(
dlsym(handle, "ss_fingerprint_enroll"));
ss_fingerprint_post_enroll = reinterpret_cast<typeof(ss_fingerprint_post_enroll)>(
ss_fingerprint_post_enroll =
reinterpret_cast<typeof(ss_fingerprint_post_enroll)>(
dlsym(handle, "ss_fingerprint_post_enroll"));
ss_fingerprint_get_auth_id = reinterpret_cast<typeof(ss_fingerprint_get_auth_id)>(
ss_fingerprint_get_auth_id =
reinterpret_cast<typeof(ss_fingerprint_get_auth_id)>(
dlsym(handle, "ss_fingerprint_get_auth_id"));
ss_fingerprint_cancel = reinterpret_cast<typeof(ss_fingerprint_cancel)>(
dlsym(handle, "ss_fingerprint_cancel"));
ss_fingerprint_enumerate = reinterpret_cast<typeof(ss_fingerprint_enumerate)>(
ss_fingerprint_enumerate =
reinterpret_cast<typeof(ss_fingerprint_enumerate)>(
dlsym(handle, "ss_fingerprint_enumerate"));
ss_fingerprint_remove = reinterpret_cast<typeof(ss_fingerprint_remove)>(
dlsym(handle, "ss_fingerprint_remove"));
ss_fingerprint_set_active_group = reinterpret_cast<typeof(ss_fingerprint_set_active_group)>(
ss_fingerprint_set_active_group =
reinterpret_cast<typeof(ss_fingerprint_set_active_group)>(
dlsym(handle, "ss_fingerprint_set_active_group"));
ss_fingerprint_authenticate = reinterpret_cast<typeof(ss_fingerprint_authenticate)>(
ss_fingerprint_authenticate =
reinterpret_cast<typeof(ss_fingerprint_authenticate)>(
dlsym(handle, "ss_fingerprint_authenticate"));
ss_fingerprint_request = reinterpret_cast<typeof(ss_fingerprint_request)>(
dlsym(handle, "ss_fingerprint_request"));
@ -319,7 +333,8 @@ bool BiometricsFingerprint::openHal() {
}
if ((err = ss_set_notify_callback(BiometricsFingerprint::notify)) != 0) {
LOG(ERROR) << "Can't register fingerprint module callback, error: " << err;
LOG(ERROR) << "Can't register fingerprint module callback, error: "
<< err;
return false;
}
@ -329,12 +344,13 @@ bool BiometricsFingerprint::openHal() {
return false;
}
void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
BiometricsFingerprint* thisPtr =
static_cast<BiometricsFingerprint*>(BiometricsFingerprint::getInstance());
void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
BiometricsFingerprint *thisPtr = static_cast<BiometricsFingerprint *>(
BiometricsFingerprint::getInstance());
std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex);
if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) {
LOG(ERROR) << "Receiving callbacks before the client callback is registered.";
LOG(ERROR)
<< "Receiving callbacks before the client callback is registered.";
return;
}
const uint64_t devId = 1;
@ -356,13 +372,14 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
FingerprintAcquiredInfo result =
VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
LOG(DEBUG) << "onAcquired(" << static_cast<int>(result) << ")";
if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode).isOk()) {
if (!thisPtr->mClientCallback->onAcquired(devId, result, vendorCode)
.isOk()) {
LOG(ERROR) << "failed to invoke fingerprint onAcquired callback";
}
} break;
case FINGERPRINT_TEMPLATE_ENROLLING:
#ifdef USES_PERCENTAGE_SAMPLES
const_cast<fingerprint_msg_t*>(msg)->data.enroll.samples_remaining =
const_cast<fingerprint_msg_t *>(msg)->data.enroll.samples_remaining =
100 - msg->data.enroll.samples_remaining;
#endif
#ifdef CALL_CANCEL_ON_ENROLL_COMPLETION
@ -397,7 +414,8 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
LOG(DEBUG) << "onAuthenticated(fid=" << msg->data.authenticated.finger.fid
<< ", gid=" << msg->data.authenticated.finger.gid << ")";
if (msg->data.authenticated.finger.fid != 0) {
const uint8_t* hat = reinterpret_cast<const uint8_t*>(&msg->data.authenticated.hat);
const uint8_t *hat =
reinterpret_cast<const uint8_t *>(&msg->data.authenticated.hat);
const hidl_vec<uint8_t> token(
std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
if (!thisPtr->mClientCallback
@ -438,7 +456,8 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_DOWN:
case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP:
struct input_event event {};
int keycode = eventCode == SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP ? KEY_UP : KEY_DOWN;
int keycode =
eventCode == SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP ? KEY_UP : KEY_DOWN;
int err;
// Report the key
@ -488,7 +507,8 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
int BiometricsFingerprint::request(int cmd, int param) {
// TO-DO: input, output handling not implemented
int result = ss_fingerprint_request(cmd, nullptr, 0, nullptr, 0, param);
LOG(INFO) << "request(cmd=" << cmd << ", param=" << param << ", result=" << result << ")";
LOG(INFO) << "request(cmd=" << cmd << ", param=" << param
<< ", result=" << result << ")";
return result;
}

54
universal7885-common/hardware/samsung/hidl/fingerprint/BiometricsFingerprint.h
View file

@ -47,50 +47,60 @@ using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintAcquiredInfo;
using ::android::hardware::biometrics::fingerprint::V2_1::
FingerprintAcquiredInfo;
using ::android::hardware::biometrics::fingerprint::V2_1::FingerprintError;
using ::android::hardware::biometrics::fingerprint::V2_1::IBiometricsFingerprintClientCallback;
using ::android::hardware::biometrics::fingerprint::V2_1::
IBiometricsFingerprintClientCallback;
using ::android::hardware::biometrics::fingerprint::V2_1::RequestStatus;
using ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
using ::android::hardware::biometrics::fingerprint::V2_3::
IBiometricsFingerprint;
struct BiometricsFingerprint : public IBiometricsFingerprint {
BiometricsFingerprint();
~BiometricsFingerprint();
// Method to wrap legacy HAL with BiometricsFingerprint class
static IBiometricsFingerprint* getInstance();
static IBiometricsFingerprint *getInstance();
// Methods from ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint
// Methods from
// ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint
// follow.
Return<uint64_t> setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) override;
const sp<IBiometricsFingerprintClientCallback> &clientCallback) override;
Return<uint64_t> preEnroll() override;
Return<RequestStatus> enroll(const hidl_array<uint8_t, 69>& hat, uint32_t gid,
Return<RequestStatus> enroll(const hidl_array<uint8_t, 69> &hat, uint32_t gid,
uint32_t timeoutSec) override;
Return<RequestStatus> postEnroll() override;
Return<uint64_t> getAuthenticatorId() override;
Return<RequestStatus> cancel() override;
Return<RequestStatus> enumerate() override;
Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string& storePath) override;
Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override;
Return<RequestStatus> setActiveGroup(uint32_t gid,
const hidl_string &storePath) override;
Return<RequestStatus> authenticate(uint64_t operationId,
uint32_t gid) override;
Return<bool> isUdfps(uint32_t sensorID) override;
Return<void> onFingerDown(uint32_t x, uint32_t y, float minor, float major) override;
Return<void> onFingerDown(uint32_t x, uint32_t y, float minor,
float major) override;
Return<void> onFingerUp() override;
Return<void> onShowUdfpsOverlay() { return Void(); }
Return<void> onHideUdfpsOverlay() { return Void(); }
private:
private:
bool openHal();
int request(int cmd, int param);
int waitForSensor(std::chrono::milliseconds pollWait, std::chrono::milliseconds timeOut);
static void notify(
const fingerprint_msg_t* msg); /* Static callback for legacy HAL implementation */
int waitForSensor(std::chrono::milliseconds pollWait,
std::chrono::milliseconds timeOut);
static void
notify(const fingerprint_msg_t
*msg); /* Static callback for legacy HAL implementation */
void handleEvent(int eventCode);
static Return<RequestStatus> ErrorFilter(int32_t error);
static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode);
static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error, int32_t* vendorCode);
static BiometricsFingerprint* sInstance;
static FingerprintError VendorErrorFilter(int32_t error, int32_t *vendorCode);
static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error,
int32_t *vendorCode);
static BiometricsFingerprint *sInstance;
std::mutex mClientCallbackMutex;
sp<IBiometricsFingerprintClientCallback> mClientCallback;
@ -100,19 +110,21 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
#endif
int (*ss_fingerprint_close)();
int (*ss_fingerprint_open)(const char* id);
int (*ss_fingerprint_open)(const char *id);
int (*ss_set_notify_callback)(fingerprint_notify_t notify);
uint64_t (*ss_fingerprint_pre_enroll)();
int (*ss_fingerprint_enroll)(const hw_auth_token_t* hat, uint32_t gid, uint32_t timeout_sec);
int (*ss_fingerprint_enroll)(const hw_auth_token_t *hat, uint32_t gid,
uint32_t timeout_sec);
int (*ss_fingerprint_post_enroll)();
uint64_t (*ss_fingerprint_get_auth_id)();
int (*ss_fingerprint_cancel)();
int (*ss_fingerprint_enumerate)();
int (*ss_fingerprint_remove)(uint32_t gid, uint32_t fid);
int (*ss_fingerprint_set_active_group)(uint32_t gid, const char* store_path);
int (*ss_fingerprint_set_active_group)(uint32_t gid, const char *store_path);
int (*ss_fingerprint_authenticate)(uint64_t operation_id, uint32_t gid);
int (*ss_fingerprint_request)(uint32_t cmd, char* inBuf, uint32_t inBuf_length, char* outBuf,
int (*ss_fingerprint_request)(uint32_t cmd, char *inBuf,
uint32_t inBuf_length, char *outBuf,
uint32_t outBuf_length, uint32_t param);
};

6
universal7885-common/hardware/samsung/hidl/fingerprint/service.cpp
View file

@ -26,13 +26,15 @@ using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint;
using android::hardware::biometrics::fingerprint::V2_3::implementation::BiometricsFingerprint;
using android::hardware::biometrics::fingerprint::V2_3::implementation::
BiometricsFingerprint;
using android::OK;
using android::sp;
int main() {
android::sp<IBiometricsFingerprint> bio = BiometricsFingerprint::getInstance();
android::sp<IBiometricsFingerprint> bio =
BiometricsFingerprint::getInstance();
configureRpcThreadpool(1, true);

4
universal7885-common/hardware/samsung/hidl/keymaster/service.cpp
View file

@ -32,11 +32,11 @@ using android::OK;
using android::status_t;
namespace skeymaster {
IKeymasterDevice* CreateSKeymasterDevice(SecurityLevel securityLevel);
IKeymasterDevice *CreateSKeymasterDevice(SecurityLevel securityLevel);
} // namespace skeymaster
int main() {
IKeymasterDevice* keymaster =
IKeymasterDevice *keymaster =
skeymaster::CreateSKeymasterDevice(SecurityLevel::TRUSTED_ENVIRONMENT);
configureRpcThreadpool(1, true);

96
universal7885-common/hardware/samsung/hidl/sensors/Sensors.cpp
View file

@ -14,11 +14,11 @@
* limitations under the License.
*/
//#define VERBOSE
// #define VERBOSE
#include "Sensors.h"
#include <sensors/convert.h>
#include "multihal.h"
#include <sensors/convert.h>
#include <android-base/logging.h>
@ -35,7 +35,7 @@ namespace implementation {
* return true indicating we need to use multi-hal functionality.
*/
static bool UseMultiHal() {
const std::string& name = MULTI_HAL_CONFIG_FILE_PATH;
const std::string &name = MULTI_HAL_CONFIG_FILE_PATH;
struct stat buffer;
return (stat(name.c_str(), &buffer) == 0);
}
@ -55,12 +55,14 @@ static Result ResultFromStatus(status_t err) {
}
}
Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(nullptr) {
Sensors::Sensors()
: mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(nullptr) {
status_t err = OK;
if (UseMultiHal()) {
mSensorModule = ::get_multi_hal_module_info();
} else {
err = hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&mSensorModule);
err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
(hw_module_t const **)&mSensorModule);
}
if (mSensorModule == NULL) {
err = UNKNOWN_ERROR;
@ -77,8 +79,8 @@ Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(
err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
if (err != OK) {
LOG(ERROR) << "Couldn't open device for module " << SENSORS_HARDWARE_MODULE_ID << " ("
<< strerror(-err) << ")";
LOG(ERROR) << "Couldn't open device for module "
<< SENSORS_HARDWARE_MODULE_ID << " (" << strerror(-err) << ")";
mInitCheck = err;
return;
@ -90,10 +92,12 @@ Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(
if (getHalDeviceVersion() == SENSORS_DEVICE_API_VERSION_1_4) {
if (mSensorDevice->inject_sensor_data == nullptr) {
LOG(ERROR) << "HAL specifies version 1.4, but does not implement inject_sensor_data()";
LOG(ERROR) << "HAL specifies version 1.4, but does not implement "
"inject_sensor_data()";
}
if (mSensorModule->set_operation_mode == nullptr) {
LOG(ERROR) << "HAL specifies version 1.4, but does not implement set_operation_mode()";
LOG(ERROR) << "HAL specifies version 1.4, but does not implement "
"set_operation_mode()";
}
}
@ -103,20 +107,18 @@ Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(
mInitCheck = OK;
}
status_t Sensors::initCheck() const {
return mInitCheck;
}
status_t Sensors::initCheck() const { return mInitCheck; }
Return<void> Sensors::getSensorsList(getSensorsList_cb _hidl_cb) {
sensor_t const* list;
sensor_t const *list;
size_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
hidl_vec<SensorInfo> out;
out.resize(count);
for (size_t i = 0; i < count; ++i) {
const sensor_t* src = &list[i];
SensorInfo* dst = &out[i];
const sensor_t *src = &list[i];
SensorInfo *dst = &out[i];
convertFromSensor(*src, dst);
@ -164,7 +166,8 @@ Return<Result> Sensors::setOperationMode(OperationMode mode) {
Return<Result> Sensors::activate(int32_t sensor_handle, bool enabled) {
return ResultFromStatus(mSensorDevice->activate(
reinterpret_cast<sensors_poll_device_t*>(mSensorDevice), sensor_handle, enabled));
reinterpret_cast<sensors_poll_device_t *>(mSensorDevice), sensor_handle,
enabled));
}
Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
@ -176,29 +179,33 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
{ // scope of reentry lock
// This enforces a single client, meaning that a maximum of one client can call poll().
// If this function is re-entred, it means that we are stuck in a state that may prevent
// the system from proceeding normally.
// This enforces a single client, meaning that a maximum of one client can
// call poll(). If this function is re-entred, it means that we are stuck in
// a state that may prevent the system from proceeding normally.
//
// Exit and let the system restart the sensor-hal-implementation hidl service.
// Exit and let the system restart the sensor-hal-implementation hidl
// service.
//
// This function must not call _hidl_cb(...) or return until there is no risk of blocking.
// This function must not call _hidl_cb(...) or return until there is no
// risk of blocking.
std::unique_lock<std::mutex> lock(mPollLock, std::try_to_lock);
if (!lock.owns_lock()) {
// cannot get the lock, hidl service will go into deadlock if it is not restarted.
// This is guaranteed to not trigger in passthrough mode.
LOG(ERROR)
<< "ISensors::poll() re-entry. I do not know what to do except killing myself.";
// cannot get the lock, hidl service will go into deadlock if it is not
// restarted. This is guaranteed to not trigger in passthrough mode.
LOG(ERROR) << "ISensors::poll() re-entry. I do not know what to do "
"except killing myself.";
::exit(-1);
}
if (maxCount <= 0) {
err = android::BAD_VALUE;
} else {
int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
int bufferSize =
maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
data.reset(new sensors_event_t[bufferSize]);
err = mSensorDevice->poll(reinterpret_cast<sensors_poll_device_t*>(mSensorDevice),
data.get(), bufferSize);
err = mSensorDevice->poll(
reinterpret_cast<sensors_poll_device_t *>(mSensorDevice), data.get(),
bufferSize);
}
}
@ -214,7 +221,7 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
continue;
}
const dynamic_sensor_meta_event_t* dyn = &data[i].dynamic_sensor_meta;
const dynamic_sensor_meta_event_t *dyn = &data[i].dynamic_sensor_meta;
if (!dyn->connected) {
continue;
@ -241,7 +248,8 @@ Return<void> Sensors::poll(int32_t maxCount, poll_cb _hidl_cb) {
Return<Result> Sensors::batch(int32_t sensor_handle, int64_t sampling_period_ns,
int64_t max_report_latency_ns) {
return ResultFromStatus(mSensorDevice->batch(mSensorDevice, sensor_handle, 0, /*flags*/
return ResultFromStatus(
mSensorDevice->batch(mSensorDevice, sensor_handle, 0, /*flags*/
sampling_period_ns, max_report_latency_ns));
}
@ -249,7 +257,7 @@ Return<Result> Sensors::flush(int32_t sensor_handle) {
return ResultFromStatus(mSensorDevice->flush(mSensorDevice, sensor_handle));
}
Return<Result> Sensors::injectSensorData(const Event& event) {
Return<Result> Sensors::injectSensorData(const Event &event) {
if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 ||
mSensorDevice->inject_sensor_data == nullptr) {
return Result::INVALID_OPERATION;
@ -258,10 +266,11 @@ Return<Result> Sensors::injectSensorData(const Event& event) {
sensors_event_t out;
convertToSensorEvent(event, &out);
return ResultFromStatus(mSensorDevice->inject_sensor_data(mSensorDevice, &out));
return ResultFromStatus(
mSensorDevice->inject_sensor_data(mSensorDevice, &out));
}
Return<void> Sensors::registerDirectChannel(const SharedMemInfo& mem,
Return<void> Sensors::registerDirectChannel(const SharedMemInfo &mem,
registerDirectChannel_cb _hidl_cb) {
if (mSensorDevice->register_direct_channel == nullptr ||
mSensorDevice->config_direct_report == nullptr) {
@ -299,8 +308,9 @@ Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {
return Result::OK;
}
Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHandle,
RateLevel rate, configDirectReport_cb _hidl_cb) {
Return<void> Sensors::configDirectReport(int32_t sensorHandle,
int32_t channelHandle, RateLevel rate,
configDirectReport_cb _hidl_cb) {
if (mSensorDevice->register_direct_channel == nullptr ||
mSensorDevice->config_direct_report == nullptr) {
// HAL does not support
@ -314,7 +324,8 @@ Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHa
return Void();
}
int err = mSensorDevice->config_direct_report(mSensorDevice, sensorHandle, channelHandle, &cfg);
int err = mSensorDevice->config_direct_report(mSensorDevice, sensorHandle,
channelHandle, &cfg);
if (rate == RateLevel::STOP) {
_hidl_cb(ResultFromStatus(err), -1);
@ -325,18 +336,19 @@ Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHa
}
// static
void Sensors::convertFromSensorEvents(size_t count, const sensors_event_t* srcArray,
hidl_vec<Event>* dstVec) {
void Sensors::convertFromSensorEvents(size_t count,
const sensors_event_t *srcArray,
hidl_vec<Event> *dstVec) {
for (size_t i = 0; i < count; ++i) {
const sensors_event_t& src = srcArray[i];
Event* dst = &(*dstVec)[i];
const sensors_event_t &src = srcArray[i];
Event *dst = &(*dstVec)[i];
convertFromSensorEvent(src, dst);
}
}
ISensors* HIDL_FETCH_ISensors(const char* /* hal */) {
Sensors* sensors = new Sensors;
ISensors *HIDL_FETCH_ISensors(const char * /* hal */) {
Sensors *sensors = new Sensors;
if (sensors->initCheck() != OK) {
delete sensors;
sensors = nullptr;

20
universal7885-common/hardware/samsung/hidl/sensors/Sensors.h
View file

@ -47,32 +47,34 @@ struct Sensors : public ::android::hardware::sensors::V1_0::ISensors {
Return<Result> flush(int32_t sensor_handle) override;
Return<Result> injectSensorData(const Event& event) override;
Return<Result> injectSensorData(const Event &event) override;
Return<void> registerDirectChannel(const SharedMemInfo& mem,
Return<void>
registerDirectChannel(const SharedMemInfo &mem,
registerDirectChannel_cb _hidl_cb) override;
Return<Result> unregisterDirectChannel(int32_t channelHandle) override;
Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle,
RateLevel rate,
configDirectReport_cb _hidl_cb) override;
private:
private:
static constexpr int32_t kPollMaxBufferSize = 128;
status_t mInitCheck;
sensors_module_t* mSensorModule;
sensors_poll_device_1_t* mSensorDevice;
sensors_module_t *mSensorModule;
sensors_poll_device_1_t *mSensorDevice;
std::mutex mPollLock;
int getHalDeviceVersion() const;
static void convertFromSensorEvents(size_t count, const sensors_event_t* src,
hidl_vec<Event>* dst);
static void convertFromSensorEvents(size_t count, const sensors_event_t *src,
hidl_vec<Event> *dst);
DISALLOW_COPY_AND_ASSIGN(Sensors);
};
extern "C" ISensors* HIDL_FETCH_ISensors(const char* name);
extern "C" ISensors *HIDL_FETCH_ISensors(const char *name);
} // namespace implementation
} // namespace V1_0

9
universal7885-common/hardware/samsung/hidl/usb/typeb/Usb.cpp
View file

@ -30,8 +30,8 @@ namespace usb {
namespace V1_0 {
namespace implementation {
Return<void> Usb::switchRole(const hidl_string& portName __unused,
const PortRole& newRole __unused) {
Return<void> Usb::switchRole(const hidl_string &portName __unused,
const PortRole &newRole __unused) {
LOG(ERROR) << __func__ << ": Not supported";
return Void();
}
@ -51,7 +51,8 @@ Return<void> Usb::queryPortStatus() {
pthread_mutex_lock(&mLock);
if (mCallback != NULL) {
Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
Return<void> ret =
mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
if (!ret.isOk()) {
LOG(ERROR) << "queryPortStatus error " << ret.description();
}
@ -63,7 +64,7 @@ Return<void> Usb::queryPortStatus() {
return Void();
}
Return<void> Usb::setCallback(const sp<IUsbCallback>& callback) {
Return<void> Usb::setCallback(const sp<IUsbCallback> &callback) {
pthread_mutex_lock(&mLock);
mCallback = callback;

5
universal7885-common/hardware/samsung/hidl/usb/typeb/Usb.h
View file

@ -48,8 +48,9 @@ using ::android::hardware::usb::V1_0::PortRole;
using ::android::hidl::base::V1_0::IBase;
struct Usb : public IUsb {
Return<void> switchRole(const hidl_string& portName, const PortRole& role) override;
Return<void> setCallback(const sp<IUsbCallback>& callback) override;
Return<void> switchRole(const hidl_string &portName,
const PortRole &role) override;
Return<void> setCallback(const sp<IUsbCallback> &callback) override;
Return<void> queryPortStatus() override;
sp<IUsbCallback> mCallback;

2
universal7885-common/hardware/samsung/hidl/usb/typeb/service.cpp
View file

@ -14,9 +14,9 @@
* limitations under the License.
*/
#include "Usb.h"
#include <android-base/logging.h>
#include <hidl/HidlTransportSupport.h>
#include "Usb.h"
using android::sp;

131
universal7885-common/hardware/samsung/hidl/usb/typec/Usb.cpp
View file

@ -20,14 +20,14 @@
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <assert.h>
#include <chrono>
#include <dirent.h>
#include <pthread.h>
#include <regex>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <chrono>
#include <regex>
#include <thread>
#include <unistd.h>
#include <unordered_map>
#include <cutils/uevent.h>
@ -50,13 +50,12 @@ Return<bool> Usb::enableUsbDataSignal(bool enable) {
ALOGI("Userspace turn %s USB data signaling", enable ? "on" : "off");
if(enable) {
if (enable) {
if (!WriteStringToFile("1", USB_DATA_PATH)) {
ALOGE("Not able to turn on usb connection notification");
result = false;
}
}
else {
} else {
if (!WriteStringToFile("0", USB_DATA_PATH)) {
ALOGE("Not able to turn off usb connection notification");
result = false;
@ -70,7 +69,8 @@ Return<bool> Usb::enableUsbDataSignal(bool enable) {
volatile bool destroyThread;
bool moistureDetectionEnabled = true;
constexpr char kContaminantDetectionPath[] = "/sys/devices/virtual/sec/ccic/water";
constexpr char kContaminantDetectionPath[] =
"/sys/devices/virtual/sec/ccic/water";
constexpr char kTypecPath[] = "/sys/class/typec";
constexpr char kDisableContaminantDetection[] = "vendor.usb.contaminantdisable";
@ -113,7 +113,8 @@ int32_t writeFile(const std::string &filename, const std::string &contents) {
return -1;
}
Status queryMoistureDetectionStatus(hidl_vec<PortStatus> *currentPortStatus_1_2) {
Status
queryMoistureDetectionStatus(hidl_vec<PortStatus> *currentPortStatus_1_2) {
std::string enabled, status, path, DetectedPath;
if (currentPortStatus_1_2 == NULL || currentPortStatus_1_2->size() == 0) {
@ -124,10 +125,13 @@ Status queryMoistureDetectionStatus(hidl_vec<PortStatus> *currentPortStatus_1_2)
(*currentPortStatus_1_2)[0].supportedContaminantProtectionModes = 0;
(*currentPortStatus_1_2)[0].supportedContaminantProtectionModes |=
V1_2::ContaminantProtectionMode::FORCE_SINK;
(*currentPortStatus_1_2)[0].contaminantProtectionStatus = V1_2::ContaminantProtectionStatus::NONE;
(*currentPortStatus_1_2)[0].contaminantDetectionStatus = V1_2::ContaminantDetectionStatus::DISABLED;
(*currentPortStatus_1_2)[0].contaminantProtectionStatus =
V1_2::ContaminantProtectionStatus::NONE;
(*currentPortStatus_1_2)[0].contaminantDetectionStatus =
V1_2::ContaminantDetectionStatus::DISABLED;
(*currentPortStatus_1_2)[0].supportsEnableContaminantPresenceDetection = true;
(*currentPortStatus_1_2)[0].supportsEnableContaminantPresenceProtection = false;
(*currentPortStatus_1_2)[0].supportsEnableContaminantPresenceProtection =
false;
if (moistureDetectionEnabled) {
if (readFile(kContaminantDetectionPath, &status)) {
@ -151,7 +155,8 @@ Status queryMoistureDetectionStatus(hidl_vec<PortStatus> *currentPortStatus_1_2)
return Status::SUCCESS;
}
std::string appendRoleNodeHelper(const std::string &portName, PortRoleType type) {
std::string appendRoleNodeHelper(const std::string &portName,
PortRoleType type) {
std::string node("/sys/class/typec/" + portName);
switch (type) {
@ -198,7 +203,8 @@ void extractRole(std::string *roleName) {
}
void switchToDrp(const std::string &portName) {
std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), PortRoleType::MODE);
std::string filename =
appendRoleNodeHelper(std::string(portName.c_str()), PortRoleType::MODE);
FILE *fp;
if (filename != "") {
@ -216,8 +222,10 @@ void switchToDrp(const std::string &portName) {
}
}
bool switchMode(const hidl_string &portName, const PortRole &newRole, struct Usb *usb) {
std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
bool switchMode(const hidl_string &portName, const PortRole &newRole,
struct Usb *usb) {
std::string filename =
appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
std::string written;
FILE *fp;
bool roleSwitch = false;
@ -246,7 +254,8 @@ bool switchMode(const hidl_string &portName, const PortRole &newRole, struct Usb
to.tv_sec = now.tv_sec + PORT_TYPE_TIMEOUT;
to.tv_nsec = now.tv_nsec;
int err = pthread_cond_timedwait(&usb->mPartnerCV, &usb->mPartnerLock, &to);
int err =
pthread_cond_timedwait(&usb->mPartnerCV, &usb->mPartnerLock, &to);
// There are no uevent signals which implies role swap timed out.
if (err == ETIMEDOUT) {
ALOGI("uevents wait timedout");
@ -272,8 +281,7 @@ bool switchMode(const hidl_string &portName, const PortRole &newRole, struct Usb
Usb::Usb()
: mLock(PTHREAD_MUTEX_INITIALIZER),
mRoleSwitchLock(PTHREAD_MUTEX_INITIALIZER),
mPartnerLock(PTHREAD_MUTEX_INITIALIZER),
mPartnerUp(false) {
mPartnerLock(PTHREAD_MUTEX_INITIALIZER), mPartnerUp(false) {
pthread_condattr_t attr;
if (pthread_condattr_init(&attr)) {
ALOGE("pthread_condattr_init failed: %s", strerror(errno));
@ -293,8 +301,10 @@ Usb::Usb()
}
}
Return<void> Usb::switchRole(const hidl_string &portName, const V1_0::PortRole &newRole) {
std::string filename = appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
Return<void> Usb::switchRole(const hidl_string &portName,
const V1_0::PortRole &newRole) {
std::string filename =
appendRoleNodeHelper(std::string(portName.c_str()), newRole.type);
std::string written;
FILE *fp;
bool roleSwitch = false;
@ -306,7 +316,8 @@ Return<void> Usb::switchRole(const hidl_string &portName, const V1_0::PortRole &
pthread_mutex_lock(&mRoleSwitchLock);
ALOGI("filename write: %s role:%s", filename.c_str(), convertRoletoString(newRole).c_str());
ALOGI("filename write: %s role:%s", filename.c_str(),
convertRoletoString(newRole).c_str());
if (newRole.type == PortRoleType::MODE) {
roleSwitch = switchMode(portName, newRole, this);
@ -346,19 +357,22 @@ Return<void> Usb::switchRole(const hidl_string &portName, const V1_0::PortRole &
return Void();
}
Status getAccessoryConnected(const std::string &portName, std::string *accessory) {
std::string filename = "/sys/class/typec/" + portName + "-partner/accessory_mode";
Status getAccessoryConnected(const std::string &portName,
std::string *accessory) {
std::string filename =
"/sys/class/typec/" + portName + "-partner/accessory_mode";
if (readFile(filename, accessory)) {
ALOGE("getAccessoryConnected: Failed to open filesystem node: %s", filename.c_str());
ALOGE("getAccessoryConnected: Failed to open filesystem node: %s",
filename.c_str());
return Status::ERROR;
}
return Status::SUCCESS;
}
Status getCurrentRoleHelper(const std::string &portName, bool connected, PortRoleType type,
uint32_t *currentRole) {
Status getCurrentRoleHelper(const std::string &portName, bool connected,
PortRoleType type, uint32_t *currentRole) {
std::string filename;
std::string roleName;
std::string accessory;
@ -395,7 +409,8 @@ Status getCurrentRoleHelper(const std::string &portName, bool connected, PortRol
}
if (readFile(filename, &roleName)) {
ALOGE("getCurrentRole: Failed to open filesystem node: %s", filename.c_str());
ALOGE("getCurrentRole: Failed to open filesystem node: %s",
filename.c_str());
return Status::ERROR;
}
@ -454,7 +469,8 @@ Status getTypeCPortNamesHelper(std::unordered_map<std::string, bool> *names) {
}
bool canSwitchRoleHelper(const std::string &portName, PortRoleType /*type*/) {
std::string filename = "/sys/class/typec/" + portName + "-partner/supports_usb_power_delivery";
std::string filename =
"/sys/class/typec/" + portName + "-partner/supports_usb_power_delivery";
std::string supportsPD;
if (!readFile(filename, &supportsPD)) {
@ -471,7 +487,8 @@ bool canSwitchRoleHelper(const std::string &portName, PortRoleType /*type*/) {
* The caller of this method would reconstruct the V1_0::PortStatus
* object if required.
*/
Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2, HALVersion version) {
Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2,
HALVersion version) {
std::unordered_map<std::string, bool> names;
Status result = getTypeCPortNamesHelper(&names);
int i = -1;
@ -484,7 +501,8 @@ Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2, HALVersi
(*currentPortStatus_1_2)[i].status_1_1.status.portName = port.first;
uint32_t currentRole;
if (getCurrentRoleHelper(port.first, port.second, PortRoleType::POWER_ROLE,
if (getCurrentRoleHelper(port.first, port.second,
PortRoleType::POWER_ROLE,
&currentRole) == Status::SUCCESS) {
(*currentPortStatus_1_2)[i].status_1_1.status.currentPowerRole =
static_cast<PortPowerRole>(currentRole);
@ -502,8 +520,8 @@ Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2, HALVersi
goto done;
}
if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE, &currentRole) ==
Status::SUCCESS) {
if (getCurrentRoleHelper(port.first, port.second, PortRoleType::MODE,
&currentRole) == Status::SUCCESS) {
(*currentPortStatus_1_2)[i].status_1_1.currentMode =
static_cast<PortMode_1_1>(currentRole);
(*currentPortStatus_1_2)[i].status_1_1.status.currentMode =
@ -515,25 +533,32 @@ Status getPortStatusHelper(hidl_vec<PortStatus> *currentPortStatus_1_2, HALVersi
(*currentPortStatus_1_2)[i].status_1_1.status.canChangeMode = true;
(*currentPortStatus_1_2)[i].status_1_1.status.canChangeDataRole =
port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE) : false;
port.second ? canSwitchRoleHelper(port.first, PortRoleType::DATA_ROLE)
: false;
(*currentPortStatus_1_2)[i].status_1_1.status.canChangePowerRole =
port.second ? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE) : false;
port.second
? canSwitchRoleHelper(port.first, PortRoleType::POWER_ROLE)
: false;
if (version == HALVersion::V1_0) {
ALOGI("HAL version V1_0");
(*currentPortStatus_1_2)[i].status_1_1.status.supportedModes = V1_0::PortMode::DRP;
(*currentPortStatus_1_2)[i].status_1_1.status.supportedModes =
V1_0::PortMode::DRP;
} else {
if (version == HALVersion::V1_1)
ALOGI("HAL version V1_1");
else
ALOGI("HAL version V1_2");
(*currentPortStatus_1_2)[i].status_1_1.supportedModes = 0 | PortMode_1_1::DRP;
(*currentPortStatus_1_2)[i].status_1_1.status.supportedModes = V1_0::PortMode::NONE;
(*currentPortStatus_1_2)[i].status_1_1.status.currentMode = V1_0::PortMode::NONE;
(*currentPortStatus_1_2)[i].status_1_1.supportedModes =
0 | PortMode_1_1::DRP;
(*currentPortStatus_1_2)[i].status_1_1.status.supportedModes =
V1_0::PortMode::NONE;
(*currentPortStatus_1_2)[i].status_1_1.status.currentMode =
V1_0::PortMode::NONE;
}
ALOGI(
"%d:%s connected:%d canChangeMode:%d canChagedata:%d canChangePower:%d "
ALOGI("%d:%s connected:%d canChangeMode:%d canChagedata:%d "
"canChangePower:%d "
"supportedModes:%d",
i, port.first.c_str(), port.second,
(*currentPortStatus_1_2)[i].status_1_1.status.canChangeMode,
@ -552,7 +577,8 @@ void queryVersionHelper(android::hardware::usb::V1_3::implementation::Usb *usb,
hidl_vec<V1_1::PortStatus_1_1> currentPortStatus_1_1;
hidl_vec<V1_0::PortStatus> currentPortStatus;
Status status;
sp<V1_1::IUsbCallback> callback_V1_1 = V1_1::IUsbCallback::castFrom(usb->mCallback_1_0);
sp<V1_1::IUsbCallback> callback_V1_1 =
V1_1::IUsbCallback::castFrom(usb->mCallback_1_0);
sp<IUsbCallback> callback_V1_2 = IUsbCallback::castFrom(usb->mCallback_1_0);
pthread_mutex_lock(&usb->mLock);
@ -576,11 +602,14 @@ void queryVersionHelper(android::hardware::usb::V1_3::implementation::Usb *usb,
Return<void> ret;
if (callback_V1_2 != NULL)
ret = callback_V1_2->notifyPortStatusChange_1_2(*currentPortStatus_1_2, status);
ret = callback_V1_2->notifyPortStatusChange_1_2(*currentPortStatus_1_2,
status);
else if (callback_V1_1 != NULL)
ret = callback_V1_1->notifyPortStatusChange_1_1(currentPortStatus_1_1, status);
ret = callback_V1_1->notifyPortStatusChange_1_1(currentPortStatus_1_1,
status);
else
ret = usb->mCallback_1_0->notifyPortStatusChange(currentPortStatus, status);
ret =
usb->mCallback_1_0->notifyPortStatusChange(currentPortStatus, status);
if (!ret.isOk())
ALOGE("queryPortStatus_1_2 error %s", ret.description().c_str());
@ -597,7 +626,8 @@ Return<void> Usb::queryPortStatus() {
return Void();
}
Return<void> Usb::enableContaminantPresenceDetection(const hidl_string & /*portName*/,
Return<void>
Usb::enableContaminantPresenceDetection(const hidl_string & /*portName*/,
bool enable) {
std::string disable = GetProperty(kDisableContaminantDetection, "");
@ -610,7 +640,8 @@ Return<void> Usb::enableContaminantPresenceDetection(const hidl_string & /*portN
return Void();
}
Return<void> Usb::enableContaminantPresenceProtection(const hidl_string & /*portName*/,
Return<void>
Usb::enableContaminantPresenceProtection(const hidl_string & /*portName*/,
bool /*enable*/) {
hidl_vec<PortStatus> currentPortStatus_1_2;
@ -653,8 +684,8 @@ static void uevent_event(uint32_t /*epevents*/, struct data *payload) {
// Role switch is not in progress and port is in disconnected state
if (!pthread_mutex_trylock(&payload->usb->mRoleSwitchLock)) {
for (unsigned long i = 0; i < currentPortStatus_1_2.size(); i++) {
DIR *dp =
opendir(std::string("/sys/class/typec/" +
DIR *dp = opendir(
std::string("/sys/class/typec/" +
std::string(currentPortStatus_1_2[i]
.status_1_1.status.portName.c_str()) +
"-partner")
@ -723,8 +754,8 @@ void *work(void *param) {
for (int n = 0; n < nevents; ++n) {
if (events[n].data.ptr)
(*(void (*)(int, struct data *payload))events[n].data.ptr)(events[n].events,
&payload);
(*(void (*)(int, struct data *payload))events[n].data.ptr)(
events[n].events, &payload);
}
}

39
universal7885-common/hardware/samsung/hidl/usb/typec/Usb.h
View file

@ -17,9 +17,9 @@
#pragma once
#include <android-base/file.h>
#include <android/hardware/usb/1.3/IUsb.h>
#include <android/hardware/usb/1.2/types.h>
#include <android/hardware/usb/1.2/IUsbCallback.h>
#include <android/hardware/usb/1.2/types.h>
#include <android/hardware/usb/1.3/IUsb.h>
#include <hidl/Status.h>
#include <utils/Log.h>
@ -36,47 +36,44 @@ namespace usb {
namespace V1_3 {
namespace implementation {
using ::android::base::WriteStringToFile;
using ::android::sp;
using ::android::base::ReadFileToString;
using ::android::base::WriteStringToFile;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::usb::V1_0::PortRole;
using ::android::hardware::usb::V1_0::PortRoleType;
using ::android::hardware::usb::V1_0::PortDataRole;
using ::android::hardware::usb::V1_0::PortPowerRole;
using ::android::hardware::usb::V1_0::PortRole;
using ::android::hardware::usb::V1_0::PortRoleType;
using ::android::hardware::usb::V1_0::Status;
using ::android::hardware::usb::V1_3::IUsb;
using ::android::hardware::usb::V1_2::IUsbCallback;
using ::android::hardware::usb::V1_2::PortStatus;
using ::android::hardware::usb::V1_1::PortMode_1_1;
using ::android::hardware::usb::V1_1::PortStatus_1_1;
using ::android::hardware::usb::V1_2::IUsbCallback;
using ::android::hardware::usb::V1_2::PortStatus;
using ::android::hardware::usb::V1_3::IUsb;
using ::android::hidl::base::V1_0::DebugInfo;
using ::android::hidl::base::V1_0::IBase;
using ::android::sp;
enum class HALVersion{
V1_0,
V1_1,
V1_2,
V1_3
};
enum class HALVersion { V1_0, V1_1, V1_2, V1_3 };
#define USB_DATA_PATH "/sys/devices/virtual/usb_notify/usb_control/usb_data_enabled"
#define USB_DATA_PATH \
"/sys/devices/virtual/usb_notify/usb_control/usb_data_enabled"
struct Usb : public IUsb {
Usb();
Return<void> switchRole(const hidl_string &portName, const PortRole &role) override;
Return<void> setCallback(const sp<V1_0::IUsbCallback>& callback) override;
Return<void> switchRole(const hidl_string &portName,
const PortRole &role) override;
Return<void> setCallback(const sp<V1_0::IUsbCallback> &callback) override;
Return<void> queryPortStatus() override;
Return<void> enableContaminantPresenceDetection(const hidl_string &portName, bool enable);
Return<void> enableContaminantPresenceProtection(const hidl_string &portName, bool enable);
Return<void> enableContaminantPresenceDetection(const hidl_string &portName,
bool enable);
Return<void> enableContaminantPresenceProtection(const hidl_string &portName,
bool enable);
Return<bool> enableUsbDataSignal(bool enable) override;
sp<V1_0::IUsbCallback> mCallback_1_0;
@ -91,7 +88,7 @@ struct Usb : public IUsb {
// Variable to signal partner coming back online after type switch
bool mPartnerUp;
private:
private:
pthread_t mPoll;
};

2
universal7885-common/hardware/samsung/hidl/usb/typec/service.cpp
View file

@ -17,8 +17,8 @@
#define LOG_TAG "android.hardware.usb@1.3-service.samsung"
#include <hidl/HidlTransportSupport.h>
#include "Usb.h"
#include <hidl/HidlTransportSupport.h>
using android::sp;

8
universal7885-common/hardware/samsung/secril_config_svc/secril_config_svc.cpp
View file

@ -30,7 +30,8 @@
void LoadProperties(std::string data) {
for (std::string line : android::base::Split(data, "\n")) {
if (line == "\0") break;
if (line == "\0")
break;
std::vector<std::string> parts = android::base::Split(line, "=");
if (parts.size() == 2) {
@ -42,10 +43,11 @@ void LoadProperties(std::string data) {
}
}
int main(int argc, char* argv[]) {
int main(int argc, char *argv[]) {
std::string prop = FACTORY_PROP;
if (argc > 1 && std::string(argv[1]) == "NetworkConfig") prop = TELEPHONY_PROP;
if (argc > 1 && std::string(argv[1]) == "NetworkConfig")
prop = TELEPHONY_PROP;
std::ifstream in(EFS_NEW + prop);
if (in.good()) {

15
universal7885-common/init/init_universal7885.cpp
View file

@ -44,19 +44,20 @@ std::vector<std::string> ro_props_default_source_order = {
};
void property_override(char const prop[], char const value[], bool add = true) {
prop_info* pi;
prop_info *pi;
pi = (prop_info*)__system_property_find(prop);
pi = (prop_info *)__system_property_find(prop);
if (pi)
__system_property_update(pi, value, strlen(value));
else if (add)
__system_property_add(prop, strlen(prop), value, strlen(value));
}
void set_ro_build_prop(const std::string& prop, const std::string& value, bool product = true) {
void set_ro_build_prop(const std::string &prop, const std::string &value,
bool product = true) {
string prop_name;
for (const auto& source : ro_props_default_source_order) {
for (const auto &source : ro_props_default_source_order) {
if (product)
prop_name = "ro.product." + source + prop;
else
@ -66,10 +67,10 @@ void set_ro_build_prop(const std::string& prop, const std::string& value, bool p
}
}
bool hasEnding(std::string const& fullString, std::string const& ending) {
bool hasEnding(std::string const &fullString, std::string const &ending) {
if (fullString.length() >= ending.length()) {
return (0 ==
fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
return (0 == fullString.compare(fullString.length() - ending.length(),
ending.length(), ending));
} else {
return false;
}

83
universal7885-common/libshims/camera/CamDevice_3_2.h
View file

@ -17,14 +17,14 @@
#ifndef ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H
#define ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H
#include "utils/Mutex.h"
#include "CameraModule.h"
#include "CameraMetadata.h"
#include "CameraDeviceSession.h"
#include "CameraMetadata.h"
#include "CameraModule.h"
#include "utils/Mutex.h"
#include <android/hardware/camera/device/3.2/ICameraDevice.h>
#include <hidl/Status.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace android {
namespace hardware {
@ -33,20 +33,20 @@ namespace device {
namespace V3_2 {
namespace implementation {
using ::android::hardware::camera::device::V3_2::RequestTemplate;
using ::android::hardware::camera::device::V3_2::ICameraDevice;
using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
using ::android::hardware::camera::device::V3_2::ICameraDeviceSession;
using ::android::Mutex;
using ::android::sp;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::camera::common::V1_0::CameraResourceCost;
using ::android::hardware::camera::common::V1_0::Status;
using ::android::hardware::camera::common::V1_0::TorchMode;
using ::android::hardware::camera::common::V1_0::helper::CameraModule;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_string;
using ::android::sp;
using ::android::Mutex;
using ::android::hardware::camera::device::V3_2::ICameraDevice;
using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
using ::android::hardware::camera::device::V3_2::ICameraDeviceSession;
using ::android::hardware::camera::device::V3_2::RequestTemplate;
/*
* The camera device HAL implementation is opened lazily (via the open call)
@ -57,13 +57,14 @@ struct CameraDevice : public virtual RefBase {
// trying to access the same physical camera.
// Also, provider will have to keep track of all CameraDevice objects in
// order to notify CameraDevice when the underlying camera is detached
CameraDevice(sp<CameraModule> module,
const std::string& cameraId,
const SortedVector<std::pair<std::string, std::string>>& cameraDeviceNames);
CameraDevice(sp<CameraModule> module, const std::string &cameraId,
const SortedVector<std::pair<std::string, std::string>>
&cameraDeviceNames);
virtual ~CameraDevice();
// Retrieve the HIDL interface, split into its own class to avoid inheritance issues when
// dealing with minor version revs and simultaneous implementation and interface inheritance
// Retrieve the HIDL interface, split into its own class to avoid inheritance
// issues when dealing with minor version revs and simultaneous implementation
// and interface inheritance
virtual sp<ICameraDevice> getInterface() {
return new TrampolineDeviceInterface_3_2(this);
}
@ -73,27 +74,33 @@ struct CameraDevice : public virtual RefBase {
// Used by provider HAL to signal external camera disconnected
void setConnectionStatus(bool connected);
/* Methods from ::android::hardware::camera::device::V3_2::ICameraDevice follow. */
/* Methods from ::android::hardware::camera::device::V3_2::ICameraDevice
* follow. */
// The following method can be called without opening the actual camera device
Return<void> getResourceCost(ICameraDevice::getResourceCost_cb _hidl_cb);
Return<void> getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<void> getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<void>
getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<void>
getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<Status> setTorchMode(TorchMode mode);
// Open the device HAL and also return a default capture session
Return<void> open(const sp<ICameraDeviceCallback>& callback, ICameraDevice::open_cb _hidl_cb);
Return<void> nuke(const sp<ICameraDeviceCallback>& callback, ICameraDevice::open_cb _hidl_cb);
Return<void> open(const sp<ICameraDeviceCallback> &callback,
ICameraDevice::open_cb _hidl_cb);
Return<void> nuke(const sp<ICameraDeviceCallback> &callback,
ICameraDevice::open_cb _hidl_cb);
// Forward the dump call to the opened session, or do nothing
Return<void> dumpState(const ::android::hardware::hidl_handle& fd);
/* End of Methods from ::android::hardware::camera::device::V3_2::ICameraDevice */
Return<void> dumpState(const ::android::hardware::hidl_handle &fd);
/* End of Methods from
* ::android::hardware::camera::device::V3_2::ICameraDevice */
protected:
// Overridden by child implementations for returning different versions of CameraDeviceSession
virtual sp<CameraDeviceSession> createSession(camera3_device_t*,
const camera_metadata_t* deviceInfo,
const sp<ICameraDeviceCallback>&);
// Overridden by child implementations for returning different versions of
// CameraDeviceSession
virtual sp<CameraDeviceSession>
createSession(camera3_device_t *, const camera_metadata_t *deviceInfo,
const sp<ICameraDeviceCallback> &);
const sp<CameraModule> mModule;
const std::string mCameraId;
@ -105,7 +112,7 @@ protected:
bool mDisconnected;
wp<CameraDeviceSession> mSession = nullptr;
const SortedVector<std::pair<std::string, std::string>>& mCameraDeviceNames;
const SortedVector<std::pair<std::string, std::string>> &mCameraDeviceNames;
// gating access to mSession and mDisconnected
mutable Mutex mLock;
@ -117,11 +124,10 @@ protected:
private:
struct TrampolineDeviceInterface_3_2 : public ICameraDevice {
TrampolineDeviceInterface_3_2(sp<CameraDevice> parent) :
mParent(parent) {}
TrampolineDeviceInterface_3_2(sp<CameraDevice> parent) : mParent(parent) {}
virtual Return<void> getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb)
override {
virtual Return<void>
getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb) override {
return mParent->getResourceCost(_hidl_cb);
}
@ -134,19 +140,18 @@ private:
return mParent->setTorchMode(mode);
}
virtual Return<void> open(const sp<V3_2::ICameraDeviceCallback>& callback,
virtual Return<void> open(const sp<V3_2::ICameraDeviceCallback> &callback,
V3_2::ICameraDevice::open_cb _hidl_cb) override {
return mParent->open(callback, _hidl_cb);
}
virtual Return<void> dumpState(const hidl_handle& fd) override {
virtual Return<void> dumpState(const hidl_handle &fd) override {
return mParent->dumpState(fd);
}
private:
sp<CameraDevice> mParent;
};
};
} // namespace implementation

62
universal7885-common/libshims/camera/CorrectCameraID.cpp
View file

@ -1,12 +1,12 @@
/*
* Copyright (c) 2022 Eureka Team.
* https://github.com/eurekadevelopment
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
* Copyright (c) 2022 Eureka Team.
* https://github.com/eurekadevelopment
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include "CamDevice_3_2.h"
#include <include/convert.h>
@ -21,13 +21,15 @@ namespace implementation {
using ::android::hardware::camera::common::V1_0::Status;
Return<void> CameraDevice::getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
Return<void> CameraDevice::getCameraCharacteristics(
ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
Status status = initStatus();
CameraMetadata cameraCharacteristics;
if (status == Status::OK) {
//Module 2.1+ codepath.
// Module 2.1+ codepath.
struct camera_info info;
if (mCameraIdInt == 1) mCameraIdInt = 2;
if (mCameraIdInt == 1)
mCameraIdInt = 2;
int ret = mModule->getCameraInfo(mCameraIdInt, &info);
if (ret == OK) {
convertToHidl(info.static_camera_characteristics, &cameraCharacteristics);
@ -40,18 +42,19 @@ Return<void> CameraDevice::getCameraCharacteristics(ICameraDevice::getCameraChar
return Void();
}
Return<void> CameraDevice::getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
Return<void> CameraDevice::getEurekaCharacteristics(
ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
return CameraDevice::getCameraCharacteristics(_hidl_cb);
}
Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
Return<void> CameraDevice::open(const sp<ICameraDeviceCallback> &callback,
ICameraDevice::open_cb _hidl_cb) {
Status status = initStatus();
sp<CameraDeviceSession> session = nullptr;
if (callback == nullptr) {
ALOGE("%s: cannot open camera %s. callback is null!",
__FUNCTION__, mCameraId.c_str());
ALOGE("%s: cannot open camera %s. callback is null!", __FUNCTION__,
mCameraId.c_str());
_hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
return Void();
}
@ -59,8 +62,8 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
if (status != Status::OK) {
// Provider will never pass initFailed device to client, so
// this must be a disconnected camera
ALOGE("%s: cannot open camera %s. camera is disconnected!",
__FUNCTION__, mCameraId.c_str());
ALOGE("%s: cannot open camera %s. camera is disconnected!", __FUNCTION__,
mCameraId.c_str());
_hidl_cb(Status::CAMERA_DISCONNECTED, nullptr);
return Void();
} else {
@ -80,11 +83,13 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
camera3_device_t *device;
std::string mCameraID = mCameraId;
if (mCameraIdInt == 1) mCameraIdInt = 2;
if (mCameraID == "1") mCameraID = "2";
if (mCameraIdInt == 1)
mCameraIdInt = 2;
if (mCameraID == "1")
mCameraID = "2";
res = mModule->open(mCameraID.c_str(),
reinterpret_cast<hw_device_t**>(&device));
reinterpret_cast<hw_device_t **>(&device));
if (res != OK) {
ALOGE("%s: cannot open camera %s!", __FUNCTION__, mCameraID.c_str());
mLock.unlock();
@ -96,8 +101,7 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
if (device->common.version < CAMERA_DEVICE_API_VERSION_3_2) {
ALOGE("%s: Could not open camera: "
"Camera device should be at least %x, reports %x instead",
__FUNCTION__,
CAMERA_DEVICE_API_VERSION_3_2,
__FUNCTION__, CAMERA_DEVICE_API_VERSION_3_2,
device->common.version);
device->common.close(&device->common);
mLock.unlock();
@ -115,8 +119,8 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
return Void();
}
session = createSession(
device, info.static_camera_characteristics, callback);
session =
createSession(device, info.static_camera_characteristics, callback);
if (session == nullptr) {
ALOGE("%s: camera device session allocation failed", __FUNCTION__);
mLock.unlock();
@ -133,10 +137,11 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
mSession = session;
IF_ALOGV() {
session->getInterface()->interfaceChain([](
::android::hardware::hidl_vec<::android::hardware::hidl_string> interfaceChain) {
session->getInterface()->interfaceChain(
[](::android::hardware::hidl_vec<::android::hardware::hidl_string>
interfaceChain) {
ALOGV("Session interface chain:");
for (const auto& iface : interfaceChain) {
for (const auto &iface : interfaceChain) {
ALOGV(" %s", iface.c_str());
}
});
@ -146,7 +151,7 @@ Return<void> CameraDevice::open(const sp<ICameraDeviceCallback>& callback,
_hidl_cb(status, session->getInterface());
return Void();
}
Return<void> CameraDevice::nuke(const sp<ICameraDeviceCallback>& callback,
Return<void> CameraDevice::nuke(const sp<ICameraDeviceCallback> &callback,
ICameraDevice::open_cb _hidl_cb) {
return CameraDevice::open(callback, _hidl_cb);
}
@ -156,4 +161,3 @@ Return<void> CameraDevice::nuke(const sp<ICameraDeviceCallback>& callback,
} // namespace camera
} // namespace hardware
} // namespace android

2
universal7885-common/libshims/fakelogprint/fakelogprint.cpp
View file

@ -1,5 +1,5 @@
#include <log/log.h>
int __android_log_print(int prio, const char* tag, const char* fmt, ...) {
int __android_log_print(int prio, const char *tag, const char *fmt, ...) {
return 0;
}

11
universal7885-common/libshims/sensor/ASensorManager.cpp
View file

@ -23,9 +23,9 @@ using android::Mutex;
static Mutex gLock;
extern "C" ALooper* ALooper_forCamera() {
extern "C" ALooper *ALooper_forCamera() {
LOG(VERBOSE) << "ALooper_forCamera";
ALooper* sLooper = NULL;
ALooper *sLooper = NULL;
Mutex::Autolock autoLock(gLock);
sLooper = new ALooper;
@ -33,7 +33,7 @@ extern "C" ALooper* ALooper_forCamera() {
return sLooper;
}
extern "C" int ALooper_release_forCamera(ALooper* sLooper) {
extern "C" int ALooper_release_forCamera(ALooper *sLooper) {
if (sLooper != nullptr) {
Mutex::Autolock autoLock(gLock);
delete sLooper;
@ -42,8 +42,9 @@ extern "C" int ALooper_release_forCamera(ALooper* sLooper) {
return 0;
}
extern "C" int ALooper_pollOnce_camera(ALooper* sLooper, int timeoutMillis, int* outFd,
int* outEvents, void** outData) {
extern "C" int ALooper_pollOnce_camera(ALooper *sLooper, int timeoutMillis,
int *outFd, int *outEvents,
void **outData) {
int res = sLooper->pollOnce(timeoutMillis, outFd, outEvents, outData);
LOG(VERBOSE) << "ALooper_pollOnce_camera => " << res;
return res;