diff --git a/common/include/daudio_constants.h b/common/include/daudio_constants.h
index b9b09e4d31d3f3479a8933b79f54ddde50ee4c77..7ff4e92f2738f026b056dd32bc9dc43f6c7ecff4 100644
--- a/common/include/daudio_constants.h
+++ b/common/include/daudio_constants.h
@@ -73,6 +73,9 @@ static constexpr int32_t LOW_LATENCY_RENDER_ID = 1 << 1 | 1 << 0;
 static constexpr int32_t DEFAULT_RENDER_ID = 1;
 static constexpr int32_t DEFAULT_CAPTURE_ID = 1 << 27 | 1 << 0;
 
+constexpr int32_t VALID_OS_TYPE = 10;
+constexpr int32_t INVALID_OS_TYPE = -1;
+
 const std::string DAUDIO_LOG_TITLE_TAG = "DAUDIO";
 const std::string DAUDIO_PREFIX = "DISTRIBUTED_AUDIO";
 const std::string AUDIO_PREFIX = "AUDIO";
@@ -122,6 +125,7 @@ constexpr const char *KEY_RANDOM_TASK_CODE = "randomTaskCode";
 constexpr const char *KEY_USERID = "userId";
 constexpr const char *KEY_TOKENID = "tokenId";
 constexpr const char *KEY_ACCOUNTID = "accountId";
+constexpr const char *KEY_OS_TYPE = "OS_TYPE";
 
 constexpr const char *KEY_SAMPLING_RATE = "samplingRate";
 constexpr const char *KEY_CHANNELS = "channels";
diff --git a/common/src/daudio_util.cpp b/common/src/daudio_util.cpp
index 25b6c48543f201653764b23601171923fae040b2..38414645eb44e89bbf3dab7213e6ab7f6c0a6578 100644
--- a/common/src/daudio_util.cpp
+++ b/common/src/daudio_util.cpp
@@ -71,6 +71,7 @@ std::map<std::string, JsonTypeCheckFunc> typeCheckMap = {
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_USERID, &DistributedHardware::IsInt32),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_TOKENID, &DistributedHardware::IsInt32),
     std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_ACCOUNTID, &DistributedHardware::IsString),
+    std::map<std::string, JsonTypeCheckFunc>::value_type(KEY_OS_TYPE, &DistributedHardware::IsInt32),
 };
 
 std::map<int32_t, std::string> eventNameMap = {
diff --git a/services/audiomanager/managersink/include/daudio_sink_manager.h b/services/audiomanager/managersink/include/daudio_sink_manager.h
index 439b5f0b35c6a0c87be9725cd682735d2b6cba74..5d4a86435636f34d62f7ebdd8975a1c5b67f2bff 100644
--- a/services/audiomanager/managersink/include/daudio_sink_manager.h
+++ b/services/audiomanager/managersink/include/daudio_sink_manager.h
@@ -73,6 +73,7 @@ public:
     int32_t ResumeDistributedHardware(const std::string &networkId);
     int32_t StopDistributedHardware(const std::string &networkId);
     void SetCallerTokenId(uint64_t tokenId);
+    int32_t CheckOsType(const std::string &networkId, bool &isInvalid);
 
 private:
     DAudioSinkManager();
@@ -86,6 +87,7 @@ private:
     std::string GetUdidByNetworkId(const std::string &networkId);
     int32_t VerifySecurityLevel(const std::string &devId);
     int32_t InitAudioDevice(std::shared_ptr<DAudioSinkDev> dev, const std::string &devId, bool isSpkOrMic);
+    int32_t ParseValueFromCjson(std::string args, std::string key);
 
 private:
     static constexpr const char* DEVCLEAR_THREAD = "sinkClearTh";
diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
index a68b43ef79b6a0c42b715a8b2f4d534a29b29382..1e671e06f15c4486abbf22cfeec208788c60c169 100644
--- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
@@ -23,6 +23,7 @@
 #include "daudio_errorcode.h"
 #include "daudio_log.h"
 #include "daudio_util.h"
+#include "device_manager.h"
 
 #undef DH_LOG_TAG
 #define DH_LOG_TAG "DAudioSinkManager"
@@ -409,6 +410,9 @@ void CtrlChannelListener::OnCtrlChannelEvent(const AVTransEvent &event)
     if (event.type == EventType::EVENT_CHANNEL_OPENED) {
         DHLOGI("Received control channel opened event, create audio device for peerDevId=%{public}s, "
             "content=%{public}s.", GetAnonyString(event.peerDevId).c_str(), event.content.c_str());
+        bool isInvalid = false;
+        CHECK_AND_RETURN_LOG(DAudioSinkManager::GetInstance().CheckOsType(event.peerDevId, isInvalid) && isInvalid,
+            "GetOsType failed or invalid osType");
         DAudioSinkManager::GetInstance().SetChannelState(event.content);
         DAudioSinkManager::GetInstance().CreateAudioDevice(event.peerDevId);
     } else if (event.type == EventType::EVENT_CHANNEL_CLOSED) {
@@ -565,6 +569,43 @@ int32_t DAudioSinkManager::VerifySecurityLevel(const std::string &devId)
     return DH_SUCCESS;
 }
 
+int32_t DAudioSinkManager::ParseValueFromCjson(std::string args, std::string key)
+{
+    DHLOGD("ParseValueFromCjson");
+    cJSON *jParam = cJSON_Parse(args.c_str());
+    CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED);
+    CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), ERR_DH_AUDIO_FAILED, jParam, "Not found key");
+    cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str());
+    CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsNumber(retItem),
+        ERR_DH_AUDIO_FAILED, jParam, "Not found key result");
+    int32_t ret = retItem->valueint;
+    cJSON_Delete(jParam);
+    return ret;
+}
+
+int32_t DAudioSinkManager::CheckOsType(const std::string &networkId, bool &isInvalid)
+{
+    std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DeviceInitCallback>();
+    int32_t ret = DeviceManager::GetInstance().InitDeviceManager(PKG_NAME, initCallback);
+    CHECK_AND_RETURN_RET_LOG(ret != DH_SUCCESS, ERR_DH_AUDIO_FAILED, "InitDeviceManager failed ret = %{public}d", ret);
+    std::vector<DistributedHardware::DmDeviceInfo> dmDeviceInfoList;
+    int32_t errCode = DeviceManager::GetInstance().GetTrustedDeviceList(PKG_NAME, "", dmDeviceInfoList);
+    CHECK_AND_RETURN_RET_LOG(errCode != DH_SUCCESS, ERR_DH_AUDIO_FAILED,
+        "Get device manager trusted device list fail, errCode %{public}d", errCode);
+    for (const auto& dmDeviceInfo : dmDeviceInfoList) {
+        if (dmDeviceInfo.networkId == networkId) {
+            int32_t osType = ParseValueFromCjson(dmDeviceInfo.extraData, KEY_OS_TYPE);
+            if (osType == INVALID_OS_TYPE && osType != ERR_DH_AUDIO_FAILED) {
+                isInvalid = true;
+            }
+            DHLOGI("remote found, osType: %{public}d, isInvalid: %{public}d", osType, isInvalid);
+            return DH_SUCCESS;
+        }
+    }
+    DHLOGI("remote not found.");
+    return DH_SUCCESS;
+}
+
 void DAudioSinkManager::SetCallerTokenId(uint64_t tokenId)
 {
     callerTokenId_ = tokenId;
diff --git a/services/audiomanager/managersource/include/daudio_source_dev.h b/services/audiomanager/managersource/include/daudio_source_dev.h
index df422afdab9336feaa4b6c6524d6a4076a795878..19a083719d7044d27c1b4c047f936a7acf5d06ec 100644
--- a/services/audiomanager/managersource/include/daudio_source_dev.h
+++ b/services/audiomanager/managersource/include/daudio_source_dev.h
@@ -89,6 +89,8 @@ private:
     void OnDisableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName);
     void OnEnableTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName);
     void OnTaskResult(int32_t resultCode, const std::string &result, const std::string &funcName);
+    int32_t ParseValueFromCjson(std::string args, std::string key);
+    int32_t CheckOsType(std::string &networkId, bool &isInvalid);
 
     int32_t HandleOpenDSpeaker(const AudioEvent &event);
     int32_t HandleCloseDSpeaker(const AudioEvent &event);
diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp
index f472c1c7695290eb1c08d506301ff1d8acd45f28..d03b4e4c792e3b3e2fddae8e1d82846286635333 100644
--- a/services/audiomanager/managersource/src/daudio_source_dev.cpp
+++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp
@@ -413,6 +413,9 @@ int32_t DAudioSourceDev::HandleOpenDSpeaker(const AudioEvent &event)
     DHLOGI("Open speaker device.");
     CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed.");
 
+    bool isInvalid = false;
+    CHECK_AND_RETURN_RET_LOG(CheckOsType(devId_, isInvalid) && isInvalid, ERR_DH_AUDIO_FAILED,
+        "GetOsType failed or invalid osType");
     CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR);
     auto eventParam = std::make_shared<AudioEvent>(event);
     auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_OPEN_SPEAKER, eventParam, 0);
@@ -527,6 +530,9 @@ int32_t DAudioSourceDev::HandleOpenDMic(const AudioEvent &event)
     DHLOGI("Open mic device.");
     CHECK_AND_RETURN_RET_LOG(!CheckAclRight(), ERR_DH_AUDIO_FAILED, "ACL check failed.");
 
+    bool isInvalid = false;
+    CHECK_AND_RETURN_RET_LOG(CheckOsType(devId_, isInvalid) && isInvalid, ERR_DH_AUDIO_FAILED,
+        "GetOsType failed or invalid osType");
     CHECK_NULL_RETURN(handler_, ERR_DH_AUDIO_NULLPTR);
     auto eventParam = std::make_shared<AudioEvent>(event);
     auto msgEvent = AppExecFwk::InnerEvent::Get(EVENT_OPEN_MIC, eventParam, 0);
@@ -1543,6 +1549,40 @@ void DAudioSourceDev::SetTokenId(uint64_t value)
     tokenId_ = value;
 }
 
+int32_t DAudioSourceDev::ParseValueFromCjson(std::string args, std::string key)
+{
+    DHLOGD("ParseValueFromCjson");
+    cJSON *jParam = cJSON_Parse(args.c_str());
+    CHECK_NULL_RETURN(jParam, ERR_DH_AUDIO_FAILED);
+    CHECK_AND_FREE_RETURN_RET_LOG(!CJsonParamCheck(jParam, { key }), ERR_DH_AUDIO_FAILED, jParam, "Not found key");
+    cJSON *retItem = cJSON_GetObjectItem(jParam, key.c_str());
+    CHECK_AND_FREE_RETURN_RET_LOG(retItem == NULL || !cJSON_IsNumber(retItem),
+        ERR_DH_AUDIO_FAILED, jParam, "Not found key result");
+    int32_t ret = retItem->valueint;
+    cJSON_Delete(jParam);
+    return ret;
+}
+
+int32_t DAudioSourceDev::CheckOsType(std::string &networkId, bool &isInvalid)
+{
+    std::vector<DistributedHardware::DmDeviceInfo> dmDeviceInfoList;
+    int32_t errCode = DeviceManager::GetInstance().GetTrustedDeviceList(PKG_NAME, "", dmDeviceInfoList);
+    CHECK_AND_RETURN_RET_LOG(errCode != DH_SUCCESS, ERR_DH_AUDIO_FAILED,
+        "Get device manager trusted device list fail, errCode %{public}d", errCode);
+    for (const auto& dmDeviceInfo : dmDeviceInfoList) {
+        if (dmDeviceInfo.networkId == networkId) {
+            int32_t osType = ParseValueFromCjson(dmDeviceInfo.extraData, KEY_OS_TYPE);
+            if (osType == INVALID_OS_TYPE && osType != ERR_DH_AUDIO_FAILED) {
+                isInvalid = true;
+            }
+            DHLOGI("remote found, osType: %{public}d, isInvalid: %{public}d", osType, isInvalid);
+            return DH_SUCCESS;
+        }
+    }
+    DHLOGI("remote not found.");
+    return DH_SUCCESS;
+}
+
 DAudioSourceDev::SourceEventHandler::SourceEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner,
     const std::shared_ptr<DAudioSourceDev> &dev) : AppExecFwk::EventHandler(runner), sourceDev_(dev)
 {
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
index de66db64d5de85083fb0f5c8d5904affbf4679df..2f9a1e678b95f74f3ae965260d56280ecf619397 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
@@ -281,5 +281,42 @@ HWTEST_F(DAudioSinkManagerTest, OnProviderEvent_001, TestSize.Level1)
     AVTransEvent event3 = { EventType::EVENT_REMOVE_STREAM, "", ""};
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.providerListener_->OnProviderEvent(event3));
 }
+
+/**
+ * @tc.name: ParseValueFromCjson_001
+ * @tc.desc: Verify the ParseValueFromCjson function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioSinkManagerTest, ParseValueFromCjson_001, TestSize.Level1)
+{
+    int32_t volume = 50;
+    std::string jsonStr = "{\"OS_TYPE\": 50}";
+    std::string key = "OS_TYPE";
+    int32_t result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, volume);
+
+    jsonStr = "invalid_json";
+    key = "volume";
+    result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "{\"brightness\": 80}";
+    result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "{\"volume\": \"high\"}";
+    result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "";
+    result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "null";
+    key = "volume";
+    result = daudioSinkManager.ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+}
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
index 85ca7d62fb444a6a176e7a443fd339522214a0ee..003fb4af483e9651e75b19b6ff8badd3466ce2c8 100644
--- a/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
+++ b/services/audiomanager/test/unittest/sourcedevice/src/daudio_source_dev_test.cpp
@@ -1233,5 +1233,42 @@ HWTEST_F(DAudioSourceDevTest, EnableDAudio_001, TestSize.Level1)
     std::string argsFull = "{\"dataType\":\"full\"}";
     EXPECT_EQ(DH_SUCCESS, sourceDev_->EnableDAudio(DH_ID_SPK, argsFull));
 }
+
+/**
+ * @tc.name: ParseValueFromCjson_001
+ * @tc.desc: Verify the ParseValueFromCjson function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioSourceDevTest, ParseValueFromCjson_001, TestSize.Level1)
+{
+    int32_t volume = 50;
+    std::string jsonStr = "{\"OS_TYPE\": 50}";
+    std::string key = "OS_TYPE";
+    int32_t result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, volume);
+
+    jsonStr = "invalid_json";
+    key = "volume";
+    result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "{\"brightness\": 80}";
+    result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "{\"volume\": \"high\"}";
+    result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "";
+    result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+
+    jsonStr = "null";
+    key = "volume";
+    result = sourceDev_->ParseValueFromCjson(jsonStr, key);
+    EXPECT_EQ(result, ERR_DH_AUDIO_FAILED);
+}
 } // namespace DistributedHardware
 } // namespace OHOS