status_t DumpsysSection::BlockingCall(int pipeWriteFd) const {
// checkService won't wait for the service to show up like getService will.
sp<IBinder> service = defaultServiceManager()->checkService(mService);
if (service == NULL) {
// Returning an error interrupts the entire incident report, so just
// log the failure.
// TODO: have a meta record inside the report that would log this
// failure inside the report, because the fact that we can't find
// the service is good data in and of itself. This is running in
// another thread so lock that carefully...
ALOGW("DumpsysSection: Can't lookup service: %s", String8(mService).string());
return NO_ERROR;
}
service->dump(pipeWriteFd, mArgs);
return NO_ERROR;
}
int getRotation(){
const String16 name("window");
const String16 interface("android.view.IWindowManager");
const sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> window;
window = sm->getService(name);
if( window != NULL ){
Parcel data, reply;
data.writeInterfaceToken(interface);
window->transact(56, data, &reply, 0);
reply.readInt32();
int rotation = reply.readInt32();
return rotation;
}
return -1;
}
// static
sp<ICrypto> JCrypto::MakeCrypto() {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder =
sm->getService(String16("media.player"));
sp<IMediaPlayerService> service =
interface_cast<IMediaPlayerService>(binder);
if (service == NULL) {
return NULL;
}
sp<ICrypto> crypto = service->makeCrypto();
if (crypto == NULL || (crypto->initCheck() != OK && crypto->initCheck() != NO_INIT)) {
return NULL;
}
return crypto;
}
// static
sp<IDrm> JDrm::MakeDrm() {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder =
sm->getService(String16("media.player"));
sp<IMediaPlayerService> service =
interface_cast<IMediaPlayerService>(binder);
if (service == NULL) {
return NULL;
}
sp<IDrm> drm = service->makeDrm();
if (drm == NULL || (drm->initCheck() != OK && drm->initCheck() != NO_INIT)) {
return NULL;
}
return drm;
}
psbMultiDisplayListener::psbMultiDisplayListener() {
#ifndef USE_MDS_LEGACY
// get mds service and register listener
sp<IServiceManager> sm = defaultServiceManager();
if (sm == NULL) {
ALOGE("%s: Fail to get service manager", __func__);
return;
}
mMds = interface_cast<IMDService>(sm->getService(String16(INTEL_MDS_SERVICE_NAME)));
if (mMds == NULL) {
ALOGE("%s: Failed to get Mds service", __func__);
return;
}
mListener = mMds->getInfoProvider();
#else
mListener = new MultiDisplayClient();
if (mListener == NULL)
return;
#endif
return;
}
status_t WifiDisplaySource::makeHDCP() {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.player"));
sp<IMediaPlayerService> service =
interface_cast<IMediaPlayerService>(binder);
CHECK(service != NULL);
mHDCP = service->makeHDCP(true /* createEncryptionModule */);
if (mHDCP == NULL) {
return ERROR_UNSUPPORTED;
}
sp<AMessage> notify = new AMessage(kWhatHDCPNotify, this);
mHDCPObserver = new HDCPObserver(notify);
status_t err = mHDCP->setObserver(mHDCPObserver);
if (err != OK) {
ALOGE("Failed to set HDCP observer.");
mHDCPObserver.clear();
mHDCP.clear();
return err;
}
ALOGI("Initiating HDCP negotiation w/ host %s:%d",
mClientInfo.mRemoteIP.c_str(), mHDCPPort);
err = mHDCP->initAsync(mClientInfo.mRemoteIP.c_str(), mHDCPPort);
if (err != OK) {
return err;
}
return OK;
}
// establish binder interface to camera service
const sp<ICameraService>& Camera::getCameraService()
{
Mutex::Autolock _l(mLock);
if (mCameraService.get() == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16("media.camera"));
if (binder != 0)
break;
ALOGW("CameraService not published, waiting...");
usleep(500000); // 0.5 s
} while(true);
if (mDeathNotifier == NULL) {
mDeathNotifier = new DeathNotifier();
}
binder->linkToDeath(mDeathNotifier);
mCameraService = interface_cast<ICameraService>(binder);
}
ALOGE_IF(mCameraService==0, "no CameraService!?");
return mCameraService;
}
// establish binder interface to service
const sp<IMediaPlayerService>& MediaPlayer::getMediaPlayerService()
{
Mutex::Autolock _l(sServiceLock);
if (sMediaPlayerService.get() == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16("media.player"));
if (binder != 0)
break;
LOGW("MediaPlayerService not published, waiting...");
usleep(500000); // 0.5 s
} while(true);
if (sDeathNotifier == NULL) {
sDeathNotifier = new DeathNotifier();
}
binder->linkToDeath(sDeathNotifier);
sMediaPlayerService = interface_cast<IMediaPlayerService>(binder);
}
LOGE_IF(sMediaPlayerService==0, "no MediaPlayerService!?");
return sMediaPlayerService;
}
int MultiDisplayComposer::setDisplayScalingLocked(uint32_t mode,
uint32_t stepx, uint32_t stepy) {
ALOGV("IMDS-Native: MultiDisplayComposer.cpp: setDisplayScalingLocked");
if (mSurfaceComposer == NULL) {
const sp<IServiceManager> sm = defaultServiceManager();
const String16 name("SurfaceFlinger");
mSurfaceComposer = sm->getService(name);
if (mSurfaceComposer == NULL) {
return -1;
}
}
uint32_t scale;
Parcel data, reply;
const String16 token("android.ui.ISurfaceComposer");
scale = mode | stepx << 16 | stepy << 24;
data.writeInterfaceToken(token);
data.writeInt32(scale);
mSurfaceComposer->transact(SFIntelHDMIScalingSetting, data, &reply);
return reply.readInt32();
}
const sp<ICameraService>& CameraBase<TCam, TCamTraits>::getCameraService()
{
Mutex::Autolock _l(gLock);
if (gCameraService.get() == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16(kCameraServiceName));
if (binder != 0) {
break;
}
ALOGW("CameraService not published, waiting...");
usleep(kCameraServicePollDelay);
} while(true);
if (gDeathNotifier == NULL) {
gDeathNotifier = new DeathNotifier();
}
binder->linkToDeath(gDeathNotifier);
gCameraService = interface_cast<ICameraService>(binder);
}
ALOGE_IF(gCameraService == 0, "no CameraService!?");
return gCameraService;
}
int main()
{
sp<IBinder> binder = defaultServiceManager()->getService(String16(ADD_SERVICE));
if(binder == NULL)
{
LOGE("Failed to get add service: %s.\n", ADD_SERVICE);
return -1;
}
sp<IAddService> service = IAddService::asInterface(binder);
if(service == NULL)
{
LOGE("Failed to get add service interface.\n");
return -2;
}
int32_t v1 = 2;
int32_t v2 = 4;
int32_t va = service->add(v1, v2);
int32_t vm = service->mul(v1, v2);
LOGI("%d + %d = %d\n", v1, v2, va);
LOGI("%d x %d = %d\n", v1, v2, vm);
return 0;
}
SfNetworkLibrary::VerifyResult SfNetworkLibrary::VerifyX509CertChain(
const std::vector<std::string>& cert_chain,
const std::string& hostname,
const std::string& auth_type) {
sp<IBinder> binder =
defaultServiceManager()->checkService(String16("audio"));
if (binder == 0) {
ALOGW("Thread cannot connect to the audio service");
} else {
sp<IAudioService> service = interface_cast<IAudioService>(binder);
int code = service->verifyX509CertChain(cert_chain, hostname, auth_type);
ALOGV("verified: %d", code);
if (code == -1) {
return VERIFY_OK;
} else if (code == 2) { // SSL_IDMISMATCH
return VERIFY_BAD_HOSTNAME;
} else if (code == 3) { // SSL_UNTRUSTED
return VERIFY_NO_TRUSTED_ROOT;
}
}
return VERIFY_INVOCATION_ERROR;
}
static jint nativeListen(JNIEnv* env, jobject remoteDisplayObj, jstring ifaceStr) {
ScopedUtfChars iface(env, ifaceStr);
sp<IServiceManager> sm = defaultServiceManager();
sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(
sm->getService(String16("media.player")));
if (service == NULL) {
ALOGE("Could not obtain IMediaPlayerService from service manager");
return 0;
}
sp<NativeRemoteDisplayClient> client(new NativeRemoteDisplayClient(env, remoteDisplayObj));
sp<IRemoteDisplay> display = service->listenForRemoteDisplay(
client, String8(iface.c_str()));
if (display == NULL) {
ALOGE("Media player service rejected request to listen for remote display '%s'.",
iface.c_str());
return 0;
}
NativeRemoteDisplay* wrapper = new NativeRemoteDisplay(display, client);
return reinterpret_cast<jint>(wrapper);
}
int main(int argc, char *argv[])
{
sp<IBinder> binder;
sp<ProcessState> proc(ProcessState::self());
//get service manager
sp<IServiceManager> sm = defaultServiceManager();
do{
//Search service by SERVICE_NAME
binder = sm->getService(String16(SERVICE_NAME));
if(binder != 0)
break;
sleep(1);
}while(true);
const sp<IDemoAPI>& bts = interface_cast<IDemoAPI>(binder);
ALOGE("bindertest client is starting.....");
ALOGE("Service Name=%s",bts->getName());
ALOGE("Service SUM %d+%d=%d",1,2,bts->sum(1,2));
return 0;
}
static void createSource(const AString &addr, int32_t port) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.player"));
sp<IMediaPlayerService> service =
interface_cast<IMediaPlayerService>(binder);
CHECK(service.get() != NULL);
enableAudioSubmix(true /* enable */);
String8 iface;
iface.append(addr.c_str());
iface.append(StringPrintf(":%d", port).c_str());
sp<RemoteDisplayClient> client = new RemoteDisplayClient;
sp<IRemoteDisplay> display = service->listenForRemoteDisplay(client, iface);
client->waitUntilDone();
display->dispose();
display.clear();
enableAudioSubmix(false /* enable */);
}
MediaRecorder::MediaRecorder()
{
LOGV("constructor");
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16("media.player"));
if (binder != NULL) {
break;
}
LOGW("MediaPlayerService not published, waiting...");
usleep(500000); // 0.5 s
} while(true);
sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
if (service != NULL) {
mMediaRecorder = service->createMediaRecorder(getpid());
}
if (mMediaRecorder != NULL) {
mCurrentState = MEDIA_RECORDER_IDLE;
}
doCleanUp();
}
sp<IMonzax> IMonzax::getMonzaxSerivce()
{
sp<IBinder> binder;
ALOGI("getMonzaxService called");
if(sMonzaxManager != NULL)
return sMonzaxManager;
sp<IServiceManager> sm = defaultServiceManager();
do {
binder = sm->getService(String16("rfid_monzax.service"));
if (binder == 0) {
ALOGW("MonzaxService not published, waiting...");
usleep(500000); // 0.5 s
}
} while(binder == 0);
if(sMonzaxManager == NULL){
sMonzaxManager = interface_cast<IMonzax>(binder);
}
return sMonzaxManager;
}
// establish binder interface to AudioPolicy service
const sp<IAudioPolicyService>& AudioSystem::get_audio_policy_service()
{
gLock.lock();
if (gAudioPolicyService == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16("media.audio_policy"));
if (binder != 0)
break;
ALOGW("AudioPolicyService not published, waiting...");
usleep(500000); // 0.5 s
} while (true);
if (gAudioPolicyServiceClient == NULL) {
gAudioPolicyServiceClient = new AudioPolicyServiceClient();
}
binder->linkToDeath(gAudioPolicyServiceClient);
gAudioPolicyService = interface_cast<IAudioPolicyService>(binder);
gLock.unlock();
} else {
gLock.unlock();
}
return gAudioPolicyService;
}
void Service::instantiate()
{
defaultServiceManager()->addService(IHelloWorld::descriptor,
new Service());
}
void BatteryPropertiesRegistrar::publish() {
defaultServiceManager()->addService(String16("batteryproperties"), this);
}
int main(int argc, char** argv) {
bool bVeryVerbose = false;
bool bVerbose = false;
bool bFences = false;
bool bBufferManager = false;
bool bQueue = false;
// process arguments
int argIndex = 1;
while (argIndex < argc) {
if (strcmp(argv[argIndex], "-h") == 0) {
printHelp();
return 0;
}
if (strcmp(argv[argIndex], "-v") == 0) {
bVerbose = true;
printf("bVerbose = %d\n", bVerbose);
}
if (strcmp(argv[argIndex], "-vv") == 0) {
bVeryVerbose = true;
printf("bVeryVerbose = %d\n", bVeryVerbose);
}
if (strcmp(argv[argIndex], "-f") == 0) {
bFences = true;
printf("bFences = %d\n", bFences);
}
if (strcmp(argv[argIndex], "-b") == 0) {
bBufferManager = true;
printf("bBufferManager = %d\n", bBufferManager);
}
if (strcmp(argv[argIndex], "-q") == 0) {
bQueue = true;
printf("bQueue = %d\n", bQueue);
}
argIndex++;
}
while (1) {
// Find and connect to HWC service
sp<IService> hwcService = interface_cast<IService>(
defaultServiceManager()->getService(String16(IA_HWC_SERVICE_NAME)));
if (hwcService == NULL) {
usleep(TENTH_SECOND);
continue;
}
sp<IDiagnostic> pDiagnostic = hwcService->GetDiagnostic();
if (pDiagnostic == NULL) {
usleep(TENTH_SECOND);
continue;
}
printf("Connected to service %s and obtained diagnostic interface\n\n",
IA_HWC_SERVICE_NAME);
while (1) {
LogEntry entry;
status_t ret = entry.read(pDiagnostic);
if (ret != OK) {
if (ret == IDiagnostic::eLogTruncated) {
printf("...\n");
} else if (ret == NOT_ENOUGH_DATA) {
fflush(stdout);
usleep(4000); // 4 ms sleep
continue;
} else {
printf("readLogEntry error, attempting to reconnect.\n\n");
break;
}
}
entry.print(bVeryVerbose, bVerbose, bFences, bBufferManager, bQueue);
}
}
return 0;
}
/* static */
void FakeSurfaceComposer::instantiate() {
defaultServiceManager()->addService(
String16("SurfaceFlinger"), new FakeSurfaceComposer());
}
// XXX: Tests that fork a process to hold the BufferQueue must run before tests
// that use a local BufferQueue, or else Binder will get unhappy
TEST_F(BufferQueueTest, BufferQueueInAnotherProcess) {
const String16 PRODUCER_NAME = String16("BQTestProducer");
const String16 CONSUMER_NAME = String16("BQTestConsumer");
pid_t forkPid = fork();
ASSERT_NE(forkPid, -1);
if (forkPid == 0) {
// Child process
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&producer, &consumer);
sp<IServiceManager> serviceManager = defaultServiceManager();
serviceManager->addService(PRODUCER_NAME, IInterface::asBinder(producer));
serviceManager->addService(CONSUMER_NAME, IInterface::asBinder(consumer));
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
LOG_ALWAYS_FATAL("Shouldn't be here");
}
sp<IServiceManager> serviceManager = defaultServiceManager();
sp<IBinder> binderProducer =
serviceManager->getService(PRODUCER_NAME);
mProducer = interface_cast<IGraphicBufferProducer>(binderProducer);
EXPECT_TRUE(mProducer != NULL);
sp<IBinder> binderConsumer =
serviceManager->getService(CONSUMER_NAME);
mConsumer = interface_cast<IGraphicBufferConsumer>(binderConsumer);
EXPECT_TRUE(mConsumer != NULL);
sp<DummyConsumer> dc(new DummyConsumer);
ASSERT_EQ(OK, mConsumer->consumerConnect(dc, false));
IGraphicBufferProducer::QueueBufferOutput output;
ASSERT_EQ(OK,
mProducer->connect(NULL, NATIVE_WINDOW_API_CPU, false, &output));
int slot;
sp<Fence> fence;
sp<GraphicBuffer> buffer;
ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
GRALLOC_USAGE_SW_WRITE_OFTEN));
ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
uint32_t* dataIn;
ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
reinterpret_cast<void**>(&dataIn)));
*dataIn = TEST_DATA;
ASSERT_EQ(OK, buffer->unlock());
IGraphicBufferProducer::QueueBufferInput input(0, false,
HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
BufferItem item;
ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
uint32_t* dataOut;
ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
reinterpret_cast<void**>(&dataOut)));
ASSERT_EQ(*dataOut, TEST_DATA);
ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
}
sp<IAndroidShm> Shm::getShmService(){
return interface_cast<IAndroidShm>(defaultServiceManager()->getService(String16("com.samsung.android.jam.IAndroidShm")));
}
/* static */
void MediaResourceManagerService::instantiate() {
defaultServiceManager()->addService(
String16("media.resource_manager"), new MediaResourceManagerService());
}
void SimulatorService::instantiate(void)
{
defaultServiceManager()->addService(
String16("liminghao.xiaomi.SimulatorService"),
new SimulatorService());
}
ITestFrameworkService *TestFrameworkService::RunTestFrameworkService() {
TestFrameworkService *service = new TestFrameworkService();
defaultServiceManager()->addService(ITestFrameworkService::descriptor, service);
ProcessState::self()->startThreadPool();
return (ITestFrameworkService *)service;
}
static void instantiate()
{
defaultServiceManager()->addService(String16(SHARED_BUFFER_SERVICE), new SharedBufferService());
}
//Singleton
void LedService::instantiate() {
defaultServiceManager()->addService(
String16("mokoid.led"), new LedService());
}
virtual int verifyChallenge(uint32_t uid, uint64_t challenge,
const uint8_t *enrolled_password_handle, uint32_t enrolled_password_handle_length,
const uint8_t *provided_password, uint32_t provided_password_length,
uint8_t **auth_token, uint32_t *auth_token_length, bool *request_reenroll) {
IPCThreadState* ipc = IPCThreadState::self();
const int calling_pid = ipc->getCallingPid();
const int calling_uid = ipc->getCallingUid();
if (!PermissionCache::checkPermission(KEYGUARD_PERMISSION, calling_pid, calling_uid)) {
return PERMISSION_DENIED;
}
// can't verify if we're missing either param
if ((enrolled_password_handle_length | provided_password_length) == 0)
return -EINVAL;
int ret;
if (device) {
const gatekeeper::password_handle_t *handle =
reinterpret_cast<const gatekeeper::password_handle_t *>(enrolled_password_handle);
// handle version 0 does not have hardware backed flag, and thus cannot be upgraded to
// a HAL if there was none before
if (handle->version == 0 || handle->hardware_backed) {
ret = device->verify(device, uid, challenge,
enrolled_password_handle, enrolled_password_handle_length,
provided_password, provided_password_length, auth_token, auth_token_length,
request_reenroll);
} else {
// upgrade scenario, a HAL has been added to this device where there was none before
SoftGateKeeperDevice soft_dev;
ret = soft_dev.verify(uid, challenge,
enrolled_password_handle, enrolled_password_handle_length,
provided_password, provided_password_length, auth_token, auth_token_length,
request_reenroll);
if (ret == 0) {
// success! re-enroll with HAL
*request_reenroll = true;
}
}
} else {
ret = soft_device->verify(uid, challenge,
enrolled_password_handle, enrolled_password_handle_length,
provided_password, provided_password_length, auth_token, auth_token_length,
request_reenroll);
}
if (ret == 0 && *auth_token != NULL && *auth_token_length > 0) {
// TODO: cache service?
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("android.security.keystore"));
sp<IKeystoreService> service = interface_cast<IKeystoreService>(binder);
if (service != NULL) {
status_t ret = service->addAuthToken(*auth_token, *auth_token_length);
if (ret != ResponseCode::NO_ERROR) {
ALOGE("Falure sending auth token to KeyStore: %d", ret);
}
} else {
ALOGE("Unable to communicate with KeyStore");
}
}
if (ret == 0) {
maybe_store_sid(uid, reinterpret_cast<const gatekeeper::password_handle_t *>(
enrolled_password_handle)->user_id);
}
return ret;
}
