diff --git a/media/jni/tuner/DemuxClient.cpp b/media/jni/tuner/DemuxClient.cpp
index abf7d56..11acb5e 100644
--- a/media/jni/tuner/DemuxClient.cpp
+++ b/media/jni/tuner/DemuxClient.cpp
@@ -44,26 +44,59 @@
     mDemux = demux;
 }
 
-Result DemuxClient::setFrontendDataSource(sp<FrontendClient> tunerFrontend) {
+Result DemuxClient::setFrontendDataSource(sp<FrontendClient> frontendClient) {
     // TODO: pending aidl interface
     /*if (mTunerDemux != NULL) {
         // TODO: handle error message
-        mTunerDemux->setFrontendDataSource(tunerFrontend->getAidlFrontend());
+        mTunerDemux->setFrontendDataSource(frontendClient->getAidlFrontend());
         return (int) Result::SUCCESS;
     }*/
 
     if (mDemux != NULL) {
-        Result res = mDemux->setFrontendDataSource(tunerFrontend->getId());
+        Result res = mDemux->setFrontendDataSource(frontendClient->getId());
         return res;
     }
 
     return Result::INVALID_STATE;
 }
 
-//FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);
+sp<FilterClient> DemuxClient::openFilter(DemuxFilterType type, int bufferSize,
+        sp<FilterClientCallback> cb) {
+    // TODO: pending aidl interface
 
-int DemuxClient::getAvSyncHwId(FilterClient /*tunerFilter*/) {
-    return 0;
+    if (mDemux != NULL) {
+        sp<HidlFilterCallback> callback = new HidlFilterCallback(cb);
+        sp<IFilter> hidlFilter = openHidlFilter(type, bufferSize, callback);
+        if (hidlFilter != NULL) {
+            sp<FilterClient> filterClient = new FilterClient();
+            filterClient->setHidlFilter(hidlFilter);
+            return filterClient;
+        }
+    }
+
+    // TODO: handle share av memory handle
+
+    return NULL;
+}
+
+int DemuxClient::getAvSyncHwId(sp<FilterClient> filterClient) {
+    // pending aidl interface
+
+    if (mDemux != NULL) {
+        uint32_t avSyncHwId;
+        Result res;
+        sp<IFilter> halFilter = filterClient->getHalFilter();
+        mDemux->getAvSyncHwId(halFilter,
+                [&](Result r, uint32_t id) {
+                    res = r;
+                    avSyncHwId = id;
+                });
+        if (res == Result::SUCCESS) {
+            return (int) avSyncHwId;
+        }
+    }
+
+    return -1;
 }
 
 long DemuxClient::getAvSyncTime(int avSyncHwId) {
@@ -120,4 +153,26 @@
 
     return Result::INVALID_STATE;
 }
+
+/////////////// DemuxClient Helper Methods ///////////////////////
+
+sp<IFilter> DemuxClient::openHidlFilter(DemuxFilterType type, int bufferSize,
+        sp<HidlFilterCallback> callback) {
+    if (mDemux == NULL) {
+        return NULL;
+    }
+
+    sp<IFilter> hidlFilter;
+    Result res;
+    mDemux->openFilter(type, bufferSize, callback,
+            [&](Result r, const sp<IFilter>& filter) {
+                hidlFilter = filter;
+                res = r;
+            });
+    if (res != Result::SUCCESS || hidlFilter == NULL) {
+        return NULL;
+    }
+
+    return hidlFilter;
+}
 }  // namespace android
diff --git a/media/jni/tuner/DemuxClient.h b/media/jni/tuner/DemuxClient.h
index ef39117..a0671a5 100644
--- a/media/jni/tuner/DemuxClient.h
+++ b/media/jni/tuner/DemuxClient.h
@@ -22,10 +22,12 @@
 #include <android/hardware/tv/tuner/1.1/types.h>
 
 #include "FilterClient.h"
+#include "FilterClientCallback.h"
 #include "FrontendClient.h"
 
 //using ::aidl::android::media::tv::tuner::ITunerDemux;
 
+using ::android::hardware::tv::tuner::V1_0::DemuxFilterType;
 using ::android::hardware::tv::tuner::V1_0::IDemux;
 
 using namespace std;
@@ -44,19 +46,19 @@
     /**
      * Set a frontend resource as data input of the demux.
      */
-    Result setFrontendDataSource(sp<FrontendClient> tunerFrontend);
+    Result setFrontendDataSource(sp<FrontendClient> frontendClient);
 
     /**
      * Open a new filter client.
      */
-    //FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);
+    sp<FilterClient> openFilter(DemuxFilterType type, int bufferSize, sp<FilterClientCallback> cb);
 
     // TODO: handle TimeFilterClient
 
     /**
      * Get hardware sync ID for audio and video.
      */
-    int getAvSyncHwId(FilterClient tunerFilter);
+    int getAvSyncHwId(sp<FilterClient> filterClient);
 
     /**
      * Get current time stamp to use for A/V sync.
@@ -85,6 +87,8 @@
     Result close();
 
 private:
+    sp<IFilter> openHidlFilter(DemuxFilterType type, int bufferSize, sp<HidlFilterCallback> cb);
+
     /**
      * An AIDL Tuner Demux Singleton assigned at the first time the Tuner Client
      * opens a demux. Default null when demux is not opened.
diff --git a/media/jni/tuner/FilterClient.cpp b/media/jni/tuner/FilterClient.cpp
index 5d468bd..a71cae60 100644
--- a/media/jni/tuner/FilterClient.cpp
+++ b/media/jni/tuner/FilterClient.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "FrontendClient"
+#define LOG_TAG "FilterClient"
 
 #include <android-base/logging.h>
 #include <utils/Log.h>
@@ -25,10 +25,6 @@
 
 namespace android {
 
-//shared_ptr<ITunerFilter> FilterClient::mTunerFilter;
-sp<IFilter> FilterClient::mFilter;
-sp<::android::hardware::tv::tuner::V1_1::IFilter> FilterClient::mFilter_1_1;
-
 /////////////// FilterClient ///////////////////////
 
 // TODO: pending aidl interface
@@ -49,8 +45,6 @@
     mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(mFilter);
 }
 
-//Result setCallback(FilterClientCallback filterClientCallback);
-
 int FilterClient::read(uint8_t* buffer, int size) {
     // TODO: pending aidl interface
 
@@ -199,6 +193,33 @@
     return Result::INVALID_STATE;
 }
 
+/////////////// IFilterCallback ///////////////////////
+
+HidlFilterCallback::HidlFilterCallback(sp<FilterClientCallback> filterClientCallback)
+        : mFilterClientCallback(filterClientCallback) {}
+
+Return<void> HidlFilterCallback::onFilterStatus(const DemuxFilterStatus status) {
+    if (mFilterClientCallback != NULL) {
+        mFilterClientCallback->onFilterStatus(status);
+    }
+    return Void();
+}
+
+Return<void> HidlFilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
+    if (mFilterClientCallback != NULL) {
+        mFilterClientCallback->onFilterEvent(filterEvent);
+    }
+    return Void();
+}
+
+Return<void> HidlFilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
+        const DemuxFilterEventExt& filterEventExt) {
+    if (mFilterClientCallback != NULL) {
+        mFilterClientCallback->onFilterEvent_1_1(filterEvent, filterEventExt);
+    }
+    return Void();
+}
+
 /////////////// FilterClient Helper Methods ///////////////////////
 
 Result FilterClient::getFilterMq() {
diff --git a/media/jni/tuner/FilterClient.h b/media/jni/tuner/FilterClient.h
index 7517e40..4af74b0 100644
--- a/media/jni/tuner/FilterClient.h
+++ b/media/jni/tuner/FilterClient.h
@@ -19,21 +19,25 @@
 
 //#include <aidl/android/media/tv/tuner/ITunerFilter.h>
 #include <android/hardware/tv/tuner/1.1/IFilter.h>
+#include <android/hardware/tv/tuner/1.1/IFilterCallback.h>
 #include <android/hardware/tv/tuner/1.1/types.h>
 #include <fmq/MessageQueue.h>
 
-//#include "FilterClientCallback.h"
+#include "FilterClientCallback.h"
 
 //using ::aidl::android::media::tv::tuner::ITunerFilter;
 
 using ::android::hardware::EventFlag;
 using ::android::hardware::MessageQueue;
 using ::android::hardware::MQDescriptorSync;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
 using ::android::hardware::hidl_handle;
 using ::android::hardware::tv::tuner::V1_0::DemuxFilterSettings;
 using ::android::hardware::tv::tuner::V1_0::IFilter;
 using ::android::hardware::tv::tuner::V1_0::Result;
 using ::android::hardware::tv::tuner::V1_1::AvStreamType;
+using ::android::hardware::tv::tuner::V1_1::IFilterCallback;
 
 using namespace std;
 
@@ -41,6 +45,32 @@
 
 namespace android {
 
+// TODO: pending aidl interface
+/*class TunerFilterCallback : public BnTunerFilterCallback {
+
+public:
+    TunerFilterCallback(sp<FilterClientCallback> filterClientCallback);
+
+    Status onFilterEvent(vector<TunerDemuxFilterEvent> events);
+    Status onFilterStatus(int status);
+
+private:
+    sp<FilterClientCallback> mFilterClientCallback;
+};*/
+
+struct HidlFilterCallback : public IFilterCallback {
+
+public:
+    HidlFilterCallback(sp<FilterClientCallback> filterClientCallback);
+    virtual Return<void> onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
+            const DemuxFilterEventExt& filterEventExt);
+    virtual Return<void> onFilterEvent(const DemuxFilterEvent& filterEvent);
+    virtual Return<void> onFilterStatus(const DemuxFilterStatus status);
+
+private:
+    sp<FilterClientCallback> mFilterClientCallback;
+};
+
 struct FilterClient : public RefBase {
 
 public:
@@ -52,11 +82,6 @@
     void setHidlFilter(sp<IFilter> filter);
 
     /**
-     * Set the filter client callback.
-     */
-    //Result setCallback(FilterClientCallback filterClientCallback);
-
-    /**
      * Read size of data from filter FMQ into buffer.
      *
      * @return the actual reading size. -1 if failed to read.
@@ -142,24 +167,28 @@
      * opens a filter. Default null when Tuner Service does not exist.
      */
     // TODO: pending on aidl interface
-    //static shared_ptr<ITunerFilter> mTunerFilter;
+    //shared_ptr<ITunerFilter> mTunerFilter;
 
     /**
      * A 1.0 Filter HAL interface that is ready before migrating to the TunerFilter.
      * This is a temprary interface before Tuner Framework migrates to use TunerService.
      * Default null when the HAL service does not exist.
      */
-    static sp<IFilter> mFilter;
+    sp<IFilter> mFilter;
 
     /**
      * A 1.1 Filter HAL interface that is ready before migrating to the TunerFilter.
      * This is a temprary interface before Tuner Framework migrates to use TunerService.
      * Default null when the HAL service does not exist.
      */
-    static sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;
+    sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;
 
     unique_ptr<MQ> mFilterMQ;
     EventFlag* mFilterMQEventFlag;
+
+    sp<FilterClientCallback> mCallback;
+    //shared_ptr<TunerFilterCallback> mAidlCallback;
+    sp<HidlFilterCallback> mHidlCallback;
 };
 }  // namespace android
 
diff --git a/media/jni/tuner/FilterClientCallback.h b/media/jni/tuner/FilterClientCallback.h
new file mode 100644
index 0000000..94b7821
--- /dev/null
+++ b/media/jni/tuner/FilterClientCallback.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 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_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_
+#define _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_
+
+using ::android::hardware::tv::tuner::V1_0::DemuxFilterEvent;
+using ::android::hardware::tv::tuner::V1_0::DemuxFilterStatus;
+using ::android::hardware::tv::tuner::V1_1::DemuxFilterEventExt;
+
+using namespace std;
+
+namespace android {
+
+struct FilterClientCallback : public RefBase {
+    virtual void onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
+            const DemuxFilterEventExt& filterEventExt);
+    virtual void onFilterEvent(const DemuxFilterEvent& filterEvent);
+    virtual void onFilterStatus(const DemuxFilterStatus status);
+};
+}  // namespace android
+
+#endif  // _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_
\ No newline at end of file