Camera: Initial offline session client

Test: N/A, no implementation yet
Bug: 135142453
Change-Id: I08fecba80ab88a8b70fe71fdd4b660d49e40324c
gugelfrei
Emilian Peev 5 years ago committed by Yin-Chia Yeh
parent 5fd603ea87
commit b2bc5a46ef

@ -189,5 +189,5 @@ interface ICameraDeviceUser
* @return Offline session object. * @return Offline session object.
*/ */
ICameraOfflineSession switchToOffline(in ICameraDeviceCallbacks callbacks, ICameraOfflineSession switchToOffline(in ICameraDeviceCallbacks callbacks,
in Surface[] offlineOutputs); in int[] offlineOutputIds);
} }

@ -41,6 +41,7 @@ cc_library_shared {
"api1/client2/CaptureSequencer.cpp", "api1/client2/CaptureSequencer.cpp",
"api1/client2/ZslProcessor.cpp", "api1/client2/ZslProcessor.cpp",
"api2/CameraDeviceClient.cpp", "api2/CameraDeviceClient.cpp",
"api2/CameraOfflineSessionClient.cpp",
"api2/CompositeStream.cpp", "api2/CompositeStream.cpp",
"api2/DepthCompositeStream.cpp", "api2/DepthCompositeStream.cpp",
"api2/HeicEncoderInfoManager.cpp", "api2/HeicEncoderInfoManager.cpp",

@ -128,6 +128,7 @@ static const String16
static constexpr int32_t kVendorClientScore = 200; static constexpr int32_t kVendorClientScore = 200;
// Matches with PROCESS_STATE_PERSISTENT_UI in ActivityManager.java // Matches with PROCESS_STATE_PERSISTENT_UI in ActivityManager.java
static constexpr int32_t kVendorClientState = 1; static constexpr int32_t kVendorClientState = 1;
const String8 CameraService::kOfflineDevice("offline-");
Mutex CameraService::sProxyMutex; Mutex CameraService::sProxyMutex;
sp<hardware::ICameraServiceProxy> CameraService::sCameraServiceProxy; sp<hardware::ICameraServiceProxy> CameraService::sCameraServiceProxy;
@ -394,7 +395,7 @@ void CameraService::onDeviceStatusChanged(const String8& id,
// to this device until the status changes // to this device until the status changes
updateStatus(StatusInternal::NOT_PRESENT, id); updateStatus(StatusInternal::NOT_PRESENT, id);
sp<BasicClient> clientToDisconnect; sp<BasicClient> clientToDisconnectOnline, clientToDisconnectOffline;
{ {
// Don't do this in updateStatus to avoid deadlock over mServiceLock // Don't do this in updateStatus to avoid deadlock over mServiceLock
Mutex::Autolock lock(mServiceLock); Mutex::Autolock lock(mServiceLock);
@ -402,23 +403,14 @@ void CameraService::onDeviceStatusChanged(const String8& id,
// Remove cached shim parameters // Remove cached shim parameters
state->setShimParams(CameraParameters()); state->setShimParams(CameraParameters());
// Remove the client from the list of active clients, if there is one // Remove online as well as offline client from the list of active clients,
clientToDisconnect = removeClientLocked(id); // if they are present
clientToDisconnectOnline = removeClientLocked(id);
clientToDisconnectOffline = removeClientLocked(kOfflineDevice + id);
} }
// Disconnect client disconnectClient(id, clientToDisconnectOnline);
if (clientToDisconnect.get() != nullptr) { disconnectClient(kOfflineDevice + id, clientToDisconnectOffline);
ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
__FUNCTION__, id.string());
// Notify the client of disconnection
clientToDisconnect->notifyError(
hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
CaptureResultExtras{});
// Ensure not in binder RPC so client disconnect PID checks work correctly
LOG_ALWAYS_FATAL_IF(CameraThreadState::getCallingPid() != getpid(),
"onDeviceStatusChanged must be called from the camera service process!");
clientToDisconnect->disconnect();
}
removeStates(id); removeStates(id);
} else { } else {
@ -431,6 +423,21 @@ void CameraService::onDeviceStatusChanged(const String8& id,
} }
void CameraService::disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect) {
if (clientToDisconnect.get() != nullptr) {
ALOGI("%s: Client for camera ID %s evicted due to device status change from HAL",
__FUNCTION__, id.string());
// Notify the client of disconnection
clientToDisconnect->notifyError(
hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DISCONNECTED,
CaptureResultExtras{});
// Ensure not in binder RPC so client disconnect PID checks work correctly
LOG_ALWAYS_FATAL_IF(CameraThreadState::getCallingPid() != getpid(),
"onDeviceStatusChanged must be called from the camera service process!");
clientToDisconnect->disconnect();
}
}
void CameraService::onTorchStatusChanged(const String8& cameraId, void CameraService::onTorchStatusChanged(const String8& cameraId,
TorchModeStatus newStatus) { TorchModeStatus newStatus) {
Mutex::Autolock al(mTorchStatusMutex); Mutex::Autolock al(mTorchStatusMutex);
@ -1696,6 +1703,77 @@ Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8&
return ret; return ret;
} }
status_t CameraService::addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient) {
if (offlineClient.get() == nullptr) {
return BAD_VALUE;
}
{
// Acquire mServiceLock and prevent other clients from connecting
std::unique_ptr<AutoConditionLock> lock =
AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
if (lock == nullptr) {
ALOGE("%s: (PID %d) rejected (too many other clients connecting)."
, __FUNCTION__, offlineClient->getClientPid());
return TIMED_OUT;
}
auto onlineClientDesc = mActiveClientManager.get(cameraId);
if (onlineClientDesc.get() == nullptr) {
ALOGE("%s: No active online client using camera id: %s", __FUNCTION__,
cameraId.c_str());
return BAD_VALUE;
}
// Offline clients do not evict or conflict with other online devices. Resource sharing
// conflicts are handled by the camera provider which will either succeed or fail before
// reaching this method.
const auto& onlinePriority = onlineClientDesc->getPriority();
auto offlineClientDesc = CameraClientManager::makeClientDescriptor(
kOfflineDevice + onlineClientDesc->getKey(), offlineClient, /*cost*/ 0,
/*conflictingKeys*/ std::set<String8>(), onlinePriority.getScore(),
onlineClientDesc->getOwnerId(), onlinePriority.getState());
// Allow only one offline device per camera
auto incompatibleClients = mActiveClientManager.getIncompatibleClients(offlineClientDesc);
if (!incompatibleClients.empty()) {
ALOGE("%s: Incompatible offline clients present!", __FUNCTION__);
return BAD_VALUE;
}
auto err = offlineClient->initialize(mCameraProviderManager, mMonitorTags);
if (err != OK) {
ALOGE("%s: Could not initialize offline client.", __FUNCTION__);
return err;
}
auto evicted = mActiveClientManager.addAndEvict(offlineClientDesc);
if (evicted.size() > 0) {
for (auto& i : evicted) {
ALOGE("%s: Invalid state: Offline client for camera %s was not removed ",
__FUNCTION__, i->getKey().string());
}
LOG_ALWAYS_FATAL("%s: Invalid state for CameraService, offline clients not evicted "
"properly", __FUNCTION__);
return BAD_VALUE;
}
logConnectedOffline(offlineClientDesc->getKey(),
static_cast<int>(offlineClientDesc->getOwnerId()),
String8(offlineClient->getPackageName()));
sp<IBinder> remoteCallback = offlineClient->getRemote();
if (remoteCallback != nullptr) {
remoteCallback->linkToDeath(this);
}
} // lock is destroyed, allow further connect calls
return OK;
}
Status CameraService::setTorchMode(const String16& cameraId, bool enabled, Status CameraService::setTorchMode(const String16& cameraId, bool enabled,
const sp<IBinder>& clientBinder) { const sp<IBinder>& clientBinder) {
Mutex::Autolock lock(mServiceLock); Mutex::Autolock lock(mServiceLock);
@ -2300,6 +2378,13 @@ void CameraService::logDisconnected(const char* cameraId, int clientPid,
clientPackage, clientPid)); clientPackage, clientPid));
} }
void CameraService::logDisconnectedOffline(const char* cameraId, int clientPid,
const char* clientPackage) {
// Log the clients evicted
logEvent(String8::format("DISCONNECT offline device %s client for package %s (PID %d)",
cameraId, clientPackage, clientPid));
}
void CameraService::logConnected(const char* cameraId, int clientPid, void CameraService::logConnected(const char* cameraId, int clientPid,
const char* clientPackage) { const char* clientPackage) {
// Log the clients evicted // Log the clients evicted
@ -2307,6 +2392,13 @@ void CameraService::logConnected(const char* cameraId, int clientPid,
clientPackage, clientPid)); clientPackage, clientPid));
} }
void CameraService::logConnectedOffline(const char* cameraId, int clientPid,
const char* clientPackage) {
// Log the clients evicted
logEvent(String8::format("CONNECT offline device %s client for package %s (PID %d)", cameraId,
clientPackage, clientPid));
}
void CameraService::logRejected(const char* cameraId, int clientPid, void CameraService::logRejected(const char* cameraId, int clientPid,
const char* clientPackage, const char* reason) { const char* clientPackage, const char* reason) {
// Log the client rejected // Log the client rejected
@ -2744,6 +2836,7 @@ void CameraService::BasicClient::opChanged(int32_t op, const String16&) {
if (mAppOpsManager == nullptr) { if (mAppOpsManager == nullptr) {
return; return;
} }
// TODO : add offline camera session case
if (op != AppOpsManager::OP_CAMERA) { if (op != AppOpsManager::OP_CAMERA) {
ALOGW("Unexpected app ops notification received: %d", op); ALOGW("Unexpected app ops notification received: %d", op);
return; return;
@ -2778,20 +2871,6 @@ void CameraService::BasicClient::block() {
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
sp<CameraService> CameraService::OfflineClient::sCameraService;
status_t CameraService::OfflineClient::startCameraOps() {
// TODO
return OK;
}
status_t CameraService::OfflineClient::finishCameraOps() {
// TODO
return OK;
}
// ----------------------------------------------------------------------------
void CameraService::Client::notifyError(int32_t errorCode, void CameraService::Client::notifyError(int32_t errorCode,
const CaptureResultExtras& resultExtras) { const CaptureResultExtras& resultExtras) {
(void) resultExtras; (void) resultExtras;

@ -68,6 +68,7 @@ class CameraService :
{ {
friend class BinderService<CameraService>; friend class BinderService<CameraService>;
friend class CameraClient; friend class CameraClient;
friend class CameraOfflineSessionClient;
public: public:
class Client; class Client;
class BasicClient; class BasicClient;
@ -185,6 +186,9 @@ public:
// Monitored UIDs availability notification // Monitored UIDs availability notification
void notifyMonitoredUids(); void notifyMonitoredUids();
// Register an offline client for a given active camera id
status_t addOfflineClient(String8 cameraId, sp<BasicClient> offlineClient);
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// Client functionality // Client functionality
@ -310,10 +314,9 @@ public:
sp<IBinder> mRemoteBinder; // immutable after constructor sp<IBinder> mRemoteBinder; // immutable after constructor
// permissions management // permissions management
status_t startCameraOps(); virtual status_t startCameraOps();
status_t finishCameraOps(); virtual status_t finishCameraOps();
private:
std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr; std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr;
class OpsCallback : public BnAppOpsCallback { class OpsCallback : public BnAppOpsCallback {
@ -402,87 +405,6 @@ public:
int mCameraId; // All API1 clients use integer camera IDs int mCameraId; // All API1 clients use integer camera IDs
}; // class Client }; // class Client
// Client for offline session. Note that offline session client does not affect camera service's
// client arbitration logic. It is camera HAL's decision to decide whether a normal camera
// client is conflicting with existing offline client(s).
// The other distinctive difference between offline clients and normal clients is that normal
// clients are created through ICameraService binder calls, while the offline session client
// is created through ICameraDeviceUser::switchToOffline call.
class OfflineClient : public virtual RefBase {
virtual status_t dump(int fd, const Vector<String16>& args) = 0;
// Block the client form using the camera
virtual void block() = 0;
// Return the package name for this client
virtual String16 getPackageName() const = 0;
// Notify client about a fatal error
// TODO: maybe let impl notify within block?
virtual void notifyError(int32_t errorCode,
const CaptureResultExtras& resultExtras) = 0;
// Get the UID of the application client using this
virtual uid_t getClientUid() const = 0;
// Get the PID of the application client using this
virtual int getClientPid() const = 0;
protected:
OfflineClient(const sp<CameraService>& cameraService,
const String16& clientPackageName,
const String8& cameraIdStr,
int clientPid,
uid_t clientUid,
int servicePid): mCameraIdStr(cameraIdStr),
mClientPackageName(clientPackageName), mClientPid(clientPid),
mClientUid(clientUid), mServicePid(servicePid) {
if (sCameraService == nullptr) {
sCameraService = cameraService;
}
}
virtual ~OfflineClient() { /*TODO*/ }
// these are initialized in the constructor.
static sp<CameraService> sCameraService;
const String8 mCameraIdStr;
String16 mClientPackageName;
pid_t mClientPid;
const uid_t mClientUid;
const pid_t mServicePid;
bool mDisconnected;
// - The app-side Binder interface to receive callbacks from us
sp<IBinder> mRemoteBinder; // immutable after constructor
// permissions management
status_t startCameraOps();
status_t finishCameraOps();
private:
std::unique_ptr<AppOpsManager> mAppOpsManager = nullptr;
class OpsCallback : public BnAppOpsCallback {
public:
explicit OpsCallback(wp<OfflineClient> client) : mClient(client) {}
virtual void opChanged(int32_t /*op*/, const String16& /*packageName*/) {
//TODO
}
private:
wp<OfflineClient> mClient;
}; // class OpsCallback
sp<OpsCallback> mOpsCallback;
// IAppOpsCallback interface, indirected through opListener
// virtual void opChanged(int32_t op, const String16& packageName);
}; // class OfflineClient
/** /**
* A listener class that implements the LISTENER interface for use with a ClientManager, and * A listener class that implements the LISTENER interface for use with a ClientManager, and
* implements the following methods: * implements the following methods:
@ -871,6 +793,17 @@ private:
*/ */
void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage); void logDisconnected(const char* cameraId, int clientPid, const char* clientPackage);
/**
* Add an event log message that a client has been disconnected from offline device.
*/
void logDisconnectedOffline(const char* cameraId, int clientPid, const char* clientPackage);
/**
* Add an event log message that an offline client has been connected.
*/
void logConnectedOffline(const char* cameraId, int clientPid,
const char* clientPackage);
/** /**
* Add an event log message that a client has been connected. * Add an event log message that a client has been connected.
*/ */
@ -1095,6 +1028,12 @@ private:
void broadcastTorchModeStatus(const String8& cameraId, void broadcastTorchModeStatus(const String8& cameraId,
hardware::camera::common::V1_0::TorchModeStatus status); hardware::camera::common::V1_0::TorchModeStatus status);
void disconnectClient(const String8& id, sp<BasicClient> clientToDisconnect);
// Regular online and offline devices must not be in conflict at camera service layer.
// Use separate keys for offline devices.
static const String8 kOfflineDevice;
// TODO: right now each BasicClient holds one AppOpsManager instance. // TODO: right now each BasicClient holds one AppOpsManager instance.
// We can refactor the code so all of clients share this instance // We can refactor the code so all of clients share this instance
AppOpsManager mAppOps; AppOpsManager mAppOps;

@ -1903,7 +1903,7 @@ binder::Status CameraDeviceClient::getGlobalAudioRestriction(/*out*/ int32_t* ou
binder::Status CameraDeviceClient::switchToOffline( binder::Status CameraDeviceClient::switchToOffline(
const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
const std::vector<view::Surface>& offlineOutputs, const std::vector<int>& offlineOutputIds,
/*out*/ /*out*/
sp<hardware::camera2::ICameraOfflineSession>* session) { sp<hardware::camera2::ICameraOfflineSession>* session) {
ATRACE_CALL(); ATRACE_CALL();
@ -1917,7 +1917,7 @@ binder::Status CameraDeviceClient::switchToOffline(
return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive");
} }
if (offlineOutputs.empty()) { if (offlineOutputIds.empty()) {
String8 msg = String8::format("Offline outputs must not be empty"); String8 msg = String8::format("Offline outputs must not be empty");
ALOGE("%s: %s", __FUNCTION__, msg.string()); ALOGE("%s: %s", __FUNCTION__, msg.string());
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
@ -1929,10 +1929,9 @@ binder::Status CameraDeviceClient::switchToOffline(
return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());
} }
std::vector<int32_t> offlineStreamIds(offlineOutputs.size()); std::vector<int32_t> offlineStreamIds(offlineOutputIds.size());
for (auto& surface : offlineOutputs) { for (const auto& streamId : offlineOutputIds) {
sp<IBinder> binder = IInterface::asBinder(surface.graphicBufferProducer); ssize_t index = mConfiguredOutputs.indexOfKey(streamId);
ssize_t index = mStreamMap.indexOfKey(binder);
if (index == NAME_NOT_FOUND) { if (index == NAME_NOT_FOUND) {
String8 msg = String8::format("Offline output is invalid"); String8 msg = String8::format("Offline output is invalid");
ALOGE("%s: %s", __FUNCTION__, msg.string()); ALOGE("%s: %s", __FUNCTION__, msg.string());
@ -1940,13 +1939,17 @@ binder::Status CameraDeviceClient::switchToOffline(
} }
// TODO: Also check whether the offline output is supported by Hal for offline mode. // TODO: Also check whether the offline output is supported by Hal for offline mode.
sp<Surface> s = new Surface(surface.graphicBufferProducer); bool isCompositeStream = false;
bool isCompositeStream = camera3::DepthCompositeStream::isDepthCompositeStream(s); for (const auto& gbp : mConfiguredOutputs[streamId].getGraphicBufferProducers()) {
isCompositeStream |= camera3::HeicCompositeStream::isHeicCompositeStream(s); sp<Surface> s = new Surface(gbp, false /*controlledByApp*/);
isCompositeStream = camera3::DepthCompositeStream::isDepthCompositeStream(s) |
camera3::HeicCompositeStream::isHeicCompositeStream(s);
}
if (isCompositeStream) { if (isCompositeStream) {
// TODO: Add composite specific handling // TODO: Add composite specific handling
} else { } else {
offlineStreamIds.push_back(mStreamMap.valueAt(index).streamId()); offlineStreamIds.push_back(streamId);
} }
} }
@ -1959,15 +1962,24 @@ binder::Status CameraDeviceClient::switchToOffline(
} }
sp<CameraOfflineSessionClient> offlineClient = new CameraOfflineSessionClient(sCameraService, sp<CameraOfflineSessionClient> offlineClient = new CameraOfflineSessionClient(sCameraService,
offlineSession, cameraCb, mClientPackageName, mCameraIdStr, mClientPid, mClientUid, offlineSession, cameraCb, mClientPackageName, mClientFeatureId, mCameraIdStr,
mServicePid); mCameraFacing, mClientPid, mClientUid, mServicePid);
ret = offlineClient->initialize(); ret = sCameraService->addOfflineClient(mCameraIdStr, offlineClient);
if (ret == OK) { if (ret == OK) {
// TODO: We need to update mStreamMap, mConfiguredOutputs // TODO: We need to update mStreamMap, mConfiguredOutputs
} else { } else {
return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, switch(ret) {
"Camera %s: Failed to initilize offline session: %s (%d)", case BAD_VALUE:
mCameraIdStr.string(), strerror(ret), ret); return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT,
"Illegal argument to HAL module for camera \"%s\"", mCameraIdStr.c_str());
case TIMED_OUT:
return STATUS_ERROR_FMT(CameraService::ERROR_CAMERA_IN_USE,
"Camera \"%s\" is already open", mCameraIdStr.c_str());
default:
return STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION,
"Failed to initialize camera \"%s\": %s (%d)", mCameraIdStr.c_str(),
strerror(-ret), ret);
}
} }
*session = offlineClient; *session = offlineClient;

@ -160,7 +160,7 @@ public:
virtual binder::Status switchToOffline( virtual binder::Status switchToOffline(
const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb, const sp<hardware::camera2::ICameraDeviceCallbacks>& cameraCb,
const std::vector<view::Surface>& offlineOutputs, const std::vector<int>& offlineOutputIds,
/*out*/ /*out*/
sp<hardware::camera2::ICameraOfflineSession>* session) override; sp<hardware::camera2::ICameraOfflineSession>* session) override;

@ -0,0 +1,140 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "CameraOfflineClient"
#define ATRACE_TAG ATRACE_TAG_CAMERA
//#define LOG_NDEBUG 0
#include "CameraOfflineSessionClient.h"
#include <utils/Trace.h>
namespace android {
using binder::Status;
status_t CameraOfflineSessionClient::initialize(sp<CameraProviderManager>, const String8&) {
return OK;
}
status_t CameraOfflineSessionClient::dump(int /*fd*/, const Vector<String16>& /*args*/) {
return OK;
}
status_t CameraOfflineSessionClient::dumpClient(int /*fd*/, const Vector<String16>& /*args*/) {
return OK;
}
binder::Status CameraOfflineSessionClient::disconnect() {
binder::Status res = Status::ok();
if (mDisconnected) {
return res;
}
mDisconnected = true;
sCameraService->removeByClient(this);
sCameraService->logDisconnectedOffline(mCameraIdStr, mClientPid, String8(mClientPackageName));
sp<IBinder> remote = getRemote();
if (remote != nullptr) {
remote->unlinkToDeath(sCameraService);
}
finishCameraOps();
ALOGI("%s: Disconnected client for offline camera %s for PID %d", __FUNCTION__,
mCameraIdStr.string(), mClientPid);
// client shouldn't be able to call into us anymore
mClientPid = 0;
return res;
}
void CameraOfflineSessionClient::notifyError(int32_t errorCode,
const CaptureResultExtras& resultExtras) {
// Thread safe. Don't bother locking.
sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
// TODO: handle composite streams
if ((remoteCb != 0)) {
remoteCb->onDeviceError(errorCode, resultExtras);
}
}
status_t CameraOfflineSessionClient::startCameraOps() {
ATRACE_CALL();
{
ALOGV("%s: Start camera ops, package name = %s, client UID = %d",
__FUNCTION__, String8(mClientPackageName).string(), mClientUid);
}
if (mAppOpsManager != nullptr) {
// Notify app ops that the camera is not available
mOpsCallback = new OpsCallback(this);
int32_t res;
// TODO : possibly change this to OP_OFFLINE_CAMERA_SESSION
mAppOpsManager->startWatchingMode(AppOpsManager::OP_CAMERA,
mClientPackageName, mOpsCallback);
// TODO : possibly change this to OP_OFFLINE_CAMERA_SESSION
res = mAppOpsManager->startOpNoThrow(AppOpsManager::OP_CAMERA,
mClientUid, mClientPackageName, /*startIfModeDefault*/ false);
if (res == AppOpsManager::MODE_ERRORED) {
ALOGI("Offline Camera %s: Access for \"%s\" has been revoked",
mCameraIdStr.string(), String8(mClientPackageName).string());
return PERMISSION_DENIED;
}
if (res == AppOpsManager::MODE_IGNORED) {
ALOGI("Offline Camera %s: Access for \"%s\" has been restricted",
mCameraIdStr.string(), String8(mClientPackageName).string());
// Return the same error as for device policy manager rejection
return -EACCES;
}
}
mOpsActive = true;
// Transition device state to OPEN
sCameraService->mUidPolicy->registerMonitorUid(mClientUid);
return OK;
}
status_t CameraOfflineSessionClient::finishCameraOps() {
ATRACE_CALL();
// Check if startCameraOps succeeded, and if so, finish the camera op
if (mOpsActive) {
// Notify app ops that the camera is available again
if (mAppOpsManager != nullptr) {
// TODO : possibly change this to OP_OFFLINE_CAMERA_SESSION
mAppOpsManager->finishOp(AppOpsManager::OP_CAMERA, mClientUid,
mClientPackageName);
mOpsActive = false;
}
}
// Always stop watching, even if no camera op is active
if (mOpsCallback != nullptr && mAppOpsManager != nullptr) {
mAppOpsManager->stopWatchingMode(mOpsCallback);
}
mOpsCallback.clear();
sCameraService->mUidPolicy->unregisterMonitorUid(mClientUid);
return OK;
}
// ----------------------------------------------------------------------------
}; // namespace android

@ -25,8 +25,14 @@ namespace android {
using android::hardware::camera2::ICameraDeviceCallbacks; using android::hardware::camera2::ICameraDeviceCallbacks;
// Client for offline session. Note that offline session client does not affect camera service's
// client arbitration logic. It is camera HAL's decision to decide whether a normal camera
// client is conflicting with existing offline client(s).
// The other distinctive difference between offline clients and normal clients is that normal
// clients are created through ICameraService binder calls, while the offline session client
// is created through ICameraDeviceUser::switchToOffline call.
class CameraOfflineSessionClient : class CameraOfflineSessionClient :
public CameraService::OfflineClient, public CameraService::BasicClient,
public hardware::camera2::BnCameraOfflineSession public hardware::camera2::BnCameraOfflineSession
// public camera2::FrameProcessorBase::FilteredListener? // public camera2::FrameProcessorBase::FilteredListener?
{ {
@ -36,46 +42,45 @@ public:
sp<CameraOfflineSessionBase> session, sp<CameraOfflineSessionBase> session,
const sp<ICameraDeviceCallbacks>& remoteCallback, const sp<ICameraDeviceCallbacks>& remoteCallback,
const String16& clientPackageName, const String16& clientPackageName,
const String8& cameraIdStr, const std::unique_ptr<String16>& clientFeatureId,
const String8& cameraIdStr, int cameraFacing,
int clientPid, uid_t clientUid, int servicePid) : int clientPid, uid_t clientUid, int servicePid) :
CameraService::OfflineClient(cameraService, clientPackageName, CameraService::BasicClient(
cameraIdStr, clientPid, clientUid, servicePid), cameraService,
mRemoteCallback(remoteCallback), mOfflineSession(session) {} IInterface::asBinder(remoteCallback),
clientPackageName, clientFeatureId,
cameraIdStr, cameraFacing, clientPid, clientUid, servicePid),
mRemoteCallback(remoteCallback), mOfflineSession(session) {}
~CameraOfflineSessionClient() {} virtual ~CameraOfflineSessionClient() {}
virtual binder::Status disconnect() override { return binder::Status::ok(); } virtual sp<IBinder> asBinderWrapper() override {
return IInterface::asBinder(this);
virtual status_t dump(int /*fd*/, const Vector<String16>& /*args*/) override {
return OK;
} }
// Block the client form using the camera virtual binder::Status disconnect() override;
virtual void block() override {};
virtual status_t dump(int /*fd*/, const Vector<String16>& /*args*/) override;
// Return the package name for this client virtual status_t dumpClient(int /*fd*/, const Vector<String16>& /*args*/) override;
virtual String16 getPackageName() const override { String16 ret; return ret; };
// Notify client about a fatal error
// TODO: maybe let impl notify within block?
virtual void notifyError(int32_t /*errorCode*/, virtual void notifyError(int32_t /*errorCode*/,
const CaptureResultExtras& /*resultExtras*/) override {} const CaptureResultExtras& /*resultExtras*/) override;
// Get the UID of the application client using this virtual status_t initialize(sp<CameraProviderManager> /*manager*/,
virtual uid_t getClientUid() const override { return 0; } const String8& /*monitorTags*/) override;
// Get the PID of the application client using this // permissions management
virtual int getClientPid() const override { return 0; } virtual status_t startCameraOps() override;
virtual status_t finishCameraOps() override;
status_t initialize() {
// TODO: Talk to camera service to add the offline session client book keeping
return OK;
}
private: private:
sp<CameraOfflineSessionBase> mSession;
const sp<hardware::camera2::ICameraDeviceCallbacks>& getRemoteCallback() {
return mRemoteCallback;
}
sp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback; sp<hardware::camera2::ICameraDeviceCallbacks> mRemoteCallback;
// This class is responsible to convert HAL callbacks to AIDL callbacks
sp<CameraOfflineSessionBase> mOfflineSession; sp<CameraOfflineSessionBase> mOfflineSession;
}; };

Loading…
Cancel
Save