diff --git a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h
index 3cb87e75766449e1e0ca122745f6bc852a2bd64f..6302cd280b206689ea98cba617a0e54d91d9ad90 100644
--- a/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h
+++ b/frameworks/js/napi/vibrator/include/vibrator_napi_utils.h
@@ -34,10 +34,21 @@ using std::string;
 constexpr int32_t CALLBACK_NUM = 3;
 constexpr uint32_t STRING_LENGTH_MAX = 64;
 
+#define CHKNRF(env, state, message) \
+    do { \
+        if ((state) != napi_ok) { \
+            MISC_HILOGE("(%{public}s) fail", #message); \
+            return false; \
+        } \
+    } while (0)
+
 enum CallbackType {
     SYSTEM_VIBRATE_CALLBACK = 1,
     COMMON_CALLBACK,
     IS_SUPPORT_EFFECT_CALLBACK,
+    GET_VIBRATOR_INFO_LIST,
+    GET_EFFECT_INFO,
+    VIBRATOR_STATE_CHANGE,
 };
 
 struct VibrateInfo {
@@ -71,6 +82,10 @@ public:
     AsyncCallbackError error;
     CallbackType callbackType = COMMON_CALLBACK;
     bool isSupportEffect {false};
+    std::vector<VibratorInfos> vibratorInfos;
+    int32_t arrayLength;
+    EffectInfo effectInfo;
+    VibratorDeviceInfo deviceInfo;
     std::string flag;
     AsyncCallbackInfo(napi_env env) : env(env) {}
     ~AsyncCallbackInfo();
@@ -80,6 +95,9 @@ using ConstructResultFunc = bool(*)(const napi_env &env, sptr<AsyncCallbackInfo>
     napi_value result[], int32_t length);
 
 bool CreateInt32Property(napi_env env, napi_value &eventObj, const char* name, int32_t value);
+bool CreateStringProperty(napi_env env, napi_value &eventObj, const char* name,
+    const char* value, int32_t valueLength);
+bool CreateBooleanProperty(napi_env env, napi_value &eventObj, const char* name, bool value);
 bool IsMatchArrayType(const napi_env &env, const napi_value &value);
 bool IsMatchType(const napi_env &env, const napi_value &value, const napi_valuetype &type);
 bool GetNapiInt32(const napi_env &env, const int32_t value, napi_value &result);
@@ -94,10 +112,18 @@ bool GetPropertyInt32(const napi_env &env, const napi_value &value, const std::s
 bool GetPropertyInt64(const napi_env &env, const napi_value &value, const std::string &type, int64_t &result);
 bool GetNapiParam(const napi_env &env, const napi_callback_info &info, size_t &argc, napi_value &argv);
 bool ConvertErrorToResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo, napi_value &result);
+napi_value ConvertToJsVibratorInfo(const napi_env& env, const VibratorInfos& vibratorInfo);
+napi_value ConvertToJsEffectInfo(const napi_env& env, const EffectInfo& effectInfo);
 bool ConstructCommonResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo, napi_value result[],
     int32_t length);
 bool ConstructIsSupportEffectResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo,
     napi_value result[], int32_t length);
+bool ConstructGetVibratorInfoListResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo,
+    napi_value result[], int32_t length);  
+bool ConstructIsSupportEffectInfoResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo,
+    napi_value result[], int32_t length);
+bool ConstructVibratorPlugInfoResult(const napi_env &env, sptr<AsyncCallbackInfo> asyncCallbackInfo,
+    napi_value result[], int32_t length);
 void EmitAsyncCallbackWork(sptr<AsyncCallbackInfo> async_callback_info);
 void EmitPromiseWork(sptr<AsyncCallbackInfo> asyncCallbackInfo);
 bool ClearVibratorPattern(VibratorPattern &vibratorPattern);
diff --git a/frameworks/native/vibrator/all/IMiscdeviceService.idl b/frameworks/native/vibrator/all/IMiscdeviceService.idl
index 2e2ceea0301a8cec7df6bde9a9da75e8645ce3fd..4ff8ac66d39ae2a6b5e44590cb00ceb90340e6e0 100644
--- a/frameworks/native/vibrator/all/IMiscdeviceService.idl
+++ b/frameworks/native/vibrator/all/IMiscdeviceService.idl
@@ -21,20 +21,25 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor;
 sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter;
 sequenceable vibrator_infos..OHOS.Sensors.VibratePattern;
 sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity;
+sequenceable vibrator_infos..OHOS.Sensors.VibratorIdentifierIPC;
+sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC;
+sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC;
 
 interface OHOS.Sensors.IMiscdeviceService {
-    void Vibrate([in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage);
-    void PlayVibratorEffect([in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage);
-    void PlayVibratorCustom([in] int vibratorId, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
-    void StopVibrator([in] int vibratorId);
-    void StopVibratorByMode([in] int vibratorId, [in] String mode);
-    void IsSupportEffect([in] String effect, [out] boolean state);
+    void Vibrate([in] VibratorIdentifierIPC identifier, [in] int timeOut, [in] int usage, [in] boolean systemUsage);
+    void PlayVibratorEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage);
+    void PlayVibratorCustom([in] VibratorIdentifierIPC identifier, [in] FileDescriptor fd, [in] long offset, [in] long length, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
+    void StopVibrator([in] VibratorIdentifierIPC identifier);
+    void StopVibratorByMode([in] VibratorIdentifierIPC identifier, [in] String mode);
+    void IsSupportEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [out] boolean state);
     void GetLightList([out] LightInfoIPC[] lightInfoIpcList);
     void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation);
     void TurnOff([in] int lightId);
-    void GetDelayTime([out] int delayTime);
-    void PlayPattern([in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
+    void GetDelayTime([in] VibratorIdentifierIPC identifier, [out] int delayTime);
+    void PlayPattern([in] VibratorIdentifierIPC identifier, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
     void TransferClientRemoteObject([in] IRemoteObject vibratorClient);
-    void PlayPrimitiveEffect([in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count);
-    void GetVibratorCapacity([out] VibratorCapacity capacity);
+    void PlayPrimitiveEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count);
+    void GetVibratorCapacity([in] VibratorIdentifierIPC identifier, [out] VibratorCapacity capacity);
+    void GetVibratorIdList([in] VibratorIdentifierIPC identifier, [out] VibratorInfoIPC[] vibratorInfoIPC);
+    void GetEffectInfo([in] VibratorIdentifierIPC identifier, [in] String effectType, [out] EffectInfoIPC effectInfoIPC);
 }
\ No newline at end of file
diff --git a/frameworks/native/vibrator/include/i_vibrator_client.h b/frameworks/native/vibrator/include/i_vibrator_client.h
index 8c83ed06649453e16196c38be3e9b273f083644d..7278d632e28258c52dbc259301de75feec6a4678 100644
--- a/frameworks/native/vibrator/include/i_vibrator_client.h
+++ b/frameworks/native/vibrator/include/i_vibrator_client.h
@@ -22,8 +22,12 @@ namespace OHOS {
 namespace Sensors {
 class IVibratorClient : public IRemoteBroker {
 public:
+    enum VibratorClientInterfaceId {
+        TRANS_ID_PLUG_ABILITY = 5,
+    };
     IVibratorClient() = default;
     virtual ~IVibratorClient() = default;
+    virtual int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) = 0;
     DECLARE_INTERFACE_DESCRIPTOR(u"IVibratorClient");
 };
 } // namespace Sensors
diff --git a/frameworks/native/vibrator/include/vibrator_client_proxy.h b/frameworks/native/vibrator/include/vibrator_client_proxy.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ef859db592b6252ebd109ade42a2f044f383535
--- /dev/null
+++ b/frameworks/native/vibrator/include/vibrator_client_proxy.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * 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 VIBRATOR_CLIENT_STUB_H
+#define VIBRATOR_CLIENT_STUB_H
+
+#include "message_parcel.h"
+#include "miscdevice_log.h"
+#include "iremote_proxy.h"
+#include "i_vibrator_client.h"
+
+#undef LOG_TAG
+#define LOG_TAG "VibratorClientProxy"
+
+namespace OHOS {
+namespace Sensors {
+class VibratorClientProxy : public IRemoteProxy<IVibratorClient> {
+public:
+    explicit VibratorClientProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IVibratorClient>(impl){}
+    virtual ~VibratorClientProxy() = default;
+    int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) override
+    {
+        MessageOption option;
+        MessageParcel dataParcel;
+        MessageParcel replyParcel;
+        
+        if (!dataParcel.WriteInterfaceToken(GetDescriptor())) {
+            MISC_HILOGE("Failed to write descriptor to parcelable");
+            return PARAMETER_ERROR;
+        }
+        if (!dataParcel.WriteInt32(eventCode)) {
+            MISC_HILOGE("Failed to write eventCode to parcelable");
+            return PARAMETER_ERROR;
+        }
+        if (!dataParcel.WriteInt32(deviceId)) {
+            MISC_HILOGE("Failed to write deviceId to parcelable");
+            return PARAMETER_ERROR;
+        }
+        int error = Remote()->SendRequest(TRANS_ID_PLUG_ABILITY, dataParcel, replyParcel, option);
+        if (error != ERR_NONE) {
+            MISC_HILOGE("failed, error code is: %{public}d", error);
+            return PARAMETER_ERROR;
+        }
+        int result = (error == ERR_NONE) ? replyParcel.ReadInt32() : -1;
+        return result;
+    }
+
+private:
+    DISALLOW_COPY_AND_MOVE(VibratorClientProxy);
+    static inline BrokerDelegator<VibratorClientProxy> delegator_;
+};
+} // namespace Sensors
+} // namespace OHOS
+#endif // VIBRATOR_CLIENT_STUB_H
diff --git a/frameworks/native/vibrator/include/vibrator_client_stub.h b/frameworks/native/vibrator/include/vibrator_client_stub.h
index 1f55bbda33dea66478822418eaea5534090dfff3..dab55ed953bc95e9916712cd815125ccd31f276e 100644
--- a/frameworks/native/vibrator/include/vibrator_client_stub.h
+++ b/frameworks/native/vibrator/include/vibrator_client_stub.h
@@ -28,6 +28,7 @@ public:
     virtual ~VibratorClientStub() = default;
     virtual int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
         MessageOption &option) override;
+    int ProcessPlugEvent(int32_t eventCode, int32_t deviceId) override;
 };
 } // namespace Sensors
 } // namespace OHOS
diff --git a/frameworks/native/vibrator/include/vibrator_service_client.h b/frameworks/native/vibrator/include/vibrator_service_client.h
index 9b5d1c56b52c40ce908b205f99d3eb574106d85c..5b60d5f6ae8001e835626726d3ec3770a992c109 100644
--- a/frameworks/native/vibrator/include/vibrator_service_client.h
+++ b/frameworks/native/vibrator/include/vibrator_service_client.h
@@ -18,6 +18,9 @@
 
 #include <dlfcn.h>
 #include <mutex>
+#include <map>
+#include <set>
+#include <vector>
 
 #include "iremote_object.h"
 #include "singleton.h"
@@ -54,35 +57,46 @@ struct VibratorDecodeHandle {
 class VibratorServiceClient : public Singleton<VibratorServiceClient> {
 public:
     ~VibratorServiceClient() override;
-    int32_t Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage);
-    int32_t Vibrate(int32_t vibratorId, const std::string &effect, int32_t loopCount, int32_t usage, bool systemUsage);
+    int32_t Vibrate(const VibratorIdentifier &identifier, int32_t timeOut, int32_t usage, bool systemUsage);
+    int32_t Vibrate(const VibratorIdentifier &identifier, const std::string &effect,
+        int32_t loopCount, int32_t usage, bool systemUsage);
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    int32_t PlayVibratorCustom(int32_t vibratorId, const RawFileDescriptor &rawFd, int32_t usage,
-        bool systemUsage, const VibratorParameter &parameter);
+    int32_t PlayVibratorCustom(const VibratorIdentifier &identifier, const RawFileDescriptor &rawFd,
+        int32_t usage, bool systemUsage, const VibratorParameter &parameter);
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    int32_t StopVibrator(int32_t vibratorId, const std::string &mode);
-    int32_t StopVibrator(int32_t vibratorId);
-    bool IsHdHapticSupported();
-    int32_t IsSupportEffect(const std::string &effect, bool &state);
+    int32_t StopVibrator(const VibratorIdentifier &identifier, const std::string &mode);
+    int32_t StopVibrator(const VibratorIdentifier &identifier);
+    bool IsHdHapticSupported(const VibratorIdentifier &identifier);
+    int32_t IsSupportEffect(const VibratorIdentifier &identifier, const std::string &effect, bool &state);
     void ProcessDeathObserver(const wptr<IRemoteObject> &object);
     int32_t PreProcess(const VibratorFileDescription &fd, VibratorPackage &package);
-    int32_t GetDelayTime(int32_t &delayTime);
-    int32_t InitPlayPattern(const VibratorPattern &pattern, int32_t usage, bool systemUsage,
-        const VibratorParameter &parameter);
-    int32_t PlayPattern(const VibratorPattern &pattern, int32_t usage, bool systemUsage,
-        const VibratorParameter &parameter);
+    int32_t GetDelayTime(const VibratorIdentifier &identifier, int32_t &delayTime);
+    int32_t InitPlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, int32_t usage,
+        bool systemUsage, const VibratorParameter &parameter);
+    int32_t PlayPattern(const VibratorIdentifier &identifier, const VibratorPattern &pattern, int32_t usage,
+        bool systemUsage, const VibratorParameter &parameter);
     int32_t FreeVibratorPackage(VibratorPackage &package);
-    int32_t PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, int32_t intensity, int32_t usage,
-        bool systemUsage, int32_t count);
-    bool IsSupportVibratorCustom();
+    int32_t PlayPrimitiveEffect(const VibratorIdentifier &identifier, const std::string &effect,
+        const PrimitiveEffect &primitiveEffect);
+    bool IsSupportVibratorCustom(const VibratorIdentifier &identifier);
     int32_t SeekTimeOnPackage(int32_t seekTime, const VibratorPackage &completePackage, VibratorPackage &seekPackage);
+    int32_t SubscribeVibratorPlugInfo(const VibratorUser *user);
+    int32_t UnsubscribeVibratorPlugInfo(const VibratorUser *user);
+    std::set<RecordVibratorPlugCallback> GetSubscribeUserCallback(int32_t deviceId);
+    bool HandleVibratorData(VibratorDeviceInfo info);
+    void SetUsage(const VibratorIdentifier &identifier, int32_t usage, bool systemUsage);
+    void SetLoopCount(const VibratorIdentifier &identifier, int32_t count);
+    void SetParameters(const VibratorIdentifier &identifier, const VibratorParameter &parameter);
+    VibratorEffectParameter GetVibratorEffectParameter(const VibratorIdentifier &identifier);
+    int32_t GetVibratorIdList(const VibratorIdentifier& identifier, std::vector<VibratorInfos>& vibratorInfo);
+    int32_t GetEffectInfo(const VibratorIdentifier& identifier,const std::string& effectType, EffectInfo& effectInfo);
 
 private:
     int32_t InitServiceClient();
     int32_t LoadDecoderLibrary(const std::string& path);
     int32_t ConvertVibratorPackage(const VibratePackage& inPkg, VibratorPackage &outPkg);
     int32_t TransferClientRemoteObject();
-    int32_t GetVibratorCapacity();
+    int32_t GetVibratorCapacity(const VibratorIdentifier &identifier, VibratorCapacity &capacity);
     void ConvertSeekVibratorPackage(const VibratorPackage &completePackage, VibratePackage &convertPackage,
         int32_t seekTime);
     void ConvertVibratorPattern(const VibratorPattern &vibratorPattern, VibratePattern &vibratePattern);
@@ -94,9 +108,14 @@ private:
     sptr<IMiscdeviceService> miscdeviceProxy_ = nullptr;
     sptr<VibratorClientStub> vibratorClient_ = nullptr;
     VibratorDecodeHandle decodeHandle_;
-    VibratorCapacity capacity_;
     std::mutex clientMutex_;
     std::mutex decodeMutex_;
+
+    std::recursive_mutex subscribeMutex_;
+    std::set<const VibratorUser *> subscribeSet_;
+
+    std::mutex vibratorEffectMutex_;
+    std::map<VibratorIdentifier, VibratorEffectParameter> vibratorEffectMap_;
 };
 } // namespace Sensors
 } // namespace OHOS
diff --git a/frameworks/native/vibrator/part/IMiscdeviceService.idl b/frameworks/native/vibrator/part/IMiscdeviceService.idl
index 2415e99d700bf8818c7a9d89f0d7cc000d0843ab..e8a100ef9a72f4af4ff200f4ed32135cfd8a97fb 100644
--- a/frameworks/native/vibrator/part/IMiscdeviceService.idl
+++ b/frameworks/native/vibrator/part/IMiscdeviceService.idl
@@ -21,19 +21,24 @@ sequenceable raw_file_descriptor..OHOS.Sensors.RawFileDescriptor;
 sequenceable vibrator_infos..OHOS.Sensors.VibrateParameter;
 sequenceable vibrator_infos..OHOS.Sensors.VibratePattern;
 sequenceable vibrator_infos..OHOS.Sensors.VibratorCapacity;
+sequenceable vibrator_infos..OHOS.Sensors.VibratorIdentifierIPC;
+sequenceable vibrator_infos..OHOS.Sensors.VibratorInfoIPC;
+sequenceable vibrator_infos..OHOS.Sensors.EffectInfoIPC;
 
 interface OHOS.Sensors.IMiscdeviceService {
-    void Vibrate([in] int vibratorId, [in] int timeOut, [in] int usage, [in] boolean systemUsage);
-    void PlayVibratorEffect([in] int vibratorId, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage);
-    void StopVibrator([in] int vibratorId);
-    void StopVibratorByMode([in] int vibratorId, [in] String mode);
-    void IsSupportEffect([in] String effect, [out] boolean state);
+    void Vibrate([in] VibratorIdentifierIPC identifier, [in] int timeOut, [in] int usage, [in] boolean systemUsage);
+    void PlayVibratorEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int loopCount, [in] int usage, [in] boolean systemUsage);
+    void StopVibrator([in] VibratorIdentifierIPC identifier);
+    void StopVibratorByMode([in] VibratorIdentifierIPC identifier, [in] String mode);
+    void IsSupportEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [out] boolean state);
     void GetLightList([out] LightInfoIPC[] lightInfoIpcList);
     void TurnOn([in] int lightId, [in] int singleColor, [in] LightAnimationIPC animation);
     void TurnOff([in] int lightId);
-    void GetDelayTime([out] int delayTime);
-    void PlayPattern([in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
+    void GetDelayTime([in] VibratorIdentifierIPC identifier, [out] int delayTime);
+    void PlayPattern([in] VibratorIdentifierIPC identifier, [in] VibratePattern pattern, [in] int usage, [in] boolean systemUsage, [in] VibrateParameter parameter);
     void TransferClientRemoteObject([in] IRemoteObject vibratorClient);
-    void PlayPrimitiveEffect([in] int vibratorId, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count);
-    void GetVibratorCapacity([out] VibratorCapacity capacity);
+    void PlayPrimitiveEffect([in] VibratorIdentifierIPC identifier, [in] String effect, [in] int intensity, [in] int usage, [in] boolean systemUsage, [in] int count);
+    void GetVibratorCapacity([in] VibratorIdentifierIPC identifier, [out] VibratorCapacity capacity);
+    void GetVibratorIdList([in] VibratorIdentifierIPC identifier, [out] VibratorInfoIPC[] vibratorInfoIPC);
+    void GetEffectInfo([in] VibratorIdentifierIPC identifier, [in] String effectType, [out] EffectInfoIPC effectInfoIPC);
 }
\ No newline at end of file
diff --git a/interfaces/inner_api/vibrator/vibrator_agent.h b/interfaces/inner_api/vibrator/vibrator_agent.h
index 859d7eac4ae9c6c25681f729b0fe28e6e1bdbdf2..e10328f8b9208ed322583faea6e7156b82a47d62 100644
--- a/interfaces/inner_api/vibrator/vibrator_agent.h
+++ b/interfaces/inner_api/vibrator/vibrator_agent.h
@@ -29,6 +29,7 @@
  */
 #ifndef VIBRATOR_AGENT_H
 #include <stdint.h>
+#include <vector>
 #include "vibrator_agent_type.h"
 #define VIBRATOR_AGENT_H
 
@@ -218,6 +219,227 @@ bool SetParameters(const VibratorParameter &parameter);
  * @since 12
  */
 int32_t PlayPrimitiveEffect(const char *effectId, int32_t intensity);
+
+/**
+ * @brief Controls this vibrator to perform a vibration with a preset vibration effect.
+ *
+ * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for
+ * example:{@link VIBRATOR_TYPE_CLOCK_TIMER}: Describes the vibration effect of the vibrator when a user adjusts the
+ * timer.
+ * @param param Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @return Returns <b>0</b> if the vibrator vibrates as expected; returns <b>-1</b> otherwise, for example, the preset
+ * vibration effect is not supported.
+ *
+ * @since 18
+ */
+int32_t StartVibratorEnhanced(const VibratorIdentifier identifier, const char *effectId);
+
+/**
+ * @brief Controls this vibrator to perform a one-shot vibration at a given duration.
+ *
+ * @param duration Indicates the duration that the one-shot vibration lasts, in milliseconds.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @return Returns <b>0</b> if the vibrator vibrates as expected; returns <b>-1</b> otherwise, for example, the given
+ * duration for the one-shot vibration is invalid.
+ *
+ * @since 18
+ */
+int32_t StartVibratorOnceEnhanced(const VibratorIdentifier identifier, int32_t duration);
+
+/**
+ * @brief Query whether the device supports custom vibration.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @return Returning true indicates support; otherwise, it indicates no support.
+ *
+ * @since 18
+ */
+bool IsSupportVibratorCustomEnhanced(const VibratorIdentifier identifier);
+
+/**
+ * @brief Play a custom vibration sequence.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param fd Indicates the file handle for custom vibration sequence.
+ * @param offset Indicates the starting address (in bytes) of the custom vibration sequence.
+ * @param length Indicates the total length (in bytes) of the custom vibration sequence.
+ * @return Returning 0 indicates success; otherwise, it indicates failure.
+ *
+ * @since 18
+ */
+int32_t PlayVibratorCustomEnhanced(const VibratorIdentifier identifier, int32_t fd, int64_t offset, int64_t length);
+
+/**
+ * @brief Sets the number of cycles for vibration.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param count Indicates the number of cycles for vibration.
+ * @since 18
+ */
+bool SetLoopCountEnhanced(const VibratorIdentifier identifier, int32_t count);
+
+/**
+ * @brief Stop the motor vibration according to the input mode.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param mode Indicates the mode of the vibration to stop. The values can be <b>time</b> and <b>preset</b>,
+ * respectively representing a one-shot vibration mode and a preset vibration mode.
+ * @return Returns <b>0</b> if the vibration is stopped as expected; returns <b>-1</b> otherwise.
+ * @since 18
+ */
+int32_t StopVibratorEnhanced(const VibratorIdentifier identifier, const char *mode);
+
+/**
+ * @brief Cancel the current motor vibration.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @return Returning 0 indicates success; otherwise, it indicates failure.
+ * @since 18
+ */
+int32_t CancelEnhanced(const VibratorIdentifier identifier);
+
+/**
+ * @brief Set the usage of vibration.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param usage Indicates the vibration usage, which is described in {@link vibrator_agent_type.h},for
+ * example:{@link USAGE_ALARM}: Describes the vibration is used for alarm.
+ * @since 18
+ */
+bool SetUsageEnhanced(const VibratorIdentifier identifier, int32_t usage, bool systemUsage = false);
+
+/**
+ * @brief Query whether the HdHaptic is supported.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @return Returning true indicates support; otherwise, it indicates no support.
+ *
+ * @since 18
+ */
+bool IsHdHapticSupportedEnhanced(const VibratorIdentifier identifier);
+
+/**
+ * @brief Query whether a vibration effect is supported.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for
+ * example:{@link VIBRATOR_TYPE_CLOCK_TIMER}: Describes the vibration effect of the vibrator when a user adjusts the
+ * timer.
+ * @param state Indicates a pointer to the query result.
+ * @return Returning 0 indicates success; otherwise, it indicates failure.
+ *
+ * @since 18
+ */
+int32_t IsSupportEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, bool *state);
+
+/**
+ * @brief Obtain the vibration delay, the time interval from the time the vibration is issued
+ *        to the time when the vibration is started, which can be used in the scene of sound
+ *        and vibration coordination.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param delayTime: Out of the parameter, return the vibration time delay, the time interval
+ *        from the time the vibration is issued to the start of the vibration, in milliseconds.
+ * @return 0 indicates success, otherwise indicates failure.
+ * @since 18
+ */
+int32_t GetDelayTimeEnhanced(const VibratorIdentifier identifier, int32_t &delayTime);
+
+/**
+ * @brief Play the vibration sequence.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param pattern: Vibration sequences, such as {@link VibratorPattern}.
+ * @return 0 indicates success, otherwise indicates failure.
+ * @since 18
+ */
+int32_t PlayPatternEnhanced(const VibratorIdentifier identifier, const VibratorPattern &pattern);
+
+/**
+ * @brief Set the vibration effect adjustment parameters.
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param parameter: Vibration adjustment parameter, such as {@link VibratorParameter}.
+ * @return true indicates success, otherwise indicates failure.
+ * @since 18
+ */
+bool SetParametersEnhanced(const VibratorIdentifier identifier, const VibratorParameter &parameter);
+
+/**
+ * @brief Control the vibrator to perform vibration with a preset vibration effect at a certain intensity.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param effectId Indicates the preset vibration effect, which is described in {@link vibrator_agent_type.h}, for
+ * example:{@link VIBRATOR_TYPE_HARD}: Describes the hard vibration effect of the vibrator.
+ * @param intensity Indicates the intensity of vibration, ranging from 1 to 100.
+ * @return Returns <b>0</b> if the vibrator vibrates as expected; otherwise indicates failure.
+ *
+ * @since 18
+ */
+int32_t PlayPrimitiveEffectEnhanced(const VibratorIdentifier identifier, const char *effectId, int32_t intensity);
+
+/**
+ * @brief Retrieve a list of vibrator IDs available for the specified parameters.
+ *
+ * This function fetches the identifiers of all vibrators that match the given parameters.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param vibratorInfo A reference to a vector that will be populated with available vibrator information,
+ *  each represented as a `VibratorInfos` structure.
+ * @return Returns <b>0</b> if the operation is successful; otherwise, indicates failure with an error code.
+ *
+ * @since 18
+ */
+int32_t GetVibratorIdList(const VibratorIdentifier& identifier, std::vector<VibratorInfos>& vibratorInfo);
+
+/**
+ * @brief Retrieve information about a specific vibration effect type.
+ *
+ * This function obtains detailed information regarding the specified vibration effect, such as its support status
+ * and duration.
+ *
+ * @param identifier Indicate the device and vibrator information that needs to be controlled, which is described in
+ *  {@link vibrator_agent_type.h}.
+ * @param effectType A string representing the type of vibration effect to query, as defined in
+ *  {@link vibrator_agent_type.h}.
+ * @param effectInfo A reference to an `EffectInfo` structure that will be populated with the effect's details.
+ * @return Returns <b>0</b> if the operation is successful; otherwise, indicates failure with an error code.
+ *
+ * @since 18
+ */
+int32_t GetEffectInfo(const VibratorIdentifier& identifier, const std::string& effectType, EffectInfo& effectInfo);
+
+/**
+ * @brief Subscribe a user to receive updates from the vibrator.
+ *
+ * This function registers a specified user to receive notifications about vibrator state changes or events.
+ *
+ * @param user The user information that needs to be subscribed to the vibrator notifications, defined as `VibratorUser`.
+ * @return Returns <b>0</b> if the subscription is successful; otherwise, indicates failure with an error code.
+ *
+ * @since 18
+ */
+int32_t SubscribeVibrator(const VibratorUser& user);
+
+/**
+ * @brief Unsubscribe a user from receiving updates from the vibrator.
+ *
+ * This function removes a specified user from receiving notifications about vibrator state changes or events.
+ *
+ * @param user The user information that needs to be unsubscribed from the vibrator notifications, defined as `VibratorUser`.
+ * @return Returns <b>0</b> if the unsubscription is successful; otherwise, indicates failure with an error code.
+ *
+ * @since 18
+ */
+int32_t UnSubscribeVibrator(const VibratorUser& user);
 } // namespace Sensors
 } // namespace OHOS
 #ifdef __cplusplus
diff --git a/interfaces/inner_api/vibrator/vibrator_agent_type.h b/interfaces/inner_api/vibrator/vibrator_agent_type.h
index 9c336720cb03112e7bda11fd801e92466d24c4fd..7398cd2a313972ab3a6207e17e926b3fc5cc0fd4 100644
--- a/interfaces/inner_api/vibrator/vibrator_agent_type.h
+++ b/interfaces/inner_api/vibrator/vibrator_agent_type.h
@@ -15,11 +15,20 @@
 
 #ifndef VIBRATOR_AGENT_TYPE_H
 #define VIBRATOR_AGENT_TYPE_H
+#include<string>
+#include<vector>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#ifndef NAME_MAX_LEN
+#define NAME_MAX_LEN 128
+#endif /* NAME_MAX_LEN */
+#ifndef VIBRATOR_USER_DATA_SIZE
+#define VIBRATOR_USER_DATA_SIZE 104
+#endif /* VIBRATOR_USER_DATA_SIZE */
+
 /**
  * @brief Describes the vibration effect of the vibrator when a user adjusts the timer.
  *
@@ -225,6 +234,124 @@ typedef struct VibratorParameter {
     int32_t frequency = 0;    // from -100 to 100
     int32_t reserved = 0;
 } VibratorParameter;
+
+/**
+ * @brief Represents the information about a vibrator device in the system.
+ *
+ * @since 18
+ */
+typedef struct VibratorInfos {
+    int32_t deviceId;
+    int32_t vibratorId;
+    std::string deviceName;
+    bool isSupportHdHaptic;
+    bool isLocalVibrator;
+} VibratorInfos;
+
+/**
+ * @brief Represents the parameters for querying vibrator information.
+ *
+ * @since 18
+ */
+typedef struct VibratorIdentifier {
+    int32_t deviceId = -1;
+    int32_t vibratorId = -1;
+    bool operator<(const VibratorIdentifier& other) const {
+        if (deviceId != other.deviceId) {
+            return deviceId < other.deviceId;
+        }
+        return vibratorId < other.vibratorId;
+    }
+} VibratorIdentifier;
+
+/**
+ * @brief Represents the parameters for playing primitive effect.
+ *
+ * @since 18
+ */
+typedef struct PrimitiveEffect {
+    int32_t intensity = 0;
+    int32_t usage = 0;
+    bool systemUsage;
+    int32_t count = 0;
+} PrimitiveEffect;
+
+/**
+ * @brief Defines the vibration effect information.
+ *
+ * The information include the capability to set the effect and the vibration duration of the effect.
+ *
+ * @since 18
+ */
+typedef struct EffectInfo {
+    bool isSupportEffect;
+} EffectInfo;
+
+/**
+ * @brief Defines the plug state events for the vibrator device.
+ *
+ * This enumeration represents the various plug and unplug state events
+ * that can occur with the vibrator device, including its connection status.
+ *
+ * @since 18
+ */
+typedef enum VibratorPlugState {
+    PLUG_STATE_EVENT_UNKNOWN = -1,  /* Unknown plug and unplug state event */
+    PLUG_STATE_EVENT_PLUG_IN = 0,   /* Event indicating that the vibrator is plugged in */
+    PLUG_STATE_EVENT_PLUG_OUT = 1,  /* Event indicating that the vibrator is unplugged */
+} VibratorPlugState;
+
+/**
+ * @brief Contains information about a vibrator device's status.
+ *
+ * This structure holds the current plug state of the vibrator device and its
+ * unique identifier. It is used to monitor and manage the vibrator's connectivity
+ * and operational mode.
+ *
+ * @since 18
+ */
+typedef struct VibratorDeviceInfo {
+    VibratorPlugState type = PLUG_STATE_EVENT_UNKNOWN;
+    int32_t deviceId = 0;
+} VibratorDeviceInfo;
+
+/**
+ * @brief Defines the callback for data reporting by the sensor agent.
+ *
+ * @since 18
+ */
+typedef void (*RecordVibratorPlugCallback)(VibratorDeviceInfo *deviceInfo);
+
+/**
+ * @brief Defines a reserved field for the sensor data subscriber.
+ *
+ * @since 18
+ */
+typedef struct UserData {
+    char userData[VIBRATOR_USER_DATA_SIZE];  /* Reserved for the sensor data subscriber */
+} UserData;
+
+/**
+ * @brief Defines information about the sensor data subscriber.
+ *
+ * @since 18
+ */
+typedef struct VibratorUser {
+    RecordVibratorPlugCallback callback;       /* Callback for reporting sensor data */
+    UserData *userData = nullptr;              /* Reserved field for the sensor data subscriber */
+} VibratorUser;
+
+/**
+ * @brief Defines information about vibrator effects
+ *
+ * @since 18
+ */
+typedef struct VibratorEffectParameter {
+    int32_t loopCount = 1;
+    int32_t usage = USAGE_UNKNOWN;
+    bool systemUsage = false;
+    VibratorParameter vibratorParameter;
+}VibratorEffectParameter;
 /** @} */
 #ifdef __cplusplus
 };
diff --git a/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h b/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h
index 1df08ede061e439a92c1aa62fdaf11569dff1a3b..206d558dfcef15aa1cd15d781acf6f0adeb21849 100644
--- a/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h
+++ b/services/miscdevice_service/haptic_matcher/include/custom_vibration_matcher.h
@@ -26,6 +26,7 @@ class CustomVibrationMatcher {
 public:
     ~CustomVibrationMatcher() = default;
     static CustomVibrationMatcher &GetInstance();
+    CustomVibrationMatcher(const VibratorIdentifierIPC& identifier, std::vector<HdfWaveInformation> wareInfo);
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
     int32_t TransformTime(const VibratePackage &package, std::vector<CompositeEffect> &compositeEffects);
     int32_t TransformEffect(const VibratePackage &package, std::vector<CompositeEffect> &compositeEffects);
diff --git a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h
index 954c274c95999ea5a11d64167734e0f60fdb3bd6..7550ee24b9786f81b4e0a9ccfac7520c06efb557 100644
--- a/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h
+++ b/services/miscdevice_service/hdi_connection/adapter/include/compatible_connection.h
@@ -27,25 +27,36 @@ public:
     CompatibleConnection() = default;
     virtual ~CompatibleConnection() {};
     int32_t ConnectHdi() override;
-    int32_t StartOnce(uint32_t duration) override;
-    int32_t Start(const std::string &effectType) override;
+    int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override;
+    int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override;
-    bool IsVibratorRunning() override;
+    int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier,
+        const HdfCompositeEffect &hdfCompositeEffect) override;
+    bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override;
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    std::optional<HdfEffectInfo> GetEffectInfo(const std::string &effect) override;
-    int32_t Stop(HdfVibratorModeV1_2 mode) override;
+    std::optional<HdfEffectInfo> GetEffectInfo(const VibratorIdentifierIPC &identifier,
+        const std::string &effect) override;
+    int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override;
-    int32_t GetVibratorCapacity(VibratorCapacity &capacity) override;
-    int32_t PlayPattern(const VibratePattern &pattern) override;
+    int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override;
+    int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override;
+    int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override;
     int32_t DestroyHdiConnection() override;
-    int32_t StartByIntensity(const std::string &effect, int32_t intensity) override;
+    int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect,
+        int32_t intensity) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t GetAllWaveInfo(std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorInfo(std::vector<HdfVibratorInfo> &hdfVibratorInfo) override;
+    int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfVibratorInfo> &vibratorInfoIpc) override;
+    int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, 
+        HdfEffectInfo &effectInfo) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
-
+    int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override;
+    DevicePlugCallback GetVibratorPlugCb() override;
+    
 private:
     DISALLOW_COPY_AND_MOVE(CompatibleConnection);
     std::thread vibrateThread_;
diff --git a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h
index 0c4426f3bc44d18960982da4142338a75814a550..7941d2cfde86a01456525189fa9e546fa757d717 100644
--- a/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h
+++ b/services/miscdevice_service/hdi_connection/adapter/include/hdi_connection.h
@@ -17,14 +17,14 @@
 #define HDI_CONNECTION_H
 
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-#include "v1_3/vibrator_interface_proxy.h"
+#include "v2_0/vibrator_interface_proxy.h"
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
 
 #include "death_recipient_template.h"
 #include "i_vibrator_hdi_connection.h"
 
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-using OHOS::HDI::Vibrator::V1_3::IVibratorInterface;
+using OHOS::HDI::Vibrator::V2_0::IVibratorInterface;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
 namespace OHOS {
 namespace Sensors {
@@ -33,25 +33,36 @@ public:
     HdiConnection() = default;
     virtual ~HdiConnection() {};
     int32_t ConnectHdi() override;
-    int32_t StartOnce(uint32_t duration) override;
-    int32_t Start(const std::string &effectType) override;
+    int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override;
+    int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override;
-    bool IsVibratorRunning() override;
+    int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier,
+        const HdfCompositeEffect &hdfCompositeEffect) override;
+    bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override;
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    std::optional<HdfEffectInfo> GetEffectInfo(const std::string &effect) override;
-    int32_t Stop(HdfVibratorModeV1_2 mode) override;
+    std::optional<HdfEffectInfo> GetEffectInfo(const VibratorIdentifierIPC &identifier,
+        const std::string &effect) override;
+    int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override;
-    int32_t GetVibratorCapacity(VibratorCapacity &capacity) override;
-    int32_t PlayPattern(const VibratePattern &pattern) override;
+    int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override;
+    int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override;
+    int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override;
     int32_t DestroyHdiConnection() override;
     void ProcessDeathObserver(const wptr<IRemoteObject> &object);
-    int32_t StartByIntensity(const std::string &effect, int32_t intensity) override;
+    int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect,
+        int32_t intensity) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t GetAllWaveInfo(std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorInfo(std::vector<HdfVibratorInfo> &hdfVibratorInfo) override;
+    int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfVibratorInfo> &vibratorInfoIpc) override;
+    int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType, 
+        HdfEffectInfo &effectInfo) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+    int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override;
+    DevicePlugCallback GetVibratorPlugCb() override;
 
 private:
     DISALLOW_COPY_AND_MOVE(HdiConnection);
@@ -59,6 +70,7 @@ private:
     sptr<IVibratorInterface> vibratorInterface_ = nullptr;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
     sptr<IRemoteObject::DeathRecipient> hdiDeathObserver_ = nullptr;
+    static DevicePlugCallback devicePlugCb_;
     void RegisterHdiDeathRecipient();
     void UnregisterHdiDeathRecipient();
     void Reconnect();
diff --git a/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ab05b490379c7823b78a1c6b062b4512f9c7b30
--- /dev/null
+++ b/services/miscdevice_service/hdi_connection/adapter/include/vibrator_plug_callback.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * 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 VIBRATOR_PLUG_CALLBACK_H
+ #define VIBRATOR_PLUG_CALLBACK_H
+ 
+ #include <nocopyable.h>
+ #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
+ #include "v2_0/ivibrator_interface.h"
+ #include "v2_0/ivibrator_plug_callback.h"
+ #include "v2_0/vibrator_types.h"
+ #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+ 
+ #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
+ using OHOS::HDI::Vibrator::V2_0::IVibratorPlugCallback;
+ #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+ 
+ namespace OHOS {
+ namespace Sensors {
+ class VibratorPlugCallback : public IVibratorPlugCallback {
+ public:
+     virtual ~VibratorPlugCallback() {}
+     int32_t OnVibratorPlugEvent(const HdfVibratorPlugInfo &vibratorPlugInfo) override;
+ };
+ } // namespace Sensors
+ } // namespace OHOS
+ #endif // VIBRATOR_PLUG_CALLBACK_H
+ 
\ No newline at end of file
diff --git a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h
index 008b3dbc116653b03daf86675a4f3c5ef107edd1..50fc46d11ad73cb8104a6ce0ab8b8c3ca31c4b24 100644
--- a/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h
+++ b/services/miscdevice_service/hdi_connection/interface/include/i_vibrator_hdi_connection.h
@@ -17,59 +17,72 @@
 #define I_VIBRATOR_HDI_CONNECTION_H
 
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-#include "v1_3/ivibrator_interface.h"
+#include "v2_0/ivibrator_interface.h"
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
 #include "vibrator_infos.h"
 
 namespace OHOS {
 namespace Sensors {
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-using OHOS::HDI::Vibrator::V1_2::HdfVibratorModeV1_2;
-using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_ONCE;
-using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_PRESET;
-using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_HDHAPTIC;
-using OHOS::HDI::Vibrator::V1_2::HDF_VIBRATOR_MODE_BUTT;
-using OHOS::HDI::Vibrator::V1_2::CurvePoint;
-using OHOS::HDI::Vibrator::V1_2::EVENT_TYPE;
-using OHOS::HDI::Vibrator::V1_2::HapticCapacity;
-using OHOS::HDI::Vibrator::V1_2::HapticPaket;
-using OHOS::HDI::Vibrator::V1_2::HapticEvent;
-using OHOS::HDI::Vibrator::V1_1::HdfEffectInfo;
-using OHOS::HDI::Vibrator::V1_3::HdfWaveInformation;
-#ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-using OHOS::HDI::Vibrator::V1_1::HdfEffectType;
-using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_TIME;
-using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_PRIMITIVE;
-using OHOS::HDI::Vibrator::V1_1::HDF_EFFECT_TYPE_BUTT;
-using OHOS::HDI::Vibrator::V1_1::TimeEffect;
-using OHOS::HDI::Vibrator::V1_1::PrimitiveEffect;
-using OHOS::HDI::Vibrator::V1_1::CompositeEffect;
-using OHOS::HDI::Vibrator::V1_1::HdfCompositeEffect;
-#endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
+using OHOS::HDI::Vibrator::V2_0::HdfVibratorMode;
+using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_ONCE;
+using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_PRESET;
+using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_HDHAPTIC;
+using OHOS::HDI::Vibrator::V2_0::HDF_VIBRATOR_MODE_BUTT;
+using OHOS::HDI::Vibrator::V2_0::CurvePoint;
+using OHOS::HDI::Vibrator::V2_0::EVENT_TYPE;
+using OHOS::HDI::Vibrator::V2_0::HapticCapacity;
+using OHOS::HDI::Vibrator::V2_0::HapticPaket;
+using OHOS::HDI::Vibrator::V2_0::HapticEvent;
+using OHOS::HDI::Vibrator::V2_0::HdfEffectInfo;
+using OHOS::HDI::Vibrator::V2_0::HdfWaveInformation;
+using OHOS::HDI::Vibrator::V2_0::HdfVibratorPlugInfo;
+using OHOS::HDI::Vibrator::V2_0::HdfVibratorInfo;
+using OHOS::HDI::Vibrator::V2_0::HdfEffectType;
+using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_TIME;
+using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_PRIMITIVE;
+using OHOS::HDI::Vibrator::V2_0::HDF_EFFECT_TYPE_BUTT;
+using OHOS::HDI::Vibrator::V2_0::TimeEffect;
+using OHOS::HDI::Vibrator::V2_0::PrimitiveEffect;
+using OHOS::HDI::Vibrator::V2_0::CompositeEffect;
+using OHOS::HDI::Vibrator::V2_0::HdfCompositeEffect;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+
+using DevicePlugCallback = std::function<void(const HdfVibratorPlugInfo PlugCallback)>;
 class IVibratorHdiConnection {
 public:
     IVibratorHdiConnection() = default;
     virtual ~IVibratorHdiConnection() = default;
     virtual int32_t ConnectHdi() = 0;
-    virtual int32_t StartOnce(uint32_t duration) = 0;
-    virtual int32_t Start(const std::string &effectType) = 0;
+    virtual int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) = 0;
+    virtual int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) = 0;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    virtual int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) = 0;
-    virtual bool IsVibratorRunning() = 0;
+    virtual int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier,
+        const HdfCompositeEffect &hdfCompositeEffect) = 0;
+    virtual bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) = 0;
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    virtual std::optional<HdfEffectInfo> GetEffectInfo(const std::string &effect) = 0;
-    virtual int32_t Stop(HdfVibratorModeV1_2 mode) = 0;
+    virtual std::optional<HdfEffectInfo> GetEffectInfo(const VibratorIdentifierIPC &identifier,
+        const std::string &effect) = 0;
+    virtual int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) = 0;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
     virtual int32_t DestroyHdiConnection() = 0;
-    virtual int32_t GetDelayTime(int32_t mode, int32_t &delayTime) = 0;
-    virtual int32_t GetVibratorCapacity(VibratorCapacity &capacity) = 0;
-    virtual int32_t PlayPattern(const VibratePattern &pattern) = 0;
-    virtual int32_t StartByIntensity(const std::string &effect, int32_t intensity) = 0;
+    virtual int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) = 0;
+    virtual int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) = 0;
+    virtual int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) = 0;
+    virtual int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect,
+        int32_t intensity) = 0;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-    virtual int32_t GetAllWaveInfo(std::vector<HdfWaveInformation> &waveInfos) = 0;
+    virtual int32_t GetVibratorInfo(std::vector<HdfVibratorInfo> &hdfVibratorInfo) = 0;
+    virtual int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfWaveInformation> &waveInfos) = 0;
+    virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfVibratorInfo> &hdfVibratorInfo) = 0;
+    virtual int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType,
+        HdfEffectInfo &effectInfo) = 0;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+    virtual int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) = 0;
+    virtual DevicePlugCallback GetVibratorPlugCb() = 0;
 
 private:
     DISALLOW_COPY_AND_MOVE(IVibratorHdiConnection);
diff --git a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h
index a604d2016174de254377ab5eff2944587a49ab73..d1cb5fe9a233a1145904c88ea2c737a4a23318ed 100644
--- a/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h
+++ b/services/miscdevice_service/hdi_connection/interface/include/vibrator_hdi_connection.h
@@ -27,24 +27,35 @@ public:
     VibratorHdiConnection() = default;
     virtual ~VibratorHdiConnection() {}
     int32_t ConnectHdi() override;
-    int32_t StartOnce(uint32_t duration) override;
-    int32_t Start(const std::string &effectType) override;
+    int32_t StartOnce(const VibratorIdentifierIPC &identifier, uint32_t duration) override;
+    int32_t Start(const VibratorIdentifierIPC &identifier, const std::string &effectType) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    int32_t EnableCompositeEffect(const HdfCompositeEffect &hdfCompositeEffect) override;
-    bool IsVibratorRunning() override;
+    int32_t EnableCompositeEffect(const VibratorIdentifierIPC &identifier,
+        const HdfCompositeEffect &hdfCompositeEffect) override;
+    bool IsVibratorRunning(const VibratorIdentifierIPC &identifier) override;
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    std::optional<HdfEffectInfo> GetEffectInfo(const std::string &effect) override;
-    int32_t Stop(HdfVibratorModeV1_2 mode) override;
+    std::optional<HdfEffectInfo> GetEffectInfo(const VibratorIdentifierIPC &identifier,
+        const std::string &effect) override;
+    int32_t Stop(const VibratorIdentifierIPC &identifier, HdfVibratorMode mode) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
     int32_t DestroyHdiConnection() override;
-    int32_t GetDelayTime(int32_t mode, int32_t &delayTime) override;
-    int32_t GetVibratorCapacity(VibratorCapacity &capacity) override;
-    int32_t PlayPattern(const VibratePattern &pattern) override;
-    int32_t StartByIntensity(const std::string &effect, int32_t intensity) override;
+    int32_t GetDelayTime(const VibratorIdentifierIPC &identifier, int32_t mode, int32_t &delayTime) override;
+    int32_t GetVibratorCapacity(const VibratorIdentifierIPC &identifier, VibratorCapacity &capacity) override;
+    int32_t PlayPattern(const VibratorIdentifierIPC &identifier, const VibratePattern &pattern) override;
+    int32_t StartByIntensity(const VibratorIdentifierIPC &identifier, const std::string &effect,
+        int32_t intensity) override;
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t GetAllWaveInfo(std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorInfo(std::vector<HdfVibratorInfo> &hdfVibratorInfo) override;
+    int32_t GetAllWaveInfo(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfWaveInformation> &waveInfos) override;
+    int32_t GetVibratorIdList(const VibratorIdentifierIPC &identifier,
+        std::vector<HdfVibratorInfo> &hdfVibratorInfo) override;
+    int32_t GetEffectInfo(const VibratorIdentifierIPC &identifier, const std::string &effectType,
+        HdfEffectInfo &effectInfo) override;
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
+    int32_t RegisterVibratorPlugCallback(DevicePlugCallback cb) override;
+    DevicePlugCallback GetVibratorPlugCb() override;
 
 private:
     DISALLOW_COPY_AND_MOVE(VibratorHdiConnection);
diff --git a/services/miscdevice_service/include/miscdevice_service.h b/services/miscdevice_service/include/miscdevice_service.h
index 2c159524be4e7190d15986eb7ae0ce9a5896f767..09606de9d84ec27f9c6a910e4a46ee6304a846a4 100644
--- a/services/miscdevice_service/include/miscdevice_service.h
+++ b/services/miscdevice_service/include/miscdevice_service.h
@@ -36,6 +36,33 @@ enum class MiscdeviceServiceState {
     STATE_RUNNING,
 };
 
+struct VibratorControlInfo {
+    int motorCount;
+    std::unordered_map<int, std::shared_ptr<VibratorThread>> vibratorThreads;
+
+    VibratorControlInfo(const std::vector<int>& motorIds) : motorCount(static_cast<int>(motorIds.size())) {
+        for (int motorId : motorIds) {
+            vibratorThreads[motorId] = std::make_shared<VibratorThread>();
+        }
+    }
+
+    std::shared_ptr<VibratorThread> GetVibratorThread(int motorId) const {
+        auto it = vibratorThreads.find(motorId);
+        if (it != vibratorThreads.end()) {
+            return it->second;
+        }
+        return nullptr;
+    }
+};
+
+struct VibratorAllInfos{
+    std::vector<VibratorInfoIPC> baseInfo;
+    VibratorControlInfo controlInfo;
+    VibratorCapacity capacityInfo; 
+    std::vector<HdfWaveInformation> waveInfo;
+    VibratorAllInfos(const std::vector<int>& motorIds) : controlInfo(motorIds) {}
+};
+
 class MiscdeviceService : public SystemAbility, public MiscdeviceServiceStub {
     DECLARE_SYSTEM_ABILITY(MiscdeviceService)
     MISCDEVICE_DECLARE_DELAYED_SP_SINGLETON(MiscdeviceService);
@@ -49,36 +76,45 @@ public:
     bool IsLightAnimationValid(const LightAnimationIPC &animation);
     int32_t Dump(int32_t fd, const std::vector<std::u16string> &args) override;
     void ProcessDeathObserver(const wptr<IRemoteObject> &object);
-    virtual int32_t Vibrate(int32_t vibratorId, int32_t timeOut, int32_t usage, bool systemUsage) override;
-    virtual int32_t PlayVibratorEffect(int32_t vibratorId, const std::string &effect,
-                                       int32_t loopCount, int32_t usage, bool systemUsage) override;
+    virtual int32_t Vibrate(const VibratorIdentifierIPC& identifier, int32_t timeOut,
+        int32_t usage, bool systemUsage) override;
+    virtual int32_t PlayVibratorEffect(const VibratorIdentifierIPC& identifier, const std::string &effect,
+        int32_t loopCount, int32_t usage, bool systemUsage) override;
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    virtual int32_t PlayVibratorCustom(int32_t vibratorId, int32_t fd, int64_t offset, int64_t length, int32_t usage,
-        bool systemUsage, const VibrateParameter &parameter) override;
+    virtual int32_t PlayVibratorCustom(const VibratorIdentifierIPC& identifier, int32_t fd, int64_t offset,
+        int64_t length, const CustomHapticInfoIPC& customHapticInfoIPC) override;
 #endif // OHOS_BUILD_ENABLE_VIBRATOR_CUSTOM
-    virtual int32_t StopVibrator(int32_t vibratorId) override;
-    virtual int32_t StopVibratorByMode(int32_t vibratorId, const std::string &mode) override;
-    virtual int32_t IsSupportEffect(const std::string &effect, bool &state) override;
+    virtual int32_t StopVibrator(const VibratorIdentifierIPC& identifier) override;
+    virtual int32_t StopVibratorByMode(const VibratorIdentifierIPC& identifier, const std::string &mode) override;
+    virtual int32_t IsSupportEffect(const VibratorIdentifierIPC& identifier, const std::string &effect,
+        bool &state) override;
     virtual int32_t GetLightList(std::vector<LightInfoIPC> &lightInfoIpcList) override;
     virtual int32_t TurnOn(int32_t lightId, int32_t singleColor, const LightAnimationIPC &animation) override;
     virtual int32_t TurnOff(int32_t lightId) override;
-    virtual int32_t PlayPattern(const VibratePattern &pattern, int32_t usage,
-        bool systemUsage, const VibrateParameter &parameter) override;
-    virtual int32_t GetDelayTime(int32_t &delayTime) override;
+    virtual int32_t PlayPattern(const VibratorIdentifierIPC& identifier, const VibratePattern &pattern,
+        const CustomHapticInfoIPC& customHapticInfoIPC) override;
+    virtual int32_t GetDelayTime(const VibratorIdentifierIPC& identifier, int32_t &delayTime) override;
     virtual int32_t TransferClientRemoteObject(const sptr<IRemoteObject> &vibratorServiceClient) override;
-    virtual int32_t PlayPrimitiveEffect(int32_t vibratorId, const std::string &effect, int32_t intensity,
-                                        int32_t usage, bool systemUsage, int32_t count) override;
-    virtual int32_t GetVibratorCapacity(VibratorCapacity &capacity) override;
+    virtual int32_t PlayPrimitiveEffect(const VibratorIdentifierIPC& identifier, const std::string &effect,
+        const PrimitiveEffectIPC& primitiveEffectIPC) override;
+    virtual int32_t GetVibratorCapacity(const VibratorIdentifierIPC& identifier, VibratorCapacity &capacity) override;
+    virtual int32_t GetVibratorIdList(const VibratorIdentifierIPC& identifier,
+        std::vector<VibratorInfoIPC>& vibratorInfoIPC) override;
+    virtual int32_t GetEffectInfo(const VibratorIdentifierIPC& identifier, const std::string& effectType,
+        EffectInfoIPC& effectInfoIPC) override;
 
 private:
     DISALLOW_COPY_AND_MOVE(MiscdeviceService);
     bool InitInterface();
     bool InitLightInterface();
     std::string GetPackageName(AccessTokenID tokenId);
-    void StartVibrateThread(VibrateInfo info);
-    int32_t StopVibratorService(int32_t vibratorId);
-    void StopVibrateThread();
-    bool ShouldIgnoreVibrate(const VibrateInfo &info);
+    void StartVibrateThread(VibrateInfo info, const VibratorIdentifierIPC& identifier);
+    int32_t StopVibratorService(const VibratorIdentifierIPC& identifier);
+    void SendMsgToClient(HdfVibratorPlugInfo info);
+    int32_t RegisterVibratorPlugCb();
+    std::shared_ptr<VibratorThread> GetVibratorThread(const VibratorIdentifierIPC& identifier);
+    void StopVibrateThread(std::shared_ptr<VibratorThread> vibratorThread);
+    bool ShouldIgnoreVibrate(const VibrateInfo &info, const VibratorIdentifierIPC& identifier);
     std::string GetCurrentTime();
     void MergeVibratorParmeters(const VibrateParameter &parameter, VibratePackage &package);
     bool CheckVibratorParmeters(const VibrateParameter &parameter);
@@ -93,10 +129,24 @@ private:
 #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB
     void OnReceiveUserSwitchEvent(const EventFwk::CommonEventData &data);
 #endif // OHOS_BUILD_ENABLE_DO_NOT_DISTURB
-    int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter &parameter);
+    int32_t CheckAuthAndParam(int32_t usage, const VibrateParameter &parameter,
+        const VibratorIdentifierIPC& identifier);
     int32_t PlayPatternCheckAuthAndParam(int32_t usage, const VibrateParameter &parameter);
     int32_t PlayPrimitiveEffectCheckAuthAndParam(int32_t intensity, int32_t usage);
     int32_t PlayVibratorEffectCheckAuthAndParam(int32_t count, int32_t usage);
+    int32_t GetHapticCapacityInfo(const VibratorIdentifierIPC& identifier, VibratorCapacity& capacityInfo);
+    int32_t GetAllWaveInfo(const VibratorIdentifierIPC& identifier, std::vector<HdfWaveInformation>& waveInfo);
+    int32_t GetHapticStartUpTime(const VibratorIdentifierIPC& identifier, int32_t mode, int32_t &startUpTime);
+    void FirstGetLocalVibratorInfo();
+    std::vector<VibratorIdentifierIPC> CheckDeviceIdIsValid(const VibratorIdentifierIPC& identifier);
+    int32_t StartVibrateThreadControl(const VibratorIdentifierIPC& identifier, VibrateInfo& info);
+    bool UpdateVibratorAllInfo(const VibratorIdentifierIPC &identifier, const HdfVibratorPlugInfo &info,
+        VibratorAllInfos &vibratorAllInfos);
+    void ConvertToServerInfos(const std::vector<HdfVibratorInfo> &baseVibratorInfo,
+        const VibratorCapacity &vibratorCapacity, const std::vector<HdfWaveInformation> &waveInfomation,
+        const HdfVibratorPlugInfo &info, VibratorAllInfos &vibratorAllInfos);
+    int32_t PerformVibrationControl(const VibratorIdentifierIPC& identifier, const VibratePattern& pattern,
+        VibrateInfo& info);
     std::mutex isVibrationPriorityReadyMutex_;
     static bool isVibrationPriorityReady_;
     VibratorHdiConnection &vibratorHdiConnection_ = VibratorHdiConnection::GetInstance();
@@ -106,7 +156,6 @@ private:
     std::vector<LightInfoIPC> lightInfos_;
     std::map<MiscdeviceDeviceId, bool> miscDeviceIdMap_;
     MiscdeviceServiceState state_;
-    std::shared_ptr<VibratorThread> vibratorThread_ = nullptr;
     std::mutex vibratorThreadMutex_;
     sptr<IRemoteObject::DeathRecipient> clientDeathObserver_ = nullptr;
     std::mutex clientDeathObserverMutex_;
@@ -114,6 +163,8 @@ private:
     std::mutex clientPidMapMutex_;
     std::mutex miscDeviceIdMapMutex_;
     std::mutex lightInfosMutex_;
+    std::mutex devicesManageMutex_;
+    static std::map<int32_t , VibratorAllInfos> devicesManageMap_;
 };
 }  // namespace Sensors
 }  // namespace OHOS
diff --git a/services/miscdevice_service/include/vibration_priority_manager.h b/services/miscdevice_service/include/vibration_priority_manager.h
index 106c251661a513afb0df2c019ca1b5291ee4aaae..ebe6f36a1b1b91477de14a7e844aacb65dfed5e0 100644
--- a/services/miscdevice_service/include/vibration_priority_manager.h
+++ b/services/miscdevice_service/include/vibration_priority_manager.h
@@ -80,7 +80,8 @@ class VibrationPriorityManager {
 public:
     DISALLOW_COPY_AND_MOVE(VibrationPriorityManager);
     bool Init();
-    VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, std::shared_ptr<VibratorThread> vibratorThread);
+    VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo,
+		std::shared_ptr<VibratorThread> vibratorThread, const VibratorIdentifierIPC& identifier);
 #ifdef OHOS_BUILD_ENABLE_DO_NOT_DISTURB
     void InitDoNotDisturbData();
     void ReregisterCurrentUserObserver();
@@ -91,7 +92,8 @@ public:
 #endif
 
 private:
-    bool IsCurrentVibrate(std::shared_ptr<VibratorThread> vibratorThread) const;
+    bool IsCurrentVibrate(std::shared_ptr<VibratorThread> vibratorThread,
+        const VibratorIdentifierIPC& identifier) const;
     bool IsLoopVibrate(const VibrateInfo &vibrateInfo) const;
     VibrateStatus ShouldIgnoreVibrate(const VibrateInfo &vibrateInfo, VibrateInfo currentVibrateInfo) const;
 #ifdef OHOS_BUILD_ENABLE_VIBRATOR_INPUT_METHOD
diff --git a/services/miscdevice_service/include/vibrator_thread.h b/services/miscdevice_service/include/vibrator_thread.h
index 14d5c02fa1ac672b5f27b9a555da3f6b5d7fe489..e6656f636baf8dd9aedf44bd59b14ae61a0d0c64 100644
--- a/services/miscdevice_service/include/vibrator_thread.h
+++ b/services/miscdevice_service/include/vibrator_thread.h
@@ -26,25 +26,33 @@ namespace OHOS {
 namespace Sensors {
 class VibratorThread : public Thread {
 public:
-    void UpdateVibratorEffect(const VibrateInfo &vibrateInfo);
+    void UpdateVibratorEffect(const VibrateInfo &vibrateInfo, const VibratorIdentifierIPC& identifier,
+        std::vector<HdfWaveInformation> &waveInfos);
     VibrateInfo GetCurrentVibrateInfo();
+    std::vector<HdfWaveInformation> GetCurrentWaveInfo();
     void SetExitStatus(bool status);
     void WakeUp();
-
+    void ResetVibrateInfo();
 protected:
     virtual bool Run();
 
 private:
-    int32_t PlayOnce(const VibrateInfo &info);
-    int32_t PlayEffect(const VibrateInfo &info);
-    int32_t PlayCustomByHdHptic(const VibrateInfo &info);
-    void HandleMultipleVibrations();
+    VibratorIdentifierIPC GetCurrentVibrateParams();
+    int32_t PlayOnce(const VibrateInfo &info, const VibratorIdentifierIPC& identifier);
+    int32_t PlayEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier);
+    int32_t PlayCustomByHdHptic(const VibrateInfo &info, const VibratorIdentifierIPC& identifier);
+    void HandleMultipleVibrations(const VibratorIdentifierIPC& identifier);
 #ifdef HDF_DRIVERS_INTERFACE_VIBRATOR
-    int32_t PlayCustomByCompositeEffect(const VibrateInfo &info);
-    int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect);
+    int32_t PlayCustomByCompositeEffect(const VibrateInfo &info, const VibratorIdentifierIPC& identifier,
+        std::vector<HdfWaveInformation> waveInfo);
+    int32_t PlayCompositeEffect(const VibrateInfo &info, const HdfCompositeEffect &hdfCompositeEffect, 
+        const VibratorIdentifierIPC& identifier);
 #endif // HDF_DRIVERS_INTERFACE_VIBRATOR
     std::mutex currentVibrationMutex_;
     VibrateInfo currentVibration_;
+    std::vector<HdfWaveInformation> waveInfos_;
+    std::mutex currentVibrateParamsMutex_;
+    VibratorIdentifierIPC currentVibrateParams_;
     std::mutex vibrateMutex_;
     std::condition_variable cv_;
     std::atomic<bool> exitFlag_ = false;
diff --git a/utils/common/include/sensors_errors.h b/utils/common/include/sensors_errors.h
index 5214aa5c0ffab13d01cf72443262c060e267a936..90e88e6af3a0759f3a4b37306a741c2789931894 100644
--- a/utils/common/include/sensors_errors.h
+++ b/utils/common/include/sensors_errors.h
@@ -30,6 +30,7 @@ enum ErrorCode : int32_t {
     PARAMETER_ERROR = 401, // Use this error code when the input parameter type or range does not match.
     IS_NOT_SUPPORTED = 801, // Use this error code when capability not supported.
     DEVICE_OPERATION_FAILED = 14600101, // Use this error code when operating the device fail.
+    CALLBACK_UNSUBSCRIBED = 14600102, //Use this error code when the user callback function is deregistered repeatedly.
 };
 
 enum {
diff --git a/utils/common/include/vibrator_infos.h b/utils/common/include/vibrator_infos.h
index 140d3c290def85b668221aa90833d379e032343c..0e6876891fd5c0c2cfc9610fabff6819a90565dd 100644
--- a/utils/common/include/vibrator_infos.h
+++ b/utils/common/include/vibrator_infos.h
@@ -136,6 +136,36 @@ struct VibrateParameter : public Parcelable {
     bool Marshalling(Parcel &parcel) const;
     static VibrateParameter* Unmarshalling(Parcel &data);
 };
+
+struct VibratorInfoIPC : public Parcelable{
+    int32_t deviceId = -1;
+    int32_t vibratorId = -1; 
+    std::string deviceName = "";
+    bool isSupportHdHaptic;
+    bool isLocalVibrator;
+    int32_t position = 0;
+    void Dump() const;
+    bool Marshalling(Parcel &parcel) const;
+    static VibratorInfoIPC* Unmarshalling(Parcel &data);
+};
+
+struct VibratorIdentifierIPC : public Parcelable {
+    int32_t deviceId = -1;
+    int32_t vibratorId = -1;
+    int32_t position = 0;
+    bool isLocalVibrator;
+    void Dump() const;
+    bool Marshalling(Parcel &parcel) const;
+    static VibratorIdentifierIPC* Unmarshalling(Parcel &data);
+};
+
+struct EffectInfoIPC : public Parcelable{
+    int32_t duration = -1;
+    bool isSupportEffect;
+    void Dump() const;
+    bool Marshalling(Parcel &parcel) const;
+    static EffectInfoIPC* Unmarshalling(Parcel &data);
+};
 } // namespace Sensors
 } // namespace OHOS
 #endif // VIBRATOR_INFOS_H