Merge "[BugFix] Reset key repeating in case a keyboard device was disabled or enabled." into sc-dev-plus-aosp
diff --git a/libs/binder/RpcSession.cpp b/libs/binder/RpcSession.cpp
index d05b848..156a834 100644
--- a/libs/binder/RpcSession.cpp
+++ b/libs/binder/RpcSession.cpp
@@ -379,7 +379,7 @@
// CHECK FOR DEDICATED CLIENT SOCKET
//
- // A server/looper should always use a dedicated session if available
+ // A server/looper should always use a dedicated connection if available
findConnection(tid, &exclusive, &available, mSession->mClientConnections,
mSession->mClientConnectionsOffset);
@@ -407,7 +407,7 @@
0 /* index hint */);
}
- // if our thread is already using a session, prioritize using that
+ // if our thread is already using a connection, prioritize using that
if (exclusive != nullptr) {
mConnection = exclusive;
mReentrant = true;
@@ -420,11 +420,10 @@
// in regular binder, this would usually be a deadlock :)
LOG_ALWAYS_FATAL_IF(mSession->mClientConnections.size() == 0,
- "Not a client of any session. You must create a session to an "
- "RPC server to make any non-nested (e.g. oneway or on another thread) "
- "calls.");
+ "Session has no client connections. This is required for an RPC server "
+ "to make any non-nested (e.g. oneway or on another thread) calls.");
- LOG_RPC_DETAIL("No available session (have %zu clients and %zu servers). Waiting...",
+ LOG_RPC_DETAIL("No available connections (have %zu clients and %zu servers). Waiting...",
mSession->mClientConnections.size(), mSession->mServerConnections.size());
mSession->mAvailableConnectionCv.wait(_l);
}
@@ -443,13 +442,13 @@
for (size_t i = 0; i < sockets.size(); i++) {
sp<RpcConnection>& socket = sockets[(i + socketsIndexHint) % sockets.size()];
- // take first available session (intuition = caching)
+ // take first available connection (intuition = caching)
if (available && *available == nullptr && socket->exclusiveTid == std::nullopt) {
*available = socket;
continue;
}
- // though, prefer to take session which is already inuse by this thread
+ // though, prefer to take connection which is already inuse by this thread
// (nested transactions)
if (exclusive && socket->exclusiveTid == tid) {
*exclusive = socket;
@@ -459,7 +458,7 @@
}
RpcSession::ExclusiveConnection::~ExclusiveConnection() {
- // reentrant use of a session means something less deep in the call stack
+ // reentrant use of a connection means something less deep in the call stack
// is using this fd, and it retains the right to it. So, we don't give up
// exclusive ownership, and no thread is freed.
if (!mReentrant) {
diff --git a/libs/binder/RpcState.cpp b/libs/binder/RpcState.cpp
index a801729..2cad2ae 100644
--- a/libs/binder/RpcState.cpp
+++ b/libs/binder/RpcState.cpp
@@ -221,8 +221,8 @@
if (sent < 0 || sent != static_cast<ssize_t>(size)) {
int savedErrno = errno;
- ALOGE("Failed to send %s (sent %zd of %zu bytes) on fd %d, error: %s", what, sent, size,
- fd.get(), strerror(savedErrno));
+ LOG_RPC_DETAIL("Failed to send %s (sent %zd of %zu bytes) on fd %d, error: %s", what, sent,
+ size, fd.get(), strerror(savedErrno));
terminate();
return -savedErrno;
@@ -241,10 +241,8 @@
if (status_t status = session->mShutdownTrigger->interruptableReadFully(fd.get(), data, size);
status != OK) {
- if (status != -ECANCELED) {
- ALOGE("Failed to read %s (%zu bytes) on fd %d, error: %s", what, size, fd.get(),
- statusToString(status).c_str());
- }
+ LOG_RPC_DETAIL("Failed to read %s (%zu bytes) on fd %d, error: %s", what, size, fd.get(),
+ statusToString(status).c_str());
return status;
}
diff --git a/libs/binder/tests/rpc_fuzzer/main.cpp b/libs/binder/tests/rpc_fuzzer/main.cpp
index e6fd392..072f8dd 100644
--- a/libs/binder/tests/rpc_fuzzer/main.cpp
+++ b/libs/binder/tests/rpc_fuzzer/main.cpp
@@ -71,43 +71,44 @@
CHECK_LT(kSock.size(), sizeof(addr.sun_path));
memcpy(&addr.sun_path, kSock.c_str(), kSock.size());
- base::unique_fd clientFd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)));
- CHECK_NE(clientFd.get(), -1);
- CHECK_EQ(0,
- TEMP_FAILURE_RETRY(
- connect(clientFd.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr))))
- << strerror(errno);
-
- // TODO(b/182938024): fuzz multiple sessions, instead of just one
-
-#if 0
- // make fuzzer more productive locally by forcing it to create a new session
- int32_t id = -1;
- CHECK(base::WriteFully(clientFd, &id, sizeof(id)));
-#endif
+ std::vector<base::unique_fd> connections;
bool hangupBeforeShutdown = provider.ConsumeBool();
- std::vector<uint8_t> writeData = provider.ConsumeRemainingBytes<uint8_t>();
- CHECK(base::WriteFully(clientFd, writeData.data(), writeData.size()));
+ while (provider.remaining_bytes() > 0) {
+ if (connections.empty() || provider.ConsumeBool()) {
+ base::unique_fd fd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0)));
+ CHECK_NE(fd.get(), -1);
+ CHECK_EQ(0,
+ TEMP_FAILURE_RETRY(
+ connect(fd.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr))))
+ << strerror(errno);
+ connections.push_back(std::move(fd));
+ } else {
+ size_t idx = provider.ConsumeIntegralInRange<size_t>(0, connections.size() - 1);
+
+ if (provider.ConsumeBool()) {
+ std::vector<uint8_t> writeData = provider.ConsumeBytes<uint8_t>(
+ provider.ConsumeIntegralInRange<size_t>(0, provider.remaining_bytes()));
+ CHECK(base::WriteFully(connections.at(idx).get(), writeData.data(),
+ writeData.size()));
+ } else {
+ connections.erase(connections.begin() + idx); // hang up
+ }
+ }
+ }
if (hangupBeforeShutdown) {
- clientFd.reset();
+ connections.clear();
+ while (!server->listSessions().empty() && server->numUninitializedSessions()) {
+ // wait for all threads to finish processing existing information
+ usleep(1);
+ }
}
- // TODO(185167543): currently this is okay because we only shutdown the one
- // thread, but once we can shutdown other sessions, we'll need to change
- // this behavior in order to make sure all of the input is actually read.
- while (!server->shutdown()) usleep(100);
-
- clientFd.reset();
+ while (!server->shutdown()) usleep(1);
serverThread.join();
- // TODO(b/185167543): better way to force a server to shutdown
- while (!server->listSessions().empty() && server->numUninitializedSessions()) {
- usleep(1);
- }
-
return 0;
}
diff --git a/libs/renderengine/include/renderengine/RenderEngine.h b/libs/renderengine/include/renderengine/RenderEngine.h
index ddaa7c7..d1bbcc5 100644
--- a/libs/renderengine/include/renderengine/RenderEngine.h
+++ b/libs/renderengine/include/renderengine/RenderEngine.h
@@ -43,6 +43,11 @@
*/
#define PROPERTY_DEBUG_RENDERENGINE_CAPTURE_SKIA_MS "debug.renderengine.capture_skia_ms"
+/**
+ * Set to the most recently saved file once the capture is finished.
+ */
+#define PROPERTY_DEBUG_RENDERENGINE_CAPTURE_FILENAME "debug.renderengine.capture_filename"
+
struct ANativeWindowBuffer;
namespace android {
diff --git a/libs/renderengine/skia/Cache.cpp b/libs/renderengine/skia/Cache.cpp
index 77e01f4..61c297c 100644
--- a/libs/renderengine/skia/Cache.cpp
+++ b/libs/renderengine/skia/Cache.cpp
@@ -37,6 +37,10 @@
0.f, 0.7f, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
67.3f, 52.2f, 0.f, 1.f);
+const auto kScaleAsymmetric = mat4(0.8f, 0.f, 0.f, 0.f,
+ 0.f, 1.1f, 0.f, 0.f,
+ 0.f, 0.f, 1.f, 0.f,
+ 0.f, 0.f, 0.f, 1.f);
// clang-format on
// When setting layer.sourceDataspace, whether it matches the destination or not determines whether
// a color correction effect is added to the shader.
@@ -77,12 +81,7 @@
// This matrix, which has different scales for x and y, will
// generate the slower (more general case) version, which has variants for translucent
// casters and rounded rects.
- // clang-format off
- layer.geometry.positionTransform = mat4(0.7f, 0.f, 0.f, 0.f,
- 0.f, 0.8f, 0.f, 0.f,
- 0.f, 0.f, 1.f, 0.f,
- 0.f, 0.f, 0.f, 1.f);
- // clang-format on
+ layer.geometry.positionTransform = kScaleAsymmetric;
for (auto translucent : {false, true}) {
layer.shadow.casterIsTranslucent = translucent;
renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,
@@ -150,7 +149,6 @@
PixelSource{
.solidColor = half3(0.1f, 0.2f, 0.3f),
},
- .alpha = 1,
};
auto layers = std::vector<const LayerSettings*>{&layer};
@@ -186,23 +184,26 @@
// The unique feature of these layers is that the boundary is slightly smaller than the rounded
// rect crop, so the rounded edges intersect that boundary and require a different clipping method.
+// For buffers, this is done with a stage that computes coverage and it will differ for round and
+// elliptical corners.
static void drawClippedLayers(SkiaRenderEngine* renderengine, const DisplaySettings& display,
const std::shared_ptr<ExternalTexture>& dstTexture,
const std::shared_ptr<ExternalTexture>& srcTexture) {
const Rect& displayRect = display.physicalDisplay;
FloatRect rect(0, 0, displayRect.width(), displayRect.height() - 20); // boundary is smaller
- // clang-format off
- const auto symmetric = mat4(0.9f, 0.f, 0.f, 0.f,
- 0.f, 0.9f, 0.f, 0.f,
- 0.f, 0.f, 1.f, 0.f,
- 8.8f, 8.1f, 0.f, 1.f);
- const auto asymmetric = mat4(0.9f, 0.f, 0.f, 0.f,
- 0.f, 0.7f, 0.f, 0.f,
- 0.f, 0.f, 1.f, 0.f,
- 8.8f, 8.1f, 0.f, 1.f);
+ PixelSource bufferSource{.buffer = Buffer{
+ .buffer = srcTexture,
+ .isOpaque = 0,
+ .maxLuminanceNits = 1000.f,
+ }};
+ PixelSource bufferOpaque{.buffer = Buffer{
+ .buffer = srcTexture,
+ .isOpaque = 1,
+ .maxLuminanceNits = 1000.f,
+ }};
+ PixelSource colorSource{.solidColor = half3(0.1f, 0.2f, 0.3f)};
- // clang-format on
LayerSettings layer{
.geometry =
Geometry{
@@ -211,23 +212,24 @@
.roundedCornersCrop =
FloatRect(0, 0, displayRect.width(), displayRect.height()),
},
- .source = PixelSource{.buffer =
- Buffer{
- .buffer = srcTexture,
- .isOpaque = 0,
- .maxLuminanceNits = 1000.f,
- }},
- .sourceDataspace = kOtherDataSpace,
};
auto layers = std::vector<const LayerSettings*>{&layer};
- for (auto transform : {symmetric, asymmetric}) {
- layer.geometry.positionTransform = transform;
- // In real use, I saw alpha of 1.0 and 0.999, probably a mistake, but cache both shaders.
- for (float alpha : {0.5f, 1.f}) {
- layer.alpha = alpha,
- renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,
- base::unique_fd(), nullptr);
+ for (auto pixelSource : {bufferSource, bufferOpaque, colorSource}) {
+ layer.source = pixelSource;
+ for (auto dataspace : {kDestDataSpace, kOtherDataSpace}) {
+ layer.sourceDataspace = dataspace;
+ // Produce a CircularRRect clip and an EllipticalRRect clip
+ for (auto transform : {kScaleAndTranslate, kScaleAsymmetric}) {
+ layer.geometry.positionTransform = transform;
+ // In real use, I saw alpha of 1.0 and 0.999, probably a mistake, but cache both
+ // shaders.
+ for (float alpha : {0.5f, 1.f}) {
+ layer.alpha = alpha,
+ renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,
+ base::unique_fd(), nullptr);
+ }
+ }
}
}
}
diff --git a/libs/renderengine/skia/debug/SkiaCapture.cpp b/libs/renderengine/skia/debug/SkiaCapture.cpp
index 40f5cf2..856fff4 100644
--- a/libs/renderengine/skia/debug/SkiaCapture.cpp
+++ b/libs/renderengine/skia/debug/SkiaCapture.cpp
@@ -34,7 +34,7 @@
namespace skia {
// The root of the filename to write a recorded SKP to. In order for this file to
-// be written to /data/user/, user must run 'adb shell setenforce 0' in the device.
+// be written to /data/user/, user must run 'adb shell setenforce 0' on the device.
static const std::string CAPTURED_FILENAME_BASE = "/data/user/re_skiacapture";
SkiaCapture::~SkiaCapture() {
@@ -152,11 +152,12 @@
// a smart pointer makes the lambda non-copyable. The lambda is only called
// once, so this is safe.
SkFILEWStream* stream = mOpenMultiPicStream.release();
- CommonPool::post([doc = std::move(mMultiPic), stream] {
+ CommonPool::post([doc = std::move(mMultiPic), stream, name = std::move(mCaptureFile)] {
ALOGD("Finalizing multi frame SKP");
doc->close();
delete stream;
- ALOGD("Multi frame SKP complete.");
+ ALOGD("Multi frame SKP saved to %s.", name.c_str());
+ base::SetProperty(PROPERTY_DEBUG_RENDERENGINE_CAPTURE_FILENAME, name);
});
mCaptureRunning = false;
}
@@ -164,12 +165,14 @@
bool SkiaCapture::setupMultiFrameCapture() {
ATRACE_CALL();
ALOGD("Set up multi-frame capture, ms = %llu", mTimerInterval.count());
+ base::SetProperty(PROPERTY_DEBUG_RENDERENGINE_CAPTURE_FILENAME, "");
+ const std::scoped_lock lock(mMutex);
- std::string captureFile;
// Attach a timestamp to the file.
- base::StringAppendF(&captureFile, "%s_%lld.mskp", CAPTURED_FILENAME_BASE.c_str(),
+ mCaptureFile.clear();
+ base::StringAppendF(&mCaptureFile, "%s_%lld.mskp", CAPTURED_FILENAME_BASE.c_str(),
std::chrono::steady_clock::now().time_since_epoch().count());
- auto stream = std::make_unique<SkFILEWStream>(captureFile.c_str());
+ auto stream = std::make_unique<SkFILEWStream>(mCaptureFile.c_str());
// We own this stream and need to hold it until close() finishes.
if (stream->isValid()) {
mOpenMultiPicStream = std::move(stream);
@@ -194,7 +197,7 @@
mCaptureRunning = true;
return true;
} else {
- ALOGE("Could not open \"%s\" for writing.", captureFile.c_str());
+ ALOGE("Could not open \"%s\" for writing.", mCaptureFile.c_str());
return false;
}
}
diff --git a/libs/renderengine/skia/debug/SkiaCapture.h b/libs/renderengine/skia/debug/SkiaCapture.h
index 5e18e60..f194629 100644
--- a/libs/renderengine/skia/debug/SkiaCapture.h
+++ b/libs/renderengine/skia/debug/SkiaCapture.h
@@ -85,6 +85,8 @@
// Mutex to ensure that a frame in progress when the timer fires is allowed to run to
// completion before we write the file to disk.
std::mutex mMutex;
+
+ std::string mCaptureFile;
};
} // namespace skia
diff --git a/libs/renderengine/skia/debug/record.sh b/libs/renderengine/skia/debug/record.sh
index 25c8cef..e99b7ae 100755
--- a/libs/renderengine/skia/debug/record.sh
+++ b/libs/renderengine/skia/debug/record.sh
@@ -16,14 +16,22 @@
# first time use requires these changes
adb root
adb shell setenforce 0
- adb shell setprop debug.renderengine.backend "skiagl"
+ adb shell setprop debug.renderengine.backend "skiaglthreaded"
adb shell stop
adb shell start
exit 1;
fi
-# name of the newest file in /data/user/ before starting
-oldname=$(adb shell ls -cr /data/user/ | head -n 1)
+check_permission() {
+ adb shell getenforce
+}
+
+mode=$(check_permission)
+
+if [ "$mode" != "Permissive" ]; then
+ echo "Cannot write to disk from RenderEngine. run 'record.sh rootandsetup'"
+ exit 5
+fi
# record frames for some number of milliseconds.
adb shell setprop debug.renderengine.capture_skia_ms $1
@@ -38,26 +46,6 @@
# the process it is recording.
# /data/user/re_skiacapture_56204430551705.mskp
-# list the files here from newest to oldest, keep only the name of the newest.
-name=$(adb shell ls -cr /data/user/ | head -n 1)
-remote_path=/data/user/$name
-
-if [[ $oldname = $name ]]; then
- echo "No new file written, probably no RenderEngine activity during recording period."
- exit 1
-fi
-
-# return the size of a file in bytes
-adb_filesize() {
- adb shell "wc -c \"$1\"" 2> /dev/null | awk '{print $1}'
-}
-
-mskp_size=$(adb_filesize "/data/user/$name")
-if [[ $mskp_size = "0" ]]; then
- echo "File opened, but remains empty after recording period + wait. Either there was no RenderEngine activity during recording period, or recording process is still working. Check /data/user/$name manually later."
- exit 1
-fi
-
spin() {
case "$spin" in
1) printf '\b|';;
@@ -69,38 +57,28 @@
sleep $1
}
-printf "MSKP captured, Waiting for file serialization to finish.\n"
+local_path=~/Downloads/
-local_path=~/Downloads/$name
+get_filename() {
+ adb shell getprop debug.renderengine.capture_filename
+}
-# wait for the file size to stop changing
-
-timeout=$(( $(date +%s) + 300))
-last_size='0' # output of last size check command
-unstable=true # false once the file size stops changing
-counter=0 # used to perform size check only 1/sec though we update spinner 20/sec
-# loop until the file size is unchanged for 1 second.
-while [ $unstable != 0 ] ; do
+remote_path=""
+counter=0 # used to check only 1/sec though we update spinner 20/sec
+while [ -z $remote_path ] ; do
spin 0.05
counter=$(( $counter+1 ))
if ! (( $counter % 20)) ; then
- new_size=$(adb_filesize "$remote_path")
- unstable=$(($new_size != $last_size))
- last_size=$new_size
- fi
- if [ $(date +%s) -gt $timeout ] ; then
- printf '\bTimed out.\n'
- exit 3
+ remote_path=$(get_filename)
fi
done
printf '\b'
-printf "MSKP file serialized: %s\n" $(echo $last_size | numfmt --to=iec)
+printf "MSKP file serialized to: $remote_path\n"
-adb pull "$remote_path" "$local_path"
-if ! [ -f "$local_path" ] ; then
- printf "something went wrong with `adb pull`."
- exit 4
-fi
+adb_pull_cmd="adb pull $remote_path $local_path"
+echo $adb_pull_cmd
+$adb_pull_cmd
+
adb shell rm "$remote_path"
-printf 'SKP saved to %s\n\n' "$local_path"
\ No newline at end of file
+printf 'SKP saved to %s\n\n' "$local_path"
diff --git a/services/sensorservice/SensorInterface.cpp b/services/sensorservice/SensorInterface.cpp
index 73a6db5..560834f 100644
--- a/services/sensorservice/SensorInterface.cpp
+++ b/services/sensorservice/SensorInterface.cpp
@@ -17,6 +17,7 @@
#include "SensorInterface.h"
#include "SensorDevice.h"
#include "SensorFusion.h"
+#include "SensorService.h"
#include <stdint.h>
#include <sys/types.h>
@@ -85,4 +86,35 @@
}
// ---------------------------------------------------------------------------
+
+ProximitySensor::ProximitySensor(const sensor_t& sensor, SensorService& service)
+ : HardwareSensor(sensor), mSensorService(service) {
+}
+
+status_t ProximitySensor::activate(void* ident, bool enabled) {
+ bool wasActive = mActive;
+ status_t status = HardwareSensor::activate(ident, enabled);
+ if (status != NO_ERROR) {
+ return status;
+ }
+ mActive = enabled;
+ if (wasActive != enabled) {
+ mSensorService.onProximityActiveLocked(enabled);
+ }
+ return NO_ERROR;
+}
+
+void ProximitySensor::willDisableAllSensors() {
+ if (mSensorDevice.isSensorActive(mSensor.getHandle())) {
+ mSensorService.onProximityActiveLocked(false);
+ }
+}
+
+void ProximitySensor::didEnableAllSensors() {
+ if (mSensorDevice.isSensorActive(mSensor.getHandle())) {
+ mSensorService.onProximityActiveLocked(true);
+ }
+}
+
+// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/sensorservice/SensorInterface.h b/services/sensorservice/SensorInterface.h
index b5375cb..ea181c9 100644
--- a/services/sensorservice/SensorInterface.h
+++ b/services/sensorservice/SensorInterface.h
@@ -26,6 +26,7 @@
// ---------------------------------------------------------------------------
class SensorDevice;
class SensorFusion;
+class SensorService;
class SensorInterface : public VirtualLightRefBase {
public:
@@ -43,6 +44,9 @@
virtual const Sensor& getSensor() const = 0;
virtual bool isVirtual() const = 0;
virtual void autoDisable(void* /*ident*/, int /*handle*/) = 0;
+
+ virtual void willDisableAllSensors() = 0;
+ virtual void didEnableAllSensors() = 0;
};
class BaseSensor : public SensorInterface {
@@ -65,6 +69,9 @@
virtual const Sensor& getSensor() const override { return mSensor; }
virtual void autoDisable(void* /*ident*/, int /*handle*/) override { }
+
+ virtual void willDisableAllSensors() override { }
+ virtual void didEnableAllSensors() override { }
protected:
SensorDevice& mSensorDevice;
Sensor mSensor;
@@ -100,6 +107,20 @@
SensorFusion& mSensorFusion;
};
+// ---------------------------------------------------------------------------
+
+class ProximitySensor : public HardwareSensor {
+public:
+ explicit ProximitySensor(const sensor_t& sensor, SensorService& service);
+
+ status_t activate(void* ident, bool enabled) override;
+
+ void willDisableAllSensors() override;
+ void didEnableAllSensors() override;
+private:
+ SensorService& mSensorService;
+ bool mActive;
+};
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/sensorservice/SensorList.h b/services/sensorservice/SensorList.h
index 617ceef..049ae7c 100644
--- a/services/sensorservice/SensorList.h
+++ b/services/sensorservice/SensorList.h
@@ -36,6 +36,15 @@
class SensorList : public Dumpable {
public:
+ struct Entry {
+ sp<SensorInterface> si;
+ const bool isForDebug;
+ const bool isVirtual;
+ Entry(SensorInterface* si_, bool debug_, bool virtual_) :
+ si(si_), isForDebug(debug_), isVirtual(virtual_) {
+ }
+ };
+
// After SensorInterface * is added into SensorList, it can be assumed that SensorList own the
// object it pointed to and the object should not be released elsewhere.
bool add(int handle, SensorInterface* si, bool isForDebug = false, bool isVirtual = false);
@@ -69,25 +78,6 @@
template <typename TF>
void forEachSensor(const TF& f) const;
- const Sensor& getNonSensor() const { return mNonSensor;}
-
- // Dumpable interface
- virtual std::string dump() const override;
- virtual void dump(util::ProtoOutputStream* proto) const override;
-
- virtual ~SensorList();
-private:
- struct Entry {
- sp<SensorInterface> si;
- const bool isForDebug;
- const bool isVirtual;
- Entry(SensorInterface* si_, bool debug_, bool virtual_) :
- si(si_), isForDebug(debug_), isVirtual(virtual_) {
- }
- };
-
- const static Sensor mNonSensor; //.getName() == "unknown",
-
// Iterate through Entry in sensor list and perform operation f on each Entry.
//
// TF is a function with the signature:
@@ -99,6 +89,16 @@
template <typename TF>
void forEachEntry(const TF& f) const;
+ const Sensor& getNonSensor() const { return mNonSensor;}
+
+ // Dumpable interface
+ virtual std::string dump() const override;
+ virtual void dump(util::ProtoOutputStream* proto) const override;
+
+ virtual ~SensorList();
+private:
+ const static Sensor mNonSensor; //.getName() == "unknown",
+
template <typename T, typename TF>
T getOne(int handle, const TF& accessor, T def = T()) const;
diff --git a/services/sensorservice/SensorService.cpp b/services/sensorservice/SensorService.cpp
index f949196..9df020d 100644
--- a/services/sensorservice/SensorService.cpp
+++ b/services/sensorservice/SensorService.cpp
@@ -51,7 +51,6 @@
#include "SensorRecord.h"
#include "SensorRegistrationInfo.h"
-#include <ctime>
#include <inttypes.h>
#include <math.h>
#include <sched.h>
@@ -61,8 +60,13 @@
#include <sys/types.h>
#include <unistd.h>
+#include <ctime>
+#include <future>
+
#include <private/android_filesystem_config.h>
+using namespace std::chrono_literals;
+
namespace android {
// ---------------------------------------------------------------------------
@@ -83,6 +87,8 @@
String16 SensorService::sSensorInterfaceDescriptorPrefix =
String16("android.frameworks.sensorservice@");
AppOpsManager SensorService::sAppOpsManager;
+std::atomic_uint64_t SensorService::curProxCallbackSeq(0);
+std::atomic_uint64_t SensorService::completedCallbackSeq(0);
#define SENSOR_SERVICE_DIR "/data/system/sensor_service"
#define SENSOR_SERVICE_HMAC_KEY_FILE SENSOR_SERVICE_DIR "/hmac_key"
@@ -97,7 +103,7 @@
SensorService::SensorService()
: mInitCheck(NO_INIT), mSocketBufferSize(SOCKET_BUFFER_SIZE_NON_BATCHED),
- mWakeLockAcquired(false) {
+ mWakeLockAcquired(false), mProximityActiveCount(0) {
mUidPolicy = new UidPolicy(this);
mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
}
@@ -168,7 +174,7 @@
(1<<SENSOR_TYPE_GAME_ROTATION_VECTOR);
for (ssize_t i=0 ; i<count ; i++) {
- bool useThisSensor=true;
+ bool useThisSensor = true;
switch (list[i].type) {
case SENSOR_TYPE_ACCELEROMETER:
@@ -197,7 +203,11 @@
break;
}
if (useThisSensor) {
- registerSensor( new HardwareSensor(list[i]) );
+ if (list[i].type == SENSOR_TYPE_PROXIMITY) {
+ registerSensor(new ProximitySensor(list[i], *this));
+ } else {
+ registerSensor( new HardwareSensor(list[i]) );
+ }
}
}
@@ -670,6 +680,10 @@
bool hasAccess = hasSensorAccessLocked(conn->getUid(), conn->getOpPackageName());
conn->onSensorAccessChanged(hasAccess);
}
+ mSensors.forEachEntry([](const SensorServiceUtil::SensorList::Entry& e) {
+ e.si->willDisableAllSensors();
+ return true;
+ });
dev.disableAllSensors();
// Clear all pending flush connections for all active sensors. If one of the active
// connections has called flush() and the underlying sensor has been disabled before a
@@ -695,6 +709,10 @@
}
SensorDevice& dev(SensorDevice::getInstance());
dev.enableAllSensors();
+ mSensors.forEachEntry([](const SensorServiceUtil::SensorList::Entry& e) {
+ e.si->didEnableAllSensors();
+ return true;
+ });
for (const sp<SensorDirectConnection>& conn : connLock->getDirectConnections()) {
bool hasAccess = hasSensorAccessLocked(conn->getUid(), conn->getOpPackageName());
conn->onSensorAccessChanged(hasAccess);
@@ -1520,6 +1538,10 @@
if (err == NO_ERROR) {
mCurrentOperatingMode = NORMAL;
dev.enableAllSensors();
+ mSensors.forEachEntry([](const SensorServiceUtil::SensorList::Entry& e) {
+ e.si->didEnableAllSensors();
+ return true;
+ });
}
return err;
}
@@ -1584,6 +1606,80 @@
mConnectionHolder.removeDirectConnection(c);
}
+void SensorService::onProximityActiveLocked(bool isActive) {
+ int prevCount = mProximityActiveCount;
+ bool activeStateChanged = false;
+ if (isActive) {
+ mProximityActiveCount++;
+ activeStateChanged = prevCount == 0;
+ } else {
+ mProximityActiveCount--;
+ if (mProximityActiveCount < 0) {
+ ALOGE("Proximity active count is negative (%d)!", mProximityActiveCount);
+ }
+ activeStateChanged = prevCount > 0 && mProximityActiveCount <= 0;
+ }
+
+ if (activeStateChanged) {
+ notifyProximityStateLocked(mProximityActiveListeners);
+ }
+}
+
+void SensorService::notifyProximityStateLocked(
+ const std::vector<sp<ProximityActiveListener>>& listnrs) {
+ std::async(
+ std::launch::async,
+ [](uint64_t mySeq, bool isActive, std::vector<sp<ProximityActiveListener>> listeners) {
+ while (completedCallbackSeq.load() != mySeq - 1)
+ std::this_thread::sleep_for(1ms);
+ for (auto& listener : listeners)
+ listener->onProximityActive(isActive);
+ completedCallbackSeq++;
+ },
+ ++curProxCallbackSeq, mProximityActiveCount > 0,
+ listnrs /* (this is meant to be a copy) */
+ );
+}
+
+status_t SensorService::addProximityActiveListener(const sp<ProximityActiveListener>& callback) {
+ if (callback == nullptr) {
+ return BAD_VALUE;
+ }
+
+ Mutex::Autolock _l(mLock);
+
+ // Check if the callback was already added.
+ for (const auto& cb : mProximityActiveListeners) {
+ if (cb == callback) {
+ return ALREADY_EXISTS;
+ }
+ }
+
+ mProximityActiveListeners.push_back(callback);
+ std::vector<sp<ProximityActiveListener>> listener(1, callback);
+ notifyProximityStateLocked(listener);
+ return OK;
+}
+
+status_t SensorService::removeProximityActiveListener(
+ const sp<ProximityActiveListener>& callback) {
+ if (callback == nullptr) {
+ return BAD_VALUE;
+ }
+
+ Mutex::Autolock _l(mLock);
+
+ for (auto iter = mProximityActiveListeners.begin();
+ iter != mProximityActiveListeners.end();
+ ++iter) {
+ if (*iter == callback) {
+ mProximityActiveListeners.erase(iter);
+ return OK;
+ }
+ }
+ return NAME_NOT_FOUND;
+}
+
sp<SensorInterface> SensorService::getSensorInterfaceFromHandle(int handle) const {
return mSensors.getInterface(handle);
}
diff --git a/services/sensorservice/SensorService.h b/services/sensorservice/SensorService.h
index a563a60..def6611 100644
--- a/services/sensorservice/SensorService.h
+++ b/services/sensorservice/SensorService.h
@@ -89,9 +89,23 @@
UID_STATE_IDLE,
};
+ class ProximityActiveListener : public virtual RefBase {
+ public:
+ // Note that the callback is invoked from an async thread and can interact with the
+ // SensorService directly.
+ virtual void onProximityActive(bool isActive) = 0;
+ };
+
+ static char const* getServiceName() ANDROID_API { return "sensorservice"; }
+ SensorService() ANDROID_API;
+
void cleanupConnection(SensorEventConnection* connection);
void cleanupConnection(SensorDirectConnection* c);
+ // Call with mLock held.
+ void onProximityActiveLocked(bool isActive);
+ void notifyProximityStateLocked(const std::vector<sp<ProximityActiveListener>>& listeners);
+
status_t enable(const sp<SensorEventConnection>& connection, int handle,
nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags,
const String16& opPackageName);
@@ -104,6 +118,9 @@
status_t flushSensor(const sp<SensorEventConnection>& connection,
const String16& opPackageName);
+ status_t addProximityActiveListener(const sp<ProximityActiveListener>& callback) ANDROID_API;
+ status_t removeProximityActiveListener(const sp<ProximityActiveListener>& callback) ANDROID_API;
+
// Returns true if a sensor should be throttled according to our rate-throttling rules.
static bool isSensorInCappedSet(int sensorType);
@@ -305,8 +322,6 @@
};
static const char* WAKE_LOCK_NAME;
- static char const* getServiceName() ANDROID_API { return "sensorservice"; }
- SensorService() ANDROID_API;
virtual ~SensorService();
virtual void onFirstRef();
@@ -326,6 +341,7 @@
virtual int setOperationParameter(
int32_t handle, int32_t type, const Vector<float> &floats, const Vector<int32_t> &ints);
virtual status_t dump(int fd, const Vector<String16>& args);
+
status_t dumpProtoLocked(int fd, ConnectionSafeAutolock* connLock) const;
String8 getSensorName(int handle) const;
String8 getSensorStringType(int handle) const;
@@ -433,6 +449,9 @@
static uint8_t sHmacGlobalKey[128];
static bool sHmacGlobalKeyIsValid;
+ static std::atomic_uint64_t curProxCallbackSeq;
+ static std::atomic_uint64_t completedCallbackSeq;
+
SensorServiceUtil::SensorList mSensors;
status_t mInitCheck;
@@ -476,6 +495,10 @@
std::map<userid_t, sp<SensorPrivacyPolicy>> mMicSensorPrivacyPolicies;
// Checks if the mic sensor privacy is enabled for the uid
bool isMicSensorPrivacyEnabledForUid(uid_t uid);
+
+ // Counts how many proximity sensors are currently active.
+ int mProximityActiveCount;
+ std::vector<sp<ProximityActiveListener>> mProximityActiveListeners;
};
} // namespace android