| /* |
| ** |
| ** Copyright (C) 2015, 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 "Radio" |
| //#define LOG_NDEBUG 0 |
| |
| #include <utils/Log.h> |
| #include <utils/threads.h> |
| #include <binder/IPCThreadState.h> |
| #include <binder/IServiceManager.h> |
| #include <binder/IMemory.h> |
| |
| #include <radio/Radio.h> |
| #include <radio/IRadio.h> |
| #include <radio/IRadioService.h> |
| #include <radio/IRadioClient.h> |
| #include <radio/RadioCallback.h> |
| |
| namespace android { |
| |
| namespace { |
| sp<IRadioService> gRadioService; |
| const int kRadioServicePollDelay = 500000; // 0.5s |
| const char* kRadioServiceName = "media.radio"; |
| Mutex gLock; |
| |
| class DeathNotifier : public IBinder::DeathRecipient |
| { |
| public: |
| DeathNotifier() { |
| } |
| |
| virtual void binderDied(const wp<IBinder>& who __unused) { |
| ALOGV("binderDied"); |
| Mutex::Autolock _l(gLock); |
| gRadioService.clear(); |
| ALOGW("Radio service died!"); |
| } |
| }; |
| |
| sp<DeathNotifier> gDeathNotifier; |
| }; // namespace anonymous |
| |
| const sp<IRadioService> Radio::getRadioService() |
| { |
| Mutex::Autolock _l(gLock); |
| if (gRadioService.get() == 0) { |
| sp<IServiceManager> sm = defaultServiceManager(); |
| sp<IBinder> binder; |
| do { |
| binder = sm->getService(String16(kRadioServiceName)); |
| if (binder != 0) { |
| break; |
| } |
| ALOGW("RadioService not published, waiting..."); |
| usleep(kRadioServicePollDelay); |
| } while(true); |
| if (gDeathNotifier == NULL) { |
| gDeathNotifier = new DeathNotifier(); |
| } |
| binder->linkToDeath(gDeathNotifier); |
| gRadioService = interface_cast<IRadioService>(binder); |
| } |
| ALOGE_IF(gRadioService == 0, "no RadioService!?"); |
| return gRadioService; |
| } |
| |
| // Static methods |
| status_t Radio::listModules(struct radio_properties *properties, |
| uint32_t *numModules) |
| { |
| ALOGV("listModules()"); |
| const sp<IRadioService> service = getRadioService(); |
| if (service == 0) { |
| return NO_INIT; |
| } |
| return service->listModules(properties, numModules); |
| } |
| |
| sp<Radio> Radio::attach(radio_handle_t handle, |
| const struct radio_band_config *config, |
| bool withAudio, |
| const sp<RadioCallback>& callback) |
| { |
| ALOGV("attach()"); |
| sp<Radio> radio; |
| const sp<IRadioService> service = getRadioService(); |
| if (service == 0) { |
| return radio; |
| } |
| radio = new Radio(handle, callback); |
| status_t status = service->attach(handle, radio, config, withAudio, radio->mIRadio); |
| |
| if (status == NO_ERROR && radio->mIRadio != 0) { |
| IInterface::asBinder(radio->mIRadio)->linkToDeath(radio); |
| } else { |
| ALOGW("Error %d connecting to radio service", status); |
| radio.clear(); |
| } |
| return radio; |
| } |
| |
| |
| |
| // Radio |
| Radio::Radio(radio_handle_t handle, const sp<RadioCallback>& callback) |
| : mHandle(handle), mCallback(callback) |
| { |
| } |
| |
| Radio::~Radio() |
| { |
| if (mIRadio != 0) { |
| mIRadio->detach(); |
| } |
| } |
| |
| |
| void Radio::detach() { |
| ALOGV("detach()"); |
| Mutex::Autolock _l(mLock); |
| mCallback.clear(); |
| if (mIRadio != 0) { |
| mIRadio->detach(); |
| IInterface::asBinder(mIRadio)->unlinkToDeath(this); |
| mIRadio = 0; |
| } |
| } |
| |
| status_t Radio::setConfiguration(const struct radio_band_config *config) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->setConfiguration(config); |
| } |
| |
| status_t Radio::getConfiguration(struct radio_band_config *config) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->getConfiguration(config); |
| } |
| |
| status_t Radio::setMute(bool mute) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->setMute(mute); |
| } |
| |
| status_t Radio::getMute(bool *mute) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->getMute(mute); |
| } |
| |
| status_t Radio::scan(radio_direction_t direction, bool skipSubchannel) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->scan(direction, skipSubchannel); |
| } |
| |
| status_t Radio::step(radio_direction_t direction, bool skipSubchannel) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->step(direction, skipSubchannel); |
| } |
| |
| status_t Radio::tune(unsigned int channel, unsigned int subChannel) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->tune(channel, subChannel); |
| } |
| |
| status_t Radio::cancel() |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->cancel(); |
| } |
| |
| status_t Radio::getProgramInformation(struct radio_program_info *info) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->getProgramInformation(info); |
| } |
| |
| status_t Radio::hasControl(bool *hasControl) |
| { |
| Mutex::Autolock _l(mLock); |
| if (mIRadio == 0) { |
| return NO_INIT; |
| } |
| return mIRadio->hasControl(hasControl); |
| } |
| |
| |
| // BpRadioClient |
| void Radio::onEvent(const sp<IMemory>& eventMemory) |
| { |
| Mutex::Autolock _l(mLock); |
| if (eventMemory == 0 || eventMemory->pointer() == NULL) { |
| return; |
| } |
| |
| // The event layout in shared memory is: |
| // sizeof(struct radio_event) bytes : the event itself |
| // 4 bytes : metadata size or 0 |
| // N bytes : metadata if present |
| struct radio_event *event = (struct radio_event *)eventMemory->pointer(); |
| uint32_t metadataOffset = sizeof(struct radio_event) + sizeof(uint32_t); |
| uint32_t metadataSize = *(uint32_t *)((uint8_t *)event + metadataOffset - sizeof(uint32_t)); |
| |
| // restore local metadata pointer from offset |
| switch (event->type) { |
| case RADIO_EVENT_TUNED: |
| case RADIO_EVENT_AF_SWITCH: |
| if (metadataSize != 0) { |
| event->info.metadata = |
| (radio_metadata_t *)((uint8_t *)event + metadataOffset); |
| } else { |
| event->info.metadata = 0; |
| } |
| break; |
| case RADIO_EVENT_METADATA: |
| if (metadataSize != 0) { |
| event->metadata = |
| (radio_metadata_t *)((uint8_t *)event + metadataOffset); |
| } else { |
| event->metadata = 0; |
| } |
| break; |
| default: |
| break; |
| } |
| |
| if (mCallback != 0) { |
| mCallback->onEvent(event); |
| } |
| } |
| |
| |
| //IBinder::DeathRecipient |
| void Radio::binderDied(const wp<IBinder>& who __unused) { |
| Mutex::Autolock _l(mLock); |
| ALOGW("Radio server binder Died "); |
| mIRadio = 0; |
| struct radio_event event; |
| memset(&event, 0, sizeof(struct radio_event)); |
| event.type = RADIO_EVENT_SERVER_DIED; |
| event.status = DEAD_OBJECT; |
| if (mCallback != 0) { |
| mCallback->onEvent(&event); |
| } |
| } |
| |
| }; // namespace android |