diff --git a/sensors/2.0/multihal/Android.bp b/sensors/2.0/multihal/Android.bp
index bf51fcd..3ce3390 100644
--- a/sensors/2.0/multihal/Android.bp
+++ b/sensors/2.0/multihal/Android.bp
@@ -25,9 +25,6 @@
     ],
     init_rc: ["android.hardware.sensors@2.0-service-multihal.rc"],
     vintf_fragments: ["android.hardware.sensors@2.0-multihal.xml"],
-    header_libs: [
-        "android.hardware.sensors@2.X-shared-utils",
-    ],
     shared_libs: [
         "android.hardware.sensors@2.0",
         "android.hardware.sensors@2.0-ScopedWakelock",
@@ -40,8 +37,5 @@
         "libpower",
         "libutils",
     ],
-    static_libs: [
-        "android.hardware.sensors@1.0-convert",
-        "android.hardware.sensors@2.X-multihal",
-    ],
+    static_libs: ["android.hardware.sensors@2.X-multihal"],
 }
diff --git a/sensors/2.0/multihal/service.cpp b/sensors/2.0/multihal/service.cpp
index f50ad7e..ef77048 100644
--- a/sensors/2.0/multihal/service.cpp
+++ b/sensors/2.0/multihal/service.cpp
@@ -23,12 +23,12 @@
 using android::hardware::configureRpcThreadpool;
 using android::hardware::joinRpcThreadpool;
 using android::hardware::sensors::V2_0::ISensors;
-using android::hardware::sensors::V2_1::implementation::HalProxyV2_0;
+using android::hardware::sensors::V2_0::implementation::HalProxy;
 
 int main(int /* argc */, char** /* argv */) {
     configureRpcThreadpool(1, true);
 
-    android::sp<ISensors> halProxy = new HalProxyV2_0();
+    android::sp<ISensors> halProxy = new HalProxy();
     if (halProxy->registerAsService() != ::android::OK) {
         ALOGE("Failed to register Sensors HAL instance");
         return -1;
diff --git a/sensors/2.1/multihal/Android.bp b/sensors/2.1/multihal/Android.bp
deleted file mode 100644
index 6a7cac9..0000000
--- a/sensors/2.1/multihal/Android.bp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright (C) 2020 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.
-
-cc_binary {
-    name: "android.hardware.sensors@2.1-service.multihal",
-    defaults: [
-        "hidl_defaults",
-    ],
-    vendor: true,
-    relative_install_path: "hw",
-    srcs: [
-        "service.cpp",
-    ],
-    init_rc: ["android.hardware.sensors@2.1-service-multihal.rc"],
-    vintf_fragments: ["android.hardware.sensors@2.1-multihal.xml"],
-    header_libs: [
-        "android.hardware.sensors@2.X-shared-utils",
-    ],
-    shared_libs: [
-        "android.hardware.sensors@2.0",
-        "android.hardware.sensors@2.0-ScopedWakelock",
-        "android.hardware.sensors@2.1",
-        "libbase",
-        "libcutils",
-        "libfmq",
-        "libhidlbase",
-        "liblog",
-        "libpower",
-        "libutils",
-    ],
-    static_libs: [
-        "android.hardware.sensors@1.0-convert",
-        "android.hardware.sensors@2.X-multihal",
-    ],
-}
diff --git a/sensors/2.1/multihal/OWNERS b/sensors/2.1/multihal/OWNERS
deleted file mode 100644
index e955670..0000000
--- a/sensors/2.1/multihal/OWNERS
+++ /dev/null
@@ -1,3 +0,0 @@
-arthuri@google.com
-bduddie@google.com
-stange@google.com
\ No newline at end of file
diff --git a/sensors/2.1/multihal/android.hardware.sensors@2.1-multihal.xml b/sensors/2.1/multihal/android.hardware.sensors@2.1-multihal.xml
deleted file mode 100644
index 18bd3ae..0000000
--- a/sensors/2.1/multihal/android.hardware.sensors@2.1-multihal.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<manifest version="1.0" type="device">
-    <hal format="hidl">
-        <name>android.hardware.sensors</name>
-        <transport>hwbinder</transport>
-        <version>2.1</version>
-        <interface>
-            <name>ISensors</name>
-            <instance>default</instance>
-        </interface>
-    </hal>
-</manifest>
diff --git a/sensors/2.1/multihal/android.hardware.sensors@2.1-service-multihal.rc b/sensors/2.1/multihal/android.hardware.sensors@2.1-service-multihal.rc
deleted file mode 100644
index fc99ee7..0000000
--- a/sensors/2.1/multihal/android.hardware.sensors@2.1-service-multihal.rc
+++ /dev/null
@@ -1,7 +0,0 @@
-service vendor.sensors-hal-2-1-multihal /vendor/bin/hw/android.hardware.sensors@2.1-service.multihal
-    class hal
-    user system
-    group system wakelock context_hub
-    writepid /dev/cpuset/system-background/tasks
-    capabilities BLOCK_SUSPEND
-    rlimit rtprio 10 10
diff --git a/sensors/2.1/multihal/service.cpp b/sensors/2.1/multihal/service.cpp
deleted file mode 100644
index d68d9a3..0000000
--- a/sensors/2.1/multihal/service.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2020 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.
- */
-
-#include <android/hardware/sensors/2.1/ISensors.h>
-#include <hidl/HidlTransportSupport.h>
-#include <log/log.h>
-#include <utils/StrongPointer.h>
-#include "HalProxy.h"
-
-using android::hardware::configureRpcThreadpool;
-using android::hardware::joinRpcThreadpool;
-using android::hardware::sensors::V2_1::ISensors;
-using android::hardware::sensors::V2_1::implementation::HalProxyV2_1;
-
-int main(int /* argc */, char** /* argv */) {
-    configureRpcThreadpool(1, true);
-
-    android::sp<ISensors> halProxy = new HalProxyV2_1();
-    if (halProxy->registerAsService() != ::android::OK) {
-        ALOGE("Failed to register Sensors HAL instance");
-        return -1;
-    }
-
-    joinRpcThreadpool();
-    return 1;  // joinRpcThreadpool shouldn't exit
-}
diff --git a/sensors/common/default/2.X/multihal/Android.bp b/sensors/common/default/2.X/multihal/Android.bp
index c80c47a..6122323 100644
--- a/sensors/common/default/2.X/multihal/Android.bp
+++ b/sensors/common/default/2.X/multihal/Android.bp
@@ -17,7 +17,6 @@
     name: "android.hardware.sensors@2.X-multihal-defaults",
     header_libs: [
         "android.hardware.sensors@2.X-multihal.header",
-        "android.hardware.sensors@2.X-shared-utils",
     ],
     shared_libs: [
         "android.hardware.sensors@1.0",
@@ -31,9 +30,6 @@
         "libpower",
         "libutils",
     ],
-    static_libs: [
-        "android.hardware.sensors@1.0-convert",
-    ],
     cflags: ["-DLOG_TAG=\"SensorsMultiHal\""],
 }
 
@@ -66,7 +62,6 @@
     ],
     srcs: [
         "HalProxy.cpp",
-        "HalProxyCallback.cpp",
     ],
     vendor_available: true,
     export_header_lib_headers: [
diff --git a/sensors/common/default/2.X/multihal/HalProxy.cpp b/sensors/common/default/2.X/multihal/HalProxy.cpp
index a09e9e9..869c033 100644
--- a/sensors/common/default/2.X/multihal/HalProxy.cpp
+++ b/sensors/common/default/2.X/multihal/HalProxy.cpp
@@ -32,17 +32,15 @@
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace implementation {
 
-using ::android::hardware::sensors::V1_0::Result;
 using ::android::hardware::sensors::V2_0::EventQueueFlagBits;
 using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
 using ::android::hardware::sensors::V2_0::implementation::getTimeNow;
 using ::android::hardware::sensors::V2_0::implementation::kWakelockTimeoutNs;
 
-typedef V2_0::implementation::ISensorsSubHal*(SensorsHalGetSubHalFunc)(uint32_t*);
-typedef V2_1::implementation::ISensorsSubHal*(SensorsHalGetSubHalV2_1Func)(uint32_t*);
+typedef ISensorsSubHal*(SensorsHalGetSubHalFunc)(uint32_t*);
 
 static constexpr int32_t kBitsAfterSubHalIndex = 24;
 
@@ -87,24 +85,7 @@
     init();
 }
 
-HalProxy::HalProxy(std::vector<ISensorsSubHalV2_0*>& subHalList) {
-    for (ISensorsSubHalV2_0* subHal : subHalList) {
-        mSubHalList.push_back(std::make_unique<SubHalWrapperV2_0>(subHal));
-    }
-
-    init();
-}
-
-HalProxy::HalProxy(std::vector<ISensorsSubHalV2_0*>& subHalList,
-                   std::vector<ISensorsSubHalV2_1*>& subHalListV2_1) {
-    for (ISensorsSubHalV2_0* subHal : subHalList) {
-        mSubHalList.push_back(std::make_unique<SubHalWrapperV2_0>(subHal));
-    }
-
-    for (ISensorsSubHalV2_1* subHal : subHalListV2_1) {
-        mSubHalList.push_back(std::make_unique<SubHalWrapperV2_1>(subHal));
-    }
-
+HalProxy::HalProxy(std::vector<ISensorsSubHal*>& subHalList) : mSubHalList(subHalList) {
     init();
 }
 
@@ -112,8 +93,8 @@
     stopThreads();
 }
 
-Return<void> HalProxy::getSensorsList_2_1(ISensorsV2_1::getSensorsList_2_1_cb _hidl_cb) {
-    std::vector<V2_1::SensorInfo> sensors;
+Return<void> HalProxy::getSensorsList(getSensorsList_cb _hidl_cb) {
+    std::vector<SensorInfo> sensors;
     for (const auto& iter : mSensors) {
         sensors.push_back(iter.second);
     }
@@ -121,31 +102,22 @@
     return Void();
 }
 
-Return<void> HalProxy::getSensorsList(ISensorsV2_0::getSensorsList_cb _hidl_cb) {
-    std::vector<V1_0::SensorInfo> sensors;
-    for (const auto& iter : mSensors) {
-        sensors.push_back(convertToOldSensorInfo(iter.second));
-    }
-    _hidl_cb(sensors);
-    return Void();
-}
-
 Return<Result> HalProxy::setOperationMode(OperationMode mode) {
     Result result = Result::OK;
     size_t subHalIndex;
     for (subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
-        result = mSubHalList[subHalIndex]->setOperationMode(mode);
+        ISensorsSubHal* subHal = mSubHalList[subHalIndex];
+        result = subHal->setOperationMode(mode);
         if (result != Result::OK) {
-            ALOGE("setOperationMode failed for SubHal: %s",
-                  mSubHalList[subHalIndex]->getName().c_str());
+            ALOGE("setOperationMode failed for SubHal: %s", subHal->getName().c_str());
             break;
         }
     }
-
     if (result != Result::OK) {
         // Reset the subhal operation modes that have been flipped
         for (size_t i = 0; i < subHalIndex; i++) {
-            mSubHalList[i]->setOperationMode(mCurrentOperationMode);
+            ISensorsSubHal* subHal = mSubHalList[i];
+            subHal->setOperationMode(mCurrentOperationMode);
         }
     } else {
         mCurrentOperationMode = mode;
@@ -161,42 +133,10 @@
             ->activate(clearSubHalIndex(sensorHandle), enabled);
 }
 
-Return<Result> HalProxy::initialize_2_1(
-        const ::android::hardware::MQDescriptorSync<V2_1::Event>& eventQueueDescriptor,
-        const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-        const sp<V2_1::ISensorsCallback>& sensorsCallback) {
-    sp<ISensorsCallbackWrapperBase> dynamicCallback =
-            new ISensorsCallbackWrapperV2_1(sensorsCallback);
-
-    // Create the Event FMQ from the eventQueueDescriptor. Reset the read/write positions.
-    auto eventQueue =
-            std::make_unique<EventMessageQueueV2_1>(eventQueueDescriptor, true /* resetPointers */);
-    std::unique_ptr<EventMessageQueueWrapperBase> queue =
-            std::make_unique<EventMessageQueueWrapperV2_1>(eventQueue);
-
-    return initializeCommon(queue, wakeLockDescriptor, dynamicCallback);
-}
-
 Return<Result> HalProxy::initialize(
-        const ::android::hardware::MQDescriptorSync<V1_0::Event>& eventQueueDescriptor,
+        const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor,
         const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-        const sp<V2_0::ISensorsCallback>& sensorsCallback) {
-    sp<ISensorsCallbackWrapperBase> dynamicCallback =
-            new ISensorsCallbackWrapperV2_0(sensorsCallback);
-
-    // Create the Event FMQ from the eventQueueDescriptor. Reset the read/write positions.
-    auto eventQueue =
-            std::make_unique<EventMessageQueueV2_0>(eventQueueDescriptor, true /* resetPointers */);
-    std::unique_ptr<EventMessageQueueWrapperBase> queue =
-            std::make_unique<EventMessageQueueWrapperV1_0>(eventQueue);
-
-    return initializeCommon(queue, wakeLockDescriptor, dynamicCallback);
-}
-
-Return<Result> HalProxy::initializeCommon(
-        std::unique_ptr<EventMessageQueueWrapperBase>& eventQueue,
-        const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-        const sp<ISensorsCallbackWrapperBase>& sensorsCallback) {
+        const sp<ISensorsCallback>& sensorsCallback) {
     Result result = Result::OK;
 
     stopThreads();
@@ -207,7 +147,7 @@
     disableAllSensors();
 
     // Clears the queue if any events were pending write before.
-    mPendingWriteEventsQueue = std::queue<std::pair<std::vector<V2_1::Event>, size_t>>();
+    mPendingWriteEventsQueue = std::queue<std::pair<std::vector<Event>, size_t>>();
     mSizePendingWriteEventsQueue = 0;
 
     // Clears previously connected dynamic sensors
@@ -216,7 +156,8 @@
     mDynamicSensorsCallback = sensorsCallback;
 
     // Create the Event FMQ from the eventQueueDescriptor. Reset the read/write positions.
-    mEventQueue = std::move(eventQueue);
+    mEventQueue =
+            std::make_unique<EventMessageQueue>(eventQueueDescriptor, true /* resetPointers */);
 
     // Create the Wake Lock FMQ that is used by the framework to communicate whenever WAKE_UP
     // events have been successfully read and handled by the framework.
@@ -245,10 +186,12 @@
     mWakelockThread = std::thread(startWakelockThread, this);
 
     for (size_t i = 0; i < mSubHalList.size(); i++) {
-        Result currRes = mSubHalList[i]->initialize(this, this, i);
+        auto subHal = mSubHalList[i];
+        const auto& subHalCallback = mSubHalCallbacks[i];
+        Result currRes = subHal->initialize(subHalCallback);
         if (currRes != Result::OK) {
             result = currRes;
-            ALOGE("Subhal '%s' failed to initialize.", mSubHalList[i]->getName().c_str());
+            ALOGE("Subhal '%s' failed to initialize.", subHal->getName().c_str());
             break;
         }
     }
@@ -274,11 +217,7 @@
     return getSubHalForSensorHandle(sensorHandle)->flush(clearSubHalIndex(sensorHandle));
 }
 
-Return<Result> HalProxy::injectSensorData_2_1(const V2_1::Event& event) {
-    return injectSensorData(convertToOldEvent(event));
-}
-
-Return<Result> HalProxy::injectSensorData(const V1_0::Event& event) {
+Return<Result> HalProxy::injectSensorData(const Event& event) {
     Result result = Result::OK;
     if (mCurrentOperationMode == OperationMode::NORMAL &&
         event.sensorType != V1_0::SensorType::ADDITIONAL_INFO) {
@@ -287,19 +226,18 @@
         result = Result::BAD_VALUE;
     }
     if (result == Result::OK) {
-        V1_0::Event subHalEvent = event;
+        Event subHalEvent = event;
         if (!isSubHalIndexValid(event.sensorHandle)) {
             return Result::BAD_VALUE;
         }
         subHalEvent.sensorHandle = clearSubHalIndex(event.sensorHandle);
-        result = getSubHalForSensorHandle(event.sensorHandle)
-                         ->injectSensorData(convertToNewEvent(subHalEvent));
+        result = getSubHalForSensorHandle(event.sensorHandle)->injectSensorData(subHalEvent);
     }
     return result;
 }
 
 Return<void> HalProxy::registerDirectChannel(const SharedMemInfo& mem,
-                                             ISensorsV2_0::registerDirectChannel_cb _hidl_cb) {
+                                             registerDirectChannel_cb _hidl_cb) {
     if (mDirectChannelSubHal == nullptr) {
         _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
     } else {
@@ -319,8 +257,7 @@
 }
 
 Return<void> HalProxy::configDirectReport(int32_t sensorHandle, int32_t channelHandle,
-                                          RateLevel rate,
-                                          ISensorsV2_0::configDirectReport_cb _hidl_cb) {
+                                          RateLevel rate, configDirectReport_cb _hidl_cb) {
     if (mDirectChannelSubHal == nullptr) {
         _hidl_cb(Result::INVALID_OPERATION, -1 /* reportToken */);
     } else if (sensorHandle == -1 && rate != RateLevel::STOP) {
@@ -365,7 +302,7 @@
     stream << "  # of non-dynamic sensors across all subhals: " << mSensors.size() << std::endl;
     stream << "  # of dynamic sensors across all subhals: " << mDynamicSensors.size() << std::endl;
     stream << "SubHals (" << mSubHalList.size() << "):" << std::endl;
-    for (auto& subHal : mSubHalList) {
+    for (ISensorsSubHal* subHal : mSubHalList) {
         stream << "  Name: " << subHal->getName() << std::endl;
         stream << "  Debug dump: " << std::endl;
         android::base::WriteStringToFd(stream.str(), writeFd);
@@ -432,37 +369,20 @@
             } else {
                 SensorsHalGetSubHalFunc* sensorsHalGetSubHalPtr =
                         (SensorsHalGetSubHalFunc*)dlsym(handle, "sensorsHalGetSubHal");
-                if (sensorsHalGetSubHalPtr != nullptr) {
+                if (sensorsHalGetSubHalPtr == nullptr) {
+                    ALOGE("Failed to locate sensorsHalGetSubHal function for library: %s",
+                          subHalLibraryFile.c_str());
+                } else {
                     std::function<SensorsHalGetSubHalFunc> sensorsHalGetSubHal =
                             *sensorsHalGetSubHalPtr;
                     uint32_t version;
-                    ISensorsSubHalV2_0* subHal = sensorsHalGetSubHal(&version);
+                    ISensorsSubHal* subHal = sensorsHalGetSubHal(&version);
                     if (version != SUB_HAL_2_0_VERSION) {
                         ALOGE("SubHal version was not 2.0 for library: %s",
                               subHalLibraryFile.c_str());
                     } else {
                         ALOGV("Loaded SubHal from library: %s", subHalLibraryFile.c_str());
-                        mSubHalList.push_back(std::make_unique<SubHalWrapperV2_0>(subHal));
-                    }
-                } else {
-                    SensorsHalGetSubHalV2_1Func* getSubHalV2_1Ptr =
-                            (SensorsHalGetSubHalV2_1Func*)dlsym(handle, "sensorsHalGetSubHal_2_1");
-
-                    if (getSubHalV2_1Ptr == nullptr) {
-                        ALOGE("Failed to locate sensorsHalGetSubHal function for library: %s",
-                              subHalLibraryFile.c_str());
-                    } else {
-                        std::function<SensorsHalGetSubHalV2_1Func> sensorsHalGetSubHal_2_1 =
-                                *getSubHalV2_1Ptr;
-                        uint32_t version;
-                        ISensorsSubHalV2_1* subHal = sensorsHalGetSubHal_2_1(&version);
-                        if (version != SUB_HAL_2_1_VERSION) {
-                            ALOGE("SubHal version was not 2.1 for library: %s",
-                                  subHalLibraryFile.c_str());
-                        } else {
-                            ALOGV("Loaded SubHal from library: %s", subHalLibraryFile.c_str());
-                            mSubHalList.push_back(std::make_unique<SubHalWrapperV2_1>(subHal));
-                        }
+                        mSubHalList.push_back(subHal);
                     }
                 }
             }
@@ -470,28 +390,36 @@
     }
 }
 
+void HalProxy::initializeSubHalCallbacks() {
+    for (size_t subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
+        sp<IHalProxyCallback> callback = new HalProxyCallback(this, subHalIndex);
+        mSubHalCallbacks.push_back(callback);
+    }
+}
+
 void HalProxy::initializeSensorList() {
     for (size_t subHalIndex = 0; subHalIndex < mSubHalList.size(); subHalIndex++) {
-        auto result = mSubHalList[subHalIndex]->getSensorsList([&](const auto& list) {
+        ISensorsSubHal* subHal = mSubHalList[subHalIndex];
+        auto result = subHal->getSensorsList([&](const auto& list) {
             for (SensorInfo sensor : list) {
                 if (!subHalIndexIsClear(sensor.sensorHandle)) {
                     ALOGE("SubHal sensorHandle's first byte was not 0");
                 } else {
                     ALOGV("Loaded sensor: %s", sensor.name.c_str());
                     sensor.sensorHandle = setSubHalIndex(sensor.sensorHandle, subHalIndex);
-                    setDirectChannelFlags(&sensor, mSubHalList[subHalIndex]);
+                    setDirectChannelFlags(&sensor, subHal);
                     mSensors[sensor.sensorHandle] = sensor;
                 }
             }
         });
         if (!result.isOk()) {
-            ALOGE("getSensorsList call failed for SubHal: %s",
-                  mSubHalList[subHalIndex]->getName().c_str());
+            ALOGE("getSensorsList call failed for SubHal: %s", subHal->getName().c_str());
         }
     }
 }
 
 void HalProxy::init() {
+    initializeSubHalCallbacks();
     initializeSensorList();
 }
 
@@ -624,7 +552,7 @@
 }
 
 void HalProxy::postEventsToMessageQueue(const std::vector<Event>& events, size_t numWakeupEvents,
-                                        V2_0::implementation::ScopedWakelock wakelock) {
+                                        ScopedWakelock wakelock) {
     size_t numToWrite = 0;
     std::lock_guard<std::mutex> lock(mEventQueueWriteMutex);
     if (wakelock.isLocked()) {
@@ -682,8 +610,7 @@
     }
 }
 
-void HalProxy::setDirectChannelFlags(SensorInfo* sensorInfo,
-                                     std::shared_ptr<ISubHalWrapperBase> subHal) {
+void HalProxy::setDirectChannelFlags(SensorInfo* sensorInfo, ISensorsSubHal* subHal) {
     bool sensorSupportsDirectChannel =
             (sensorInfo->flags & (V1_0::SensorFlagBits::MASK_DIRECT_REPORT |
                                   V1_0::SensorFlagBits::MASK_DIRECT_CHANNEL)) != 0;
@@ -697,7 +624,7 @@
     }
 }
 
-std::shared_ptr<ISubHalWrapperBase> HalProxy::getSubHalForSensorHandle(int32_t sensorHandle) {
+ISensorsSubHal* HalProxy::getSubHalForSensorHandle(int32_t sensorHandle) {
     return mSubHalList[extractSubHalIndex(sensorHandle)];
 }
 
@@ -724,8 +651,46 @@
     return (sensorHandle & kSensorHandleSubHalIndexMask) == 0;
 }
 
+void HalProxyCallback::postEvents(const std::vector<Event>& events, ScopedWakelock wakelock) {
+    if (events.empty() || !mHalProxy->areThreadsRunning()) return;
+    size_t numWakeupEvents;
+    std::vector<Event> processedEvents = processEvents(events, &numWakeupEvents);
+    if (numWakeupEvents > 0) {
+        ALOG_ASSERT(wakelock.isLocked(),
+                    "Wakeup events posted while wakelock unlocked for subhal"
+                    " w/ index %" PRId32 ".",
+                    mSubHalIndex);
+    } else {
+        ALOG_ASSERT(!wakelock.isLocked(),
+                    "No Wakeup events posted but wakelock locked for subhal"
+                    " w/ index %" PRId32 ".",
+                    mSubHalIndex);
+    }
+    mHalProxy->postEventsToMessageQueue(processedEvents, numWakeupEvents, std::move(wakelock));
+}
+
+ScopedWakelock HalProxyCallback::createScopedWakelock(bool lock) {
+    ScopedWakelock wakelock(mHalProxy, lock);
+    return wakelock;
+}
+
+std::vector<Event> HalProxyCallback::processEvents(const std::vector<Event>& events,
+                                                   size_t* numWakeupEvents) const {
+    *numWakeupEvents = 0;
+    std::vector<Event> eventsOut;
+    for (Event event : events) {
+        event.sensorHandle = setSubHalIndex(event.sensorHandle, mSubHalIndex);
+        eventsOut.push_back(event);
+        const SensorInfo& sensor = mHalProxy->getSensorInfo(event.sensorHandle);
+        if ((sensor.flags & V1_0::SensorFlagBits::WAKE_UP) != 0) {
+            (*numWakeupEvents)++;
+        }
+    }
+    return eventsOut;
+}
+
 }  // namespace implementation
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/default/2.X/multihal/HalProxyCallback.cpp b/sensors/common/default/2.X/multihal/HalProxyCallback.cpp
deleted file mode 100644
index a0e0c6b..0000000
--- a/sensors/common/default/2.X/multihal/HalProxyCallback.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2019 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.
- */
-
-#include "HalProxyCallback.h"
-
-namespace android {
-namespace hardware {
-namespace sensors {
-namespace V2_0 {
-namespace implementation {
-
-static constexpr int32_t kBitsAfterSubHalIndex = 24;
-
-/**
- * Set the subhal index as first byte of sensor handle and return this modified version.
- *
- * @param sensorHandle The sensor handle to modify.
- * @param subHalIndex The index in the hal proxy of the sub hal this sensor belongs to.
- *
- * @return The modified sensor handle.
- */
-int32_t setSubHalIndex(int32_t sensorHandle, size_t subHalIndex) {
-    return sensorHandle | (static_cast<int32_t>(subHalIndex) << kBitsAfterSubHalIndex);
-}
-
-void HalProxyCallbackBase::postEvents(const std::vector<V2_1::Event>& events,
-                                      ScopedWakelock wakelock) {
-    if (events.empty() || !mCallback->areThreadsRunning()) return;
-    size_t numWakeupEvents;
-    std::vector<V2_1::Event> processedEvents = processEvents(events, &numWakeupEvents);
-    if (numWakeupEvents > 0) {
-        ALOG_ASSERT(wakelock.isLocked(),
-                    "Wakeup events posted while wakelock unlocked for subhal"
-                    " w/ index %" PRId32 ".",
-                    mSubHalIndex);
-    } else {
-        ALOG_ASSERT(!wakelock.isLocked(),
-                    "No Wakeup events posted but wakelock locked for subhal"
-                    " w/ index %" PRId32 ".",
-                    mSubHalIndex);
-    }
-    mCallback->postEventsToMessageQueue(processedEvents, numWakeupEvents, std::move(wakelock));
-}
-
-ScopedWakelock HalProxyCallbackBase::createScopedWakelock(bool lock) {
-    ScopedWakelock wakelock(mRefCounter, lock);
-    return wakelock;
-}
-
-std::vector<V2_1::Event> HalProxyCallbackBase::processEvents(const std::vector<V2_1::Event>& events,
-                                                             size_t* numWakeupEvents) const {
-    *numWakeupEvents = 0;
-    std::vector<V2_1::Event> eventsOut;
-    for (V2_1::Event event : events) {
-        event.sensorHandle = setSubHalIndex(event.sensorHandle, mSubHalIndex);
-        eventsOut.push_back(event);
-        const V2_1::SensorInfo& sensor = mCallback->getSensorInfo(event.sensorHandle);
-        if ((sensor.flags & V1_0::SensorFlagBits::WAKE_UP) != 0) {
-            (*numWakeupEvents)++;
-        }
-    }
-    return eventsOut;
-}
-
-}  // namespace implementation
-}  // namespace V2_0
-}  // namespace sensors
-}  // namespace hardware
-}  // namespace android
diff --git a/sensors/common/default/2.X/multihal/include/HalProxy.h b/sensors/common/default/2.X/multihal/include/HalProxy.h
index fb0b806..d7e8795 100644
--- a/sensors/common/default/2.X/multihal/include/HalProxy.h
+++ b/sensors/common/default/2.X/multihal/include/HalProxy.h
@@ -16,17 +16,12 @@
 
 #pragma once
 
-#include "EventMessageQueueWrapper.h"
-#include "HalProxyCallback.h"
-#include "ISensorsCallbackWrapper.h"
-#include "SubHalWrapper.h"
 #include "V2_0/ScopedWakelock.h"
 #include "V2_0/SubHal.h"
 #include "V2_1/SubHal.h"
-#include "convertV2_1.h"
 
-#include <android/hardware/sensors/2.1/ISensors.h>
-#include <android/hardware/sensors/2.1/types.h>
+#include <android/hardware/sensors/2.0/ISensors.h>
+#include <android/hardware/sensors/2.0/types.h>
 #include <fmq/MessageQueue.h>
 #include <hardware_legacy/power.h>
 #include <hidl/MQDescriptor.h>
@@ -43,97 +38,96 @@
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace implementation {
 
-/**
- * HalProxy is the main interface for Multi-HAL. It is responsible for managing  subHALs and
- * proxying function calls to/from the subHAL APIs from the sensors framework. It also manages any
- * wakelocks allocated through the IHalProxyCallback and manages posting events to the sensors
- * framework.
- */
-class HalProxy : public V2_0::implementation::IScopedWakelockRefCounter,
-                 public V2_0::implementation::ISubHalCallback {
+using ::android::sp;
+using ::android::hardware::EventFlag;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::MessageQueue;
+using ::android::hardware::MQDescriptor;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+class HalProxy : public ISensors, public IScopedWakelockRefCounter {
   public:
-    using Event = ::android::hardware::sensors::V2_1::Event;
+    using Event = ::android::hardware::sensors::V1_0::Event;
     using OperationMode = ::android::hardware::sensors::V1_0::OperationMode;
     using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
     using Result = ::android::hardware::sensors::V1_0::Result;
-    using SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;
+    using SensorInfo = ::android::hardware::sensors::V1_0::SensorInfo;
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
-    using IHalProxyCallbackV2_0 = V2_0::implementation::IHalProxyCallback;
-    using IHalProxyCallbackV2_1 = V2_1::implementation::IHalProxyCallback;
-    using ISensorsSubHalV2_0 = V2_0::implementation::ISensorsSubHal;
-    using ISensorsSubHalV2_1 = V2_1::implementation::ISensorsSubHal;
-    using ISensorsV2_0 = V2_0::ISensors;
-    using ISensorsV2_1 = V2_1::ISensors;
-    using HalProxyCallbackBase = V2_0::implementation::HalProxyCallbackBase;
+    using ISensorsSubHal = ::android::hardware::sensors::V2_0::implementation::ISensorsSubHal;
 
     explicit HalProxy();
     // Test only constructor.
-    explicit HalProxy(std::vector<ISensorsSubHalV2_0*>& subHalList);
-    explicit HalProxy(std::vector<ISensorsSubHalV2_0*>& subHalList,
-                      std::vector<ISensorsSubHalV2_1*>& subHalListV2_1);
+    explicit HalProxy(std::vector<ISensorsSubHal*>& subHalList);
     ~HalProxy();
 
-    // Methods from ::android::hardware::sensors::V2_1::ISensors follow.
-    Return<void> getSensorsList_2_1(ISensorsV2_1::getSensorsList_2_1_cb _hidl_cb);
-
-    Return<Result> initialize_2_1(
-            const ::android::hardware::MQDescriptorSync<V2_1::Event>& eventQueueDescriptor,
-            const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-            const sp<V2_1::ISensorsCallback>& sensorsCallback);
-
-    Return<Result> injectSensorData_2_1(const Event& event);
-
     // Methods from ::android::hardware::sensors::V2_0::ISensors follow.
-    Return<void> getSensorsList(ISensorsV2_0::getSensorsList_cb _hidl_cb);
+    Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
 
-    Return<Result> setOperationMode(OperationMode mode);
+    Return<Result> setOperationMode(OperationMode mode) override;
 
-    Return<Result> activate(int32_t sensorHandle, bool enabled);
+    Return<Result> activate(int32_t sensorHandle, bool enabled) override;
 
     Return<Result> initialize(
-            const ::android::hardware::MQDescriptorSync<V1_0::Event>& eventQueueDescriptor,
+            const ::android::hardware::MQDescriptorSync<Event>& eventQueueDescriptor,
             const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-            const sp<V2_0::ISensorsCallback>& sensorsCallback);
-
-    Return<Result> initializeCommon(
-            std::unique_ptr<EventMessageQueueWrapperBase>& eventQueue,
-            const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-            const sp<ISensorsCallbackWrapperBase>& sensorsCallback);
+            const sp<ISensorsCallback>& sensorsCallback) override;
 
     Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                         int64_t maxReportLatencyNs);
+                         int64_t maxReportLatencyNs) override;
 
-    Return<Result> flush(int32_t sensorHandle);
+    Return<Result> flush(int32_t sensorHandle) override;
 
-    Return<Result> injectSensorData(const V1_0::Event& event);
+    Return<Result> injectSensorData(const Event& event) override;
 
     Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                       ISensorsV2_0::registerDirectChannel_cb _hidl_cb);
+                                       registerDirectChannel_cb _hidl_cb) override;
 
-    Return<Result> unregisterDirectChannel(int32_t channelHandle);
+    Return<Result> unregisterDirectChannel(int32_t channelHandle) override;
 
     Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
-                                    ISensorsV2_0::configDirectReport_cb _hidl_cb);
+                                    configDirectReport_cb _hidl_cb) override;
 
-    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args);
+    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override;
 
+    // Below methods from ::android::hardware::sensors::V2_0::ISensorsCallback with a minor change
+    // to pass in the sub-HAL index. While the above methods are invoked from the sensors framework
+    // via the binder, these methods are invoked from a callback provided to sub-HALs inside the
+    // same process as the HalProxy, but potentially running on different threads.
     Return<void> onDynamicSensorsConnected(const hidl_vec<SensorInfo>& dynamicSensorsAdded,
-                                           int32_t subHalIndex) override;
+                                           int32_t subHalIndex);
 
     Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& dynamicSensorHandlesRemoved,
-                                              int32_t subHalIndex) override;
+                                              int32_t subHalIndex);
 
+    // Below methods are for HalProxyCallback
+
+    /**
+     * Post events to the event message queue if there is room to write them. Otherwise post the
+     * remaining events to a background thread for a blocking write with a kPendingWriteTimeoutNs
+     * timeout.
+     *
+     * @param events The list of events to post to the message queue.
+     * @param numWakeupEvents The number of wakeup events in events.
+     * @param wakelock The wakelock associated with this post of events.
+     */
     void postEventsToMessageQueue(const std::vector<Event>& events, size_t numWakeupEvents,
-                                  V2_0::implementation::ScopedWakelock wakelock) override;
+                                  ScopedWakelock wakelock);
 
-    const SensorInfo& getSensorInfo(int32_t sensorHandle) override {
-        return mSensors[sensorHandle];
-    }
+    /**
+     * Get the sensor info associated with that sensorHandle.
+     *
+     * @param sensorHandle The sensor handle.
+     *
+     * @return The sensor info object in the mapping.
+     */
+    const SensorInfo& getSensorInfo(int32_t sensorHandle) { return mSensors[sensorHandle]; }
 
-    bool areThreadsRunning() override { return mThreadsRun.load(); }
+    bool areThreadsRunning() { return mThreadsRun.load(); }
 
     // Below methods are from IScopedWakelockRefCounter interface
     bool incrementRefCountAndMaybeAcquireWakelock(size_t delta,
@@ -142,14 +136,13 @@
     void decrementRefCountAndMaybeReleaseWakelock(size_t delta, int64_t timeoutStart = -1) override;
 
   private:
-    using EventMessageQueueV2_1 = MessageQueue<V2_1::Event, kSynchronizedReadWrite>;
-    using EventMessageQueueV2_0 = MessageQueue<V1_0::Event, kSynchronizedReadWrite>;
+    using EventMessageQueue = MessageQueue<Event, kSynchronizedReadWrite>;
     using WakeLockMessageQueue = MessageQueue<uint32_t, kSynchronizedReadWrite>;
 
     /**
      * The Event FMQ where sensor events are written
      */
-    std::unique_ptr<EventMessageQueueWrapperBase> mEventQueue;
+    std::unique_ptr<EventMessageQueue> mEventQueue;
 
     /**
      * The Wake Lock FMQ that is read to determine when the framework has handled WAKE_UP events
@@ -168,12 +161,15 @@
     /**
      * Callback to the sensors framework to inform it that new sensors have been added or removed.
      */
-    sp<ISensorsCallbackWrapperBase> mDynamicSensorsCallback;
+    sp<ISensorsCallback> mDynamicSensorsCallback;
 
     /**
-     * SubHal objects that have been saved from vendor dynamic libraries.
+     * SubHal object pointers that have been saved from vendor dynamic libraries.
      */
-    std::vector<std::shared_ptr<ISubHalWrapperBase>> mSubHalList;
+    std::vector<ISensorsSubHal*> mSubHalList;
+
+    //! The list of subhal callbacks for each subhal where the indices correlate with mSubHalList
+    std::vector<const sp<IHalProxyCallback>> mSubHalCallbacks;
 
     /**
      * Map of sensor handles to SensorInfo objects that contains the sensor info from subhals as
@@ -191,7 +187,7 @@
     OperationMode mCurrentOperationMode = OperationMode::NORMAL;
 
     //! The single subHal that supports directChannel reporting.
-    std::shared_ptr<ISubHalWrapperBase> mDirectChannelSubHal;
+    ISensorsSubHal* mDirectChannelSubHal = nullptr;
 
     //! The timeout for each pending write on background thread for events.
     static const int64_t kPendingWriteTimeoutNs = 5 * INT64_C(1000000000) /* 5 seconds */;
@@ -243,9 +239,9 @@
     //! The refcount of how many ScopedWakelocks and pending wakeup events are active
     size_t mWakelockRefCount = 0;
 
-    int64_t mWakelockTimeoutStartTime = V2_0::implementation::getTimeNow();
+    int64_t mWakelockTimeoutStartTime = getTimeNow();
 
-    int64_t mWakelockTimeoutResetTime = V2_0::implementation::getTimeNow();
+    int64_t mWakelockTimeoutResetTime = getTimeNow();
 
     const char* kWakelockName = "SensorsHAL_WAKEUP";
 
@@ -325,7 +321,7 @@
      *    disabled.
      * @param subHal The subhal pointer that the current sensorInfo object came from.
      */
-    void setDirectChannelFlags(SensorInfo* sensorInfo, std::shared_ptr<ISubHalWrapperBase> subHal);
+    void setDirectChannelFlags(SensorInfo* sensorInfo, ISensorsSubHal* subHal);
 
     /*
      * Get the subhal pointer which can be found by indexing into the mSubHalList vector
@@ -333,7 +329,7 @@
      *
      * @param sensorHandle The handle used to identify a sensor in one of the subhals.
      */
-    std::shared_ptr<ISubHalWrapperBase> getSubHalForSensorHandle(int32_t sensorHandle);
+    ISensorsSubHal* getSubHalForSensorHandle(int32_t sensorHandle);
 
     /**
      * Checks that sensorHandle's subhal index byte is within bounds of mSubHalList.
@@ -372,81 +368,39 @@
 };
 
 /**
- * Since a newer HAL can't masquerade as a older HAL, IHalProxy enables the HalProxy to be compiled
- * either for HAL 2.0 or HAL 2.1 depending on the build configuration.
+ * Callback class used to provide the HalProxy with the index of which subHal is invoking
  */
-template <class ISensorsVersion>
-class IHalProxy : public HalProxy, public ISensorsVersion {
-    Return<void> getSensorsList(ISensorsV2_0::getSensorsList_cb _hidl_cb) override {
-        return HalProxy::getSensorsList(_hidl_cb);
+class HalProxyCallback : public IHalProxyCallback {
+    using SensorInfo = ::android::hardware::sensors::V1_0::SensorInfo;
+
+  public:
+    HalProxyCallback(HalProxy* halProxy, int32_t subHalIndex)
+        : mHalProxy(halProxy), mSubHalIndex(subHalIndex) {}
+
+    Return<void> onDynamicSensorsConnected(
+            const hidl_vec<SensorInfo>& dynamicSensorsAdded) override {
+        return mHalProxy->onDynamicSensorsConnected(dynamicSensorsAdded, mSubHalIndex);
     }
 
-    Return<Result> setOperationMode(OperationMode mode) override {
-        return HalProxy::setOperationMode(mode);
+    Return<void> onDynamicSensorsDisconnected(
+            const hidl_vec<int32_t>& dynamicSensorHandlesRemoved) override {
+        return mHalProxy->onDynamicSensorsDisconnected(dynamicSensorHandlesRemoved, mSubHalIndex);
     }
 
-    Return<Result> activate(int32_t sensorHandle, bool enabled) override {
-        return HalProxy::activate(sensorHandle, enabled);
-    }
+    void postEvents(const std::vector<Event>& events, ScopedWakelock wakelock);
 
-    Return<Result> initialize(
-            const ::android::hardware::MQDescriptorSync<V1_0::Event>& eventQueueDescriptor,
-            const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-            const sp<V2_0::ISensorsCallback>& sensorsCallback) override {
-        return HalProxy::initialize(eventQueueDescriptor, wakeLockDescriptor, sensorsCallback);
-    }
+    ScopedWakelock createScopedWakelock(bool lock);
 
-    Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                         int64_t maxReportLatencyNs) override {
-        return HalProxy::batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
-    }
+  private:
+    HalProxy* mHalProxy;
+    int32_t mSubHalIndex;
 
-    Return<Result> flush(int32_t sensorHandle) override { return HalProxy::flush(sensorHandle); }
-
-    Return<Result> injectSensorData(const V1_0::Event& event) override {
-        return HalProxy::injectSensorData(event);
-    }
-
-    Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                       ISensorsV2_0::registerDirectChannel_cb _hidl_cb) override {
-        return HalProxy::registerDirectChannel(mem, _hidl_cb);
-    }
-
-    Return<Result> unregisterDirectChannel(int32_t channelHandle) override {
-        return HalProxy::unregisterDirectChannel(channelHandle);
-    }
-
-    Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
-                                    ISensorsV2_0::configDirectReport_cb _hidl_cb) override {
-        return HalProxy::configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb);
-    }
-
-    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override {
-        return HalProxy::debug(fd, args);
-    }
-};
-
-class HalProxyV2_0 : public IHalProxy<V2_0::ISensors> {};
-
-class HalProxyV2_1 : public IHalProxy<V2_1::ISensors> {
-    Return<void> getSensorsList_2_1(ISensorsV2_1::getSensorsList_2_1_cb _hidl_cb) override {
-        return HalProxy::getSensorsList_2_1(_hidl_cb);
-    }
-
-    Return<Result> initialize_2_1(
-            const ::android::hardware::MQDescriptorSync<V2_1::Event>& eventQueueDescriptor,
-            const ::android::hardware::MQDescriptorSync<uint32_t>& wakeLockDescriptor,
-            const sp<V2_1::ISensorsCallback>& sensorsCallback) override {
-        return HalProxy::initialize_2_1(eventQueueDescriptor, wakeLockDescriptor, sensorsCallback);
-    }
-
-    Return<Result> injectSensorData_2_1(const Event& event) override {
-        return HalProxy::injectSensorData_2_1(event);
-    }
+    std::vector<Event> processEvents(const std::vector<Event>& events,
+                                     size_t* numWakeupEvents) const;
 };
 
 }  // namespace implementation
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/default/2.X/multihal/include/HalProxyCallback.h b/sensors/common/default/2.X/multihal/include/HalProxyCallback.h
deleted file mode 100644
index e62b7d1..0000000
--- a/sensors/common/default/2.X/multihal/include/HalProxyCallback.h
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
- * Copyright (C) 2019 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.
- */
-
-#pragma once
-
-#include "V2_0/ScopedWakelock.h"
-#include "V2_0/SubHal.h"
-#include "V2_1/SubHal.h"
-#include "convertV2_1.h"
-
-#include <android/hardware/sensors/2.1/ISensors.h>
-#include <android/hardware/sensors/2.1/types.h>
-#include <log/log.h>
-
-namespace android {
-namespace hardware {
-namespace sensors {
-namespace V2_0 {
-namespace implementation {
-
-/**
- * Interface used to communicate with the HalProxy when subHals interact with their provided
- * callback.
- */
-class ISubHalCallback {
-  public:
-    virtual ~ISubHalCallback() {}
-
-    // Below methods from ::android::hardware::sensors::V2_0::ISensorsCallback with a minor change
-    // to pass in the sub-HAL index. While the above methods are invoked from the sensors framework
-    // via the binder, these methods are invoked from a callback provided to sub-HALs inside the
-    // same process as the HalProxy, but potentially running on different threads.
-    virtual Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V2_1::SensorInfo>& dynamicSensorsAdded, int32_t subHalIndex) = 0;
-
-    virtual Return<void> onDynamicSensorsDisconnected(
-            const hidl_vec<int32_t>& dynamicSensorHandlesRemoved, int32_t subHalIndex) = 0;
-
-    /**
-     * Post events to the event message queue if there is room to write them. Otherwise post the
-     * remaining events to a background thread for a blocking write with a kPendingWriteTimeoutNs
-     * timeout.
-     *
-     * @param events The list of events to post to the message queue.
-     * @param numWakeupEvents The number of wakeup events in events.
-     * @param wakelock The wakelock associated with this post of events.
-     */
-    virtual void postEventsToMessageQueue(const std::vector<V2_1::Event>& events,
-                                          size_t numWakeupEvents,
-                                          V2_0::implementation::ScopedWakelock wakelock) = 0;
-
-    /**
-     * Get the sensor info associated with that sensorHandle.
-     *
-     * @param sensorHandle The sensor handle.
-     *
-     * @return The sensor info object in the mapping.
-     */
-    virtual const V2_1::SensorInfo& getSensorInfo(int32_t sensorHandle) = 0;
-
-    virtual bool areThreadsRunning() = 0;
-};
-
-/**
- * Callback class given to subhals that allows the HalProxy to know which subhal a given invocation
- * is coming from.
- */
-class HalProxyCallbackBase : public VirtualLightRefBase {
-  public:
-    HalProxyCallbackBase(ISubHalCallback* callback,
-                         V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                         int32_t subHalIndex)
-        : mCallback(callback), mRefCounter(refCounter), mSubHalIndex(subHalIndex) {}
-
-    void postEvents(const std::vector<V2_1::Event>& events,
-                    V2_0::implementation::ScopedWakelock wakelock);
-
-    V2_0::implementation::ScopedWakelock createScopedWakelock(bool lock);
-
-  protected:
-    ISubHalCallback* mCallback;
-    V2_0::implementation::IScopedWakelockRefCounter* mRefCounter;
-    int32_t mSubHalIndex;
-
-  private:
-    std::vector<V2_1::Event> processEvents(const std::vector<V2_1::Event>& events,
-                                           size_t* numWakeupEvents) const;
-};
-
-class HalProxyCallbackV2_0 : public HalProxyCallbackBase,
-                             public V2_0::implementation::IHalProxyCallback {
-  public:
-    HalProxyCallbackV2_0(ISubHalCallback* callback,
-                         V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                         int32_t subHalIndex)
-        : HalProxyCallbackBase(callback, refCounter, subHalIndex) {}
-
-    Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V1_0::SensorInfo>& dynamicSensorsAdded) override {
-        return mCallback->onDynamicSensorsConnected(
-                V2_1::implementation::convertToNewSensorInfos(dynamicSensorsAdded), mSubHalIndex);
-    }
-
-    Return<void> onDynamicSensorsDisconnected(
-            const hidl_vec<int32_t>& dynamicSensorHandlesRemoved) override {
-        return mCallback->onDynamicSensorsDisconnected(dynamicSensorHandlesRemoved, mSubHalIndex);
-    }
-
-    void postEvents(const std::vector<V1_0::Event>& events,
-                    V2_0::implementation::ScopedWakelock wakelock) override {
-        HalProxyCallbackBase::postEvents(V2_1::implementation::convertToNewEvents(events),
-                                         std::move(wakelock));
-    }
-
-    V2_0::implementation::ScopedWakelock createScopedWakelock(bool lock) override {
-        return HalProxyCallbackBase::createScopedWakelock(lock);
-    }
-};
-
-class HalProxyCallbackV2_1 : public HalProxyCallbackBase,
-                             public V2_1::implementation::IHalProxyCallback {
-  public:
-    HalProxyCallbackV2_1(ISubHalCallback* callback,
-                         V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                         int32_t subHalIndex)
-        : HalProxyCallbackBase(callback, refCounter, subHalIndex) {}
-
-    Return<void> onDynamicSensorsConnected_2_1(
-            const hidl_vec<V2_1::SensorInfo>& dynamicSensorsAdded) override {
-        return mCallback->onDynamicSensorsConnected(dynamicSensorsAdded, mSubHalIndex);
-    }
-
-    Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V1_0::SensorInfo>& /* dynamicSensorsAdded */) override {
-        LOG_ALWAYS_FATAL("Old dynamic sensors method can't be used");
-        return Void();
-    }
-
-    Return<void> onDynamicSensorsDisconnected(
-            const hidl_vec<int32_t>& dynamicSensorHandlesRemoved) override {
-        return mCallback->onDynamicSensorsDisconnected(dynamicSensorHandlesRemoved, mSubHalIndex);
-    }
-
-    void postEvents(const std::vector<V2_1::Event>& events,
-                    V2_0::implementation::ScopedWakelock wakelock) override {
-        return HalProxyCallbackBase::postEvents(events, std::move(wakelock));
-    }
-
-    V2_0::implementation::ScopedWakelock createScopedWakelock(bool lock) override {
-        return HalProxyCallbackBase::createScopedWakelock(lock);
-    }
-};
-
-}  // namespace implementation
-}  // namespace V2_0
-}  // namespace sensors
-}  // namespace hardware
-}  // namespace android
\ No newline at end of file
diff --git a/sensors/common/default/2.X/multihal/include/SubHalWrapper.h b/sensors/common/default/2.X/multihal/include/SubHalWrapper.h
deleted file mode 100644
index 149bb5e..0000000
--- a/sensors/common/default/2.X/multihal/include/SubHalWrapper.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (C) 2020 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.
- */
-
-#pragma once
-
-#include "HalProxyCallback.h"
-#include "V2_0/SubHal.h"
-#include "V2_1/SubHal.h"
-
-#include "android/hardware/sensors/1.0/ISensors.h"
-#include "android/hardware/sensors/1.0/types.h"
-#include "android/hardware/sensors/2.0/ISensors.h"
-#include "android/hardware/sensors/2.0/ISensorsCallback.h"
-#include "android/hardware/sensors/2.1/ISensors.h"
-#include "android/hardware/sensors/2.1/ISensorsCallback.h"
-#include "android/hardware/sensors/2.1/types.h"
-
-#include <utils/LightRefBase.h>
-
-#include <cassert>
-
-namespace android {
-namespace hardware {
-namespace sensors {
-namespace V2_1 {
-namespace implementation {
-
-/**
- * The following subHal wrapper classes abstract away common functionality across V2.0 and V2.1
- * subHal interfaces. Much of the logic is common between the two versions and this allows users of
- * the classes to only care about the type used at initialization and then interact with either
- * version of the subHal interface without worrying about the type.
- */
-class ISubHalWrapperBase {
-  protected:
-    using Event = ::android::hardware::sensors::V2_1::Event;
-    using OperationMode = ::android::hardware::sensors::V1_0::OperationMode;
-    using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
-    using Result = ::android::hardware::sensors::V1_0::Result;
-    using SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;
-    using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
-
-  public:
-    virtual ~ISubHalWrapperBase() {}
-
-    virtual bool supportsNewEvents() = 0;
-
-    virtual Return<Result> initialize(V2_0::implementation::ISubHalCallback* callback,
-                                      V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                                      int32_t subHalIndex) = 0;
-
-    virtual Return<void> getSensorsList(
-            ::android::hardware::sensors::V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) = 0;
-
-    virtual Return<Result> setOperationMode(OperationMode mode) = 0;
-
-    virtual Return<Result> activate(int32_t sensorHandle, bool enabled) = 0;
-
-    virtual Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                                 int64_t maxReportLatencyNs) = 0;
-
-    virtual Return<Result> flush(int32_t sensorHandle) = 0;
-
-    virtual Return<Result> injectSensorData(const Event& event) = 0;
-
-    virtual Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                               ISensors::registerDirectChannel_cb _hidl_cb) = 0;
-
-    virtual Return<Result> unregisterDirectChannel(int32_t channelHandle) = 0;
-
-    virtual Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle,
-                                            RateLevel rate,
-                                            ISensors::configDirectReport_cb _hidl_cb) = 0;
-
-    virtual Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) = 0;
-
-    virtual const std::string getName() = 0;
-};
-
-template <typename T>
-class SubHalWrapperBase : public ISubHalWrapperBase {
-  public:
-    SubHalWrapperBase(T* subHal) : mSubHal(subHal){};
-
-    virtual bool supportsNewEvents() override { return false; }
-
-    virtual Return<void> getSensorsList(
-            ::android::hardware::sensors::V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) override {
-        return mSubHal->getSensorsList(
-                [&](const auto& list) { _hidl_cb(convertToNewSensorInfos(list)); });
-    }
-
-    Return<Result> setOperationMode(OperationMode mode) override {
-        return mSubHal->setOperationMode(mode);
-    }
-
-    Return<Result> activate(int32_t sensorHandle, bool enabled) override {
-        return mSubHal->activate(sensorHandle, enabled);
-    }
-
-    Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                         int64_t maxReportLatencyNs) override {
-        return mSubHal->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
-    }
-
-    Return<Result> flush(int32_t sensorHandle) override { return mSubHal->flush(sensorHandle); }
-
-    virtual Return<Result> injectSensorData(const Event& event) override {
-        return mSubHal->injectSensorData(convertToOldEvent(event));
-    }
-
-    Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                       ISensors::registerDirectChannel_cb _hidl_cb) override {
-        return mSubHal->registerDirectChannel(mem, _hidl_cb);
-    }
-
-    Return<Result> unregisterDirectChannel(int32_t channelHandle) override {
-        return mSubHal->unregisterDirectChannel(channelHandle);
-    }
-
-    Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
-                                    ISensors::configDirectReport_cb _hidl_cb) override {
-        return mSubHal->configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb);
-    }
-
-    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override {
-        return mSubHal->debug(fd, args);
-    }
-
-    const std::string getName() override { return mSubHal->getName(); }
-
-  protected:
-    T* mSubHal;
-};
-
-class SubHalWrapperV2_0 : public SubHalWrapperBase<V2_0::implementation::ISensorsSubHal> {
-  public:
-    SubHalWrapperV2_0(V2_0::implementation::ISensorsSubHal* subHal) : SubHalWrapperBase(subHal){};
-
-    Return<Result> initialize(V2_0::implementation::ISubHalCallback* callback,
-                              V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                              int32_t subHalIndex) override {
-        return mSubHal->initialize(
-                new V2_0::implementation::HalProxyCallbackV2_0(callback, refCounter, subHalIndex));
-    }
-};
-
-class SubHalWrapperV2_1 : public SubHalWrapperBase<V2_1::implementation::ISensorsSubHal> {
-  public:
-    SubHalWrapperV2_1(V2_1::implementation::ISensorsSubHal* subHal) : SubHalWrapperBase(subHal) {}
-
-    bool supportsNewEvents() override { return true; }
-
-    virtual Return<void> getSensorsList(
-            ::android::hardware::sensors::V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) override {
-        return mSubHal->getSensorsList_2_1([&](const auto& list) { _hidl_cb(list); });
-    }
-
-    virtual Return<Result> injectSensorData(const Event& event) override {
-        return mSubHal->injectSensorData_2_1(event);
-    }
-
-    Return<Result> initialize(V2_0::implementation::ISubHalCallback* callback,
-                              V2_0::implementation::IScopedWakelockRefCounter* refCounter,
-                              int32_t subHalIndex) override {
-        return mSubHal->initialize(
-                new V2_0::implementation::HalProxyCallbackV2_1(callback, refCounter, subHalIndex));
-    }
-};
-
-}  // namespace implementation
-}  // namespace V2_1
-}  // namespace sensors
-}  // namespace hardware
-}  // namespace android
diff --git a/sensors/common/default/2.X/multihal/include/V2_0/ScopedWakelock.h b/sensors/common/default/2.X/multihal/include/V2_0/ScopedWakelock.h
index 1cc5cd5..aa6d9db 100644
--- a/sensors/common/default/2.X/multihal/include/V2_0/ScopedWakelock.h
+++ b/sensors/common/default/2.X/multihal/include/V2_0/ScopedWakelock.h
@@ -88,7 +88,7 @@
     bool isLocked() const { return mLocked; }
 
   private:
-    friend class HalProxyCallbackBase;
+    friend class HalProxyCallback;
     IScopedWakelockRefCounter* mRefCounter;
     int64_t mCreatedAtTimeNs;
     bool mLocked;
diff --git a/sensors/common/default/2.X/multihal/tests/Android.bp b/sensors/common/default/2.X/multihal/tests/Android.bp
index a15faed..e0b3b8d 100644
--- a/sensors/common/default/2.X/multihal/tests/Android.bp
+++ b/sensors/common/default/2.X/multihal/tests/Android.bp
@@ -20,7 +20,6 @@
     ],
     header_libs: [
         "android.hardware.sensors@2.0-multihal.header",
-        "android.hardware.sensors@2.X-shared-utils",
     ],
     export_include_dirs: ["fake_subhal"],
     shared_libs: [
@@ -37,7 +36,6 @@
         "libutils",
     ],
     static_libs: [
-        "android.hardware.sensors@1.0-convert",
         "android.hardware.sensors@2.X-multihal",
     ],
     cflags: [
@@ -50,7 +48,6 @@
     vendor: true,
     defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"],
     cflags: [
-        "-DSUB_HAL_VERSION_2_0",
         "-DSUPPORT_CONTINUOUS_SENSORS",
         "-DSUB_HAL_NAME=\"FakeSubHal-Continuous\"",
     ],
@@ -61,17 +58,6 @@
     vendor: true,
     defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"],
     cflags: [
-        "-DSUB_HAL_VERSION_2_0",
-        "-DSUPPORT_ON_CHANGE_SENSORS",
-        "-DSUB_HAL_NAME=\"FakeSubHal-OnChange\"",
-    ],
-}
-
-cc_library {
-    name: "android.hardware.sensors@2.X-fakesubhal-config3",
-    vendor: true,
-    defaults: ["android.hardware.sensors@2.X-fakesubhal-defaults"],
-    cflags: [
         "-DSUPPORT_ON_CHANGE_SENSORS",
         "-DSUB_HAL_NAME=\"FakeSubHal-OnChange\"",
     ],
@@ -92,11 +78,7 @@
     name: "android.hardware.sensors@2.X-halproxy-unit-tests",
     srcs: ["HalProxy_test.cpp"],
     vendor: true,
-    header_libs: [
-        "android.hardware.sensors@2.X-shared-utils",
-    ],
     static_libs: [
-        "android.hardware.sensors@1.0-convert",
         "android.hardware.sensors@2.0-ScopedWakelock.testlib",
         "android.hardware.sensors@2.X-multihal",
         "android.hardware.sensors@2.X-fakesubhal-unittest",
diff --git a/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp b/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp
index 858786a..867c4a1 100644
--- a/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp
+++ b/sensors/common/default/2.X/multihal/tests/HalProxy_test.cpp
@@ -15,15 +15,12 @@
 
 #include <gtest/gtest.h>
 
-#include <android/hardware/sensors/1.0/types.h>
 #include <android/hardware/sensors/2.0/types.h>
-#include <android/hardware/sensors/2.1/types.h>
 #include <fmq/MessageQueue.h>
 
 #include "HalProxy.h"
 #include "SensorsSubHal.h"
 #include "V2_0/ScopedWakelock.h"
-#include "convertV2_1.h"
 
 #include <chrono>
 #include <set>
@@ -41,35 +38,27 @@
 using ::android::hardware::sensors::V1_0::SensorInfo;
 using ::android::hardware::sensors::V1_0::SensorType;
 using ::android::hardware::sensors::V2_0::EventQueueFlagBits;
+using ::android::hardware::sensors::V2_0::ISensorsCallback;
 using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
-using ::android::hardware::sensors::V2_0::implementation::HalProxyCallbackBase;
-using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock;
-using ::android::hardware::sensors::V2_1::implementation::convertToNewEvents;
-using ::android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos;
-using ::android::hardware::sensors::V2_1::implementation::HalProxy;
-using ::android::hardware::sensors::V2_1::subhal::implementation::AddAndRemoveDynamicSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::
+using ::android::hardware::sensors::V2_0::implementation::HalProxy;
+using ::android::hardware::sensors::V2_0::implementation::HalProxyCallback;
+using ::android::hardware::sensors::V2_0::subhal::implementation::AddAndRemoveDynamicSensorsSubHal;
+using ::android::hardware::sensors::V2_0::subhal::implementation::AllSensorsSubHal;
+using ::android::hardware::sensors::V2_0::subhal::implementation::
         AllSupportDirectChannelSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::
+using ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal;
+using ::android::hardware::sensors::V2_0::subhal::implementation::
         DoesNotSupportDirectChannelSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal;
-using ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0;
-using ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1;
-using ::android::hardware::sensors::V2_1::subhal::implementation::
+using ::android::hardware::sensors::V2_0::subhal::implementation::OnChangeSensorsSubHal;
+using ::android::hardware::sensors::V2_0::subhal::implementation::SensorsSubHal;
+using ::android::hardware::sensors::V2_0::subhal::implementation::
         SetOperationModeFailingSensorsSubHal;
 
-using ISensorsCallbackV2_0 = ::android::hardware::sensors::V2_0::ISensorsCallback;
-using ISensorsCallbackV2_1 = ::android::hardware::sensors::V2_1::ISensorsCallback;
-using EventV1_0 = ::android::hardware::sensors::V1_0::Event;
-using EventV2_1 = ::android::hardware::sensors::V2_1::Event;
-using EventMessageQueueV2_1 = MessageQueue<EventV2_1, ::android::hardware::kSynchronizedReadWrite>;
-using EventMessageQueueV2_0 = MessageQueue<EventV1_0, ::android::hardware::kSynchronizedReadWrite>;
+using EventMessageQueue = MessageQueue<Event, ::android::hardware::kSynchronizedReadWrite>;
 using WakeupMessageQueue = MessageQueue<uint32_t, ::android::hardware::kSynchronizedReadWrite>;
 
 // The barebones sensors callback class passed into halproxy initialize calls
-class SensorsCallback : public ISensorsCallbackV2_0 {
+class SensorsCallback : public ISensorsCallback {
   public:
     Return<void> onDynamicSensorsConnected(
             const hidl_vec<SensorInfo>& /*dynamicSensorsAdded*/) override {
@@ -84,30 +73,8 @@
     }
 };
 
-class SensorsCallbackV2_1 : public ISensorsCallbackV2_1 {
-  public:
-    Return<void> onDynamicSensorsConnected_2_1(
-            const hidl_vec<::android::hardware::sensors::V2_1::SensorInfo>& /*dynamicSensorsAdded*/)
-            override {
-        // Nothing yet
-        return Return<void>();
-    }
-
-    Return<void> onDynamicSensorsConnected(
-            const hidl_vec<SensorInfo>& /*dynamicSensorsAdded*/) override {
-        // Nothing yet
-        return Return<void>();
-    }
-
-    Return<void> onDynamicSensorsDisconnected(
-            const hidl_vec<int32_t>& /*dynamicSensorHandlesRemoved*/) override {
-        // Nothing yet
-        return Return<void>();
-    }
-};
-
 // The sensors callback that expects a variable list of sensors to be added
-class TestSensorsCallback : public ISensorsCallbackV2_0 {
+class TestSensorsCallback : public ISensorsCallback {
   public:
     Return<void> onDynamicSensorsConnected(
             const hidl_vec<SensorInfo>& dynamicSensorsAdded) override {
@@ -162,10 +129,10 @@
 void ackWakeupEventsToHalProxy(size_t numEvents, std::unique_ptr<WakeupMessageQueue>& wakelockQueue,
                                EventFlag* wakelockQueueFlag);
 
-bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueueV2_0>& eventQueue,
+bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueue>& eventQueue,
                           EventFlag* eventQueueFlag);
 
-std::unique_ptr<EventMessageQueueV2_0> makeEventFMQ(size_t size);
+std::unique_ptr<EventMessageQueue> makeEventFMQ(size_t size);
 
 std::unique_ptr<WakeupMessageQueue> makeWakelockFMQ(size_t size);
 
@@ -175,7 +142,7 @@
  *
  * @return A proximity event.
  */
-EventV1_0 makeProximityEvent();
+Event makeProximityEvent();
 
 /**
  * Construct and return a HIDL Event type thats sensorHandle refers to a proximity sensor
@@ -183,7 +150,7 @@
  *
  * @return A proximity event.
  */
-EventV1_0 makeAccelerometerEvent();
+Event makeAccelerometerEvent();
 
 /**
  * Make a certain number of proximity type events with the sensorHandle field set to
@@ -193,7 +160,7 @@
  *
  * @return The created list of events.
  */
-std::vector<EventV1_0> makeMultipleProximityEvents(size_t numEvents);
+std::vector<Event> makeMultipleProximityEvents(size_t numEvents);
 
 /**
  * Make a certain number of accelerometer type events with the sensorHandle field set to
@@ -203,7 +170,7 @@
  *
  * @return The created list of events.
  */
-std::vector<EventV1_0> makeMultipleAccelerometerEvents(size_t numEvents);
+std::vector<Event> makeMultipleAccelerometerEvents(size_t numEvents);
 
 /**
  * Given a SensorInfo vector and a sensor handles vector populate 'sensors' with SensorInfo
@@ -221,7 +188,7 @@
 
 // Tests follow
 TEST(HalProxyTest, GetSensorsListOneSubHalTest) {
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> fakeSubHals{&subHal};
     HalProxy proxy(fakeSubHals);
 
@@ -233,8 +200,8 @@
 }
 
 TEST(HalProxyTest, GetSensorsListTwoSubHalTest) {
-    ContinuousSensorsSubHal<SensorsSubHalV2_0> continuousSubHal;
-    OnChangeSensorsSubHal<SensorsSubHalV2_0> onChangeSubHal;
+    ContinuousSensorsSubHal continuousSubHal;
+    OnChangeSensorsSubHal onChangeSubHal;
     std::vector<ISensorsSubHal*> fakeSubHals;
     fakeSubHals.push_back(&continuousSubHal);
     fakeSubHals.push_back(&onChangeSubHal);
@@ -254,8 +221,8 @@
 }
 
 TEST(HalProxyTest, SetOperationModeTwoSubHalSuccessTest) {
-    ContinuousSensorsSubHal<SensorsSubHalV2_0> subHal1;
-    OnChangeSensorsSubHal<SensorsSubHalV2_0> subHal2;
+    ContinuousSensorsSubHal subHal1;
+    OnChangeSensorsSubHal subHal2;
 
     std::vector<ISensorsSubHal*> fakeSubHals{&subHal1, &subHal2};
     HalProxy proxy(fakeSubHals);
@@ -271,7 +238,7 @@
 }
 
 TEST(HalProxyTest, SetOperationModeTwoSubHalFailTest) {
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal1;
+    AllSensorsSubHal subHal1;
     SetOperationModeFailingSensorsSubHal subHal2;
 
     std::vector<ISensorsSubHal*> fakeSubHals{&subHal1, &subHal2};
@@ -312,16 +279,16 @@
 
 TEST(HalProxyTest, PostSingleNonWakeupEvent) {
     constexpr size_t kQueueSize = 5;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events{makeAccelerometerEvent()};
-    subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events{makeAccelerometerEvent()};
+    subHal.postEvents(events, false /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), 1);
 }
@@ -329,28 +296,28 @@
 TEST(HalProxyTest, PostMultipleNonWakeupEvent) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 3;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-    subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+    subHal.postEvents(events, false /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
 }
 
 TEST(HalProxyTest, PostSingleWakeupEvent) {
     constexpr size_t kQueueSize = 5;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
     EventFlag* eventQueueFlag;
@@ -359,8 +326,8 @@
     EventFlag* wakelockQueueFlag;
     EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag);
 
-    std::vector<EventV1_0> events{makeProximityEvent()};
-    subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+    std::vector<Event> events{makeProximityEvent()};
+    subHal.postEvents(events, true /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), 1);
 
@@ -371,12 +338,12 @@
 TEST(HalProxyTest, PostMultipleWakeupEvents) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 3;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
     EventFlag* eventQueueFlag;
@@ -385,8 +352,8 @@
     EventFlag* wakelockQueueFlag;
     EventFlag::createEventFlag(wakeLockQueue->getEventFlagWord(), &wakelockQueueFlag);
 
-    std::vector<EventV1_0> events = makeMultipleProximityEvents(kNumEvents);
-    subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+    std::vector<Event> events = makeMultipleProximityEvents(kNumEvents);
+    subHal.postEvents(events, true /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
 
@@ -397,20 +364,20 @@
 TEST(HalProxyTest, PostEventsMultipleSubhals) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 2;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+    AllSensorsSubHal subHal1, subHal2;
     std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-    subHal1.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+    subHal1.postEvents(events, false /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), kNumEvents);
 
-    subHal2.postEvents(convertToNewEvents(events), false /* wakeup */);
+    subHal2.postEvents(events, false /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2);
 }
@@ -418,19 +385,19 @@
 TEST(HalProxyTest, PostEventsDelayedWrite) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 6;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+    AllSensorsSubHal subHal1, subHal2;
     std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
     EventFlag* eventQueueFlag;
     EventFlag::createEventFlag(eventQueue->getEventFlagWord(), &eventQueueFlag);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-    subHal1.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+    subHal1.postEvents(events, false /* wakeup */);
 
     EXPECT_EQ(eventQueue->availableToRead(), kQueueSize);
 
@@ -446,20 +413,18 @@
 TEST(HalProxyTest, PostEventsMultipleSubhalsThreaded) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 2;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal1, subHal2;
+    AllSensorsSubHal subHal1, subHal2;
     std::vector<ISensorsSubHal*> subHals{&subHal1, &subHal2};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
 
-    std::thread t1(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal1,
-                   convertToNewEvents(events), false);
-    std::thread t2(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal2,
-                   convertToNewEvents(events), false);
+    std::thread t1(&AllSensorsSubHal::postEvents, &subHal1, events, false);
+    std::thread t2(&AllSensorsSubHal::postEvents, &subHal2, events, false);
 
     t1.join();
     t2.join();
@@ -470,34 +435,34 @@
 TEST(HalProxyTest, DestructingWithEventsPendingOnBackgroundThread) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 6;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-    subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+    subHal.postEvents(events, false /* wakeup */);
 
     // Destructing HalProxy object with events on the background thread
 }
 
 TEST(HalProxyTest, DestructingWithUnackedWakeupEventsPosted) {
     constexpr size_t kQueueSize = 5;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events{makeProximityEvent()};
-    subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+    std::vector<Event> events{makeProximityEvent()};
+    subHal.postEvents(events, true /* wakeup */);
 
     // Not sending any acks back through wakeLockQueue
 
@@ -507,17 +472,17 @@
 TEST(HalProxyTest, ReinitializeWithEventsPendingOnBackgroundThread) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumEvents = 10;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-    subHal.postEvents(convertToNewEvents(events), false /* wakeup */);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kNumEvents);
+    subHal.postEvents(events, false /* wakeup */);
 
     eventQueue = makeEventFMQ(kQueueSize);
     wakeLockQueue = makeWakelockFMQ(kQueueSize);
@@ -527,23 +492,23 @@
     EXPECT_EQ(secondInitResult, Result::OK);
     // Small sleep so that pending writes thread has a change to hit writeBlocking call.
     std::this_thread::sleep_for(std::chrono::milliseconds(5));
-    EventV1_0 eventOut;
+    Event eventOut;
     EXPECT_FALSE(eventQueue->read(&eventOut));
 }
 
 TEST(HalProxyTest, ReinitializingWithUnackedWakeupEventsPosted) {
     constexpr size_t kQueueSize = 5;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
-    std::vector<EventV1_0> events{makeProximityEvent()};
-    subHal.postEvents(convertToNewEvents(events), true /* wakeup */);
+    std::vector<Event> events{makeProximityEvent()};
+    subHal.postEvents(events, true /* wakeup */);
 
     // Not sending any acks back through wakeLockQueue
 
@@ -558,12 +523,12 @@
 TEST(HalProxyTest, InitializeManyTimesInARow) {
     constexpr size_t kQueueSize = 5;
     constexpr size_t kNumTimesToInit = 100;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
 
     for (size_t i = 0; i < kNumTimesToInit; i++) {
@@ -575,15 +540,15 @@
 
 TEST(HalProxyTest, OperationModeResetOnInitialize) {
     constexpr size_t kQueueSize = 5;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal;
+    AllSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.setOperationMode(OperationMode::DATA_INJECTION);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
-    EventV1_0 event = makeAccelerometerEvent();
+    Event event = makeAccelerometerEvent();
     // Should not be able to inject a non AdditionInfo type event because operation mode should
     // have been reset to NORMAL
     EXPECT_EQ(proxy.injectSensorData(event), Result::BAD_VALUE);
@@ -594,7 +559,7 @@
     constexpr size_t kNumSensors = 5;
     AddAndRemoveDynamicSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
     HalProxy proxy(subHals);
 
@@ -609,9 +574,9 @@
     }
 
     TestSensorsCallback* callback = new TestSensorsCallback();
-    ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+    ::android::sp<ISensorsCallback> callbackPtr = callback;
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
-    subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+    subHal.addDynamicSensors(sensorsToConnect);
 
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
     subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove);
@@ -628,7 +593,7 @@
     AddAndRemoveDynamicSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(0);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(0);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(0);
 
     std::vector<SensorInfo> sensorsToConnect;
@@ -637,9 +602,9 @@
                                                  sensorHandlesToExpect);
 
     TestSensorsCallback* callback = new TestSensorsCallback();
-    ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+    ::android::sp<ISensorsCallback> callbackPtr = callback;
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
-    subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+    subHal.addDynamicSensors(sensorsToConnect);
 
     std::vector<SensorInfo> sensorsSeen = callback->getSensorsConnected();
     EXPECT_EQ(kNumSensors, sensorsSeen.size());
@@ -656,7 +621,7 @@
     AddAndRemoveDynamicSensorsSubHal subHal;
     std::vector<ISensorsSubHal*> subHals{&subHal};
     HalProxy proxy(subHals);
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(0);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(0);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(0);
 
     std::vector<SensorInfo> sensorsToConnect;
@@ -681,9 +646,9 @@
                                           nonDynamicSensorHandles.end());
 
     TestSensorsCallback* callback = new TestSensorsCallback();
-    ::android::sp<ISensorsCallbackV2_0> callbackPtr = callback;
+    ::android::sp<ISensorsCallback> callbackPtr = callback;
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callbackPtr);
-    subHal.addDynamicSensors(convertToNewSensorInfos(sensorsToConnect));
+    subHal.addDynamicSensors(sensorsToConnect);
     subHal.removeDynamicSensors(sensorHandlesToAttemptToRemove);
 
     std::vector<int32_t> sensorHandlesSeen = callback->getSensorHandlesDisconnected();
@@ -702,15 +667,15 @@
     constexpr size_t kNumSubHals = 3;
     constexpr size_t kQueueSize = 5;
     int32_t kNumSubHalsInt32 = static_cast<int32_t>(kNumSubHals);
-    std::vector<AllSensorsSubHal<SensorsSubHalV2_0>> subHalObjs(kNumSubHals);
+    std::vector<AllSensorsSubHal> subHalObjs(kNumSubHals);
     std::vector<ISensorsSubHal*> subHals;
     for (const auto& subHal : subHalObjs) {
         subHals.push_back((ISensorsSubHal*)(&subHal));
     }
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     // Initialize for the injectSensorData call so callback postEvents is valid
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
@@ -722,7 +687,7 @@
     EXPECT_EQ(proxy.activate(0x00000001 | (kNumSubHalsInt32 << 24), true), Result::BAD_VALUE);
     EXPECT_EQ(proxy.batch(0x00000001 | (kNumSubHalsInt32 << 24), 0, 0), Result::BAD_VALUE);
     EXPECT_EQ(proxy.flush(0x00000001 | (kNumSubHalsInt32 << 24)), Result::BAD_VALUE);
-    EventV1_0 event;
+    Event event;
     event.sensorHandle = 0x00000001 | (kNumSubHalsInt32 << 24);
     EXPECT_EQ(proxy.injectSensorData(event), Result::BAD_VALUE);
 }
@@ -731,28 +696,28 @@
     constexpr size_t kQueueSize = 5;
     constexpr int32_t subhal1Index = 0;
     constexpr int32_t subhal2Index = 1;
-    AllSensorsSubHal<SensorsSubHalV2_0> subhal1;
-    AllSensorsSubHal<SensorsSubHalV2_0> subhal2;
+    AllSensorsSubHal subhal1;
+    AllSensorsSubHal subhal2;
     std::vector<ISensorsSubHal*> subHals{&subhal1, &subhal2};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
     int32_t sensorHandleToPost = 0x00000001;
-    EventV1_0 eventIn = makeAccelerometerEvent();
+    Event eventIn = makeAccelerometerEvent();
     eventIn.sensorHandle = sensorHandleToPost;
-    std::vector<EventV1_0> eventsToPost{eventIn};
-    subhal1.postEvents(convertToNewEvents(eventsToPost), false);
+    std::vector<Event> eventsToPost{eventIn};
+    subhal1.postEvents(eventsToPost, false);
 
-    EventV1_0 eventOut;
+    Event eventOut;
     EXPECT_TRUE(eventQueue->read(&eventOut));
 
     EXPECT_EQ(eventOut.sensorHandle, (subhal1Index << 24) | sensorHandleToPost);
 
-    subhal2.postEvents(convertToNewEvents(eventsToPost), false);
+    subhal2.postEvents(eventsToPost, false);
 
     EXPECT_TRUE(eventQueue->read(&eventOut));
 
@@ -763,22 +728,22 @@
     constexpr size_t kQueueSize = 5;
     // TODO: Make this constant linked to same limit in HalProxy.h
     constexpr size_t kMaxPendingQueueSize = 100000;
-    AllSensorsSubHal<SensorsSubHalV2_0> subhal;
+    AllSensorsSubHal subhal;
     std::vector<ISensorsSubHal*> subHals{&subhal};
 
-    std::unique_ptr<EventMessageQueueV2_0> eventQueue = makeEventFMQ(kQueueSize);
+    std::unique_ptr<EventMessageQueue> eventQueue = makeEventFMQ(kQueueSize);
     std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_0> callback = new SensorsCallback();
+    ::android::sp<ISensorsCallback> callback = new SensorsCallback();
     EventFlag* eventQueueFlag;
     EventFlag::createEventFlag(eventQueue->getEventFlagWord(), &eventQueueFlag);
     HalProxy proxy(subHals);
     proxy.initialize(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
 
     // Fill pending queue
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kQueueSize);
-    subhal.postEvents(convertToNewEvents(events), false);
+    std::vector<Event> events = makeMultipleAccelerometerEvents(kQueueSize);
+    subhal.postEvents(events, false);
     events = makeMultipleAccelerometerEvents(kMaxPendingQueueSize);
-    subhal.postEvents(convertToNewEvents(events), false);
+    subhal.postEvents(events, false);
 
     // Drain pending queue
     for (int i = 0; i < kMaxPendingQueueSize + kQueueSize; i += kQueueSize) {
@@ -787,9 +752,9 @@
 
     // Put one event on pending queue
     events = makeMultipleAccelerometerEvents(kQueueSize);
-    subhal.postEvents(convertToNewEvents(events), false);
+    subhal.postEvents(events, false);
     events = {makeAccelerometerEvent()};
-    subhal.postEvents(convertToNewEvents(events), false);
+    subhal.postEvents(events, false);
 
     // Read out to make room for one event on pending queue to write to FMQ
     ASSERT_TRUE(readEventsOutOfQueue(kQueueSize, eventQueue, eventQueueFlag));
@@ -798,35 +763,6 @@
     EXPECT_TRUE(readEventsOutOfQueue(1, eventQueue, eventQueueFlag));
 }
 
-TEST(HalProxyTest, PostEventsMultipleSubhalsThreadedV2_1) {
-    constexpr size_t kQueueSize = 5;
-    constexpr size_t kNumEvents = 2;
-    AllSensorsSubHal<SensorsSubHalV2_0> subHal1;
-    AllSensorsSubHal<SensorsSubHalV2_1> subHal2;
-    std::vector<::android::hardware::sensors::V2_0::implementation::ISensorsSubHal*> subHalsV2_0{
-            &subHal1};
-    std::vector<::android::hardware::sensors::V2_1::implementation::ISensorsSubHal*> subHalsV2_1{
-            &subHal2};
-    HalProxy proxy(subHalsV2_0, subHalsV2_1);
-    std::unique_ptr<EventMessageQueueV2_1> eventQueue =
-            std::make_unique<EventMessageQueueV2_1>(kQueueSize, true);
-    std::unique_ptr<WakeupMessageQueue> wakeLockQueue = makeWakelockFMQ(kQueueSize);
-    ::android::sp<ISensorsCallbackV2_1> callback = new SensorsCallbackV2_1();
-    proxy.initialize_2_1(*eventQueue->getDesc(), *wakeLockQueue->getDesc(), callback);
-
-    std::vector<EventV1_0> events = makeMultipleAccelerometerEvents(kNumEvents);
-
-    std::thread t1(&AllSensorsSubHal<SensorsSubHalV2_0>::postEvents, &subHal1,
-                   convertToNewEvents(events), false);
-    std::thread t2(&AllSensorsSubHal<SensorsSubHalV2_1>::postEvents, &subHal2,
-                   convertToNewEvents(events), false);
-
-    t1.join();
-    t2.join();
-
-    EXPECT_EQ(eventQueue->availableToRead(), kNumEvents * 2);
-}
-
 // Helper implementations follow
 void testSensorsListFromProxyAndSubHal(const std::vector<SensorInfo>& proxySensorsList,
                                        const std::vector<SensorInfo>& subHalSensorsList) {
@@ -865,26 +801,26 @@
     wakelockQueueFlag->wake(static_cast<uint32_t>(WakeLockQueueFlagBits::DATA_WRITTEN));
 }
 
-bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueueV2_0>& eventQueue,
+bool readEventsOutOfQueue(size_t numEvents, std::unique_ptr<EventMessageQueue>& eventQueue,
                           EventFlag* eventQueueFlag) {
     constexpr int64_t kReadBlockingTimeout = INT64_C(500000000);
-    std::vector<EventV1_0> events(numEvents);
+    std::vector<Event> events(numEvents);
     return eventQueue->readBlocking(events.data(), numEvents,
                                     static_cast<uint32_t>(EventQueueFlagBits::EVENTS_READ),
                                     static_cast<uint32_t>(EventQueueFlagBits::READ_AND_PROCESS),
                                     kReadBlockingTimeout, eventQueueFlag);
 }
 
-std::unique_ptr<EventMessageQueueV2_0> makeEventFMQ(size_t size) {
-    return std::make_unique<EventMessageQueueV2_0>(size, true);
+std::unique_ptr<EventMessageQueue> makeEventFMQ(size_t size) {
+    return std::make_unique<EventMessageQueue>(size, true);
 }
 
 std::unique_ptr<WakeupMessageQueue> makeWakelockFMQ(size_t size) {
     return std::make_unique<WakeupMessageQueue>(size, true);
 }
 
-EventV1_0 makeProximityEvent() {
-    EventV1_0 event;
+Event makeProximityEvent() {
+    Event event;
     event.timestamp = 0xFF00FF00;
     // This is the sensorhandle of proximity, which is wakeup type
     event.sensorHandle = 0x00000008;
@@ -893,8 +829,8 @@
     return event;
 }
 
-EventV1_0 makeAccelerometerEvent() {
-    EventV1_0 event;
+Event makeAccelerometerEvent() {
+    Event event;
     event.timestamp = 0xFF00FF00;
     // This is the sensorhandle of proximity, which is wakeup type
     event.sensorHandle = 0x00000001;
@@ -903,16 +839,16 @@
     return event;
 }
 
-std::vector<EventV1_0> makeMultipleProximityEvents(size_t numEvents) {
-    std::vector<EventV1_0> events;
+std::vector<Event> makeMultipleProximityEvents(size_t numEvents) {
+    std::vector<Event> events;
     for (size_t i = 0; i < numEvents; i++) {
         events.push_back(makeProximityEvent());
     }
     return events;
 }
 
-std::vector<EventV1_0> makeMultipleAccelerometerEvents(size_t numEvents) {
-    std::vector<EventV1_0> events;
+std::vector<Event> makeMultipleAccelerometerEvents(size_t numEvents) {
+    std::vector<Event> events;
     for (size_t i = 0; i < numEvents; i++) {
         events.push_back(makeAccelerometerEvent());
     }
diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h
deleted file mode 100644
index 4542bfd..0000000
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/IHalProxyCallbackWrapper.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2020 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.
- */
-
-#pragma once
-
-#include "V2_0/SubHal.h"
-#include "V2_1/SubHal.h"
-#include "convertV2_1.h"
-
-namespace android {
-namespace hardware {
-namespace sensors {
-namespace V2_1 {
-namespace subhal {
-namespace implementation {
-
-/**
- * The following callback wrapper classes abstract away common functionality across V2.0 and V2.1
- * interfaces. Much of the logic is common between the two versions and this allows users of the
- * classes to only care about the type used at initialization and then interact with either version
- * of the callback interface without worrying about the type.
- */
-class IHalProxyCallbackWrapperBase {
-  protected:
-    using ScopedWakelock = V2_0::implementation::ScopedWakelock;
-
-  public:
-    virtual ~IHalProxyCallbackWrapperBase() {}
-
-    virtual Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V2_1::SensorInfo>& sensorInfos) = 0;
-
-    virtual Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) = 0;
-
-    virtual void postEvents(const std::vector<V2_1::Event>& events, ScopedWakelock wakelock) = 0;
-
-    virtual ScopedWakelock createScopedWakelock(bool lock) = 0;
-};
-
-template <typename T>
-class HalProxyCallbackWrapperBase : public IHalProxyCallbackWrapperBase {
-  public:
-    HalProxyCallbackWrapperBase(sp<T> callback) : mCallback(callback){};
-
-    Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) override {
-        return mCallback->onDynamicSensorsDisconnected(sensorHandles);
-    }
-
-    ScopedWakelock createScopedWakelock(bool lock) override {
-        return mCallback->createScopedWakelock(lock);
-    }
-
-  protected:
-    sp<T> mCallback;
-};
-
-class HalProxyCallbackWrapperV2_0
-    : public HalProxyCallbackWrapperBase<V2_0::implementation::IHalProxyCallback> {
-  public:
-    HalProxyCallbackWrapperV2_0(sp<V2_0::implementation::IHalProxyCallback> callback)
-        : HalProxyCallbackWrapperBase(callback){};
-
-    Return<void> onDynamicSensorsConnected(const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
-        return mCallback->onDynamicSensorsConnected(
-                V2_1::implementation::convertToOldSensorInfos(sensorInfos));
-    }
-
-    void postEvents(const std::vector<V2_1::Event>& events, ScopedWakelock wakelock) override {
-        return mCallback->postEvents(V2_1::implementation::convertToOldEvents(events),
-                                     std::move(wakelock));
-    }
-};
-
-class HalProxyCallbackWrapperV2_1
-    : public HalProxyCallbackWrapperBase<V2_1::implementation::IHalProxyCallback> {
-  public:
-    HalProxyCallbackWrapperV2_1(sp<V2_1::implementation::IHalProxyCallback> callback)
-        : HalProxyCallbackWrapperBase(callback){};
-
-    Return<void> onDynamicSensorsConnected(const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
-        return mCallback->onDynamicSensorsConnected_2_1(sensorInfos);
-    }
-
-    void postEvents(const std::vector<V2_1::Event>& events, ScopedWakelock wakelock) {
-        return mCallback->postEvents(events, std::move(wakelock));
-    }
-};
-
-}  // namespace implementation
-}  // namespace subhal
-}  // namespace V2_1
-}  // namespace sensors
-}  // namespace hardware
-}  // namespace android
diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp
index 1efd971..de89a00 100644
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp
+++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.cpp
@@ -24,18 +24,13 @@
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace subhal {
 namespace implementation {
 
 using ::android::hardware::sensors::V1_0::MetaDataEventType;
-using ::android::hardware::sensors::V1_0::OperationMode;
-using ::android::hardware::sensors::V1_0::Result;
 using ::android::hardware::sensors::V1_0::SensorFlagBits;
 using ::android::hardware::sensors::V1_0::SensorStatus;
-using ::android::hardware::sensors::V2_1::Event;
-using ::android::hardware::sensors::V2_1::SensorInfo;
-using ::android::hardware::sensors::V2_1::SensorType;
 
 Sensor::Sensor(int32_t sensorHandle, ISensorsEventCallback* callback)
     : mIsEnabled(false),
@@ -348,7 +343,7 @@
 
 }  // namespace implementation
 }  // namespace subhal
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h
index 5cf9f83..60f5d3d 100644
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h
+++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/Sensor.h
@@ -16,7 +16,7 @@
 
 #pragma once
 
-#include <android/hardware/sensors/2.1/types.h>
+#include <android/hardware/sensors/1.0/types.h>
 
 #include <condition_variable>
 #include <memory>
@@ -24,16 +24,16 @@
 #include <thread>
 #include <vector>
 
+using ::android::hardware::sensors::V1_0::Event;
 using ::android::hardware::sensors::V1_0::OperationMode;
 using ::android::hardware::sensors::V1_0::Result;
-using ::android::hardware::sensors::V2_1::Event;
-using ::android::hardware::sensors::V2_1::SensorInfo;
-using ::android::hardware::sensors::V2_1::SensorType;
+using ::android::hardware::sensors::V1_0::SensorInfo;
+using ::android::hardware::sensors::V1_0::SensorType;
 
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace subhal {
 namespace implementation {
 
@@ -151,7 +151,7 @@
 
 }  // namespace implementation
 }  // namespace subhal
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp
index 20a4e9d..ff5ff38 100644
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp
+++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.cpp
@@ -16,66 +16,33 @@
 
 #include "SensorsSubHal.h"
 
-#include <android/hardware/sensors/2.1/types.h>
+#include <android/hardware/sensors/2.0/types.h>
 #include <log/log.h>
 
-#ifdef SUB_HAL_VERSION_2_0
-::android::hardware::sensors::V2_0::implementation::ISensorsSubHal* sensorsHalGetSubHal(
-        uint32_t* version) {
+ISensorsSubHal* sensorsHalGetSubHal(uint32_t* version) {
 #if defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
-            subHal;
+    static ::android::hardware::sensors::V2_0::subhal::implementation::AllSensorsSubHal subHal;
 #elif defined SUPPORT_CONTINUOUS_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
+    static ::android::hardware::sensors::V2_0::subhal::implementation::ContinuousSensorsSubHal
             subHal;
 #elif defined SUPPORT_ON_CHANGE_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
-            subHal;
+    static ::android::hardware::sensors::V2_0::subhal::implementation::OnChangeSensorsSubHal subHal;
 #else
-    static ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_0>
-            subHal;
+    static ::android::hardware::sensors::V2_0::subhal::implementation::SensorsSubHal subHal;
 #endif  // defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS
     *version = SUB_HAL_2_0_VERSION;
     return &subHal;
 }
 
-#else  // SUB_HAL_VERSION_2_0
-
-::android::hardware::sensors::V2_1::implementation::ISensorsSubHal* sensorsHalGetSubHal_2_1(
-        uint32_t* version) {
-#if defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::AllSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1>
-            subHal;
-#elif defined SUPPORT_CONTINUOUS_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::ContinuousSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1>
-            subHal;
-#elif defined SUPPORT_ON_CHANGE_SENSORS
-    static ::android::hardware::sensors::V2_1::subhal::implementation::OnChangeSensorsSubHal<
-            ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1>
-            subHal;
-#else
-    static ::android::hardware::sensors::V2_1::subhal::implementation::SensorsSubHalV2_1 subHal;
-#endif  // defined SUPPORT_CONTINUOUS_SENSORS && defined SUPPORT_ON_CHANGE_SENSORS
-    *version = SUB_HAL_2_1_VERSION;
-    return &subHal;
-}
-
-#endif  // SUB_HAL_VERSION_2_0
-
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace subhal {
 namespace implementation {
 
 using ::android::hardware::Void;
+using ::android::hardware::sensors::V1_0::Event;
 using ::android::hardware::sensors::V1_0::OperationMode;
 using ::android::hardware::sensors::V1_0::RateLevel;
 using ::android::hardware::sensors::V1_0::Result;
@@ -83,12 +50,11 @@
 using ::android::hardware::sensors::V2_0::SensorTimeout;
 using ::android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
 using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock;
-using ::android::hardware::sensors::V2_1::Event;
 
-ISensorsSubHalBase::ISensorsSubHalBase() : mCallback(nullptr), mNextHandle(1) {}
+SensorsSubHal::SensorsSubHal() : mCallback(nullptr), mNextHandle(1) {}
 
 // Methods from ::android::hardware::sensors::V2_0::ISensors follow.
-Return<void> ISensorsSubHalBase::getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) {
+Return<void> SensorsSubHal::getSensorsList(getSensorsList_cb _hidl_cb) {
     std::vector<SensorInfo> sensors;
     for (const auto& sensor : mSensors) {
         sensors.push_back(sensor.second->getSensorInfo());
@@ -98,7 +64,7 @@
     return Void();
 }
 
-Return<Result> ISensorsSubHalBase::setOperationMode(OperationMode mode) {
+Return<Result> SensorsSubHal::setOperationMode(OperationMode mode) {
     for (auto sensor : mSensors) {
         sensor.second->setOperationMode(mode);
     }
@@ -106,7 +72,7 @@
     return Result::OK;
 }
 
-Return<Result> ISensorsSubHalBase::activate(int32_t sensorHandle, bool enabled) {
+Return<Result> SensorsSubHal::activate(int32_t sensorHandle, bool enabled) {
     auto sensor = mSensors.find(sensorHandle);
     if (sensor != mSensors.end()) {
         sensor->second->activate(enabled);
@@ -115,8 +81,8 @@
     return Result::BAD_VALUE;
 }
 
-Return<Result> ISensorsSubHalBase::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                                         int64_t /* maxReportLatencyNs */) {
+Return<Result> SensorsSubHal::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
+                                    int64_t /* maxReportLatencyNs */) {
     auto sensor = mSensors.find(sensorHandle);
     if (sensor != mSensors.end()) {
         sensor->second->batch(samplingPeriodNs);
@@ -125,7 +91,7 @@
     return Result::BAD_VALUE;
 }
 
-Return<Result> ISensorsSubHalBase::flush(int32_t sensorHandle) {
+Return<Result> SensorsSubHal::flush(int32_t sensorHandle) {
     auto sensor = mSensors.find(sensorHandle);
     if (sensor != mSensors.end()) {
         return sensor->second->flush();
@@ -133,7 +99,7 @@
     return Result::BAD_VALUE;
 }
 
-Return<Result> ISensorsSubHalBase::injectSensorData(const Event& event) {
+Return<Result> SensorsSubHal::injectSensorData(const Event& event) {
     auto sensor = mSensors.find(event.sensorHandle);
     if (sensor != mSensors.end()) {
         return sensor->second->injectEvent(event);
@@ -142,24 +108,24 @@
     return Result::BAD_VALUE;
 }
 
-Return<void> ISensorsSubHalBase::registerDirectChannel(
-        const SharedMemInfo& /* mem */, V2_0::ISensors::registerDirectChannel_cb _hidl_cb) {
+Return<void> SensorsSubHal::registerDirectChannel(const SharedMemInfo& /* mem */,
+                                                  registerDirectChannel_cb _hidl_cb) {
     _hidl_cb(Result::INVALID_OPERATION, -1 /* channelHandle */);
     return Return<void>();
 }
 
-Return<Result> ISensorsSubHalBase::unregisterDirectChannel(int32_t /* channelHandle */) {
+Return<Result> SensorsSubHal::unregisterDirectChannel(int32_t /* channelHandle */) {
     return Result::INVALID_OPERATION;
 }
 
-Return<void> ISensorsSubHalBase::configDirectReport(
-        int32_t /* sensorHandle */, int32_t /* channelHandle */, RateLevel /* rate */,
-        V2_0::ISensors::configDirectReport_cb _hidl_cb) {
+Return<void> SensorsSubHal::configDirectReport(int32_t /* sensorHandle */,
+                                               int32_t /* channelHandle */, RateLevel /* rate */,
+                                               configDirectReport_cb _hidl_cb) {
     _hidl_cb(Result::INVALID_OPERATION, 0 /* reportToken */);
     return Return<void>();
 }
 
-Return<void> ISensorsSubHalBase::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) {
+Return<void> SensorsSubHal::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) {
     if (fd.getNativeHandle() == nullptr || fd->numFds < 1) {
         ALOGE("%s: missing fd for writing", __FUNCTION__);
         return Void();
@@ -190,18 +156,44 @@
     return Return<void>();
 }
 
-Return<Result> ISensorsSubHalBase::initialize(
-        std::unique_ptr<IHalProxyCallbackWrapperBase>& halProxyCallback) {
-    mCallback = std::move(halProxyCallback);
+Return<Result> SensorsSubHal::initialize(const sp<IHalProxyCallback>& halProxyCallback) {
+    mCallback = halProxyCallback;
     setOperationMode(OperationMode::NORMAL);
     return Result::OK;
 }
 
-void ISensorsSubHalBase::postEvents(const std::vector<Event>& events, bool wakeup) {
+void SensorsSubHal::postEvents(const std::vector<Event>& events, bool wakeup) {
     ScopedWakelock wakelock = mCallback->createScopedWakelock(wakeup);
     mCallback->postEvents(events, std::move(wakelock));
 }
 
+ContinuousSensorsSubHal::ContinuousSensorsSubHal() {
+    AddSensor<AccelSensor>();
+    AddSensor<GyroSensor>();
+    AddSensor<MagnetometerSensor>();
+    AddSensor<PressureSensor>();
+    AddSensor<DeviceTempSensor>();
+}
+
+OnChangeSensorsSubHal::OnChangeSensorsSubHal() {
+    AddSensor<AmbientTempSensor>();
+    AddSensor<LightSensor>();
+    AddSensor<ProximitySensor>();
+    AddSensor<RelativeHumiditySensor>();
+}
+
+AllSensorsSubHal::AllSensorsSubHal() {
+    AddSensor<AccelSensor>();
+    AddSensor<GyroSensor>();
+    AddSensor<MagnetometerSensor>();
+    AddSensor<PressureSensor>();
+    AddSensor<DeviceTempSensor>();
+    AddSensor<AmbientTempSensor>();
+    AddSensor<LightSensor>();
+    AddSensor<ProximitySensor>();
+    AddSensor<RelativeHumiditySensor>();
+}
+
 Return<Result> SetOperationModeFailingSensorsSubHal::setOperationMode(OperationMode /*mode*/) {
     return Result::BAD_VALUE;
 }
@@ -214,7 +206,7 @@
         sensorInfo.flags |= V1_0::SensorFlagBits::MASK_DIRECT_REPORT;
         sensors.push_back(sensorInfo);
     }
-    _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors));
+    _hidl_cb(sensors);
     return Void();
 }
 
@@ -226,7 +218,7 @@
         sensorInfo.flags &= ~static_cast<uint32_t>(V1_0::SensorFlagBits::MASK_DIRECT_REPORT);
         sensors.push_back(sensorInfo);
     }
-    _hidl_cb(V2_1::implementation::convertToOldSensorInfos(sensors));
+    _hidl_cb(sensors);
     return Void();
 }
 
@@ -242,7 +234,7 @@
 
 }  // namespace implementation
 }  // namespace subhal
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h
index 1a78e84..6da4404 100644
--- a/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h
+++ b/sensors/common/default/2.X/multihal/tests/fake_subhal/SensorsSubHal.h
@@ -17,9 +17,7 @@
 #pragma once
 
 #include "V2_0/SubHal.h"
-#include "V2_1/SubHal.h"
 
-#include "IHalProxyCallbackWrapper.h"
 #include "Sensor.h"
 
 #include <vector>
@@ -27,54 +25,54 @@
 namespace android {
 namespace hardware {
 namespace sensors {
-namespace V2_1 {
+namespace V2_0 {
 namespace subhal {
 namespace implementation {
 
 using ::android::hardware::sensors::V1_0::OperationMode;
 using ::android::hardware::sensors::V1_0::Result;
+using ::android::hardware::sensors::V2_0::implementation::IHalProxyCallback;
 
 /**
  * Implementation of a ISensorsSubHal that can be used to test the implementation of multihal 2.0.
  * See the README file for more details on how this class can be used for testing.
  */
-class ISensorsSubHalBase : public ISensorsEventCallback {
-  protected:
-    using Event = ::android::hardware::sensors::V2_1::Event;
+class SensorsSubHal : public ISensorsSubHal, public ISensorsEventCallback {
+    using Event = ::android::hardware::sensors::V1_0::Event;
     using RateLevel = ::android::hardware::sensors::V1_0::RateLevel;
     using SharedMemInfo = ::android::hardware::sensors::V1_0::SharedMemInfo;
 
   public:
-    ISensorsSubHalBase();
-
-    Return<void> getSensorsList(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb);
-    Return<Result> injectSensorData(const Event& event);
-    Return<Result> initialize(std::unique_ptr<IHalProxyCallbackWrapperBase>& halProxyCallback);
+    SensorsSubHal();
 
     // Methods from ::android::hardware::sensors::V2_0::ISensors follow.
-    virtual Return<Result> setOperationMode(OperationMode mode);
+    virtual Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
+
+    virtual Return<Result> setOperationMode(OperationMode mode) override;
 
     OperationMode getOperationMode() const { return mCurrentOperationMode; }
 
-    Return<Result> activate(int32_t sensorHandle, bool enabled);
+    Return<Result> activate(int32_t sensorHandle, bool enabled) override;
 
     Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                         int64_t maxReportLatencyNs);
+                         int64_t maxReportLatencyNs) override;
 
-    Return<Result> flush(int32_t sensorHandle);
+    Return<Result> flush(int32_t sensorHandle) override;
+
+    Return<Result> injectSensorData(const Event& event) override;
 
     Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                       V2_0::ISensors::registerDirectChannel_cb _hidl_cb);
+                                       registerDirectChannel_cb _hidl_cb) override;
 
-    Return<Result> unregisterDirectChannel(int32_t channelHandle);
+    Return<Result> unregisterDirectChannel(int32_t channelHandle) override;
 
     Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
-                                    V2_0::ISensors::configDirectReport_cb _hidl_cb);
+                                    configDirectReport_cb _hidl_cb) override;
 
-    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args);
+    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override;
 
     // Methods from ::android::hardware::sensors::V2_0::implementation::ISensorsSubHal follow.
-    const std::string getName() {
+    const std::string getName() override {
 #ifdef SUB_HAL_NAME
         return SUB_HAL_NAME;
 #else   // SUB_HAL_NAME
@@ -82,6 +80,8 @@
 #endif  // SUB_HAL_NAME
     }
 
+    Return<Result> initialize(const sp<IHalProxyCallback>& halProxyCallback) override;
+
     // Method from ISensorsEventCallback.
     void postEvents(const std::vector<Event>& events, bool wakeup) override;
 
@@ -103,7 +103,7 @@
      * disconnected, sensor events need to be sent to the framework, and when a wakelock should be
      * acquired.
      */
-    std::unique_ptr<IHalProxyCallbackWrapperBase> mCallback;
+    sp<IHalProxyCallback> mCallback;
 
   private:
     /**
@@ -118,143 +118,40 @@
     int32_t mNextHandle;
 };
 
-template <class SubHalClass>
-class SensorsSubHalBase : public ISensorsSubHalBase, public SubHalClass {
-  public:
-    Return<Result> setOperationMode(OperationMode mode) override {
-        return ISensorsSubHalBase::setOperationMode(mode);
-    }
-
-    Return<Result> activate(int32_t sensorHandle, bool enabled) override {
-        return ISensorsSubHalBase::activate(sensorHandle, enabled);
-    }
-
-    Return<Result> batch(int32_t sensorHandle, int64_t samplingPeriodNs,
-                         int64_t maxReportLatencyNs) override {
-        return ISensorsSubHalBase::batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs);
-    }
-
-    Return<Result> flush(int32_t sensorHandle) override {
-        return ISensorsSubHalBase::flush(sensorHandle);
-    }
-
-    Return<void> registerDirectChannel(const SharedMemInfo& mem,
-                                       V2_0::ISensors::registerDirectChannel_cb _hidl_cb) override {
-        return ISensorsSubHalBase::registerDirectChannel(mem, _hidl_cb);
-    }
-
-    Return<Result> unregisterDirectChannel(int32_t channelHandle) override {
-        return ISensorsSubHalBase::unregisterDirectChannel(channelHandle);
-    }
-
-    Return<void> configDirectReport(int32_t sensorHandle, int32_t channelHandle, RateLevel rate,
-                                    V2_0::ISensors::configDirectReport_cb _hidl_cb) override {
-        return ISensorsSubHalBase::configDirectReport(sensorHandle, channelHandle, rate, _hidl_cb);
-    }
-
-    Return<void> debug(const hidl_handle& fd, const hidl_vec<hidl_string>& args) override {
-        return ISensorsSubHalBase::debug(fd, args);
-    }
-
-    const std::string getName() override { return ISensorsSubHalBase::getName(); }
-};
-
-class SensorsSubHalV2_0 : public SensorsSubHalBase<V2_0::implementation::ISensorsSubHal> {
-  public:
-    virtual Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override {
-        return ISensorsSubHalBase::getSensorsList([&](const auto& list) {
-            _hidl_cb(V2_1::implementation::convertToOldSensorInfos(list));
-        });
-    }
-
-    Return<Result> injectSensorData(const V1_0::Event& event) override {
-        return ISensorsSubHalBase::injectSensorData(V2_1::implementation::convertToNewEvent(event));
-    }
-
-    Return<Result> initialize(
-            const sp<V2_0::implementation::IHalProxyCallback>& halProxyCallback) override {
-        std::unique_ptr<IHalProxyCallbackWrapperBase> wrapper =
-                std::make_unique<HalProxyCallbackWrapperV2_0>(halProxyCallback);
-        return ISensorsSubHalBase::initialize(wrapper);
-    }
-};
-
-class SensorsSubHalV2_1 : public SensorsSubHalBase<V2_1::implementation::ISensorsSubHal> {
-  public:
-    Return<void> getSensorsList_2_1(V2_1::ISensors::getSensorsList_2_1_cb _hidl_cb) override {
-        return ISensorsSubHalBase::getSensorsList(_hidl_cb);
-    }
-
-    Return<Result> injectSensorData_2_1(const V2_1::Event& event) override {
-        return ISensorsSubHalBase::injectSensorData(event);
-    }
-
-    Return<Result> initialize(
-            const sp<V2_1::implementation::IHalProxyCallback>& halProxyCallback) override {
-        std::unique_ptr<IHalProxyCallbackWrapperBase> wrapper =
-                std::make_unique<HalProxyCallbackWrapperV2_1>(halProxyCallback);
-        return ISensorsSubHalBase::initialize(wrapper);
-    }
-};
-
 // SubHal that has continuous sensors for testing purposes.
-template <class SubHalVersion>
-class ContinuousSensorsSubHal : public SubHalVersion {
+class ContinuousSensorsSubHal : public SensorsSubHal {
   public:
-    ContinuousSensorsSubHal() {
-        ISensorsSubHalBase::AddSensor<AccelSensor>();
-        ISensorsSubHalBase::AddSensor<GyroSensor>();
-        ISensorsSubHalBase::AddSensor<MagnetometerSensor>();
-        ISensorsSubHalBase::AddSensor<PressureSensor>();
-        ISensorsSubHalBase::AddSensor<DeviceTempSensor>();
-    }
+    ContinuousSensorsSubHal();
 };
 
 // SubHal that has on-change sensors for testing purposes.
-template <class SubHalVersion>
-class OnChangeSensorsSubHal : public SubHalVersion {
+class OnChangeSensorsSubHal : public SensorsSubHal {
   public:
-    OnChangeSensorsSubHal() {
-        ISensorsSubHalBase::AddSensor<AmbientTempSensor>();
-        ISensorsSubHalBase::AddSensor<LightSensor>();
-        ISensorsSubHalBase::AddSensor<ProximitySensor>();
-        ISensorsSubHalBase::AddSensor<RelativeHumiditySensor>();
-    }
+    OnChangeSensorsSubHal();
 };
 
 // SubHal that has both continuous and on-change sensors for testing purposes.
-template <class SubHalVersion>
-class AllSensorsSubHal : public SubHalVersion {
+class AllSensorsSubHal : public SensorsSubHal {
   public:
-    AllSensorsSubHal() {
-        ISensorsSubHalBase::AddSensor<AccelSensor>();
-        ISensorsSubHalBase::AddSensor<GyroSensor>();
-        ISensorsSubHalBase::AddSensor<MagnetometerSensor>();
-        ISensorsSubHalBase::AddSensor<PressureSensor>();
-        ISensorsSubHalBase::AddSensor<DeviceTempSensor>();
-        ISensorsSubHalBase::AddSensor<AmbientTempSensor>();
-        ISensorsSubHalBase::AddSensor<LightSensor>();
-        ISensorsSubHalBase::AddSensor<ProximitySensor>();
-        ISensorsSubHalBase::AddSensor<RelativeHumiditySensor>();
-    }
+    AllSensorsSubHal();
 };
 
-class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class SetOperationModeFailingSensorsSubHal : public AllSensorsSubHal {
   public:
     Return<Result> setOperationMode(OperationMode mode) override;
 };
 
-class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class AllSupportDirectChannelSensorsSubHal : public AllSensorsSubHal {
   public:
-    Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override;
+    Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
 };
 
-class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class DoesNotSupportDirectChannelSensorsSubHal : public AllSensorsSubHal {
   public:
-    Return<void> getSensorsList(V2_0::ISensors::getSensorsList_cb _hidl_cb) override;
+    Return<void> getSensorsList(getSensorsList_cb _hidl_cb) override;
 };
 
-class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal<SensorsSubHalV2_0> {
+class AddAndRemoveDynamicSensorsSubHal : public AllSensorsSubHal {
   public:
     void addDynamicSensors(const std::vector<SensorInfo>& sensorsAdded);
     void removeDynamicSensors(const std::vector<int32_t>& sensorHandlesAdded);
@@ -262,7 +159,7 @@
 
 }  // namespace implementation
 }  // namespace subhal
-}  // namespace V2_1
+}  // namespace V2_0
 }  // namespace sensors
 }  // namespace hardware
 }  // namespace android
diff --git a/sensors/common/utils/EventMessageQueueWrapper.h b/sensors/common/utils/EventMessageQueueWrapper.h
index c4f92c8..bf3261f 100644
--- a/sensors/common/utils/EventMessageQueueWrapper.h
+++ b/sensors/common/utils/EventMessageQueueWrapper.h
@@ -39,14 +39,8 @@
 
     virtual std::atomic<uint32_t>* getEventFlagWord() = 0;
     virtual size_t availableToRead() = 0;
-    virtual size_t availableToWrite() = 0;
     virtual bool read(V2_1::Event* events, size_t numToRead) = 0;
-    virtual bool write(const V2_1::Event* events, size_t numToWrite) = 0;
     virtual bool write(const std::vector<V2_1::Event>& events) = 0;
-    virtual bool writeBlocking(const V2_1::Event* events, size_t count, uint32_t readNotification,
-                               uint32_t writeNotification, int64_t timeOutNanos,
-                               android::hardware::EventFlag* evFlag) = 0;
-    virtual size_t getQuantumCount() = 0;
 };
 
 class EventMessageQueueWrapperV1_0 : public EventMessageQueueWrapperBase {
@@ -66,30 +60,15 @@
 
     virtual size_t availableToRead() override { return mQueue->availableToRead(); }
 
-    size_t availableToWrite() override { return mQueue->availableToWrite(); }
-
     virtual bool read(V2_1::Event* events, size_t numToRead) override {
         return mQueue->read(reinterpret_cast<V1_0::Event*>(events), numToRead);
     }
 
-    bool write(const V2_1::Event* events, size_t numToWrite) override {
-        return mQueue->write(reinterpret_cast<const V1_0::Event*>(events), numToWrite);
-    }
-
     virtual bool write(const std::vector<V2_1::Event>& events) override {
         const std::vector<V1_0::Event>& oldEvents = convertToOldEvents(events);
         return mQueue->write(oldEvents.data(), oldEvents.size());
     }
 
-    bool writeBlocking(const V2_1::Event* events, size_t count, uint32_t readNotification,
-                       uint32_t writeNotification, int64_t timeOutNanos,
-                       android::hardware::EventFlag* evFlag) override {
-        return mQueue->writeBlocking(reinterpret_cast<const V1_0::Event*>(events), count,
-                                     readNotification, writeNotification, timeOutNanos, evFlag);
-    }
-
-    size_t getQuantumCount() override { return mQueue->getQuantumCount(); }
-
   private:
     std::unique_ptr<EventMessageQueue> mQueue;
 };
@@ -109,29 +88,14 @@
 
     virtual size_t availableToRead() override { return mQueue->availableToRead(); }
 
-    size_t availableToWrite() override { return mQueue->availableToWrite(); }
-
     virtual bool read(V2_1::Event* events, size_t numToRead) override {
         return mQueue->read(events, numToRead);
     }
 
-    bool write(const V2_1::Event* events, size_t numToWrite) override {
-        return mQueue->write(events, numToWrite);
-    }
-
     bool write(const std::vector<V2_1::Event>& events) override {
         return mQueue->write(events.data(), events.size());
     }
 
-    bool writeBlocking(const V2_1::Event* events, size_t count, uint32_t readNotification,
-                       uint32_t writeNotification, int64_t timeOutNanos,
-                       android::hardware::EventFlag* evFlag) override {
-        return mQueue->writeBlocking(events, count, readNotification, writeNotification,
-                                     timeOutNanos, evFlag);
-    }
-
-    size_t getQuantumCount() override { return mQueue->getQuantumCount(); }
-
   private:
     std::unique_ptr<EventMessageQueue> mQueue;
 };
diff --git a/sensors/common/utils/ISensorsCallbackWrapper.h b/sensors/common/utils/ISensorsCallbackWrapper.h
deleted file mode 100644
index 816b225..0000000
--- a/sensors/common/utils/ISensorsCallbackWrapper.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2020 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_HARDWARE_SENSORS_V2_1_ISENSORSCALLBACKWRAPPER_H
-#define ANDROID_HARDWARE_SENSORS_V2_1_ISENSORSCALLBACKWRAPPER_H
-
-#include "convertV2_1.h"
-
-#include "android/hardware/sensors/1.0/ISensors.h"
-#include "android/hardware/sensors/1.0/types.h"
-#include "android/hardware/sensors/2.0/ISensors.h"
-#include "android/hardware/sensors/2.0/ISensorsCallback.h"
-#include "android/hardware/sensors/2.1/ISensors.h"
-#include "android/hardware/sensors/2.1/ISensorsCallback.h"
-#include "android/hardware/sensors/2.1/types.h"
-
-#include <utils/LightRefBase.h>
-
-#include <cassert>
-
-namespace android {
-namespace hardware {
-namespace sensors {
-namespace V2_1 {
-namespace implementation {
-
-/**
- * The ISensorsCallbackWrapper classes below abstract away the common logic between both the V2.0
- * and V2.1 versions of the Sensors HAL interface. This allows users of these classes to only care
- * about the HAL version at init time and then interact with either version of the callback without
- * worrying about the class type by utilizing the base class.
- */
-class ISensorsCallbackWrapperBase : public VirtualLightRefBase {
-  public:
-    virtual Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V2_1::SensorInfo>& sensorInfos) = 0;
-
-    virtual Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) = 0;
-};
-
-template <typename T>
-class SensorsCallbackWrapperBase : public ISensorsCallbackWrapperBase {
-  public:
-    SensorsCallbackWrapperBase(sp<T> sensorsCallback) : mSensorsCallback(sensorsCallback){};
-
-    virtual Return<void> onDynamicSensorsConnected(
-            const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
-        return mSensorsCallback->onDynamicSensorsConnected(convertToOldSensorInfos(sensorInfos));
-    }
-
-    Return<void> onDynamicSensorsDisconnected(const hidl_vec<int32_t>& sensorHandles) {
-        return mSensorsCallback->onDynamicSensorsDisconnected(sensorHandles);
-    }
-
-  protected:
-    sp<T> mSensorsCallback;
-};
-
-class ISensorsCallbackWrapperV2_0
-    : public SensorsCallbackWrapperBase<hardware::sensors::V2_0::ISensorsCallback> {
-  public:
-    ISensorsCallbackWrapperV2_0(sp<hardware::sensors::V2_0::ISensorsCallback> sensorsCallback)
-        : SensorsCallbackWrapperBase(sensorsCallback){};
-};
-
-class ISensorsCallbackWrapperV2_1
-    : public SensorsCallbackWrapperBase<hardware::sensors::V2_1::ISensorsCallback> {
-  public:
-    ISensorsCallbackWrapperV2_1(sp<hardware::sensors::V2_1::ISensorsCallback> sensorsCallback)
-        : SensorsCallbackWrapperBase(sensorsCallback) {}
-
-    Return<void> onDynamicSensorsConnected(const hidl_vec<V2_1::SensorInfo>& sensorInfos) override {
-        return mSensorsCallback->onDynamicSensorsConnected_2_1(sensorInfos);
-    }
-};
-
-}  // namespace implementation
-}  // namespace V2_1
-}  // namespace sensors
-}  // namespace hardware
-}  // namespace android
-
-#endif  // ANDROID_HARDWARE_SENSORS_V2_1_ISENSORSCALLBACKWRAPPER_H
\ No newline at end of file