diff --git a/services/tuner/TunerFrontend.cpp b/services/tuner/TunerFrontend.cpp
index ba4553b..17c60c0 100644
--- a/services/tuner/TunerFrontend.cpp
+++ b/services/tuner/TunerFrontend.cpp
@@ -19,8 +19,8 @@
 #include "TunerFrontend.h"
 #include "TunerService.h"
 
-using ::aidl::android::media::tv::tuner::TunerAtsc3PlpInfo;
 using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
+using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
 using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
 using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
 using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
@@ -69,12 +69,13 @@
 using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
 using ::android::hardware::tv::tuner::V1_0::FrontendSettings;;
 using ::android::hardware::tv::tuner::V1_0::Result;
+using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
 
 namespace android {
 
-TunerFrontend::TunerFrontend(sp<ITuner> tuner, int frontendHandle) {
+TunerFrontend::TunerFrontend(sp<ITuner> tuner, int id) {
     mTuner = tuner;
-    mId = TunerService::getResourceIdFromHandle(frontendHandle);
+    mId = id;
 
     if (mTuner != NULL) {
         Result status;
@@ -308,10 +309,14 @@
 }
 
 Status TunerFrontend::getStatus(const std::vector<int32_t>& /*statusTypes*/,
-		std::vector<TunerFrontendStatus>* /*_aidl_return*/) {
+        std::vector<TunerFrontendStatus>* /*_aidl_return*/) {
     return Status::ok();
 }
 
+Status TunerFrontend::getFrontendId(int* _aidl_return) {
+    *_aidl_return = mId;
+    return Status::ok();
+}
 /////////////// FrontendCallback ///////////////////////
 
 Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
@@ -323,59 +328,56 @@
 Return<void> TunerFrontend::FrontendCallback::onScanMessage(
         FrontendScanMessageType type, const FrontendScanMessage& message) {
     ALOGD("FrontendCallback::onScanMessage, type=%d", type);
+    TunerFrontendScanMessage scanMessage;
     switch(type) {
         case FrontendScanMessageType::LOCKED: {
-            if (message.isLocked()) {
-                mTunerFrontendCallback->onLocked();
-            }
+            scanMessage.set<TunerFrontendScanMessage::isLocked>(message.isLocked());
             break;
         }
         case FrontendScanMessageType::END: {
-            if (message.isEnd()) {
-                mTunerFrontendCallback->onScanStopped();
-            }
+            scanMessage.set<TunerFrontendScanMessage::isEnd>(message.isEnd());
             break;
         }
         case FrontendScanMessageType::PROGRESS_PERCENT: {
-            mTunerFrontendCallback->onProgress((int)message.progressPercent());
+            scanMessage.set<TunerFrontendScanMessage::progressPercent>(message.progressPercent());
             break;
         }
         case FrontendScanMessageType::FREQUENCY: {
             auto f = message.frequencies();
-            std::vector<int32_t> frequencies(std::begin(f), std::end(f));
-            mTunerFrontendCallback->onFrequenciesReport(frequencies);
+            std::vector<int> frequencies(std::begin(f), std::end(f));
+            scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
             break;
         }
         case FrontendScanMessageType::SYMBOL_RATE: {
             auto s = message.symbolRates();
-            std::vector<int32_t> symbolRates(std::begin(s), std::end(s));
-            mTunerFrontendCallback->onSymbolRates(symbolRates);
+            std::vector<int> symbolRates(std::begin(s), std::end(s));
+            scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
             break;
         }
         case FrontendScanMessageType::HIERARCHY: {
-            mTunerFrontendCallback->onHierarchy((int)message.hierarchy());
+            scanMessage.set<TunerFrontendScanMessage::hierarchy>((int)message.hierarchy());
             break;
         }
         case FrontendScanMessageType::ANALOG_TYPE: {
-            mTunerFrontendCallback->onSignalType((int)message.analogType());
+            scanMessage.set<TunerFrontendScanMessage::analogType>((int)message.analogType());
             break;
         }
         case FrontendScanMessageType::PLP_IDS: {
             auto p = message.plpIds();
-            std::vector<int32_t> plpIds(std::begin(p), std::end(p));
-            mTunerFrontendCallback->onPlpIds(plpIds);
+            std::vector<uint8_t> plpIds(std::begin(p), std::end(p));
+            scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
             break;
         }
         case FrontendScanMessageType::GROUP_IDS: {
             auto g = message.groupIds();
-            std::vector<int32_t> groupIds(std::begin(g), std::end(g));
-            mTunerFrontendCallback->onGroupIds(groupIds);
+            std::vector<uint8_t> groupIds(std::begin(g), std::end(g));
+            scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
             break;
         }
         case FrontendScanMessageType::INPUT_STREAM_IDS: {
             auto i = message.inputStreamIds();
-            std::vector<int32_t> streamIds(std::begin(i), std::end(i));
-            mTunerFrontendCallback->onInputStreamIds(streamIds);
+            std::vector<char16_t> streamIds(std::begin(i), std::end(i));
+            scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
             break;
         }
         case FrontendScanMessageType::STANDARD: {
@@ -383,37 +385,81 @@
             int standard;
             if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {
                 standard = (int) std.sStd();
-                mTunerFrontendCallback->onDvbsStandard(standard);
             } else if (std.getDiscriminator() ==
                     FrontendScanMessage::Standard::hidl_discriminator::tStd) {
                 standard = (int) std.tStd();
-                mTunerFrontendCallback->onDvbsStandard(standard);
             } else if (std.getDiscriminator() ==
                     FrontendScanMessage::Standard::hidl_discriminator::sifStd) {
                 standard = (int) std.sifStd();
-                mTunerFrontendCallback->onAnalogSifStandard(standard);
             }
+            scanMessage.set<TunerFrontendScanMessage::std>(standard);
             break;
         }
         case FrontendScanMessageType::ATSC3_PLP_INFO: {
             std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
-            std::vector<TunerAtsc3PlpInfo> tunerPlpInfos;
+            std::vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
             for (int i = 0; i < plpInfos.size(); i++) {
                 auto info = plpInfos[i];
                 int plpId = (int) info.plpId;
                 bool lls = (bool) info.bLlsFlag;
-                TunerAtsc3PlpInfo plpInfo{
+                TunerFrontendScanAtsc3PlpInfo plpInfo{
                     .plpId = plpId,
                     .llsFlag = lls,
                 };
                 tunerPlpInfos.push_back(plpInfo);
             }
-            mTunerFrontendCallback->onAtsc3PlpInfos(tunerPlpInfos);
+            scanMessage.set<TunerFrontendScanMessage::atsc3PlpInfos>(tunerPlpInfos);
             break;
         }
         default:
             break;
     }
+    mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
+    return Void();
+}
+
+Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1(
+        FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message) {
+    ALOGD("onScanMessageExt1_1::onScanMessage, type=%d", type);
+    TunerFrontendScanMessage scanMessage;
+    switch(type) {
+        case FrontendScanMessageTypeExt1_1::MODULATION: {
+            FrontendModulation m = message.modulation();
+            int modulation;
+            if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbc) {
+                modulation = (int) m.dvbc();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbt) {
+                modulation = (int) m.dvbt();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbs) {
+                modulation = (int) m.dvbs();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs) {
+                modulation = (int) m.isdbs();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs3) {
+                modulation = (int) m.isdbs3();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbt) {
+                modulation = (int) m.isdbt();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc) {
+                modulation = (int) m.atsc();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc3) {
+                modulation = (int) m.atsc3();
+            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dtmb) {
+                modulation = (int) m.dtmb();
+            }
+            scanMessage.set<TunerFrontendScanMessage::modulation>(modulation);
+            break;
+        }
+        case FrontendScanMessageTypeExt1_1::DVBC_ANNEX: {
+            scanMessage.set<TunerFrontendScanMessage::annex>((int)message.annex());
+            break;
+        }
+        case FrontendScanMessageTypeExt1_1::HIGH_PRIORITY: {
+            scanMessage.set<TunerFrontendScanMessage::isHighPriority>(message.isHighPriority());
+            break;
+        }
+        default:
+            break;
+    }
+    mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
     return Void();
 }