diff --git a/services/incremental/IncrementalService.cpp b/services/incremental/IncrementalService.cpp
index 980ae08..2426e8f 100644
--- a/services/incremental/IncrementalService.cpp
+++ b/services/incremental/IncrementalService.cpp
@@ -155,7 +155,7 @@
 } // namespace
 
 IncrementalService::IncFsMount::~IncFsMount() {
-    incrementalService.mIncrementalManager->destroyDataLoader(mountId);
+    incrementalService.mDataLoaderManager->destroyDataLoader(mountId);
     control.reset();
     LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';
     for (auto&& [target, _] : bindPoints) {
@@ -229,14 +229,14 @@
 
 IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)
       : mVold(sm.getVoldService()),
-        mIncrementalManager(sm.getIncrementalManager()),
+        mDataLoaderManager(sm.getDataLoaderManager()),
         mIncFs(sm.getIncFs()),
         mIncrementalDir(rootDir) {
     if (!mVold) {
         LOG(FATAL) << "Vold service is unavailable";
     }
-    if (!mIncrementalManager) {
-        LOG(FATAL) << "IncrementalManager service is unavailable";
+    if (!mDataLoaderManager) {
+        LOG(FATAL) << "DataLoaderManagerService is unavailable";
     }
     mountExistingImages();
 }
@@ -921,7 +921,6 @@
     if (!ifs) {
         return false;
     }
-    bool started = false;
     std::unique_lock l(ifs->lock);
     if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {
         if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {
@@ -929,11 +928,19 @@
             return false;
         }
     }
-    auto status = mIncrementalManager->startDataLoader(ifs->mountId, &started);
+    sp<IDataLoader> dataloader;
+    auto status = mDataLoaderManager->getDataLoader(ifs->mountId, &dataloader);
     if (!status.isOk()) {
         return false;
     }
-    return started;
+    if (!dataloader) {
+        return false;
+    }
+    status = dataloader->start();
+    if (!status.isOk()) {
+        return false;
+    }
+    return true;
 }
 
 void IncrementalService::mountExistingImages() {
@@ -1086,8 +1093,8 @@
     sp<IncrementalDataLoaderListener> listener =
             new IncrementalDataLoaderListener(*this, *externalListener);
     bool created = false;
-    auto status = mIncrementalManager->prepareDataLoader(ifs.mountId, fsControlParcel, *dlp,
-                                                         listener, &created);
+    auto status = mDataLoaderManager->initializeDataLoader(ifs.mountId, *dlp, fsControlParcel,
+                                                           listener, &created);
     if (!status.isOk() || !created) {
         LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;
         return false;
@@ -1229,16 +1236,7 @@
     ifs->dataLoaderStatus = newStatus;
     switch (newStatus) {
         case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {
-            auto now = Clock::now();
-            if (ifs->connectionLostTime.time_since_epoch().count() == 0) {
-                ifs->connectionLostTime = now;
-                break;
-            }
-            auto duration =
-                    std::chrono::duration_cast<Seconds>(now - ifs->connectionLostTime).count();
-            if (duration >= 10) {
-                incrementalService.mIncrementalManager->showHealthBlockedUI(mountId);
-            }
+            // TODO(b/150411019): handle data loader connection loss
             break;
         }
         case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {
diff --git a/services/incremental/IncrementalService.h b/services/incremental/IncrementalService.h
index 19424973..8ff441b 100644
--- a/services/incremental/IncrementalService.h
+++ b/services/incremental/IncrementalService.h
@@ -19,7 +19,6 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <android/content/pm/DataLoaderParamsParcel.h>
-#include <android/os/incremental/IIncrementalManager.h>
 #include <binder/IServiceManager.h>
 #include <utils/String16.h>
 #include <utils/StrongPointer.h>
@@ -220,7 +219,7 @@
 
     // Member variables
     std::unique_ptr<VoldServiceWrapper> mVold;
-    std::unique_ptr<IncrementalManagerWrapper> mIncrementalManager;
+    std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;
     std::unique_ptr<IncFsWrapper> mIncFs;
     const std::string mIncrementalDir;
 
diff --git a/services/incremental/ServiceWrappers.cpp b/services/incremental/ServiceWrappers.cpp
index 5d978a1c..2e31ef1 100644
--- a/services/incremental/ServiceWrappers.cpp
+++ b/services/incremental/ServiceWrappers.cpp
@@ -23,7 +23,7 @@
 namespace android::os::incremental {
 
 static constexpr auto kVoldServiceName = "vold"sv;
-static constexpr auto kIncrementalManagerName = "incremental"sv;
+static constexpr auto kDataLoaderManagerName = "dataloader_manager"sv;
 
 RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)
       : mServiceManager(std::move(serviceManager)) {}
@@ -46,11 +46,11 @@
     return nullptr;
 }
 
-std::unique_ptr<IncrementalManagerWrapper> RealServiceManager::getIncrementalManager() {
-    sp<IIncrementalManager> manager =
-            RealServiceManager::getRealService<IIncrementalManager>(kIncrementalManagerName);
+std::unique_ptr<DataLoaderManagerWrapper> RealServiceManager::getDataLoaderManager() {
+    sp<IDataLoaderManager> manager =
+            RealServiceManager::getRealService<IDataLoaderManager>(kDataLoaderManagerName);
     if (manager) {
-        return std::make_unique<RealIncrementalManager>(manager);
+        return std::make_unique<RealDataLoaderManager>(manager);
     }
     return nullptr;
 }
diff --git a/services/incremental/ServiceWrappers.h b/services/incremental/ServiceWrappers.h
index c574ca7..5349ebf 100644
--- a/services/incremental/ServiceWrappers.h
+++ b/services/incremental/ServiceWrappers.h
@@ -20,9 +20,10 @@
 #include <android-base/unique_fd.h>
 #include <android/content/pm/DataLoaderParamsParcel.h>
 #include <android/content/pm/FileSystemControlParcel.h>
+#include <android/content/pm/IDataLoader.h>
+#include <android/content/pm/IDataLoaderManager.h>
 #include <android/content/pm/IDataLoaderStatusListener.h>
 #include <android/os/IVold.h>
-#include <android/os/incremental/IIncrementalManager.h>
 #include <binder/IServiceManager.h>
 #include <incfs.h>
 
@@ -50,17 +51,16 @@
                                      const std::string& targetDir) const = 0;
 };
 
-class IncrementalManagerWrapper {
+class DataLoaderManagerWrapper {
 public:
-    virtual ~IncrementalManagerWrapper() = default;
-    virtual binder::Status prepareDataLoader(MountId mountId,
-                                             const FileSystemControlParcel& control,
-                                             const DataLoaderParamsParcel& params,
-                                             const sp<IDataLoaderStatusListener>& listener,
-                                             bool* _aidl_return) const = 0;
-    virtual binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const = 0;
+    virtual ~DataLoaderManagerWrapper() = default;
+    virtual binder::Status initializeDataLoader(MountId mountId,
+                                                const DataLoaderParamsParcel& params,
+                                                const FileSystemControlParcel& control,
+                                                const sp<IDataLoaderStatusListener>& listener,
+                                                bool* _aidl_return) const = 0;
+    virtual binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const = 0;
     virtual binder::Status destroyDataLoader(MountId mountId) const = 0;
-    virtual binder::Status showHealthBlockedUI(MountId mountId) const = 0;
 };
 
 class IncFsWrapper {
@@ -82,7 +82,7 @@
 public:
     virtual ~ServiceManagerWrapper() = default;
     virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;
-    virtual std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() = 0;
+    virtual std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() = 0;
     virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;
 };
 
@@ -109,29 +109,26 @@
     sp<os::IVold> mInterface;
 };
 
-class RealIncrementalManager : public IncrementalManagerWrapper {
+class RealDataLoaderManager : public DataLoaderManagerWrapper {
 public:
-    RealIncrementalManager(const sp<os::incremental::IIncrementalManager> manager)
+    RealDataLoaderManager(const sp<content::pm::IDataLoaderManager> manager)
           : mInterface(manager) {}
-    ~RealIncrementalManager() = default;
-    binder::Status prepareDataLoader(MountId mountId, const FileSystemControlParcel& control,
-                                     const DataLoaderParamsParcel& params,
-                                     const sp<IDataLoaderStatusListener>& listener,
-                                     bool* _aidl_return) const override {
-        return mInterface->prepareDataLoader(mountId, control, params, listener, _aidl_return);
+    ~RealDataLoaderManager() = default;
+    binder::Status initializeDataLoader(MountId mountId, const DataLoaderParamsParcel& params,
+                                        const FileSystemControlParcel& control,
+                                        const sp<IDataLoaderStatusListener>& listener,
+                                        bool* _aidl_return) const override {
+        return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);
     }
-    binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const override {
-        return mInterface->startDataLoader(mountId, _aidl_return);
+    binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const override {
+        return mInterface->getDataLoader(mountId, _aidl_return);
     }
     binder::Status destroyDataLoader(MountId mountId) const override {
         return mInterface->destroyDataLoader(mountId);
     }
-    binder::Status showHealthBlockedUI(MountId mountId) const override {
-        return mInterface->showHealthBlockedUI(mountId);
-    }
 
 private:
-    sp<os::incremental::IIncrementalManager> mInterface;
+    sp<content::pm::IDataLoaderManager> mInterface;
 };
 
 class RealServiceManager : public ServiceManagerWrapper {
@@ -139,7 +136,7 @@
     RealServiceManager(sp<IServiceManager> serviceManager);
     ~RealServiceManager() = default;
     std::unique_ptr<VoldServiceWrapper> getVoldService() override;
-    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() override;
+    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() override;
     std::unique_ptr<IncFsWrapper> getIncFs() override;
 
 private:
diff --git a/services/incremental/test/IncrementalServiceTest.cpp b/services/incremental/test/IncrementalServiceTest.cpp
index aca6ca4..6002226 100644
--- a/services/incremental/test/IncrementalServiceTest.cpp
+++ b/services/incremental/test/IncrementalServiceTest.cpp
@@ -93,47 +93,60 @@
     TemporaryFile logFile;
 };
 
-class MockIncrementalManager : public IncrementalManagerWrapper {
+class FakeDataLoader : public IDataLoader {
 public:
-    MOCK_CONST_METHOD5(prepareDataLoader,
-                       binder::Status(int32_t mountId, const FileSystemControlParcel& control,
-                                      const DataLoaderParamsParcel& params,
+    IBinder* onAsBinder() override { return nullptr; }
+    binder::Status create(int32_t, const DataLoaderParamsParcel&, const FileSystemControlParcel&,
+                          const sp<IDataLoaderStatusListener>&) override {
+        return binder::Status::ok();
+    }
+    binder::Status start() override { return binder::Status::ok(); }
+    binder::Status stop() override { return binder::Status::ok(); }
+    binder::Status destroy() override { return binder::Status::ok(); }
+    binder::Status prepareImage(const std::vector<InstallationFileParcel>&,
+                                const std::vector<std::string>&) override {
+        return binder::Status::ok();
+    }
+};
+
+class MockDataLoaderManager : public DataLoaderManagerWrapper {
+public:
+    MOCK_CONST_METHOD5(initializeDataLoader,
+                       binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,
+                                      const FileSystemControlParcel& control,
                                       const sp<IDataLoaderStatusListener>& listener,
                                       bool* _aidl_return));
-    MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));
+    MOCK_CONST_METHOD2(getDataLoader,
+                       binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));
     MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));
-    MOCK_CONST_METHOD3(newFileForDataLoader,
-                       binder::Status(int32_t mountId, FileId fileId,
-                                      const ::std::vector<uint8_t>& metadata));
-    MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));
 
-    binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,
-                                       const DataLoaderParamsParcel& params,
-                                       const sp<IDataLoaderStatusListener>& listener,
-                                       bool* _aidl_return) {
+    binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,
+                                          const FileSystemControlParcel& control,
+                                          const sp<IDataLoaderStatusListener>& listener,
+                                          bool* _aidl_return) {
         mId = mountId;
         mListener = listener;
         *_aidl_return = true;
         return binder::Status::ok();
     }
 
-    binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {
-        *_aidl_return = true;
+    binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {
+        *_aidl_return = mDataLoader;
         return binder::Status::ok();
     }
 
-    void prepareDataLoaderFails() {
-        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
+    void initializeDataLoaderFails() {
+        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
                 .WillByDefault(Return(
                         (binder::Status::fromExceptionCode(1, String8("failed to prepare")))));
     }
-    void prepareDataLoaderSuccess() {
-        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))
-                .WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));
+    void initializeDataLoaderSuccess() {
+        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))
+                .WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));
     }
-    void startDataLoaderSuccess() {
-        ON_CALL(*this, startDataLoader(_, _))
-                .WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));
+    void getDataLoaderSuccess() {
+        ON_CALL(*this, getDataLoader(_, _))
+                .WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));
     }
     void setDataLoaderStatusNotReady() {
         mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
@@ -145,6 +158,7 @@
 private:
     int mId;
     sp<IDataLoaderStatusListener> mListener;
+    sp<IDataLoader> mDataLoader = sp<IDataLoader>(new FakeDataLoader());
 };
 
 class MockIncFs : public IncFsWrapper {
@@ -197,20 +211,20 @@
 class MockServiceManager : public ServiceManagerWrapper {
 public:
     MockServiceManager(std::unique_ptr<MockVoldService> vold,
-                       std::unique_ptr<MockIncrementalManager> manager,
+                       std::unique_ptr<MockDataLoaderManager> manager,
                        std::unique_ptr<MockIncFs> incfs)
           : mVold(std::move(vold)),
-            mIncrementalManager(std::move(manager)),
+            mDataLoaderManager(std::move(manager)),
             mIncFs(std::move(incfs)) {}
     std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }
-    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {
-        return std::move(mIncrementalManager);
+    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() final {
+        return std::move(mDataLoaderManager);
     }
     std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }
 
 private:
     std::unique_ptr<MockVoldService> mVold;
-    std::unique_ptr<MockIncrementalManager> mIncrementalManager;
+    std::unique_ptr<MockDataLoaderManager> mDataLoaderManager;
     std::unique_ptr<MockIncFs> mIncFs;
 };
 
@@ -221,14 +235,14 @@
     void SetUp() override {
         auto vold = std::make_unique<NiceMock<MockVoldService>>();
         mVold = vold.get();
-        auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();
-        mIncrementalManager = incrementalManager.get();
+        auto dataloaderManager = std::make_unique<NiceMock<MockDataLoaderManager>>();
+        mDataLoaderManager = dataloaderManager.get();
         auto incFs = std::make_unique<NiceMock<MockIncFs>>();
         mIncFs = incFs.get();
         mIncrementalService =
                 std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),
                                                                         std::move(
-                                                                                incrementalManager),
+                                                                                dataloaderManager),
                                                                         std::move(incFs)),
                                                      mRootDir.path);
         mDataLoaderParcel.packageName = "com.test";
@@ -260,7 +274,7 @@
 protected:
     NiceMock<MockVoldService>* mVold;
     NiceMock<MockIncFs>* mIncFs;
-    NiceMock<MockIncrementalManager>* mIncrementalManager;
+    NiceMock<MockDataLoaderManager>* mDataLoaderManager;
     std::unique_ptr<IncrementalService> mIncrementalService;
     TemporaryDir mRootDir;
     DataLoaderParamsParcel mDataLoaderParcel;
@@ -268,7 +282,7 @@
 
 TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {
     mVold->mountIncFsFails();
-    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -278,7 +292,7 @@
 
 TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {
     mVold->mountIncFsInvalidControlParcel();
-    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -289,8 +303,8 @@
 TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {
     mVold->mountIncFsSuccess();
     mIncFs->makeFileFails();
-    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_));
     TemporaryDir tempDir;
     int storageId =
@@ -303,8 +317,8 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountFails();
-    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_));
     TemporaryDir tempDir;
     int storageId =
@@ -317,8 +331,8 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderFails();
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    mDataLoaderManager->initializeDataLoaderFails();
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
     TemporaryDir tempDir;
     int storageId =
@@ -331,8 +345,8 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderSuccess();
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    mDataLoaderManager->initializeDataLoaderSuccess();
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
     TemporaryDir tempDir;
     int storageId =
@@ -346,31 +360,31 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderSuccess();
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    mDataLoaderManager->initializeDataLoaderSuccess();
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
                                                IncrementalService::CreateOptions::CreateNew);
     ASSERT_GE(storageId, 0);
-    mIncrementalManager->setDataLoaderStatusNotReady();
+    mDataLoaderManager->setDataLoaderStatusNotReady();
 }
 
 TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderSuccess();
-    mIncrementalManager->startDataLoaderSuccess();
-    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));
+    mDataLoaderManager->initializeDataLoaderSuccess();
+    mDataLoaderManager->getDataLoaderSuccess();
+    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));
     EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
                                                IncrementalService::CreateOptions::CreateNew);
     ASSERT_GE(storageId, 0);
-    mIncrementalManager->setDataLoaderStatusReady();
+    mDataLoaderManager->setDataLoaderStatusReady();
     ASSERT_TRUE(mIncrementalService->startLoading(storageId));
 }
 
@@ -378,8 +392,8 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderSuccess();
-    mIncrementalManager->startDataLoaderSuccess();
+    mDataLoaderManager->initializeDataLoaderSuccess();
+    mDataLoaderManager->getDataLoaderSuccess();
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -402,8 +416,8 @@
     mVold->mountIncFsSuccess();
     mIncFs->makeFileSuccess();
     mVold->bindMountSuccess();
-    mIncrementalManager->prepareDataLoaderSuccess();
-    mIncrementalManager->startDataLoaderSuccess();
+    mDataLoaderManager->initializeDataLoaderSuccess();
+    mDataLoaderManager->getDataLoaderSuccess();
     TemporaryDir tempDir;
     int storageId =
             mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},