Merge "Add TunerTimeFilter/Lnb interface and add openLnb in TunerService"
diff --git a/services/tuner/Android.bp b/services/tuner/Android.bp
index edccbf7..1379090 100644
--- a/services/tuner/Android.bp
+++ b/services/tuner/Android.bp
@@ -64,8 +64,7 @@
name: "libtunerservice",
srcs: [
- "TunerService.cpp",
- "TunerFrontend.cpp"
+ "Tuner*.cpp"
],
shared_libs: [
diff --git a/services/tuner/TunerFrontend.cpp b/services/tuner/TunerFrontend.cpp
index 17c60c0..e92489d 100644
--- a/services/tuner/TunerFrontend.cpp
+++ b/services/tuner/TunerFrontend.cpp
@@ -17,7 +17,6 @@
#define LOG_TAG "TunerFrontend"
#include "TunerFrontend.h"
-#include "TunerService.h"
using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
@@ -73,26 +72,19 @@
namespace android {
-TunerFrontend::TunerFrontend(sp<ITuner> tuner, int id) {
- mTuner = tuner;
+TunerFrontend::TunerFrontend(sp<IFrontend> frontend, int id) {
+ mFrontend = frontend;
+ mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
mId = id;
-
- if (mTuner != NULL) {
- Result status;
- mTuner->openFrontendById(mId, [&](Result result, const sp<IFrontend>& frontend) {
- mFrontend = frontend;
- status = result;
- });
- if (status != Result::SUCCESS) {
- mFrontend = NULL;
- }
- }
}
-TunerFrontend::~TunerFrontend() {}
+TunerFrontend::~TunerFrontend() {
+ mFrontend = NULL;
+ mId = -1;
+}
Status TunerFrontend::setCallback(
- const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
+ const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
if (mFrontend == NULL) {
ALOGE("IFrontend is not initialized");
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
@@ -125,6 +117,7 @@
return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
}
+ // TODO: extend TunerFrontendSettings to use 1.1 types
FrontendSettings frontendSettings;
switch (settings.getTag()) {
case TunerFrontendSettings::analog:
@@ -308,8 +301,8 @@
return Status::ok();
}
-Status TunerFrontend::getStatus(const std::vector<int32_t>& /*statusTypes*/,
- std::vector<TunerFrontendStatus>* /*_aidl_return*/) {
+Status TunerFrontend::getStatus(const vector<int32_t>& /*statusTypes*/,
+ vector<TunerFrontendStatus>* /*_aidl_return*/) {
return Status::ok();
}
@@ -317,6 +310,7 @@
*_aidl_return = mId;
return Status::ok();
}
+
/////////////// FrontendCallback ///////////////////////
Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
@@ -344,13 +338,13 @@
}
case FrontendScanMessageType::FREQUENCY: {
auto f = message.frequencies();
- std::vector<int> frequencies(std::begin(f), std::end(f));
+ vector<int> frequencies(begin(f), end(f));
scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
break;
}
case FrontendScanMessageType::SYMBOL_RATE: {
auto s = message.symbolRates();
- std::vector<int> symbolRates(std::begin(s), std::end(s));
+ vector<int> symbolRates(begin(s), end(s));
scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
break;
}
@@ -364,19 +358,19 @@
}
case FrontendScanMessageType::PLP_IDS: {
auto p = message.plpIds();
- std::vector<uint8_t> plpIds(std::begin(p), std::end(p));
+ vector<uint8_t> plpIds(begin(p), end(p));
scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
break;
}
case FrontendScanMessageType::GROUP_IDS: {
auto g = message.groupIds();
- std::vector<uint8_t> groupIds(std::begin(g), std::end(g));
+ vector<uint8_t> groupIds(begin(g), end(g));
scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
break;
}
case FrontendScanMessageType::INPUT_STREAM_IDS: {
auto i = message.inputStreamIds();
- std::vector<char16_t> streamIds(std::begin(i), std::end(i));
+ vector<char16_t> streamIds(begin(i), end(i));
scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
break;
}
@@ -396,8 +390,8 @@
break;
}
case FrontendScanMessageType::ATSC3_PLP_INFO: {
- std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
- std::vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
+ vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
+ vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
for (int i = 0; i < plpInfos.size(); i++) {
auto info = plpInfos[i];
int plpId = (int) info.plpId;
@@ -463,7 +457,7 @@
return Void();
}
-////////////////////////////////////////////////////////////////////////////////
+/////////////// TunerFrontend Helper Methods ///////////////////////
hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(
const TunerFrontendAtsc3Settings& settings) {
diff --git a/services/tuner/TunerFrontend.h b/services/tuner/TunerFrontend.h
index f1f66e7..99cdcdf 100644
--- a/services/tuner/TunerFrontend.h
+++ b/services/tuner/TunerFrontend.h
@@ -19,6 +19,7 @@
#include <aidl/android/media/tv/tuner/BnTunerFrontend.h>
#include <android/hardware/tv/tuner/1.0/ITuner.h>
+#include <android/hardware/tv/tuner/1.1/IFrontend.h>
#include <android/hardware/tv/tuner/1.1/IFrontendCallback.h>
#include <media/stagefright/foundation/ADebug.h>
#include <utils/Log.h>
@@ -41,20 +42,21 @@
using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage;
using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType;
using ::android::hardware::tv::tuner::V1_0::IFrontend;
-using ::android::hardware::tv::tuner::V1_0::ITuner;
using ::android::hardware::tv::tuner::V1_1::IFrontendCallback;
using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1;
using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1;
+using namespace std;
+
namespace android {
class TunerFrontend : public BnTunerFrontend {
public:
- TunerFrontend(sp<ITuner> tuner, int id);
+ TunerFrontend(sp<IFrontend> frontend, int id);
virtual ~TunerFrontend();
Status setCallback(
- const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
+ const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
Status tune(const TunerFrontendSettings& settings) override;
Status stopTune() override;
Status scan(const TunerFrontendSettings& settings, int frontendScanType) override;
@@ -62,12 +64,12 @@
Status setLnb(int lnbHandle) override;
Status setLna(bool bEnable) override;
Status close() override;
- Status getStatus(const std::vector<int32_t>& statusTypes,
- std::vector<TunerFrontendStatus>* _aidl_return) override;
+ Status getStatus(const vector<int32_t>& statusTypes,
+ vector<TunerFrontendStatus>* _aidl_return) override;
Status getFrontendId(int* _aidl_return) override;
struct FrontendCallback : public IFrontendCallback {
- FrontendCallback(const std::shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
+ FrontendCallback(const shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
: mTunerFrontendCallback(tunerFrontendCallback) {};
virtual Return<void> onEvent(FrontendEventType frontendEventType);
@@ -76,16 +78,17 @@
virtual Return<void> onScanMessageExt1_1(
FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message);
- std::shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;
+ shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;
};
private:
hidl_vec<FrontendAtsc3PlpSettings> getAtsc3PlpSettings(
const TunerFrontendAtsc3Settings& settings);
FrontendDvbsCodeRate getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate);
+
int mId;
- sp<ITuner> mTuner;
sp<IFrontend> mFrontend;
+ sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFrontend_1_1;
};
} // namespace android
diff --git a/services/tuner/TunerLnb.cpp b/services/tuner/TunerLnb.cpp
new file mode 100644
index 0000000..18aa11e
--- /dev/null
+++ b/services/tuner/TunerLnb.cpp
@@ -0,0 +1,91 @@
+/**
+ * Copyright 2021, 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 "TunerLnb"
+
+#include "TunerLnb.h"
+
+using ::android::hardware::tv::tuner::V1_0::Result;
+
+namespace android {
+
+TunerLnb::TunerLnb(sp<ILnb> lnb, int id) {
+ mLnb = lnb;
+ mId = id;
+}
+
+TunerLnb::~TunerLnb() {
+ mLnb = NULL;
+ mId = -1;
+}
+
+Status TunerLnb::setCallback(
+ const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) {
+ if (mLnb == NULL) {
+ ALOGE("ILnb is not initialized");
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
+ }
+
+ if (tunerLnbCallback == NULL) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_ARGUMENT));
+ }
+
+ sp<ILnbCallback> lnbCallback = new LnbCallback(tunerLnbCallback);
+ Result status = mLnb->setCallback(lnbCallback);
+ if (status == Result::SUCCESS) {
+ return Status::ok();
+ }
+
+ return Status::fromServiceSpecificError(static_cast<int32_t>(status));
+}
+
+Status TunerLnb::setVoltage(int /*voltage*/) {
+ return Status::ok();
+}
+
+Status TunerLnb::setTone(int /*voltage*/) {
+ return Status::ok();
+}
+
+Status TunerLnb::setSatellitePosition(int /*position*/) {
+ return Status::ok();
+}
+
+Status TunerLnb::sendDiseqcMessage(const vector<uint8_t>& /*diseqcMessage*/) {
+ return Status::ok();
+}
+
+Status TunerLnb::close() {
+ return Status::ok();
+}
+
+/////////////// ILnbCallback ///////////////////////
+
+Return<void> TunerLnb::LnbCallback::onEvent(const LnbEventType lnbEventType) {
+ if (mTunerLnbCallback != NULL) {
+ mTunerLnbCallback->onEvent((int)lnbEventType);
+ }
+ return Void();
+}
+
+Return<void> TunerLnb::LnbCallback::onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage) {
+ if (mTunerLnbCallback != NULL && diseqcMessage != NULL) {
+ vector<uint8_t> msg(begin(diseqcMessage), end(diseqcMessage));
+ mTunerLnbCallback->onDiseqcMessage(msg);
+ }
+ return Void();
+}
+} // namespace android
diff --git a/services/tuner/TunerLnb.h b/services/tuner/TunerLnb.h
new file mode 100644
index 0000000..19ba3c2
--- /dev/null
+++ b/services/tuner/TunerLnb.h
@@ -0,0 +1,69 @@
+/**
+ * Copyright 2021, 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.
+ */
+
+#ifndef ANDROID_MEDIA_TUNERFLNB_H
+#define ANDROID_MEDIA_TUNERFLNB_H
+
+#include <aidl/android/media/tv/tuner/BnTunerLnb.h>
+#include <android/hardware/tv/tuner/1.0/ILnb.h>
+#include <android/hardware/tv/tuner/1.0/ILnbCallback.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <utils/Log.h>
+
+using Status = ::ndk::ScopedAStatus;
+using ::aidl::android::media::tv::tuner::BnTunerLnb;
+using ::aidl::android::media::tv::tuner::ITunerLnbCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::tv::tuner::V1_0::ILnb;
+using ::android::hardware::tv::tuner::V1_0::ILnbCallback;
+using ::android::hardware::tv::tuner::V1_0::LnbEventType;
+
+using namespace std;
+
+namespace android {
+
+class TunerLnb : public BnTunerLnb {
+
+public:
+ TunerLnb(sp<ILnb> lnb, int id);
+ virtual ~TunerLnb();
+ Status setCallback(const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) override;
+ Status setVoltage(int voltage) override;
+ Status setTone(int voltage) override;
+ Status setSatellitePosition(int position) override;
+ Status sendDiseqcMessage(const vector<uint8_t>& diseqcMessage) override;
+ Status close() override;
+
+ struct LnbCallback : public ILnbCallback {
+ LnbCallback(const shared_ptr<ITunerLnbCallback> tunerLnbCallback)
+ : mTunerLnbCallback(tunerLnbCallback) {};
+
+ virtual Return<void> onEvent(const LnbEventType lnbEventType);
+ virtual Return<void> onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage);
+
+ shared_ptr<ITunerLnbCallback> mTunerLnbCallback;
+ };
+
+private:
+ int mId;
+ sp<ILnb> mLnb;
+};
+
+} // namespace android
+
+#endif // ANDROID_MEDIA_TUNERFLNB_H
diff --git a/services/tuner/TunerService.cpp b/services/tuner/TunerService.cpp
index c34ddf6..ef3d1f2 100644
--- a/services/tuner/TunerService.cpp
+++ b/services/tuner/TunerService.cpp
@@ -18,8 +18,9 @@
#include <android/binder_manager.h>
#include <utils/Log.h>
-#include "TunerFrontend.h"
#include "TunerService.h"
+#include "TunerFrontend.h"
+#include "TunerLnb.h"
using ::aidl::android::media::tv::tuner::TunerFrontendAnalogCapabilities;
using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3Capabilities;
@@ -39,6 +40,9 @@
using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
using ::android::hardware::tv::tuner::V1_0::FrontendId;
using ::android::hardware::tv::tuner::V1_0::FrontendType;
+using ::android::hardware::tv::tuner::V1_0::IFrontend;
+using ::android::hardware::tv::tuner::V1_0::ILnb;
+using ::android::hardware::tv::tuner::V1_0::LnbId;
using ::android::hardware::tv::tuner::V1_0::Result;
namespace android {
@@ -47,7 +51,7 @@
TunerService::~TunerService() {}
void TunerService::instantiate() {
- std::shared_ptr<TunerService> service =
+ shared_ptr<TunerService> service =
::ndk::SharedRefBase::make<TunerService>();
AServiceManager_addService(service->asBinder().get(), getServiceName());
}
@@ -61,8 +65,8 @@
static_assert(sizeof(HidlPayload) == sizeof(AidlPayload), "Payload types are incompatible");
static_assert(
has_typedef_fixed_size<AidlPayload>::value == true ||
- std::is_fundamental<AidlPayload>::value ||
- std::is_enum<AidlPayload>::value,
+ is_fundamental<AidlPayload>::value ||
+ is_enum<AidlPayload>::value,
"Only fundamental types, enums, and AIDL parcelables annotated with @FixedSize "
"and built for the NDK backend are supported as AIDL payload types.");
aidlDesc->fileDescriptor = ndk::ScopedFileDescriptor(dup(hidlDesc.handle()->data[0]));
@@ -192,7 +196,7 @@
if (getQueueDescResult == Result::SUCCESS) {
unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, SynchronizedReadWrite>(
mFilterMQDesc, &mAidlMQDesc);
- mAidlMq = new (std::nothrow) AidlMessageQueue(mAidlMQDesc);
+ mAidlMq = new (nothrow) AidlMessageQueue(mAidlMQDesc);
EventFlag::createEventFlag(mAidlMq->getEventFlagWord(), &mEventFlag);
} else {
ALOGD("get MQDesc failed, res = %d", getQueueDescResult);
@@ -200,9 +204,9 @@
return getQueueDescResult;
}
-Status TunerService::getFrontendIds(std::vector<int32_t>* ids, int32_t* /* _aidl_return */) {
+Status TunerService::getFrontendIds(vector<int32_t>* ids, int32_t* /* _aidl_return */) {
if (!getITuner()) {
- return ::ndk::ScopedAStatus::fromServiceSpecificError(
+ return Status::fromServiceSpecificError(
static_cast<int32_t>(Result::NOT_INITIALIZED));
}
hidl_vec<FrontendId> feIds;
@@ -212,10 +216,10 @@
res = r;
});
if (res != Result::SUCCESS) {
- return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
+ return Status::fromServiceSpecificError(static_cast<int32_t>(res));
}
ids->resize(feIds.size());
- std::copy(feIds.begin(), feIds.end(), ids->begin());
+ copy(feIds.begin(), feIds.end(), ids->begin());
return Status::ok();
}
@@ -230,7 +234,7 @@
Result res;
FrontendInfo info;
- int feId = getResourceIdFromHandle(frontendHandle);
+ int feId = getResourceIdFromHandle(frontendHandle, FRONTEND);
mTuner->getFrontendInfo(feId, [&](Result r, const FrontendInfo& feInfo) {
info = feInfo;
res = r;
@@ -245,15 +249,85 @@
}
Status TunerService::openFrontend(
- int32_t frontendHandle, std::shared_ptr<ITunerFrontend>* _aidl_return) {
+ int32_t frontendHandle, shared_ptr<ITunerFrontend>* _aidl_return) {
if (mTuner == nullptr) {
ALOGE("ITuner service is not init.");
- return ::ndk::ScopedAStatus::fromServiceSpecificError(
- static_cast<int32_t>(Result::UNAVAILABLE));
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
}
- int id = getResourceIdFromHandle(frontendHandle);
- *_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(mTuner, id);
+ Result status;
+ sp<IFrontend> frontend;
+ int id = getResourceIdFromHandle(frontendHandle, FRONTEND);
+ mTuner->openFrontendById(id, [&](Result result, const sp<IFrontend>& fe) {
+ frontend = fe;
+ status = result;
+ });
+ if (status != Result::SUCCESS) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(status));
+ }
+ *_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(frontend, id);
+ return Status::ok();
+}
+
+Status TunerService::getFmqSyncReadWrite(
+ MQDescriptor<int8_t, SynchronizedReadWrite>* mqDesc, bool* _aidl_return) {
+ ALOGD("getFmqSyncReadWrite");
+ // TODO: put the following methods AIDL, and should be called from clients.
+ openDemux();
+ openFilter();
+ configFilter();
+ mFilter->start();
+ if (mqDesc == nullptr) {
+ ALOGD("getFmqSyncReadWrite null MQDescriptor.");
+ *_aidl_return = false;
+ } else {
+ ALOGD("getFmqSyncReadWrite true");
+ *_aidl_return = true;
+ *mqDesc = move(mAidlMQDesc);
+ }
+ return ndk::ScopedAStatus::ok();
+}
+
+Status TunerService::openLnb(int lnbHandle, shared_ptr<ITunerLnb>* _aidl_return) {
+ if (mTuner == nullptr) {
+ ALOGE("ITuner service is not init.");
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
+ }
+
+ Result status;
+ sp<ILnb> lnb;
+ int id = getResourceIdFromHandle(lnbHandle, LNB);
+ mTuner->openLnbById(id, [&](Result result, const sp<ILnb>& lnbSp){
+ lnb = lnbSp;
+ status = result;
+ });
+ if (status != Result::SUCCESS) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(status));
+ }
+
+ *_aidl_return = ::ndk::SharedRefBase::make<TunerLnb>(lnb, id);
+ return Status::ok();
+}
+
+Status TunerService::openLnbByName(const string& lnbName, shared_ptr<ITunerLnb>* _aidl_return) {
+ if (mTuner == nullptr) {
+ ALOGE("ITuner service is not init.");
+ return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
+ }
+
+ int lnbId;
+ Result status;
+ sp<ILnb> lnb;
+ mTuner->openLnbByName(lnbName, [&](Result r, LnbId id, const sp<ILnb>& lnbSp) {
+ status = r;
+ lnb = lnbSp;
+ lnbId = (int)id;
+ });
+ if (status != Result::SUCCESS) {
+ return Status::fromServiceSpecificError(static_cast<int32_t>(status));
+ }
+
+ *_aidl_return = ::ndk::SharedRefBase::make<TunerLnb>(lnb, lnbId);
return Status::ok();
}
@@ -367,24 +441,4 @@
info.caps = caps;
return info;
}
-
-Status TunerService::getFmqSyncReadWrite(
- MQDescriptor<int8_t, SynchronizedReadWrite>* mqDesc, bool* _aidl_return) {
- ALOGD("getFmqSyncReadWrite");
- // TODO: put the following methods AIDL, and should be called from clients.
- openDemux();
- openFilter();
- configFilter();
- mFilter->start();
- if (mqDesc == nullptr) {
- ALOGD("getFmqSyncReadWrite null MQDescriptor.");
- *_aidl_return = false;
- } else {
- ALOGD("getFmqSyncReadWrite true");
- *_aidl_return = true;
- *mqDesc = std::move(mAidlMQDesc);
- }
- return ndk::ScopedAStatus::ok();
-}
-
} // namespace android
diff --git a/services/tuner/TunerService.h b/services/tuner/TunerService.h
index 021ed26..82b6fcd 100644
--- a/services/tuner/TunerService.h
+++ b/services/tuner/TunerService.h
@@ -28,6 +28,7 @@
using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
using ::aidl::android::media::tv::tuner::BnTunerService;
using ::aidl::android::media::tv::tuner::ITunerFrontend;
+using ::aidl::android::media::tv::tuner::ITunerLnb;
using ::aidl::android::media::tv::tuner::TunerFrontendInfo;
using ::android::hardware::details::logError;
@@ -55,8 +56,16 @@
using Status = ::ndk::ScopedAStatus;
+using namespace std;
+
namespace android {
+typedef enum {
+ FRONTEND,
+ LNB,
+ DEMUX,
+ DESCRAMBLER,
+} TunerResourceType;
struct FilterCallback : public IFilterCallback {
~FilterCallback() {}
@@ -80,16 +89,18 @@
virtual ~TunerService();
// TODO: create a map between resource id and handles.
- static int getResourceIdFromHandle(int resourceHandle) {
+ static int getResourceIdFromHandle(int resourceHandle, int /*type*/) {
return (resourceHandle & 0x00ff0000) >> 16;
}
- Status getFrontendIds(std::vector<int32_t>* ids, int32_t* _aidl_return) override;
+ Status getFrontendIds(vector<int32_t>* ids, int32_t* _aidl_return) override;
Status getFrontendInfo(int32_t frontendHandle, TunerFrontendInfo* _aidl_return) override;
Status openFrontend(
- int32_t frontendHandle, std::shared_ptr<ITunerFrontend>* _aidl_return) override;
+ int32_t frontendHandle, shared_ptr<ITunerFrontend>* _aidl_return) override;
Status getFmqSyncReadWrite(
MQDescriptor<int8_t, SynchronizedReadWrite>* mqDesc, bool* _aidl_return) override;
+ Status openLnb(int lnbHandle, shared_ptr<ITunerLnb>* _aidl_return) override;
+ Status openLnbByName(const string& lnbName, shared_ptr<ITunerLnb>* _aidl_return) override;
private:
template <typename HidlPayload, typename AidlPayload, typename AidlFlavor>
diff --git a/services/tuner/TunerTimeFilter.cpp b/services/tuner/TunerTimeFilter.cpp
new file mode 100644
index 0000000..dce76d2
--- /dev/null
+++ b/services/tuner/TunerTimeFilter.cpp
@@ -0,0 +1,50 @@
+/**
+ * Copyright 2021, 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 "TunerTimeFilter"
+
+#include "TunerTimeFilter.h"
+
+namespace android {
+
+TunerTimeFilter::TunerTimeFilter(sp<ITimeFilter> timeFilter) {
+ mTimeFilter = timeFilter;
+}
+
+TunerTimeFilter::~TunerTimeFilter() {
+ mTimeFilter = NULL;
+}
+
+Status TunerTimeFilter::setTimeStamp(int64_t /*timeStamp*/) {
+ return Status::ok();
+}
+
+Status TunerTimeFilter::clearTimeStamp() {
+ return Status::ok();
+}
+
+Status TunerTimeFilter::getSourceTime(int64_t* /*_aidl_return*/) {
+ return Status::ok();
+}
+
+Status TunerTimeFilter::getTimeStamp(int64_t* /*_aidl_return*/) {
+ return Status::ok();
+}
+
+Status TunerTimeFilter::close() {
+ return Status::ok();
+}
+} // namespace android
diff --git a/services/tuner/TunerTimeFilter.h b/services/tuner/TunerTimeFilter.h
new file mode 100644
index 0000000..50b8f54
--- /dev/null
+++ b/services/tuner/TunerTimeFilter.h
@@ -0,0 +1,53 @@
+/**
+ * Copyright 2021, 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.
+ */
+
+#ifndef ANDROID_MEDIA_TUNERFTIMEFILTER_H
+#define ANDROID_MEDIA_TUNERFTIMEFILTER_H
+
+#include <aidl/android/media/tv/tuner/BnTunerTimeFilter.h>
+#include <android/hardware/tv/tuner/1.0/ITimeFilter.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <utils/Log.h>
+
+using Status = ::ndk::ScopedAStatus;
+using ::aidl::android::media::tv::tuner::BnTunerTimeFilter;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::tv::tuner::V1_0::ITimeFilter;
+
+using namespace std;
+
+namespace android {
+
+class TunerTimeFilter : public BnTunerTimeFilter {
+
+public:
+ TunerTimeFilter(sp<ITimeFilter> timeFilter);
+ virtual ~TunerTimeFilter();
+ Status setTimeStamp(int64_t timeStamp) override;
+ Status clearTimeStamp() override;
+ Status getSourceTime(int64_t* _aidl_return) override;
+ Status getTimeStamp(int64_t* _aidl_return) override;
+ Status close() override;
+
+private:
+ sp<ITimeFilter> mTimeFilter;
+};
+
+} // namespace android
+
+#endif // ANDROID_MEDIA_TUNERFTIMEFILTER_H
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
index 2a54dc6..bfc3e30 100644
--- a/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerFrontend.aidl
@@ -21,7 +21,7 @@
import android.media.tv.tuner.TunerFrontendStatus;
/**
- * Tuner Frontend interface handles tuner related operations.
+ * Tuner Frontend interface handles frontend related operations.
*
* {@hide}
*/
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerLnb.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerLnb.aidl
new file mode 100644
index 0000000..d62145e
--- /dev/null
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerLnb.aidl
@@ -0,0 +1,56 @@
+/**
+ * Copyright 2021, 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.
+ */
+
+package android.media.tv.tuner;
+
+import android.media.tv.tuner.ITunerLnbCallback;
+
+/**
+ * Tuner Lnb interface handles Lnb related operations.
+ *
+ * {@hide}
+ */
+interface ITunerLnb {
+ /**
+ * Set the lnb callback.
+ */
+ void setCallback(in ITunerLnbCallback tunerLnbCallback);
+
+ /**
+ * Set the lnb's power voltage.
+ */
+ void setVoltage(in int voltage);
+
+ /**
+ * Set the lnb's tone mode.
+ */
+ void setTone(in int tone);
+
+ /**
+ * Select the lnb's position.
+ */
+ void setSatellitePosition(in int position);
+
+ /**
+ * Sends DiSEqC (Digital Satellite Equipment Control) message.
+ */
+ void sendDiseqcMessage(in byte[] diseqcMessage);
+
+ /**
+ * Releases the LNB instance.
+ */
+ void close();
+}
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerLnbCallback.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerLnbCallback.aidl
new file mode 100644
index 0000000..117352f
--- /dev/null
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerLnbCallback.aidl
@@ -0,0 +1,34 @@
+/**
+ * Copyright 2021, 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.
+ */
+
+package android.media.tv.tuner;
+
+/**
+ * TuneLnbCallback interface handles tuner lnb related callbacks.
+ *
+ * {@hide}
+ */
+interface ITunerLnbCallback {
+ /**
+ * Notify the client that a new event happened on the Lnb.
+ */
+ void onEvent(in int lnbEventType);
+
+ /**
+ * notify the client of new DiSEqC message.
+ */
+ void onDiseqcMessage(in byte[] diseqcMessage);
+}
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerService.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerService.aidl
index 205e222..5b60685 100644
--- a/services/tuner/aidl/android/media/tv/tuner/ITunerService.aidl
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerService.aidl
@@ -20,6 +20,7 @@
import android.hardware.common.fmq.SynchronizedReadWrite;
import android.hardware.common.fmq.UnsynchronizedWrite;
import android.media.tv.tuner.ITunerFrontend;
+import android.media.tv.tuner.ITunerLnb;
import android.media.tv.tuner.TunerFrontendInfo;
/**
@@ -59,4 +60,21 @@
* @return true if succeeds, false otherwise.
*/
boolean getFmqSyncReadWrite(out MQDescriptor<byte, SynchronizedReadWrite> mqDesc);
+
+ /**
+ * Open a new interface of ITunerLnb given a lnbHandle.
+ *
+ * @param lnbHandle the handle of the LNB granted by TRM.
+ * @return a newly created ITunerLnb interface.
+ */
+ ITunerLnb openLnb(in int lnbHandle);
+
+ /**
+ * Open a new interface of ITunerLnb given a LNB name.
+ *
+ * @param lnbName the name for an external LNB to be opened.
+ * @return a newly created ITunerLnb interface.
+ */
+ ITunerLnb openLnbByName(in String lnbName);
+
}
diff --git a/services/tuner/aidl/android/media/tv/tuner/ITunerTimeFilter.aidl b/services/tuner/aidl/android/media/tv/tuner/ITunerTimeFilter.aidl
new file mode 100644
index 0000000..f84b9bf
--- /dev/null
+++ b/services/tuner/aidl/android/media/tv/tuner/ITunerTimeFilter.aidl
@@ -0,0 +1,49 @@
+/**
+ * Copyright 2021, 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.
+ */
+
+package android.media.tv.tuner;
+
+/**
+ * Tuner Time Filter interface handles time filter related operations.
+ *
+ * {@hide}
+ */
+interface ITunerTimeFilter {
+ /**
+ * Set time stamp for time based filter.
+ */
+ void setTimeStamp(in long timeStamp);
+
+ /**
+ * Clear the time stamp in the time filter.
+ */
+ void clearTimeStamp();
+
+ /**
+ * Get the time from the beginning of current data source.
+ */
+ long getSourceTime();
+
+ /**
+ * Get the current time in the time filter.
+ */
+ long getTimeStamp();
+
+ /**
+ * Close the Time Filter instance.
+ */
+ void close();
+}