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

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

@ -14,23 +14,23 @@
* limitations under the License. * limitations under the License.
*/ */
#include <jni.h> #include <jni.h>
#include <media/IAudioFlinger.h>
#include <media/AudioSystem.h> #include <media/AudioSystem.h>
#include <media/IAudioFlinger.h>
#define FM_FAILURE -1 #define FM_FAILURE -1
#define FM_SUCCESS 0 #define FM_SUCCESS 0
#define IOHANDLE 13 #define IOHANDLE 13
using namespace android; using namespace android;
extern "C" extern "C" JNIEXPORT jboolean JNICALL
JNIEXPORT jboolean JNICALL Java_com_eurekateam_fmradio_NativeFMInterface_setAudioRoute(
Java_com_eurekateam_fmradio_NativeFMInterface_setAudioRoute __unused JNIEnv *env, __unused jobject thiz, jboolean speaker) {
(__unused JNIEnv *env, __unused jobject thiz, jboolean speaker) { const sp<IAudioFlinger> &af = AudioSystem::get_audio_flinger();
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0)
if (af == 0) return PERMISSION_DENIED; return PERMISSION_DENIED;
if (speaker){ if (speaker) {
af->setParameters(IOHANDLE, String8("routing=2")); af->setParameters(IOHANDLE, String8("routing=2"));
}else{ } else {
af->setParameters(IOHANDLE, String8("routing=8")); af->setParameters(IOHANDLE, String8("routing=8"));
} }
return FM_SUCCESS; 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_SPACING = (V4L2_CID_USER_S610_BASE + 0x01),
V4L2_CID_S610_CH_BAND = (V4L2_CID_USER_S610_BASE + 0x02), 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 = (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_SOFT_MUTE_COEFF = (V4L2_CID_USER_S610_BASE + 0x5),
V4L2_CID_S610_RSSI_CURR = (V4L2_CID_USER_S610_BASE + 0x06), V4L2_CID_S610_RSSI_CURR = (V4L2_CID_USER_S610_BASE + 0x06),
V4L2_CID_S610_SNR_CURR = (V4L2_CID_USER_S610_BASE + 0x07), 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_IF_COUNT2 = (V4L2_CID_USER_S610_BASE + 0x0C),
V4L2_CID_S610_RSSI_TH = (V4L2_CID_USER_S610_BASE + 0x0D), 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_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_ADDR = (V4L2_CID_USER_S610_BASE + 0x10),
V4L2_CID_S610_REG_RW = (V4L2_CID_USER_S610_BASE + 0x11), V4L2_CID_S610_REG_RW = (V4L2_CID_USER_S610_BASE + 0x11),
}; };
@ -38,17 +38,10 @@ enum fm_channel_spacing {
}; };
/* Mute modes */ /* Mute modes */
enum fm_mute_mode { enum fm_mute_mode { FM_MUTE_ON = 0, FM_MUTE_OFF = 1, FM_MUTE_ATTENUATE = 2 };
FM_MUTE_ON = 0,
FM_MUTE_OFF = 1,
FM_MUTE_ATTENUATE = 2
};
/* FM RDS modes */ /* FM RDS modes */
enum fm_rds_mode { enum fm_rds_mode { FM_RDS_DISABLE = 0, FM_RDS_ENABLE = 1 };
FM_RDS_DISABLE = 0,
FM_RDS_ENABLE = 1
};
#define FM_RADIO_RDS_DATA_MAX 48 #define FM_RADIO_RDS_DATA_MAX 48
@ -61,5 +54,3 @@ enum s610_aud_mode {
S610_AUD_ENABLE = 1, S610_AUD_ENABLE = 1,
S610_AUD_DISABLE = 0, 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]; __u32 reserved[8];
}; };
struct v4l2_hw_freq_seek { struct v4l2_hw_freq_seek {
__u32 tuner; __u32 tuner;
__u32 type; /* enum v4l2_tuner_type */ __u32 type; /* enum v4l2_tuner_type */
@ -48,7 +47,8 @@ struct v4l2_control {
__s32 value; __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") * @driver: name of the driver module (e.g. "bttv")
* @card: name of the card (e.g. "Hauppauge WinTV") * @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_CTRL_CLASS_USER 0x00980000 /* Old-style 'user' controls */
#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900) #define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900)
#define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5) #define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE + 5)
#define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9) #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 <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/hardware/parts/1.0/IBatteryStats.h> #include <vendor/eureka/hardware/parts/1.0/IBatteryStats.h>
#include "jni.h"
using android::sp; using android::sp;
using vendor::eureka::hardware::parts::V1_0::IBatteryStats; 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(); static android::sp<IBatteryStats> service = IBatteryStats::getService();
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env, Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(
__unused jclass obj, JNIEnv *env, __unused jclass obj, jint enable) {
jint enable) {
if (enable == 1) { if (enable == 1) {
service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE); service->setBatteryWritable(SysfsType::CHARGE, Number::ENABLE);
} else { } else {
@ -23,16 +22,15 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setChargeSysfs(JNIEnv* env,
} }
extern "C" JNIEXPORT jint JNICALL extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs(JNIEnv* env, Java_com_eurekateam_samsungextras_interfaces_Battery_getChargeSysfs(
__unused jclass obj) { JNIEnv *env, __unused jclass obj) {
int ret = service->getBatteryStats(SysfsType::CHARGE); int ret = service->getBatteryStats(SysfsType::CHARGE);
return ret; return ret;
} }
extern "C" JNIEXPORT void JNICALL extern "C" JNIEXPORT void JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv* env, Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(
__unused jobject obj, JNIEnv *env, __unused jobject obj, jint enable) {
jint enable) {
if (enable == 1) { if (enable == 1) {
service->setBatteryWritable(SysfsType::FASTCHARGE, Number::ENABLE); service->setBatteryWritable(SysfsType::FASTCHARGE, Number::ENABLE);
} else { } else {
@ -40,15 +38,14 @@ Java_com_eurekateam_samsungextras_interfaces_Battery_setFastCharge(JNIEnv* env,
} }
} }
extern "C" JNIEXPORT jint JNICALL extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(JNIEnv* env, Java_com_eurekateam_samsungextras_interfaces_Battery_getFastChargeSysfs(
__unused jclass obj) { JNIEnv *env, __unused jclass obj) {
int ret = service->getBatteryStats(SysfsType::FASTCHARGE); int ret = service->getBatteryStats(SysfsType::FASTCHARGE);
return ret; return ret;
} }
extern "C" JNIEXPORT jint JNICALL extern "C" JNIEXPORT jint JNICALL
Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(JNIEnv* env, Java_com_eurekateam_samsungextras_interfaces_Battery_getGeneralBatteryStats(
__unused jobject obj, JNIEnv *env, __unused jobject obj, jint id) {
jint id) {
/** /**
* id: * id:
* 1 = BATTERY_CAPACITY_MAX * 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 <hardware/hardware.h>
#include <hidl/HidlSupport.h> #include <hidl/HidlSupport.h>
#include <hidl/LegacySupport.h> #include <hidl/LegacySupport.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <vendor/eureka/hardware/parts/1.0/IDisplayConfigs.h> #include <vendor/eureka/hardware/parts/1.0/IDisplayConfigs.h>
#include "jni.h"
using android::sp; 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::Display;
using vendor::eureka::hardware::parts::V1_0::IDisplayConfigs; using vendor::eureka::hardware::parts::V1_0::IDisplayConfigs;
using vendor::eureka::hardware::parts::V1_0::Number;
static android::sp<IDisplayConfigs> service = IDisplayConfigs::getService(); static android::sp<IDisplayConfigs> service = IDisplayConfigs::getService();
extern "C" JNIEXPORT void JNICALL 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) { if (enable) {
service->writeDisplay(Number::ENABLE, service->writeDisplay(Number::ENABLE, Display::DOUBLE_TAP);
Display::DOUBLE_TAP);
} else { } else {
service->writeDisplay(Number::DISABLE, service->writeDisplay(Number::DISABLE, Display::DOUBLE_TAP);
Display::DOUBLE_TAP);
} }
} }
extern "C" JNIEXPORT void JNICALL 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) { if (enable) {
service->writeDisplay(Number::ENABLE, Display::GLOVE_MODE); service->writeDisplay(Number::ENABLE, Display::GLOVE_MODE);
} else { } else {

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

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

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

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

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

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

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<void> setChannelSpacing(V1_2::Space space);
Return<V1_2::Space> getChannelSpacing(); Return<V1_2::Space> getChannelSpacing();
// Methods from ::android::hidl::base::V1_0::IBase follow. // 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. // limitations under the License.
#include "Battery.h" #include "Battery.h"
#include <unistd.h>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <unistd.h>
namespace vendor::eureka::hardware::parts::V1_0 { 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"; filename = "/sys/class/sec/switch/afc_disable";
break; break;
case SysfsType::CHARGE: 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; break;
default: default:
filename = ""; filename = "";
@ -83,13 +84,15 @@ Return<void> BatteryStats::setBatteryWritable(parts::V1_0::SysfsType stats,
FastCharge = true; FastCharge = true;
break; break;
case SysfsType::CHARGE: 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; break;
default: default:
filename = ""; filename = "";
break; break;
} }
if (FastCharge) seteuid(ANDROID_SYSTEM_UID); if (FastCharge)
seteuid(ANDROID_SYSTEM_UID);
file.open(filename); file.open(filename);
int write; int write;
if (value == Number::ENABLE) { if (value == Number::ENABLE) {
@ -99,11 +102,10 @@ Return<void> BatteryStats::setBatteryWritable(parts::V1_0::SysfsType stats,
} }
file << write; file << write;
file.close(); file.close();
if (FastCharge) seteuid(ANDROID_ROOT_UID); if (FastCharge)
seteuid(ANDROID_ROOT_UID);
return Void(); return Void();
} }
IBatteryStats* BatteryStats::getInstance(void) { IBatteryStats *BatteryStats::getInstance(void) { return new BatteryStats(); }
return new BatteryStats();
}
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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; Return<void> setBatteryWritable(SysfsType stats, Number value) override;
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IBatteryStats* getInstance(void); static IBatteryStats *getInstance(void);
}; };
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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> #include <sstream>
namespace vendor::eureka::hardware::parts::V1_0 { 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::ofstream file;
std::string writevalue; std::string writevalue;
if (type == Display::DOUBLE_TAP){ if (type == Display::DOUBLE_TAP) {
writevalue = "aot_enable"; writevalue = "aot_enable";
} else if (type == Display::GLOVE_MODE){ } else if (type == Display::GLOVE_MODE) {
writevalue = "glove_mode"; writevalue = "glove_mode";
} }
@ -38,7 +39,7 @@ Return<void> DisplayConfigs::writeDisplay(parts::V1_0::Number enable, parts::V1_
return Void(); return Void();
} }
IDisplayConfigs* DisplayConfigs::getInstance(void) { IDisplayConfigs *DisplayConfigs::getInstance(void) {
return new DisplayConfigs(); return new DisplayConfigs();
} }
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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; using ::android::hardware::Void;
struct DisplayConfigs : public IDisplayConfigs { 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); Return<void> writeDisplay(Number enable, Display type);
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IDisplayConfigs* getInstance(void); static IDisplayConfigs *getInstance(void);
}; };
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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 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::ifstream file;
std::string value; std::string value;
int32_t intvalue; int32_t intvalue;
@ -104,7 +105,7 @@ Return<int32_t> FlashBrightness::readFlashlightstats(parts::V1_0::Device device)
return -1; return -1;
} }
IFlashBrightness* FlashBrightness::getInstance(void) { IFlashBrightness *FlashBrightness::getInstance(void) {
return new FlashBrightness(); return new FlashBrightness();
} }
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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; using ::android::hardware::Void;
struct FlashBrightness : public IFlashBrightness { 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> setFlashlightEnable(Number enable);
Return<void> setFlashlightWritable(Value value); Return<void> setFlashlightWritable(Value value);
Return<int32_t> readFlashlightstats(Device device); Return<int32_t> readFlashlightstats(Device device);
// Methods from ::android::hidl::base::V1_0::IBase follow. // Methods from ::android::hidl::base::V1_0::IBase follow.
static IFlashBrightness* getInstance(void); static IFlashBrightness *getInstance(void);
}; };
} // namespace vendor::eureka::hardware::parts::V1_0 } // 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" #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 <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 "Battery.h"
#include "FlashLight.h"
#include "Display.h" #include "Display.h"
#include "FlashLight.h"
using android::sp; using android::sp;
using android::hardware::configureRpcThreadpool; using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool; using android::hardware::joinRpcThreadpool;
using vendor::eureka::hardware::parts::V1_0::BatteryStats; 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::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::IDisplayConfigs;
using vendor::eureka::hardware::parts::V1_0::IFlashBrightness;
int main() { int main() {
int ret; int ret;
android::sp<IBatteryStats> mBatteryService = BatteryStats::getInstance(); android::sp<IBatteryStats> mBatteryService = BatteryStats::getInstance();
android::sp<IFlashBrightness> mFlashLightService = FlashBrightness::getInstance(); android::sp<IFlashBrightness> mFlashLightService =
FlashBrightness::getInstance();
android::sp<IDisplayConfigs> mDisplayService = DisplayConfigs::getInstance(); android::sp<IDisplayConfigs> mDisplayService = DisplayConfigs::getInstance();
configureRpcThreadpool(4, true /*callerWillJoin*/); 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. * Write value to path and close file.
*/ */
template <typename T> template <typename T> static void set(const std::string &path, const T &value) {
static void set(const std::string& path, const T& value) {
std::ofstream file(path); std::ofstream file(path);
file << value << std::endl; file << value << std::endl;
} }
template <typename T> template <typename T> static T get(const std::string &path, const T &def) {
static T get(const std::string& path, const T& def) {
std::ifstream file(path); std::ifstream file(path);
T result; T result;
@ -38,23 +36,25 @@ static T get(const std::string& path, const T& def) {
} }
Lights::Lights() { Lights::Lights() {
mLights.emplace(LightType::BACKLIGHT, mLights.emplace(LightType::BACKLIGHT, std::bind(&Lights::handleBacklight,
std::bind(&Lights::handleBacklight, this, std::placeholders::_1)); this, std::placeholders::_1));
#ifdef BUTTON_BRIGHTNESS_NODE #ifdef BUTTON_BRIGHTNESS_NODE
mLights.emplace(LightType::BUTTONS, mLights.emplace(LightType::BUTTONS, std::bind(&Lights::handleButtons, this,
std::bind(&Lights::handleButtons, this, std::placeholders::_1)); std::placeholders::_1));
#endif /* BUTTON_BRIGHTNESS_NODE */ #endif /* BUTTON_BRIGHTNESS_NODE */
#ifdef LED_BLINK_NODE #ifdef LED_BLINK_NODE
mLights.emplace(LightType::BATTERY, mLights.emplace(LightType::BATTERY, std::bind(&Lights::handleBattery, this,
std::bind(&Lights::handleBattery, this, std::placeholders::_1)); std::placeholders::_1));
mLights.emplace(LightType::NOTIFICATIONS, mLights.emplace(
LightType::NOTIFICATIONS,
std::bind(&Lights::handleNotifications, this, std::placeholders::_1)); std::bind(&Lights::handleNotifications, this, std::placeholders::_1));
mLights.emplace(LightType::ATTENTION, mLights.emplace(LightType::ATTENTION, std::bind(&Lights::handleAttention,
std::bind(&Lights::handleAttention, this, std::placeholders::_1)); this, std::placeholders::_1));
#endif /* LED_BLINK_NODE */ #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); LightType type = static_cast<LightType>(id);
auto it = mLights.find(type); auto it = mLights.find(type);
@ -72,8 +72,9 @@ ndk::ScopedAStatus Lights::setLightState(int32_t id, const HwLightState& state)
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
void Lights::handleBacklight(const HwLightState& state) { void Lights::handleBacklight(const HwLightState &state) {
uint32_t max_brightness = get(PANEL_MAX_BRIGHTNESS_NODE, MAX_INPUT_BRIGHTNESS); uint32_t max_brightness =
get(PANEL_MAX_BRIGHTNESS_NODE, MAX_INPUT_BRIGHTNESS);
uint32_t brightness = rgbToBrightness(state); uint32_t brightness = rgbToBrightness(state);
if (max_brightness != MAX_INPUT_BRIGHTNESS) { if (max_brightness != MAX_INPUT_BRIGHTNESS) {
@ -84,7 +85,7 @@ void Lights::handleBacklight(const HwLightState& state) {
} }
#ifdef BUTTON_BRIGHTNESS_NODE #ifdef BUTTON_BRIGHTNESS_NODE
void Lights::handleButtons(const HwLightState& state) { void Lights::handleButtons(const HwLightState &state) {
#ifdef VAR_BUTTON_BRIGHTNESS #ifdef VAR_BUTTON_BRIGHTNESS
uint32_t brightness = rgbToBrightness(state); uint32_t brightness = rgbToBrightness(state);
#else #else
@ -96,17 +97,17 @@ void Lights::handleButtons(const HwLightState& state) {
#endif #endif
#ifdef LED_BLINK_NODE #ifdef LED_BLINK_NODE
void Lights::handleBattery(const HwLightState& state) { void Lights::handleBattery(const HwLightState &state) {
mBatteryState = state; mBatteryState = state;
setNotificationLED(); setNotificationLED();
} }
void Lights::handleNotifications(const HwLightState& state) { void Lights::handleNotifications(const HwLightState &state) {
mNotificationState = state; mNotificationState = state;
setNotificationLED(); setNotificationLED();
} }
void Lights::handleAttention(const HwLightState& state) { void Lights::handleAttention(const HwLightState &state) {
mAttentionState = state; mAttentionState = state;
setNotificationLED(); setNotificationLED();
} }
@ -128,7 +129,8 @@ void Lights::setNotificationLED() {
adjusted_brightness = LED_BRIGHTNESS_ATTENTION; adjusted_brightness = LED_BRIGHTNESS_ATTENTION;
state = mAttentionState; state = mAttentionState;
if (state.flashMode == FlashMode::HARDWARE) { 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; state.color = 0x000000ff;
} }
if (state.flashMode == FlashMode::NONE) { if (state.flashMode == FlashMode::NONE) {
@ -148,8 +150,9 @@ void Lights::setNotificationLED() {
} }
state.color = calibrateColor(state.color & COLOR_MASK, adjusted_brightness); state.color = calibrateColor(state.color & COLOR_MASK, adjusted_brightness);
set(LED_BLINK_NODE, ::android::base::StringPrintf("0x%08x %d %d", state.color, state.flashOnMs, set(LED_BLINK_NODE,
state.flashOffMs)); ::android::base::StringPrintf("0x%08x %d %d", state.color,
state.flashOnMs, state.flashOffMs));
#ifdef LED_BLN_NODE #ifdef LED_BLN_NODE
if (bln) { 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 green = ((color >> 8) & 0xFF) * LED_ADJUSTMENT_G;
uint32_t blue = (color & 0xFF) * LED_ADJUSTMENT_B; uint32_t blue = (color & 0xFF) * LED_ADJUSTMENT_B;
return (((red * brightness) / 255) << 16) + (((green * brightness) / 255) << 8) + return (((red * brightness) / 255) << 16) +
((blue * brightness) / 255); (((green * brightness) / 255) << 8) + ((blue * brightness) / 255);
} }
#endif /* LED_BLINK_NODE */ #endif /* LED_BLINK_NODE */
#define AutoHwLight(light) \ #define AutoHwLight(light) \
{ .id = (int32_t)light, .type = light, .ordinal = 0 } { .id = (int32_t)light, .type = light, .ordinal = 0 }
ndk::ScopedAStatus Lights::getLights(std::vector<HwLight>* _aidl_return) { ndk::ScopedAStatus Lights::getLights(std::vector<HwLight> *_aidl_return) {
for (auto const& light : mLights) { for (auto const &light : mLights) {
_aidl_return->push_back(AutoHwLight(light.first)); _aidl_return->push_back(AutoHwLight(light.first));
} }
return ndk::ScopedAStatus::ok(); 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; uint32_t color = state.color & COLOR_MASK;
return ((77 * ((color >> 16) & 0xff)) + (150 * ((color >> 8) & 0xff)) + 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 #pragma once
#include "samsung_lights.h"
#include <aidl/android/hardware/light/BnLights.h> #include <aidl/android/hardware/light/BnLights.h>
#include <unordered_map> #include <unordered_map>
#include "samsung_lights.h"
using ::aidl::android::hardware::light::HwLight; using ::aidl::android::hardware::light::HwLight;
using ::aidl::android::hardware::light::HwLightState; using ::aidl::android::hardware::light::HwLightState;
@ -19,21 +19,22 @@ namespace hardware {
namespace light { namespace light {
class Lights : public BnLights { class Lights : public BnLights {
public: public:
Lights(); Lights();
ndk::ScopedAStatus setLightState(int32_t id, const HwLightState& state) override; ndk::ScopedAStatus setLightState(int32_t id,
ndk::ScopedAStatus getLights(std::vector<HwLight>* _aidl_return) override; const HwLightState &state) override;
ndk::ScopedAStatus getLights(std::vector<HwLight> *_aidl_return) override;
private: private:
void handleBacklight(const HwLightState& state); void handleBacklight(const HwLightState &state);
#ifdef BUTTON_BRIGHTNESS_NODE #ifdef BUTTON_BRIGHTNESS_NODE
void handleButtons(const HwLightState& state); void handleButtons(const HwLightState &state);
#endif /* BUTTON_BRIGHTNESS_NODE */ #endif /* BUTTON_BRIGHTNESS_NODE */
#ifdef LED_BLINK_NODE #ifdef LED_BLINK_NODE
void handleBattery(const HwLightState& state); void handleBattery(const HwLightState &state);
void handleNotifications(const HwLightState& state); void handleNotifications(const HwLightState &state);
void handleAttention(const HwLightState& state); void handleAttention(const HwLightState &state);
void setNotificationLED(); void setNotificationLED();
uint32_t calibrateColor(uint32_t color, int32_t brightness); uint32_t calibrateColor(uint32_t color, int32_t brightness);
@ -42,10 +43,11 @@ class Lights : public BnLights {
HwLightState mNotificationState; HwLightState mNotificationState;
#endif /* LED_BLINK_NODE */ #endif /* LED_BLINK_NODE */
uint32_t rgbToBrightness(const HwLightState& state); uint32_t rgbToBrightness(const HwLightState &state);
std::mutex mLock; 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 } // 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" #define LED_BLN_NODE "/sys/class/misc/backlightnotification/notification_led"
// Uncomment to enable variable button brightness // Uncomment to enable variable button brightness
//#define VAR_BUTTON_BRIGHTNESS 1 // #define VAR_BUTTON_BRIGHTNESS 1
/* /*
* Brightness adjustment factors * 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>(); std::shared_ptr<Lights> lights = ndk::SharedRefBase::make<Lights>();
const std::string instance = std::string() + Lights::descriptor + "/default"; 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); CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool(); 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) #define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL)
#include <fcntl.h> #include <fcntl.h>
#include <memory>
#include <poll.h> #include <poll.h>
#include <sys/eventfd.h> #include <sys/eventfd.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <utils/Log.h> #include <utils/Log.h>
#include <utils/Trace.h> #include <utils/Trace.h>
#include <memory>
#include "InteractionHandler.h" #include "InteractionHandler.h"
@ -33,26 +33,24 @@
#define MSINSEC 1000L #define MSINSEC 1000L
#define USINMS 1000000L #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"}; "/sys/class/graphics/fb0/idle_state"};
InteractionHandler::InteractionHandler(std::shared_ptr<HintManager> const& hint_manager) InteractionHandler::InteractionHandler(
: mState(INTERACTION_STATE_UNINITIALIZED), std::shared_ptr<HintManager> const &hint_manager)
mWaitMs(100), : mState(INTERACTION_STATE_UNINITIALIZED), mWaitMs(100),
mMinDurationMs(1400), mMinDurationMs(1400), mMaxDurationMs(5650), mDurationMs(0),
mMaxDurationMs(5650),
mDurationMs(0),
mHintManager(hint_manager) {} mHintManager(hint_manager) {}
InteractionHandler::~InteractionHandler() { InteractionHandler::~InteractionHandler() { Exit(); }
Exit();
}
static int fb_idle_open(void) { static int fb_idle_open(void) {
int fd; int fd;
for (auto& path : fb_idle_patch) { for (auto &path : fb_idle_patch) {
fd = open(path.c_str(), O_RDONLY); 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); ALOGE("Unable to open fb idle state path (%d)", errno);
return -1; return -1;
@ -61,7 +59,8 @@ static int fb_idle_open(void) {
bool InteractionHandler::Init() { bool InteractionHandler::Init() {
std::lock_guard<std::mutex> lk(mLock); 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(); mIdleFd = fb_idle_open();
@ -75,14 +74,16 @@ bool InteractionHandler::Init() {
} }
mState = INTERACTION_STATE_IDLE; 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; return true;
} }
void InteractionHandler::Exit() { void InteractionHandler::Exit() {
std::unique_lock<std::mutex> lk(mLock); std::unique_lock<std::mutex> lk(mLock);
if (mState == INTERACTION_STATE_UNINITIALIZED) return; if (mState == INTERACTION_STATE_UNINITIALIZED)
return;
AbortWaitLocked(); AbortWaitLocked();
mState = INTERACTION_STATE_UNINITIALIZED; mState = INTERACTION_STATE_UNINITIALIZED;
@ -113,7 +114,8 @@ void InteractionHandler::PerfRel() {
ATRACE_INT("interaction_lock", 0); 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; size_t diff_in_us = 0;
diff_in_us += (end.tv_sec - start.tv_sec) * MSINSEC; diff_in_us += (end.tv_sec - start.tv_sec) * MSINSEC;
diff_in_us += (end.tv_nsec - start.tv_nsec) / USINMS; 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); size_t elapsed_time = CalcTimespecDiffMs(mLastTimespec, cur_timespec);
// don't hint if previous hint's duration covers this hint's duration // don't hint if previous hint's duration covers this hint's duration
if (elapsed_time <= (mDurationMs - finalDuration)) { if (elapsed_time <= (mDurationMs - finalDuration)) {
ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld", __func__, ALOGV("%s: Previous duration (%d) cover this (%d) elapsed: %lld",
static_cast<int>(mDurationMs), static_cast<int>(finalDuration), __func__, static_cast<int>(mDurationMs),
static_cast<int>(finalDuration),
static_cast<long long>(elapsed_time)); static_cast<long long>(elapsed_time));
return; return;
} }
@ -175,7 +178,8 @@ void InteractionHandler::Release() {
uint64_t val; uint64_t val;
ssize_t ret = read(mEventFd, &val, sizeof(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() { void InteractionHandler::AbortWaitLocked() {
uint64_t val = 1; uint64_t val = 1;
ssize_t ret = write(mEventFd, &val, sizeof(val)); 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) { void InteractionHandler::WaitForIdle(int32_t wait_ms, int32_t timeout_ms) {
@ -249,7 +254,8 @@ void InteractionHandler::Routine() {
while (true) { while (true) {
lk.lock(); lk.lock();
mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; }); mCond.wait(lk, [&] { return mState != INTERACTION_STATE_IDLE; });
if (mState == INTERACTION_STATE_UNINITIALIZED) return; if (mState == INTERACTION_STATE_UNINITIALIZED)
return;
mState = INTERACTION_STATE_WAITING; mState = INTERACTION_STATE_WAITING;
lk.unlock(); lk.unlock();

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

@ -35,14 +35,14 @@ enum interaction_state {
}; };
class InteractionHandler { class InteractionHandler {
public: public:
InteractionHandler(std::shared_ptr<HintManager> const& hint_manager); InteractionHandler(std::shared_ptr<HintManager> const &hint_manager);
~InteractionHandler(); ~InteractionHandler();
bool Init(); bool Init();
void Exit(); void Exit();
void Acquire(int32_t duration); void Acquire(int32_t duration);
private: private:
void Release(); void Release();
void WaitForIdle(int32_t wait_ms, int32_t timeout_ms); void WaitForIdle(int32_t wait_ms, int32_t timeout_ms);
void AbortWaitLocked(); 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"; constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering";
Power::Power(std::shared_ptr<HintManager> hm) Power::Power(std::shared_ptr<HintManager> hm)
: mHintManager(hm), : mHintManager(hm), mInteractionHandler(nullptr), mVRModeOn(false),
mInteractionHandler(nullptr),
mVRModeOn(false),
mSustainedPerfModeOn(false) { mSustainedPerfModeOn(false) {
mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager); mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager);
mInteractionHandler->Init(); mInteractionHandler->Init();
@ -169,7 +167,7 @@ ndk::ScopedAStatus Power::setMode(Mode type, bool enabled) {
return ndk::ScopedAStatus::ok(); 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)); bool supported = mHintManager->IsHintSupported(toString(type));
switch (type) { switch (type) {
case Mode::LOW_POWER: // LOW_POWER handled insides PowerHAL specifically case Mode::LOW_POWER: // LOW_POWER handled insides PowerHAL specifically
@ -185,13 +183,15 @@ ndk::ScopedAStatus Power::isModeSupported(Mode type, bool* _aidl_return) {
break; break;
} }
LOG(INFO) << "Power mode " << toString(type) << " isModeSupported: " << supported; LOG(INFO) << "Power mode " << toString(type)
<< " isModeSupported: " << supported;
*_aidl_return = supported; *_aidl_return = supported;
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) { 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); ATRACE_INT(toString(type).c_str(), durationMs);
switch (type) { switch (type) {
case Boost::INTERACTION: case Boost::INTERACTION:
@ -215,7 +215,8 @@ ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
break; break;
} }
if (durationMs > 0) { if (durationMs > 0) {
mHintManager->DoHint(toString(type), std::chrono::milliseconds(durationMs)); mHintManager->DoHint(toString(type),
std::chrono::milliseconds(durationMs));
} else if (durationMs == 0) { } else if (durationMs == 0) {
mHintManager->DoHint(toString(type)); mHintManager->DoHint(toString(type));
} else { } else {
@ -227,18 +228,17 @@ ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
return ndk::ScopedAStatus::ok(); 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)); 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; *_aidl_return = supported;
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
constexpr const char* boolToString(bool b) { constexpr const char *boolToString(bool b) { return b ? "true" : "false"; }
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( std::string buf(::android::base::StringPrintf(
"HintManager Running: %s\n" "HintManager Running: %s\n"
"VRMode: %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; using ::android::perfmgr::HintManager;
class Power : public ::aidl::android::hardware::power::BnPower { class Power : public ::aidl::android::hardware::power::BnPower {
public: public:
Power(std::shared_ptr<HintManager> hm); Power(std::shared_ptr<HintManager> hm);
ndk::ScopedAStatus setMode(Mode type, bool enabled) override; 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 setBoost(Boost type, int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(Boost type, bool* _aidl_return) override; ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override;
binder_status_t dump(int fd, const char** args, uint32_t numArgs) override; binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
private: private:
std::shared_ptr<HintManager> mHintManager; std::shared_ptr<HintManager> mHintManager;
std::unique_ptr<InteractionHandler> mInteractionHandler; std::unique_ptr<InteractionHandler> mInteractionHandler;
std::atomic<bool> mVRModeOn; 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 impl {
namespace pixel { 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; LOG(DEBUG) << "PowerExt setMode: " << mode << " to: " << enabled;
ATRACE_INT(mode.c_str(), 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(); 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); bool supported = mHintManager->IsHintSupported(mode);
LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported; LOG(INFO) << "PowerExt mode " << mode << " isModeSupported: " << supported;
*_aidl_return = supported; *_aidl_return = supported;
return ndk::ScopedAStatus::ok(); 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; LOG(DEBUG) << "PowerExt setBoost: " << boost << " duration: " << durationMs;
ATRACE_INT(boost.c_str(), 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(); 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); bool supported = mHintManager->IsHintSupported(boost);
LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported; LOG(INFO) << "PowerExt boost " << boost << " isBoostSupported: " << supported;
*_aidl_return = 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; using ::android::perfmgr::HintManager;
class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt { class PowerExt
public: : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt {
public:
PowerExt(std::shared_ptr<HintManager> hm) : mHintManager(hm) {} PowerExt(std::shared_ptr<HintManager> hm) : mHintManager(hm) {}
ndk::ScopedAStatus setMode(const std::string& mode, bool enabled) override; ndk::ScopedAStatus setMode(const std::string &mode, bool enabled) override;
ndk::ScopedAStatus isModeSupported(const std::string& mode, bool* _aidl_return) override; ndk::ScopedAStatus isModeSupported(const std::string &mode,
ndk::ScopedAStatus setBoost(const std::string& boost, int32_t durationMs) override; bool *_aidl_return) override;
ndk::ScopedAStatus isBoostSupported(const std::string& boost, 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; 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."; LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is starting.";
// Parse config but do not start the looper // 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) { if (!hm) {
LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath; LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath;
} }
@ -53,10 +54,12 @@ int main() {
std::shared_ptr<PowerExt> pwExt = ndk::SharedRefBase::make<PowerExt>(hm); std::shared_ptr<PowerExt> pwExt = ndk::SharedRefBase::make<PowerExt>(hm);
// attach the extension to the same binder we will be registering // 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"; 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); CHECK(status == STATUS_OK);
LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is started."; 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 hardware {
namespace vibrator { namespace vibrator {
static std::map<Effect, int> CP_TRIGGER_EFFECTS { static std::map<Effect, int> CP_TRIGGER_EFFECTS{{Effect::CLICK, 10},
{ Effect::CLICK, 10 }, {Effect::DOUBLE_CLICK, 14},
{ Effect::DOUBLE_CLICK, 14 }, {Effect::HEAVY_CLICK, 23},
{ Effect::HEAVY_CLICK, 23 }, {Effect::TEXTURE_TICK, 50},
{ Effect::TEXTURE_TICK, 50 }, {Effect::TICK, 50}};
{ Effect::TICK, 50 }
};
/* /*
* Write value to path and close file. * Write value to path and close file.
*/ */
template <typename T> 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); std::ofstream node(path);
if (!node) { if (!node) {
LOG(ERROR) << "Failed to open: " << path; 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(); return ndk::ScopedAStatus::ok();
} }
static bool nodeExists(const std::string& path) { static bool nodeExists(const std::string &path) {
std::ofstream f(path.c_str()); std::ofstream f(path.c_str());
return f.good(); return f.good();
} }
@ -60,10 +58,12 @@ Vibrator::Vibrator() {
mHasTimedOutEffect = nodeExists(VIBRATOR_CP_TRIGGER_PATH); mHasTimedOutEffect = nodeExists(VIBRATOR_CP_TRIGGER_PATH);
} }
ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) { ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) {
*_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK | *_aidl_return =
IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS | IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
IVibrator::CAP_ALWAYS_ON_CONTROL*/; IVibrator::CAP_ALWAYS_ON_CONTROL*/
;
if (mHasTimedOutIntensity) { if (mHasTimedOutIntensity) {
*_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL | *_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
@ -73,11 +73,11 @@ ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus Vibrator::off() { ndk::ScopedAStatus Vibrator::off() { return activate(0); }
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; ndk::ScopedAStatus status;
if (mHasTimedOutEffect) if (mHasTimedOutEffect)
@ -99,7 +99,10 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibrat
return status; 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; ndk::ScopedAStatus status;
uint32_t amplitude = strengthToAmplitude(strength, &status); uint32_t amplitude = strengthToAmplitude(strength, &status);
uint32_t ms = 1000; uint32_t ms = 1000;
@ -110,7 +113,8 @@ ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, con
activate(0); activate(0);
setAmplitude(amplitude); 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]); writeNode(VIBRATOR_CP_TRIGGER_PATH, CP_TRIGGER_EFFECTS[effect]);
} else { } else {
if (mHasTimedOutEffect) if (mHasTimedOutEffect)
@ -137,15 +141,17 @@ ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, con
return status; return status;
} }
ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) { ndk::ScopedAStatus
*_aidl_return = {Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK, Vibrator::getSupportedEffects(std::vector<Effect> *_aidl_return) {
Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD, Effect::POP, *_aidl_return = {
Effect::RINGTONE_1, Effect::RINGTONE_2, Effect::RINGTONE_3, Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK,
Effect::RINGTONE_4, Effect::RINGTONE_5, Effect::RINGTONE_6, Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD,
Effect::RINGTONE_7, Effect::RINGTONE_7, Effect::RINGTONE_8, Effect::POP, Effect::RINGTONE_1, Effect::RINGTONE_2,
Effect::RINGTONE_9, Effect::RINGTONE_10, Effect::RINGTONE_11, Effect::RINGTONE_3, Effect::RINGTONE_4, Effect::RINGTONE_5,
Effect::RINGTONE_12, Effect::RINGTONE_13, Effect::RINGTONE_14, Effect::RINGTONE_6, Effect::RINGTONE_7, Effect::RINGTONE_7,
Effect::RINGTONE_15}; 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(); return ndk::ScopedAStatus::ok();
} }
@ -183,31 +189,39 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) {
return ndk::ScopedAStatus::ok(); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
@ -260,7 +280,8 @@ ndk::ScopedAStatus Vibrator::activate(uint32_t timeoutMs) {
return writeNode(VIBRATOR_TIMEOUT_PATH, 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(); *status = ndk::ScopedAStatus::ok();
switch (strength) { switch (strength) {
@ -276,7 +297,7 @@ uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatu
return 0; return 0;
} }
uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus* status) { uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus *status) {
*status = ndk::ScopedAStatus::ok(); *status = ndk::ScopedAStatus::ok();
switch (effect) { switch (effect) {
case Effect::CLICK: 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_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable"
#define VIBRATOR_INTENSITY_PATH "/sys/class/timed_output/vibrator/intensity" #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::Braking;
using ::aidl::android::hardware::vibrator::Effect;
using ::aidl::android::hardware::vibrator::EffectStrength;
using ::aidl::android::hardware::vibrator::CompositeEffect; using ::aidl::android::hardware::vibrator::CompositeEffect;
using ::aidl::android::hardware::vibrator::CompositePrimitive; 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; using ::aidl::android::hardware::vibrator::PrimitivePwle;
namespace aidl { namespace aidl {
@ -32,35 +33,52 @@ namespace vibrator {
class Vibrator : public BnVibrator { class Vibrator : public BnVibrator {
public: public:
Vibrator(); Vibrator();
ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override; ndk::ScopedAStatus getCapabilities(int32_t *_aidl_return) override;
ndk::ScopedAStatus off() override; ndk::ScopedAStatus off() override;
ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) override; ndk::ScopedAStatus
ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) override; on(int32_t timeoutMs,
ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override; 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 setAmplitude(float amplitude) override;
ndk::ScopedAStatus setExternalControl(bool enabled) override; ndk::ScopedAStatus setExternalControl(bool enabled) override;
ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getCompositionDelayMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override; ndk::ScopedAStatus getCompositionSizeMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus getSupportedPrimitives(std::vector<CompositePrimitive>* _aidl_return) override; ndk::ScopedAStatus getSupportedPrimitives(
ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t* _aidl_return) override; std::vector<CompositePrimitive> *_aidl_return) override;
ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite, const std::shared_ptr<IVibratorCallback>& callback) override; ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive,
ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override; int32_t *_aidl_return) override;
ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) 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 alwaysOnDisable(int32_t id) override;
ndk::ScopedAStatus getResonantFrequency(float* _aidl_return) override; ndk::ScopedAStatus getResonantFrequency(float *_aidl_return) override;
ndk::ScopedAStatus getQFactor(float* _aidl_return) override; ndk::ScopedAStatus getQFactor(float *_aidl_return) override;
ndk::ScopedAStatus getFrequencyResolution(float* _aidl_return) override; ndk::ScopedAStatus getFrequencyResolution(float *_aidl_return) override;
ndk::ScopedAStatus getFrequencyMinimum(float* _aidl_return) override; ndk::ScopedAStatus getFrequencyMinimum(float *_aidl_return) override;
ndk::ScopedAStatus getBandwidthAmplitudeMap(std::vector<float>* _aidl_return) override; ndk::ScopedAStatus
ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override; getBandwidthAmplitudeMap(std::vector<float> *_aidl_return) override;
ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override; ndk::ScopedAStatus
ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override; getPwlePrimitiveDurationMax(int32_t *_aidl_return) override;
ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle>& composite, const std::shared_ptr<IVibratorCallback>& callback) 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: private:
ndk::ScopedAStatus activate(uint32_t ms); ndk::ScopedAStatus activate(uint32_t ms);
static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus* status); static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus *status);
static uint8_t strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status); static uint8_t strengthToAmplitude(EffectStrength strength,
ndk::ScopedAStatus *status);
bool mEnabled{false}; bool mEnabled{false};
bool mExternalControl{false}; bool mExternalControl{false};

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

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

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

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

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

@ -20,9 +20,10 @@
#define SAMSUNG_CAMERA_DEBUG #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::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 { class SamsungCameraProvider : public LegacyCameraProviderImpl_2_5 {
public: public:
@ -30,6 +31,7 @@ public:
~SamsungCameraProvider(); ~SamsungCameraProvider();
Return<void> getCameraIdList(ICameraProvider::getCameraIdList_cb _hidl_cb); Return<void> getCameraIdList(ICameraProvider::getCameraIdList_cb _hidl_cb);
private: private:
std::vector<int> mExtraIDs; std::vector<int> mExtraIDs;
std::vector<int> mDisabledIDs; 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::status_t;
using android::hardware::camera::provider::V2_5::ICameraProvider; using android::hardware::camera::provider::V2_5::ICameraProvider;
int main() int main() {
{
using namespace android::hardware::camera::provider::V2_5::implementation; using namespace android::hardware::camera::provider::V2_5::implementation;
ALOGI("CameraProvider@2.5 legacy service is starting."); 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"); status_t status = provider->registerAsService("legacy/0");
LOG_ALWAYS_FATAL_IF(status != android::OK, "Error while registering provider service: %d", LOG_ALWAYS_FATAL_IF(status != android::OK,
status); "Error while registering provider service: %d", status);
::android::hardware::joinRpcThreadpool(); ::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 <hardware/hw_auth_token.h>
#include "BiometricsFingerprint.h"
#include <hardware/fingerprint.h> #include <hardware/fingerprint.h>
#include <hardware/hardware.h> #include <hardware/hardware.h>
#include "BiometricsFingerprint.h"
#include <dlfcn.h> #include <dlfcn.h>
#include <fstream>
#include <inttypes.h> #include <inttypes.h>
#include <unistd.h> #include <unistd.h>
#include <fstream>
#ifdef HAS_FINGERPRINT_GESTURES #ifdef HAS_FINGERPRINT_GESTURES
#include <fcntl.h> #include <fcntl.h>
@ -39,9 +39,10 @@ namespace fingerprint {
namespace V2_3 { namespace V2_3 {
namespace implementation { 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) { BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
sInstance = this; // keep track of the most recent instance sInstance = this; // keep track of the most recent instance
@ -58,7 +59,8 @@ BiometricsFingerprint::BiometricsFingerprint() : mClientCallback(nullptr) {
return; 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); ioctl(uinputFd, UI_SET_KEYBIT, KEY_DOWN);
if (err != 0) { if (err != 0) {
LOG(ERROR) << "Unable to enable key events"; LOG(ERROR) << "Unable to enable key events";
@ -99,13 +101,12 @@ Return<bool> BiometricsFingerprint::isUdfps(uint32_t) {
return false; 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();
} }
Return<void> BiometricsFingerprint::onFingerUp() { Return<void> BiometricsFingerprint::onFingerUp() { return Void(); }
return Void();
}
Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) { Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
switch (error) { switch (error) {
@ -134,14 +135,16 @@ Return<RequestStatus> BiometricsFingerprint::ErrorFilter(int32_t error) {
case -110: case -110:
return RequestStatus::SYS_ETIMEDOUT; return RequestStatus::SYS_ETIMEDOUT;
default: 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; return RequestStatus::SYS_UNKNOWN;
} }
} }
// Translate from errors returned by traditional HAL (see fingerprint.h) to // Translate from errors returned by traditional HAL (see fingerprint.h) to
// HIDL-compliant FingerprintError. // HIDL-compliant FingerprintError.
FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error, int32_t* vendorCode) { FingerprintError BiometricsFingerprint::VendorErrorFilter(int32_t error,
int32_t *vendorCode) {
*vendorCode = 0; *vendorCode = 0;
switch (error) { switch (error) {
case FINGERPRINT_ERROR_HW_UNAVAILABLE: 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) // Translate acquired messages returned by traditional HAL (see fingerprint.h)
// to HIDL-compliant FingerprintAcquiredInfo. // to HIDL-compliant FingerprintAcquiredInfo.
FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(int32_t info, FingerprintAcquiredInfo
int32_t* vendorCode) { BiometricsFingerprint::VendorAcquiredFilter(int32_t info, int32_t *vendorCode) {
*vendorCode = 0; *vendorCode = 0;
switch (info) { switch (info) {
case FINGERPRINT_ACQUIRED_GOOD: case FINGERPRINT_ACQUIRED_GOOD:
@ -199,7 +202,7 @@ FingerprintAcquiredInfo BiometricsFingerprint::VendorAcquiredFilter(int32_t info
} }
Return<uint64_t> BiometricsFingerprint::setNotify( Return<uint64_t> BiometricsFingerprint::setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) { const sp<IBiometricsFingerprintClientCallback> &clientCallback) {
std::lock_guard<std::mutex> lock(mClientCallbackMutex); std::lock_guard<std::mutex> lock(mClientCallbackMutex);
mClientCallback = clientCallback; mClientCallback = clientCallback;
// This is here because HAL 2.3 doesn't have a way to propagate a // 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 ss_fingerprint_pre_enroll();
} }
Return<RequestStatus> BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69>& hat, Return<RequestStatus>
uint32_t gid, uint32_t timeoutSec) { BiometricsFingerprint::enroll(const hidl_array<uint8_t, 69> &hat, uint32_t gid,
const hw_auth_token_t* authToken = reinterpret_cast<const hw_auth_token_t*>(hat.data()); 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)); return ErrorFilter(ss_fingerprint_enroll(authToken, gid, timeoutSec));
} }
@ -251,12 +256,14 @@ Return<RequestStatus> BiometricsFingerprint::enumerate() {
return RequestStatus::SYS_UNKNOWN; 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 ErrorFilter(ss_fingerprint_remove(gid, fid));
} }
Return<RequestStatus> BiometricsFingerprint::setActiveGroup(uint32_t gid, Return<RequestStatus>
const hidl_string& storePath) { BiometricsFingerprint::setActiveGroup(uint32_t gid,
const hidl_string &storePath) {
if (storePath.size() >= PATH_MAX || storePath.size() <= 0) { if (storePath.size() >= PATH_MAX || storePath.size() <= 0) {
LOG(ERROR) << "Bad path length: " << storePath.size(); LOG(ERROR) << "Bad path length: " << storePath.size();
return RequestStatus::SYS_EINVAL; 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 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)); return ErrorFilter(ss_fingerprint_authenticate(operationId, gid));
} }
IBiometricsFingerprint* BiometricsFingerprint::getInstance() { IBiometricsFingerprint *BiometricsFingerprint::getInstance() {
if (!sInstance) { if (!sInstance) {
sInstance = new BiometricsFingerprint(); sInstance = new BiometricsFingerprint();
} }
@ -281,34 +289,40 @@ IBiometricsFingerprint* BiometricsFingerprint::getInstance() {
} }
bool BiometricsFingerprint::openHal() { bool BiometricsFingerprint::openHal() {
void* handle = dlopen("libbauthserver.so", RTLD_NOW); void *handle = dlopen("libbauthserver.so", RTLD_NOW);
if (handle) { if (handle) {
int err; int err;
ss_fingerprint_close = reinterpret_cast<typeof(ss_fingerprint_close)>( ss_fingerprint_close = reinterpret_cast<typeof(ss_fingerprint_close)>(
dlsym(handle, "ss_fingerprint_close")); dlsym(handle, "ss_fingerprint_close"));
ss_fingerprint_open = ss_fingerprint_open = reinterpret_cast<typeof(ss_fingerprint_open)>(
reinterpret_cast<typeof(ss_fingerprint_open)>(dlsym(handle, "ss_fingerprint_open")); dlsym(handle, "ss_fingerprint_open"));
ss_set_notify_callback = reinterpret_cast<typeof(ss_set_notify_callback)>( ss_set_notify_callback = reinterpret_cast<typeof(ss_set_notify_callback)>(
dlsym(handle, "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")); dlsym(handle, "ss_fingerprint_pre_enroll"));
ss_fingerprint_enroll = reinterpret_cast<typeof(ss_fingerprint_enroll)>( ss_fingerprint_enroll = reinterpret_cast<typeof(ss_fingerprint_enroll)>(
dlsym(handle, "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")); 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")); dlsym(handle, "ss_fingerprint_get_auth_id"));
ss_fingerprint_cancel = reinterpret_cast<typeof(ss_fingerprint_cancel)>( ss_fingerprint_cancel = reinterpret_cast<typeof(ss_fingerprint_cancel)>(
dlsym(handle, "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")); dlsym(handle, "ss_fingerprint_enumerate"));
ss_fingerprint_remove = reinterpret_cast<typeof(ss_fingerprint_remove)>( ss_fingerprint_remove = reinterpret_cast<typeof(ss_fingerprint_remove)>(
dlsym(handle, "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")); 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")); dlsym(handle, "ss_fingerprint_authenticate"));
ss_fingerprint_request = reinterpret_cast<typeof(ss_fingerprint_request)>( ss_fingerprint_request = reinterpret_cast<typeof(ss_fingerprint_request)>(
dlsym(handle, "ss_fingerprint_request")); dlsym(handle, "ss_fingerprint_request"));
@ -319,7 +333,8 @@ bool BiometricsFingerprint::openHal() {
} }
if ((err = ss_set_notify_callback(BiometricsFingerprint::notify)) != 0) { 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; return false;
} }
@ -329,12 +344,13 @@ bool BiometricsFingerprint::openHal() {
return false; return false;
} }
void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) { void BiometricsFingerprint::notify(const fingerprint_msg_t *msg) {
BiometricsFingerprint* thisPtr = BiometricsFingerprint *thisPtr = static_cast<BiometricsFingerprint *>(
static_cast<BiometricsFingerprint*>(BiometricsFingerprint::getInstance()); BiometricsFingerprint::getInstance());
std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex); std::lock_guard<std::mutex> lock(thisPtr->mClientCallbackMutex);
if (thisPtr == nullptr || thisPtr->mClientCallback == nullptr) { 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; return;
} }
const uint64_t devId = 1; const uint64_t devId = 1;
@ -356,13 +372,14 @@ void BiometricsFingerprint::notify(const fingerprint_msg_t* msg) {
FingerprintAcquiredInfo result = FingerprintAcquiredInfo result =
VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode); VendorAcquiredFilter(msg->data.acquired.acquired_info, &vendorCode);
LOG(DEBUG) << "onAcquired(" << static_cast<int>(result) << ")"; 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"; LOG(ERROR) << "failed to invoke fingerprint onAcquired callback";
} }
} break; } break;
case FINGERPRINT_TEMPLATE_ENROLLING: case FINGERPRINT_TEMPLATE_ENROLLING:
#ifdef USES_PERCENTAGE_SAMPLES #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; 100 - msg->data.enroll.samples_remaining;
#endif #endif
#ifdef CALL_CANCEL_ON_ENROLL_COMPLETION #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 LOG(DEBUG) << "onAuthenticated(fid=" << msg->data.authenticated.finger.fid
<< ", gid=" << msg->data.authenticated.finger.gid << ")"; << ", gid=" << msg->data.authenticated.finger.gid << ")";
if (msg->data.authenticated.finger.fid != 0) { 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( const hidl_vec<uint8_t> token(
std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat))); std::vector<uint8_t>(hat, hat + sizeof(msg->data.authenticated.hat)));
if (!thisPtr->mClientCallback 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_DOWN:
case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP: case SEM_FINGERPRINT_EVENT_GESTURE_SWIPE_UP:
struct input_event event {}; 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; int err;
// Report the key // Report the key
@ -488,7 +507,8 @@ void BiometricsFingerprint::handleEvent(int eventCode) {
int BiometricsFingerprint::request(int cmd, int param) { int BiometricsFingerprint::request(int cmd, int param) {
// TO-DO: input, output handling not implemented // TO-DO: input, output handling not implemented
int result = ss_fingerprint_request(cmd, nullptr, 0, nullptr, 0, param); 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; 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::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; 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::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_1::RequestStatus;
using ::android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint; using ::android::hardware::biometrics::fingerprint::V2_3::
IBiometricsFingerprint;
struct BiometricsFingerprint : public IBiometricsFingerprint { struct BiometricsFingerprint : public IBiometricsFingerprint {
BiometricsFingerprint(); BiometricsFingerprint();
~BiometricsFingerprint(); ~BiometricsFingerprint();
// Method to wrap legacy HAL with BiometricsFingerprint class // 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. // follow.
Return<uint64_t> setNotify( Return<uint64_t> setNotify(
const sp<IBiometricsFingerprintClientCallback>& clientCallback) override; const sp<IBiometricsFingerprintClientCallback> &clientCallback) override;
Return<uint64_t> preEnroll() 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; uint32_t timeoutSec) override;
Return<RequestStatus> postEnroll() override; Return<RequestStatus> postEnroll() override;
Return<uint64_t> getAuthenticatorId() override; Return<uint64_t> getAuthenticatorId() override;
Return<RequestStatus> cancel() override; Return<RequestStatus> cancel() override;
Return<RequestStatus> enumerate() override; Return<RequestStatus> enumerate() override;
Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override; Return<RequestStatus> remove(uint32_t gid, uint32_t fid) override;
Return<RequestStatus> setActiveGroup(uint32_t gid, const hidl_string& storePath) override; Return<RequestStatus> setActiveGroup(uint32_t gid,
Return<RequestStatus> authenticate(uint64_t operationId, uint32_t gid) override; const hidl_string &storePath) override;
Return<RequestStatus> authenticate(uint64_t operationId,
uint32_t gid) override;
Return<bool> isUdfps(uint32_t sensorID) 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> onFingerUp() override;
Return<void> onShowUdfpsOverlay() { return Void(); } Return<void> onShowUdfpsOverlay() { return Void(); }
Return<void> onHideUdfpsOverlay() { return Void(); } Return<void> onHideUdfpsOverlay() { return Void(); }
private: private:
bool openHal(); bool openHal();
int request(int cmd, int param); int request(int cmd, int param);
int waitForSensor(std::chrono::milliseconds pollWait, std::chrono::milliseconds timeOut); int waitForSensor(std::chrono::milliseconds pollWait,
static void notify( std::chrono::milliseconds timeOut);
const fingerprint_msg_t* msg); /* Static callback for legacy HAL implementation */ static void
notify(const fingerprint_msg_t
*msg); /* Static callback for legacy HAL implementation */
void handleEvent(int eventCode); void handleEvent(int eventCode);
static Return<RequestStatus> ErrorFilter(int32_t error); static Return<RequestStatus> ErrorFilter(int32_t error);
static FingerprintError VendorErrorFilter(int32_t error, int32_t* vendorCode); static FingerprintError VendorErrorFilter(int32_t error, int32_t *vendorCode);
static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error, int32_t* vendorCode); static FingerprintAcquiredInfo VendorAcquiredFilter(int32_t error,
static BiometricsFingerprint* sInstance; int32_t *vendorCode);
static BiometricsFingerprint *sInstance;
std::mutex mClientCallbackMutex; std::mutex mClientCallbackMutex;
sp<IBiometricsFingerprintClientCallback> mClientCallback; sp<IBiometricsFingerprintClientCallback> mClientCallback;
@ -100,19 +110,21 @@ struct BiometricsFingerprint : public IBiometricsFingerprint {
#endif #endif
int (*ss_fingerprint_close)(); 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); int (*ss_set_notify_callback)(fingerprint_notify_t notify);
uint64_t (*ss_fingerprint_pre_enroll)(); 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)(); int (*ss_fingerprint_post_enroll)();
uint64_t (*ss_fingerprint_get_auth_id)(); uint64_t (*ss_fingerprint_get_auth_id)();
int (*ss_fingerprint_cancel)(); int (*ss_fingerprint_cancel)();
int (*ss_fingerprint_enumerate)(); int (*ss_fingerprint_enumerate)();
int (*ss_fingerprint_remove)(uint32_t gid, uint32_t fid); 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_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); 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::joinRpcThreadpool;
using android::hardware::biometrics::fingerprint::V2_3::IBiometricsFingerprint; 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::OK;
using android::sp; using android::sp;
int main() { int main() {
android::sp<IBiometricsFingerprint> bio = BiometricsFingerprint::getInstance(); android::sp<IBiometricsFingerprint> bio =
BiometricsFingerprint::getInstance();
configureRpcThreadpool(1, true); 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; using android::status_t;
namespace skeymaster { namespace skeymaster {
IKeymasterDevice* CreateSKeymasterDevice(SecurityLevel securityLevel); IKeymasterDevice *CreateSKeymasterDevice(SecurityLevel securityLevel);
} // namespace skeymaster } // namespace skeymaster
int main() { int main() {
IKeymasterDevice* keymaster = IKeymasterDevice *keymaster =
skeymaster::CreateSKeymasterDevice(SecurityLevel::TRUSTED_ENVIRONMENT); skeymaster::CreateSKeymasterDevice(SecurityLevel::TRUSTED_ENVIRONMENT);
configureRpcThreadpool(1, true); configureRpcThreadpool(1, true);

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

@ -14,11 +14,11 @@
* limitations under the License. * limitations under the License.
*/ */
//#define VERBOSE // #define VERBOSE
#include "Sensors.h" #include "Sensors.h"
#include <sensors/convert.h>
#include "multihal.h" #include "multihal.h"
#include <sensors/convert.h>
#include <android-base/logging.h> #include <android-base/logging.h>
@ -35,7 +35,7 @@ namespace implementation {
* return true indicating we need to use multi-hal functionality. * return true indicating we need to use multi-hal functionality.
*/ */
static bool UseMultiHal() { static bool UseMultiHal() {
const std::string& name = MULTI_HAL_CONFIG_FILE_PATH; const std::string &name = MULTI_HAL_CONFIG_FILE_PATH;
struct stat buffer; struct stat buffer;
return (stat(name.c_str(), &buffer) == 0); 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; status_t err = OK;
if (UseMultiHal()) { if (UseMultiHal()) {
mSensorModule = ::get_multi_hal_module_info(); mSensorModule = ::get_multi_hal_module_info();
} else { } 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) { if (mSensorModule == NULL) {
err = UNKNOWN_ERROR; err = UNKNOWN_ERROR;
@ -77,8 +79,8 @@ Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(
err = sensors_open_1(&mSensorModule->common, &mSensorDevice); err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
if (err != OK) { if (err != OK) {
LOG(ERROR) << "Couldn't open device for module " << SENSORS_HARDWARE_MODULE_ID << " (" LOG(ERROR) << "Couldn't open device for module "
<< strerror(-err) << ")"; << SENSORS_HARDWARE_MODULE_ID << " (" << strerror(-err) << ")";
mInitCheck = err; mInitCheck = err;
return; return;
@ -90,10 +92,12 @@ Sensors::Sensors() : mInitCheck(NO_INIT), mSensorModule(nullptr), mSensorDevice(
if (getHalDeviceVersion() == SENSORS_DEVICE_API_VERSION_1_4) { if (getHalDeviceVersion() == SENSORS_DEVICE_API_VERSION_1_4) {
if (mSensorDevice->inject_sensor_data == nullptr) { 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) { 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; mInitCheck = OK;
} }
status_t Sensors::initCheck() const { status_t Sensors::initCheck() const { return mInitCheck; }
return mInitCheck;
}
Return<void> Sensors::getSensorsList(getSensorsList_cb _hidl_cb) { 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); size_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
hidl_vec<SensorInfo> out; hidl_vec<SensorInfo> out;
out.resize(count); out.resize(count);
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const sensor_t* src = &list[i]; const sensor_t *src = &list[i];
SensorInfo* dst = &out[i]; SensorInfo *dst = &out[i];
convertFromSensor(*src, dst); convertFromSensor(*src, dst);
@ -164,7 +166,8 @@ Return<Result> Sensors::setOperationMode(OperationMode mode) {
Return<Result> Sensors::activate(int32_t sensor_handle, bool enabled) { Return<Result> Sensors::activate(int32_t sensor_handle, bool enabled) {
return ResultFromStatus(mSensorDevice->activate( 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) { 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 { // scope of reentry lock
// This enforces a single client, meaning that a maximum of one client can call poll(). // This enforces a single client, meaning that a maximum of one client can
// If this function is re-entred, it means that we are stuck in a state that may prevent // call poll(). If this function is re-entred, it means that we are stuck in
// the system from proceeding normally. // 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); std::unique_lock<std::mutex> lock(mPollLock, std::try_to_lock);
if (!lock.owns_lock()) { if (!lock.owns_lock()) {
// cannot get the lock, hidl service will go into deadlock if it is not restarted. // cannot get the lock, hidl service will go into deadlock if it is not
// This is guaranteed to not trigger in passthrough mode. // restarted. This is guaranteed to not trigger in passthrough mode.
LOG(ERROR) LOG(ERROR) << "ISensors::poll() re-entry. I do not know what to do "
<< "ISensors::poll() re-entry. I do not know what to do except killing myself."; "except killing myself.";
::exit(-1); ::exit(-1);
} }
if (maxCount <= 0) { if (maxCount <= 0) {
err = android::BAD_VALUE; err = android::BAD_VALUE;
} else { } else {
int bufferSize = maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize; int bufferSize =
maxCount <= kPollMaxBufferSize ? maxCount : kPollMaxBufferSize;
data.reset(new sensors_event_t[bufferSize]); data.reset(new sensors_event_t[bufferSize]);
err = mSensorDevice->poll(reinterpret_cast<sensors_poll_device_t*>(mSensorDevice), err = mSensorDevice->poll(
data.get(), bufferSize); 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; 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) { if (!dyn->connected) {
continue; 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, Return<Result> Sensors::batch(int32_t sensor_handle, int64_t sampling_period_ns,
int64_t max_report_latency_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)); 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 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 || if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4 ||
mSensorDevice->inject_sensor_data == nullptr) { mSensorDevice->inject_sensor_data == nullptr) {
return Result::INVALID_OPERATION; return Result::INVALID_OPERATION;
@ -258,10 +266,11 @@ Return<Result> Sensors::injectSensorData(const Event& event) {
sensors_event_t out; sensors_event_t out;
convertToSensorEvent(event, &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) { registerDirectChannel_cb _hidl_cb) {
if (mSensorDevice->register_direct_channel == nullptr || if (mSensorDevice->register_direct_channel == nullptr ||
mSensorDevice->config_direct_report == nullptr) { mSensorDevice->config_direct_report == nullptr) {
@ -299,8 +308,9 @@ Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {
return Result::OK; return Result::OK;
} }
Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHandle, Return<void> Sensors::configDirectReport(int32_t sensorHandle,
RateLevel rate, configDirectReport_cb _hidl_cb) { int32_t channelHandle, RateLevel rate,
configDirectReport_cb _hidl_cb) {
if (mSensorDevice->register_direct_channel == nullptr || if (mSensorDevice->register_direct_channel == nullptr ||
mSensorDevice->config_direct_report == nullptr) { mSensorDevice->config_direct_report == nullptr) {
// HAL does not support // HAL does not support
@ -314,7 +324,8 @@ Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHa
return Void(); 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) { if (rate == RateLevel::STOP) {
_hidl_cb(ResultFromStatus(err), -1); _hidl_cb(ResultFromStatus(err), -1);
@ -325,18 +336,19 @@ Return<void> Sensors::configDirectReport(int32_t sensorHandle, int32_t channelHa
} }
// static // static
void Sensors::convertFromSensorEvents(size_t count, const sensors_event_t* srcArray, void Sensors::convertFromSensorEvents(size_t count,
hidl_vec<Event>* dstVec) { const sensors_event_t *srcArray,
hidl_vec<Event> *dstVec) {
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
const sensors_event_t& src = srcArray[i]; const sensors_event_t &src = srcArray[i];
Event* dst = &(*dstVec)[i]; Event *dst = &(*dstVec)[i];
convertFromSensorEvent(src, dst); convertFromSensorEvent(src, dst);
} }
} }
ISensors* HIDL_FETCH_ISensors(const char* /* hal */) { ISensors *HIDL_FETCH_ISensors(const char * /* hal */) {
Sensors* sensors = new Sensors; Sensors *sensors = new Sensors;
if (sensors->initCheck() != OK) { if (sensors->initCheck() != OK) {
delete sensors; delete sensors;
sensors = nullptr; 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> 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; registerDirectChannel_cb _hidl_cb) override;
Return<Result> unregisterDirectChannel(int32_t channelHandle) 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; configDirectReport_cb _hidl_cb) override;
private: private:
static constexpr int32_t kPollMaxBufferSize = 128; static constexpr int32_t kPollMaxBufferSize = 128;
status_t mInitCheck; status_t mInitCheck;
sensors_module_t* mSensorModule; sensors_module_t *mSensorModule;
sensors_poll_device_1_t* mSensorDevice; sensors_poll_device_1_t *mSensorDevice;
std::mutex mPollLock; std::mutex mPollLock;
int getHalDeviceVersion() const; int getHalDeviceVersion() const;
static void convertFromSensorEvents(size_t count, const sensors_event_t* src, static void convertFromSensorEvents(size_t count, const sensors_event_t *src,
hidl_vec<Event>* dst); hidl_vec<Event> *dst);
DISALLOW_COPY_AND_ASSIGN(Sensors); 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 implementation
} // namespace V1_0 } // 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 V1_0 {
namespace implementation { namespace implementation {
Return<void> Usb::switchRole(const hidl_string& portName __unused, Return<void> Usb::switchRole(const hidl_string &portName __unused,
const PortRole& newRole __unused) { const PortRole &newRole __unused) {
LOG(ERROR) << __func__ << ": Not supported"; LOG(ERROR) << __func__ << ": Not supported";
return Void(); return Void();
} }
@ -51,7 +51,8 @@ Return<void> Usb::queryPortStatus() {
pthread_mutex_lock(&mLock); pthread_mutex_lock(&mLock);
if (mCallback != NULL) { if (mCallback != NULL) {
Return<void> ret = mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS); Return<void> ret =
mCallback->notifyPortStatusChange(currentPortStatus, Status::SUCCESS);
if (!ret.isOk()) { if (!ret.isOk()) {
LOG(ERROR) << "queryPortStatus error " << ret.description(); LOG(ERROR) << "queryPortStatus error " << ret.description();
} }
@ -63,7 +64,7 @@ Return<void> Usb::queryPortStatus() {
return Void(); return Void();
} }
Return<void> Usb::setCallback(const sp<IUsbCallback>& callback) { Return<void> Usb::setCallback(const sp<IUsbCallback> &callback) {
pthread_mutex_lock(&mLock); pthread_mutex_lock(&mLock);
mCallback = callback; 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; using ::android::hidl::base::V1_0::IBase;
struct Usb : public IUsb { struct Usb : public IUsb {
Return<void> switchRole(const hidl_string& portName, const PortRole& role) override; Return<void> switchRole(const hidl_string &portName,
Return<void> setCallback(const sp<IUsbCallback>& callback) override; const PortRole &role) override;
Return<void> setCallback(const sp<IUsbCallback> &callback) override;
Return<void> queryPortStatus() override; Return<void> queryPortStatus() override;
sp<IUsbCallback> mCallback; sp<IUsbCallback> mCallback;

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

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

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

@ -17,9 +17,9 @@
#pragma once #pragma once
#include <android-base/file.h> #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/IUsbCallback.h>
#include <android/hardware/usb/1.2/types.h>
#include <android/hardware/usb/1.3/IUsb.h>
#include <hidl/Status.h> #include <hidl/Status.h>
#include <utils/Log.h> #include <utils/Log.h>
@ -36,47 +36,44 @@ namespace usb {
namespace V1_3 { namespace V1_3 {
namespace implementation { namespace implementation {
using ::android::base::WriteStringToFile; using ::android::sp;
using ::android::base::ReadFileToString; using ::android::base::ReadFileToString;
using ::android::base::WriteStringToFile;
using ::android::hardware::hidl_array; using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory; using ::android::hardware::hidl_memory;
using ::android::hardware::hidl_string; using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec; using ::android::hardware::hidl_vec;
using ::android::hardware::Return; using ::android::hardware::Return;
using ::android::hardware::Void; 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::PortDataRole;
using ::android::hardware::usb::V1_0::PortPowerRole; using ::android::hardware::usb::V1_0::PortPowerRole;
using ::android::hardware::usb::V1_0::PortRole; using ::android::hardware::usb::V1_0::PortRole;
using ::android::hardware::usb::V1_0::PortRoleType; using ::android::hardware::usb::V1_0::PortRoleType;
using ::android::hardware::usb::V1_0::Status; 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::PortMode_1_1;
using ::android::hardware::usb::V1_1::PortStatus_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::DebugInfo;
using ::android::hidl::base::V1_0::IBase; using ::android::hidl::base::V1_0::IBase;
using ::android::sp;
enum class HALVersion{ enum class HALVersion { V1_0, V1_1, V1_2, V1_3 };
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 { struct Usb : public IUsb {
Usb(); Usb();
Return<void> switchRole(const hidl_string &portName, const PortRole &role) override; Return<void> switchRole(const hidl_string &portName,
Return<void> setCallback(const sp<V1_0::IUsbCallback>& callback) override; const PortRole &role) override;
Return<void> setCallback(const sp<V1_0::IUsbCallback> &callback) override;
Return<void> queryPortStatus() override; Return<void> queryPortStatus() override;
Return<void> enableContaminantPresenceDetection(const hidl_string &portName, bool enable); Return<void> enableContaminantPresenceDetection(const hidl_string &portName,
Return<void> enableContaminantPresenceProtection(const hidl_string &portName, bool enable); bool enable);
Return<void> enableContaminantPresenceProtection(const hidl_string &portName,
bool enable);
Return<bool> enableUsbDataSignal(bool enable) override; Return<bool> enableUsbDataSignal(bool enable) override;
sp<V1_0::IUsbCallback> mCallback_1_0; 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 // Variable to signal partner coming back online after type switch
bool mPartnerUp; bool mPartnerUp;
private: private:
pthread_t mPoll; 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" #define LOG_TAG "android.hardware.usb@1.3-service.samsung"
#include <hidl/HidlTransportSupport.h>
#include "Usb.h" #include "Usb.h"
#include <hidl/HidlTransportSupport.h>
using android::sp; 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) { void LoadProperties(std::string data) {
for (std::string line : android::base::Split(data, "\n")) { 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, "="); std::vector<std::string> parts = android::base::Split(line, "=");
if (parts.size() == 2) { 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; 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); std::ifstream in(EFS_NEW + prop);
if (in.good()) { 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) { 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) if (pi)
__system_property_update(pi, value, strlen(value)); __system_property_update(pi, value, strlen(value));
else if (add) else if (add)
__system_property_add(prop, strlen(prop), value, strlen(value)); __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; string prop_name;
for (const auto& source : ro_props_default_source_order) { for (const auto &source : ro_props_default_source_order) {
if (product) if (product)
prop_name = "ro.product." + source + prop; prop_name = "ro.product." + source + prop;
else 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()) { if (fullString.length() >= ending.length()) {
return (0 == return (0 == fullString.compare(fullString.length() - ending.length(),
fullString.compare(fullString.length() - ending.length(), ending.length(), ending)); ending.length(), ending));
} else { } else {
return false; 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 #ifndef ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H
#define 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 "CameraDeviceSession.h"
#include "CameraMetadata.h"
#include "CameraModule.h"
#include "utils/Mutex.h"
#include <android/hardware/camera/device/3.2/ICameraDevice.h> #include <android/hardware/camera/device/3.2/ICameraDevice.h>
#include <hidl/Status.h>
#include <hidl/MQDescriptor.h> #include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
namespace android { namespace android {
namespace hardware { namespace hardware {
@ -33,20 +33,20 @@ namespace device {
namespace V3_2 { namespace V3_2 {
namespace implementation { namespace implementation {
using ::android::hardware::camera::device::V3_2::RequestTemplate; using ::android::Mutex;
using ::android::hardware::camera::device::V3_2::ICameraDevice; using ::android::sp;
using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback; using ::android::hardware::hidl_string;
using ::android::hardware::camera::device::V3_2::ICameraDeviceSession; 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::CameraResourceCost;
using ::android::hardware::camera::common::V1_0::Status; using ::android::hardware::camera::common::V1_0::Status;
using ::android::hardware::camera::common::V1_0::TorchMode; using ::android::hardware::camera::common::V1_0::TorchMode;
using ::android::hardware::camera::common::V1_0::helper::CameraModule; using ::android::hardware::camera::common::V1_0::helper::CameraModule;
using ::android::hardware::Return; using ::android::hardware::camera::device::V3_2::ICameraDevice;
using ::android::hardware::Void; using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
using ::android::hardware::hidl_vec; using ::android::hardware::camera::device::V3_2::ICameraDeviceSession;
using ::android::hardware::hidl_string; using ::android::hardware::camera::device::V3_2::RequestTemplate;
using ::android::sp;
using ::android::Mutex;
/* /*
* The camera device HAL implementation is opened lazily (via the open call) * 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. // trying to access the same physical camera.
// Also, provider will have to keep track of all CameraDevice objects in // Also, provider will have to keep track of all CameraDevice objects in
// order to notify CameraDevice when the underlying camera is detached // order to notify CameraDevice when the underlying camera is detached
CameraDevice(sp<CameraModule> module, CameraDevice(sp<CameraModule> module, const std::string &cameraId,
const std::string& cameraId, const SortedVector<std::pair<std::string, std::string>>
const SortedVector<std::pair<std::string, std::string>>& cameraDeviceNames); &cameraDeviceNames);
virtual ~CameraDevice(); virtual ~CameraDevice();
// Retrieve the HIDL interface, split into its own class to avoid inheritance issues when // Retrieve the HIDL interface, split into its own class to avoid inheritance
// dealing with minor version revs and simultaneous implementation and interface inheritance // issues when dealing with minor version revs and simultaneous implementation
// and interface inheritance
virtual sp<ICameraDevice> getInterface() { virtual sp<ICameraDevice> getInterface() {
return new TrampolineDeviceInterface_3_2(this); return new TrampolineDeviceInterface_3_2(this);
} }
@ -73,27 +74,33 @@ struct CameraDevice : public virtual RefBase {
// Used by provider HAL to signal external camera disconnected // Used by provider HAL to signal external camera disconnected
void setConnectionStatus(bool connected); 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 // The following method can be called without opening the actual camera device
Return<void> getResourceCost(ICameraDevice::getResourceCost_cb _hidl_cb); Return<void> getResourceCost(ICameraDevice::getResourceCost_cb _hidl_cb);
Return<void> getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb); Return<void>
Return<void> getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb); getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<void>
getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
Return<Status> setTorchMode(TorchMode mode); Return<Status> setTorchMode(TorchMode mode);
// Open the device HAL and also return a default capture session // 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> open(const sp<ICameraDeviceCallback> &callback,
Return<void> nuke(const sp<ICameraDeviceCallback>& callback, ICameraDevice::open_cb _hidl_cb); 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 // Forward the dump call to the opened session, or do nothing
Return<void> dumpState(const ::android::hardware::hidl_handle& fd); Return<void> dumpState(const ::android::hardware::hidl_handle &fd);
/* End of Methods from ::android::hardware::camera::device::V3_2::ICameraDevice */ /* End of Methods from
* ::android::hardware::camera::device::V3_2::ICameraDevice */
protected: protected:
// Overridden by child implementations for returning different versions of
// Overridden by child implementations for returning different versions of CameraDeviceSession // CameraDeviceSession
virtual sp<CameraDeviceSession> createSession(camera3_device_t*, virtual sp<CameraDeviceSession>
const camera_metadata_t* deviceInfo, createSession(camera3_device_t *, const camera_metadata_t *deviceInfo,
const sp<ICameraDeviceCallback>&); const sp<ICameraDeviceCallback> &);
const sp<CameraModule> mModule; const sp<CameraModule> mModule;
const std::string mCameraId; const std::string mCameraId;
@ -105,7 +112,7 @@ protected:
bool mDisconnected; bool mDisconnected;
wp<CameraDeviceSession> mSession = nullptr; 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 // gating access to mSession and mDisconnected
mutable Mutex mLock; mutable Mutex mLock;
@ -117,11 +124,10 @@ protected:
private: private:
struct TrampolineDeviceInterface_3_2 : public ICameraDevice { struct TrampolineDeviceInterface_3_2 : public ICameraDevice {
TrampolineDeviceInterface_3_2(sp<CameraDevice> parent) : TrampolineDeviceInterface_3_2(sp<CameraDevice> parent) : mParent(parent) {}
mParent(parent) {}
virtual Return<void> getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb) virtual Return<void>
override { getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb) override {
return mParent->getResourceCost(_hidl_cb); return mParent->getResourceCost(_hidl_cb);
} }
@ -134,19 +140,18 @@ private:
return mParent->setTorchMode(mode); 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 { V3_2::ICameraDevice::open_cb _hidl_cb) override {
return mParent->open(callback, _hidl_cb); 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); return mParent->dumpState(fd);
} }
private: private:
sp<CameraDevice> mParent; sp<CameraDevice> mParent;
}; };
}; };
} // namespace implementation } // namespace implementation

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

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

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

@ -1,5 +1,5 @@
#include <log/log.h> #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; return 0;
} }

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

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